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

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

type TextMarkClass struct {
	_ structs.HostLayout

	ParentClass gobject.ObjectClass

	Padding [8]uintptr
}

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

// Marks a position in a `GtkTextbuffer` that is preserved
// across modifications.
//
// You may wish to begin by reading the
// [text widget conceptual overview](section-text-widget.html),
// which gives an overview of all the objects and data types
// related to the text widget and how they work together.
//
// A `GtkTextMark` is like a bookmark in a text buffer; it preserves
// a position in the text. You can convert the mark to an iterator using
// [method@Gtk.TextBuffer.get_iter_at_mark]. Unlike iterators, marks remain
// valid across buffer mutations, because their behavior is defined when
// text is inserted or deleted. When text containing a mark is deleted,
// the mark remains in the position originally occupied by the deleted
// text. When text is inserted at a mark, a mark with “left gravity” will
// be moved to the beginning of the newly-inserted text, and a mark with
// “right gravity” will be moved to the end.
//
// Note that “left” and “right” here refer to logical direction (left
// is the toward the start of the buffer); in some languages such as
// Hebrew the logically-leftmost text is not actually on the left when
// displayed.
//
// Marks are reference counted, but the reference count only controls
// the validity of the memory; marks can be deleted from the buffer at
// any time with [method@Gtk.TextBuffer.delete_mark]. Once deleted from
// the buffer, a mark is essentially useless.
//
// Marks optionally have names; these can be convenient to avoid passing
// the `GtkTextMark` object around.
//
// Marks are typically created using the [method@Gtk.TextBuffer.create_mark]
// function.
type TextMark struct {
	gobject.Object
}

var xTextMarkGLibType func() types.GType

func TextMarkGLibType() types.GType {
	return xTextMarkGLibType()
}

func TextMarkNewFromInternalPtr(ptr uintptr) *TextMark {
	cls := &TextMark{}
	cls.Ptr = ptr
	return cls
}

var xNewTextMark func(uintptr, bool) uintptr

// Creates a text mark.
//
// Add it to a buffer using [method@Gtk.TextBuffer.add_mark].
// If @name is %NULL, the mark is anonymous; otherwise, the mark can be
// retrieved by name using [method@Gtk.TextBuffer.get_mark]. If a mark
// has left gravity, and text is inserted at the mark’s current location,
// the mark will be moved to the left of the newly-inserted text. If the
// mark has right gravity (@left_gravity = %FALSE), the mark will end up
// on the right of newly-inserted text. The standard left-to-right cursor
// is a mark with right gravity (when you type, the cursor stays on the
// right side of the text you’re typing).
func NewTextMark(NameVar *string, LeftGravityVar bool) *TextMark {
	var cls *TextMark

	NameVarPtr := core.GStrdupNullable(NameVar)
	defer core.GFreeNullable(NameVarPtr)

	cret := xNewTextMark(NameVarPtr, LeftGravityVar)

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

var xTextMarkGetBuffer func(uintptr) uintptr

// Gets the buffer this mark is located inside.
//
// Returns %NULL if the mark is deleted.
func (x *TextMark) GetBuffer() *TextBuffer {
	var cls *TextBuffer

	cret := xTextMarkGetBuffer(x.GoPointer())

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

var xTextMarkGetDeleted func(uintptr) bool

// Returns %TRUE if the mark has been removed from its buffer.
//
// See [method@Gtk.TextBuffer.add_mark] for a way to add it
// to a buffer again.
func (x *TextMark) GetDeleted() bool {

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

var xTextMarkGetLeftGravity func(uintptr) bool

// Determines whether the mark has left gravity.
func (x *TextMark) GetLeftGravity() bool {

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

var xTextMarkGetName func(uintptr) string

// Returns the mark name.
//
// Returns %NULL for anonymous marks.
func (x *TextMark) GetName() string {

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

var xTextMarkGetVisible func(uintptr) bool

// Returns %TRUE if the mark is visible.
//
// A cursor is displayed for visible marks.
func (x *TextMark) GetVisible() bool {

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

var xTextMarkSetVisible func(uintptr, bool)

// Sets the visibility of @mark.
//
// The insertion point is normally visible, i.e. you can see it as
// a vertical bar. Also, the text widget uses a visible mark to
// indicate where a drop will occur when dragging-and-dropping text.
// Most other marks are not visible.
//
// Marks are not visible by default.
func (x *TextMark) SetVisible(SettingVar bool) {

	xTextMarkSetVisible(x.GoPointer(), SettingVar)

}

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

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

// SetPropertyLeftGravity sets the "left-gravity" property.
// Whether the mark has left gravity.
//
// When text is inserted at the mark’s current location, if the mark
// has left gravity it will be moved to the left of the newly-inserted
// text, otherwise to the right.
func (x *TextMark) SetPropertyLeftGravity(value bool) {
	var v gobject.Value
	v.Init(gobject.TypeBooleanVal)
	v.SetBoolean(value)
	x.SetProperty("left-gravity", &v)
}

// GetPropertyLeftGravity gets the "left-gravity" property.
// Whether the mark has left gravity.
//
// When text is inserted at the mark’s current location, if the mark
// has left gravity it will be moved to the left of the newly-inserted
// text, otherwise to the right.
func (x *TextMark) GetPropertyLeftGravity() bool {
	var v gobject.Value
	x.GetProperty("left-gravity", &v)
	return v.GetBoolean()
}

// SetPropertyName sets the "name" property.
// The name of the mark or %NULL if the mark is anonymous.
func (x *TextMark) SetPropertyName(value string) {
	var v gobject.Value
	v.Init(gobject.TypeStringVal)
	v.SetString(&value)
	x.SetProperty("name", &v)
}

// GetPropertyName gets the "name" property.
// The name of the mark or %NULL if the mark is anonymous.
func (x *TextMark) GetPropertyName() string {
	var v gobject.Value
	x.GetProperty("name", &v)
	return v.GetString()
}

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

	core.PuregoSafeRegister(&xTextMarkGLibType, libs, "gtk_text_mark_get_type")

	core.PuregoSafeRegister(&xNewTextMark, libs, "gtk_text_mark_new")

	core.PuregoSafeRegister(&xTextMarkGetBuffer, libs, "gtk_text_mark_get_buffer")
	core.PuregoSafeRegister(&xTextMarkGetDeleted, libs, "gtk_text_mark_get_deleted")
	core.PuregoSafeRegister(&xTextMarkGetLeftGravity, libs, "gtk_text_mark_get_left_gravity")
	core.PuregoSafeRegister(&xTextMarkGetName, libs, "gtk_text_mark_get_name")
	core.PuregoSafeRegister(&xTextMarkGetVisible, libs, "gtk_text_mark_get_visible")
	core.PuregoSafeRegister(&xTextMarkSetVisible, libs, "gtk_text_mark_set_visible")

}