// Package gsk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gsk

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/cairo"
	"github.com/bnema/puregotk/v4/gdk"
	"github.com/bnema/puregotk/v4/glib"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
	"github.com/bnema/puregotk/v4/graphene"
)

type RendererClass struct {
	_ structs.HostLayout
}

func (x *RendererClass) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// Renders a scene graph defined via a tree of [class@Gsk.RenderNode] instances.
//
// Typically you will use a `GskRenderer` instance to repeatedly call
// [method@Gsk.Renderer.render] to update the contents of its associated
// [class@Gdk.Surface].
//
// It is necessary to realize a `GskRenderer` instance using
// [method@Gsk.Renderer.realize] before calling [method@Gsk.Renderer.render],
// in order to create the appropriate windowing system resources needed
// to render the scene.
type Renderer struct {
	gobject.Object
}

var xRendererGLibType func() types.GType

func RendererGLibType() types.GType {
	return xRendererGLibType()
}

func RendererNewFromInternalPtr(ptr uintptr) *Renderer {
	cls := &Renderer{}
	cls.Ptr = ptr
	return cls
}

var xNewRendererForSurface func(uintptr) uintptr

// Creates an appropriate `GskRenderer` instance for the given surface.
//
// If the `GSK_RENDERER` environment variable is set, GSK will
// try that renderer first, before trying the backend-specific
// default. The ultimate fallback is the cairo renderer.
//
// The renderer will be realized before it is returned.
func NewRendererForSurface(SurfaceVar *gdk.Surface) *Renderer {
	var cls *Renderer

	cret := xNewRendererForSurface(SurfaceVar.GoPointer())

	if cret == 0 {
		return nil
	}
	cls = &Renderer{}
	cls.Ptr = cret
	return cls
}

var xRendererGetSurface func(uintptr) uintptr

// Retrieves the surface that the renderer is associated with.
//
// If the renderer has not been realized yet, `NULL` will be returned.
func (x *Renderer) GetSurface() *gdk.Surface {
	var cls *gdk.Surface

	cret := xRendererGetSurface(x.GoPointer())

	if cret == 0 {
		return nil
	}
	gobject.IncreaseRef(cret)
	cls = &gdk.Surface{}
	cls.Ptr = cret
	return cls
}

var xRendererIsRealized func(uintptr) bool

// Checks whether the renderer is realized or not.
func (x *Renderer) IsRealized() bool {

	cret := xRendererIsRealized(x.GoPointer())
	return cret
}

var xRendererRealize func(uintptr, uintptr, **glib.Error) bool

// Creates the resources needed by the renderer.
//
// Since GTK 4.6, the surface may be `NULL`, which allows using
// renderers without having to create a surface. Since GTK 4.14,
// it is recommended to use [method@Gsk.Renderer.realize_for_display]
// for this case.
//
// Note that it is mandatory to call [method@Gsk.Renderer.unrealize]
// before destroying the renderer.
func (x *Renderer) Realize(SurfaceVar *gdk.Surface) (bool, error) {
	var cerr *glib.Error

	cret := xRendererRealize(x.GoPointer(), SurfaceVar.GoPointer(), &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xRendererRealizeForDisplay func(uintptr, uintptr, **glib.Error) bool

// Creates the resources needed by the renderer.
//
// Note that it is mandatory to call [method@Gsk.Renderer.unrealize]
// before destroying the renderer.
func (x *Renderer) RealizeForDisplay(DisplayVar *gdk.Display) (bool, error) {
	var cerr *glib.Error

	cret := xRendererRealizeForDisplay(x.GoPointer(), DisplayVar.GoPointer(), &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xRendererRender func(uintptr, uintptr, *cairo.Region)

// Renders the scene graph, described by a tree of `GskRenderNode` instances
// to the renderer's surface, ensuring that the given region gets redrawn.
//
// If the renderer has no associated surface, this function does nothing.
//
// Renderers must ensure that changes of the contents given by the @root
// node as well as the area given by @region are redrawn. They are however
// free to not redraw any pixel outside of @region if they can guarantee that
// it didn't change.
//
// The renderer will acquire a reference on the `GskRenderNode` tree while
// the rendering is in progress.
func (x *Renderer) Render(RootVar *RenderNode, RegionVar *cairo.Region) {

	xRendererRender(x.GoPointer(), RootVar.GoPointer(), RegionVar)

}

var xRendererRenderTexture func(uintptr, uintptr, *graphene.Rect) uintptr

// Renders a scene graph, described by a tree of `GskRenderNode` instances,
// to a texture.
//
// The renderer will acquire a reference on the `GskRenderNode` tree while
// the rendering is in progress.
//
// If you want to apply any transformations to @root, you should put it into a
// transform node and pass that node instead.
func (x *Renderer) RenderTexture(RootVar *RenderNode, ViewportVar *graphene.Rect) *gdk.Texture {
	var cls *gdk.Texture

	cret := xRendererRenderTexture(x.GoPointer(), RootVar.GoPointer(), ViewportVar)

	if cret == 0 {
		return nil
	}
	cls = &gdk.Texture{}
	cls.Ptr = cret
	return cls
}

var xRendererUnrealize func(uintptr)

// Releases all the resources created by [method@Gsk.Renderer.realize].
func (x *Renderer) Unrealize() {

	xRendererUnrealize(x.GoPointer())

}

func (c *Renderer) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *Renderer) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

// GetPropertyRealized gets the "realized" property.
// Whether the renderer has been associated with a surface or draw context.
func (x *Renderer) GetPropertyRealized() bool {
	var v gobject.Value
	x.GetProperty("realized", &v)
	return v.GetBoolean()
}

func init() {
	core.SetPackageName("GSK", "gtk4")
	core.SetSharedLibraries("GSK", []string{"libgtk-4.so.1"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GSK") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xRendererGLibType, libs, "gsk_renderer_get_type")

	core.PuregoSafeRegister(&xNewRendererForSurface, libs, "gsk_renderer_new_for_surface")

	core.PuregoSafeRegister(&xRendererGetSurface, libs, "gsk_renderer_get_surface")
	core.PuregoSafeRegister(&xRendererIsRealized, libs, "gsk_renderer_is_realized")
	core.PuregoSafeRegister(&xRendererRealize, libs, "gsk_renderer_realize")
	core.PuregoSafeRegister(&xRendererRealizeForDisplay, libs, "gsk_renderer_realize_for_display")
	core.PuregoSafeRegister(&xRendererRender, libs, "gsk_renderer_render")
	core.PuregoSafeRegister(&xRendererRenderTexture, libs, "gsk_renderer_render_texture")
	core.PuregoSafeRegister(&xRendererUnrealize, libs, "gsk_renderer_unrealize")

}