// Code generated by cmd/codegen from https://github.com/AllenDang/cimgui-go.
// DO NOT EDIT.

package imgui

// #include "structs_accessor.h"
// #include "wrapper.h"
// #include "../imgui/extra_types.h"
import "C"
import (
	"unsafe"

	"github.com/AllenDang/cimgui-go/internal"
	"github.com/AllenDang/cimgui-go/utils/vectors"
)

func (self *BitVector) InternalClear() {
	selfArg, selfFin := self.Handle()
	C.ImBitVector_Clear(internal.ReinterpretCast[*C.ImBitVector](selfArg))

	selfFin()
}

func (self *BitVector) InternalClearBit(n int32) {
	selfArg, selfFin := self.Handle()
	C.ImBitVector_ClearBit(internal.ReinterpretCast[*C.ImBitVector](selfArg), C.int(n))

	selfFin()
}

func (self *BitVector) InternalCreate(sz int32) {
	selfArg, selfFin := self.Handle()
	C.ImBitVector_Create(internal.ReinterpretCast[*C.ImBitVector](selfArg), C.int(sz))

	selfFin()
}

func (self *BitVector) InternalSetBit(n int32) {
	selfArg, selfFin := self.Handle()
	C.ImBitVector_SetBit(internal.ReinterpretCast[*C.ImBitVector](selfArg), C.int(n))

	selfFin()
}

func (self *BitVector) InternalTestBit(n int32) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImBitVector_TestBit(internal.ReinterpretCast[*C.ImBitVector](selfArg), C.int(n)) == C.bool(true)
}

// ColorHSVV parameter default value hint:
// a: 1.0f
func ColorHSVV(h, s, v, a float32) Color {
	pOut := new(Color)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImColor_HSV(internal.ReinterpretCast[*C.ImColor](pOutArg), C.float(h), C.float(s), C.float(v), C.float(a))

	pOutFin()

	return *pOut
}

// SetHSVV parameter default value hint:
// a: 1.0f
func (self *Color) SetHSVV(h, s, v, a float32) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImColor_SetHSV(internal.ReinterpretCast[*C.ImColor](selfArg), C.float(h), C.float(s), C.float(v), C.float(a))

	selfFin()
}

func (self *Color) Destroy() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImColor_destroy(internal.ReinterpretCast[*C.ImColor](selfArg))

	selfFin()
}

// == (TexRef._TexData ? TexRef._TexData->TexID : TexRef._TexID)
func (self *DrawCmd) TexID() TextureID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewTextureIDFromC(func() *C.ImTextureID {
		result := C.ImDrawCmd_GetTexID(internal.ReinterpretCast[*C.ImDrawCmd](selfArg))
		return &result
	}())
}

// Also ensure our padding fields are zeroed
func NewDrawCmd() *DrawCmd {
	return NewDrawCmdFromC(C.ImDrawCmd_ImDrawCmd())
}

func (self *DrawCmd) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImDrawCmd_destroy(internal.ReinterpretCast[*C.ImDrawCmd](selfArg))

	selfFin()
}

func InternalNewDrawDataBuilder() *DrawDataBuilder {
	return NewDrawDataBuilderFromC(C.ImDrawDataBuilder_ImDrawDataBuilder())
}

func (self *DrawDataBuilder) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImDrawDataBuilder_destroy(internal.ReinterpretCast[*C.ImDrawDataBuilder](selfArg))

	selfFin()
}

// Helper to add an external draw list into an existing ImDrawData.
func (self *DrawData) AddDrawList(draw_list *DrawList) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	C.ImDrawData_AddDrawList(internal.ReinterpretCast[*C.ImDrawData](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg))

	selfFin()
	draw_listFin()
}

func (self *DrawData) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImDrawData_Clear(internal.ReinterpretCast[*C.ImDrawData](selfArg))

	selfFin()
}

// Helper to convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
func (self *DrawData) DeIndexAllBuffers() {
	selfArg, selfFin := self.Handle()
	C.ImDrawData_DeIndexAllBuffers(internal.ReinterpretCast[*C.ImDrawData](selfArg))

	selfFin()
}

func NewDrawData() *DrawData {
	return NewDrawDataFromC(C.ImDrawData_ImDrawData())
}

// Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than Dear ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
func (self *DrawData) ScaleClipRects(fb_scale Vec2) {
	selfArg, selfFin := self.Handle()
	C.ImDrawData_ScaleClipRects(internal.ReinterpretCast[*C.ImDrawData](selfArg), internal.ReinterpretCast[C.ImVec2](fb_scale.ToC()))

	selfFin()
}

func (self *DrawData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImDrawData_destroy(internal.ReinterpretCast[*C.ImDrawData](selfArg))

	selfFin()
}

func InternalNewDrawListSharedData() *DrawListSharedData {
	return NewDrawListSharedDataFromC(C.ImDrawListSharedData_ImDrawListSharedData())
}

func (self *DrawListSharedData) InternalSetCircleTessellationMaxError(max_error float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawListSharedData_SetCircleTessellationMaxError(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg), C.float(max_error))

	selfFin()
}

func (self *DrawListSharedData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImDrawListSharedData_destroy(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg))

	selfFin()
}

// Do not clear Channels[] so our allocations are reused next frame
func (self *DrawListSplitter) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImDrawListSplitter_Clear(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg))

	selfFin()
}

func (self *DrawListSplitter) ClearFreeMemory() {
	selfArg, selfFin := self.Handle()
	C.ImDrawListSplitter_ClearFreeMemory(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg))

	selfFin()
}

func NewDrawListSplitter() *DrawListSplitter {
	return NewDrawListSplitterFromC(C.ImDrawListSplitter_ImDrawListSplitter())
}

func (self *DrawListSplitter) Merge(draw_list *DrawList) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	C.ImDrawListSplitter_Merge(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg))

	selfFin()
	draw_listFin()
}

func (self *DrawListSplitter) SetCurrentChannel(draw_list *DrawList, channel_idx int32) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	C.ImDrawListSplitter_SetCurrentChannel(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.int(channel_idx))

	selfFin()
	draw_listFin()
}

func (self *DrawListSplitter) Split(draw_list *DrawList, count int32) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	C.ImDrawListSplitter_Split(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.int(count))

	selfFin()
	draw_listFin()
}

func (self *DrawListSplitter) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImDrawListSplitter_destroy(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg))

	selfFin()
}

// Cubic Bezier (4 control points)
// AddBezierCubicV parameter default value hint:
// num_segments: 0
func (self *DrawList) AddBezierCubicV(p1, p2, p3, p4 Vec2, col uint32, thickness float32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddBezierCubic(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.ImU32(col), C.float(thickness), C.int(num_segments))

	selfFin()
}

// Quadratic Bezier (3 control points)
// AddBezierQuadraticV parameter default value hint:
// num_segments: 0
func (self *DrawList) AddBezierQuadraticV(p1, p2, p3 Vec2, col uint32, thickness float32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddBezierQuadratic(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.ImU32(col), C.float(thickness), C.int(num_segments))

	selfFin()
}

// AddCallbackV parameter default value hint:
// userdata_size: 0
func (self *DrawList) AddCallbackV(callback DrawCallback, userdata uintptr, userdata_size uint64) {
	selfArg, selfFin := self.Handle()
	callbackArg, callbackFin := callback.C()
	C.wrap_ImDrawList_AddCallbackV(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImDrawCallback](callbackArg), C.uintptr_t(userdata), C.xulong(userdata_size))

	selfFin()
	callbackFin()
}

// AddCircleV parameter default value hint:
// num_segments: 0
// thickness: 1.0f
func (self *DrawList) AddCircleV(center Vec2, radius float32, col uint32, num_segments int32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddCircle(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col), C.int(num_segments), C.float(thickness))

	selfFin()
}

// AddCircleFilledV parameter default value hint:
// num_segments: 0
func (self *DrawList) AddCircleFilledV(center Vec2, radius float32, col uint32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddCircleFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col), C.int(num_segments))

	selfFin()
}

func (self *DrawList) AddConcavePolyFilled(points *Vec2, num_points int32, col uint32) {
	selfArg, selfFin := self.Handle()
	pointsArg, pointsFin := internal.Wrap(points)
	C.ImDrawList_AddConcavePolyFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[*C.ImVec2](pointsArg), C.int(num_points), C.ImU32(col))

	selfFin()
	pointsFin()
}

func (self *DrawList) AddConvexPolyFilled(points *Vec2, num_points int32, col uint32) {
	selfArg, selfFin := self.Handle()
	pointsArg, pointsFin := internal.Wrap(points)
	C.ImDrawList_AddConvexPolyFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[*C.ImVec2](pointsArg), C.int(num_points), C.ImU32(col))

	selfFin()
	pointsFin()
}

// This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
func (self *DrawList) AddDrawCmd() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddDrawCmd(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

// AddEllipseV parameter default value hint:
// rot: 0.0f
// num_segments: 0
// thickness: 1.0f
func (self *DrawList) AddEllipseV(center, radius Vec2, col uint32, rot float32, num_segments int32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddEllipse(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), internal.ReinterpretCast[C.ImVec2](radius.ToC()), C.ImU32(col), C.float(rot), C.int(num_segments), C.float(thickness))

	selfFin()
}

// AddEllipseFilledV parameter default value hint:
// rot: 0.0f
// num_segments: 0
func (self *DrawList) AddEllipseFilledV(center, radius Vec2, col uint32, rot float32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddEllipseFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), internal.ReinterpretCast[C.ImVec2](radius.ToC()), C.ImU32(col), C.float(rot), C.int(num_segments))

	selfFin()
}

// AddImageV parameter default value hint:
// uv_min: ImVec2(0,0)
// uv_max: ImVec2(1,1)
// col: 4294967295
func (self *DrawList) AddImageV(tex_ref TextureRef, p_min, p_max, uv_min, uv_max Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.ImDrawList_AddImage(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), internal.ReinterpretCast[C.ImVec2](uv_min.ToC()), internal.ReinterpretCast[C.ImVec2](uv_max.ToC()), C.ImU32(col))

	selfFin()
	tex_refFin()
}

// AddImageQuadV parameter default value hint:
// uv1: ImVec2(0,0)
// uv2: ImVec2(1,0)
// uv3: ImVec2(1,1)
// uv4: ImVec2(0,1)
// col: 4294967295
func (self *DrawList) AddImageQuadV(tex_ref TextureRef, p1, p2, p3, p4, uv1, uv2, uv3, uv4 Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.ImDrawList_AddImageQuad(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()), internal.ReinterpretCast[C.ImVec2](uv2.ToC()), internal.ReinterpretCast[C.ImVec2](uv3.ToC()), internal.ReinterpretCast[C.ImVec2](uv4.ToC()), C.ImU32(col))

	selfFin()
	tex_refFin()
}

// AddImageRoundedV parameter default value hint:
// flags: 0
func (self *DrawList) AddImageRoundedV(tex_ref TextureRef, p_min, p_max, uv_min, uv_max Vec2, col uint32, rounding float32, flags DrawFlags) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.ImDrawList_AddImageRounded(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), internal.ReinterpretCast[C.ImVec2](uv_min.ToC()), internal.ReinterpretCast[C.ImVec2](uv_max.ToC()), C.ImU32(col), C.float(rounding), C.ImDrawFlags(flags))

	selfFin()
	tex_refFin()
}

// AddLineV parameter default value hint:
// thickness: 1.0f
func (self *DrawList) AddLineV(p1, p2 Vec2, col uint32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddLine(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), C.ImU32(col), C.float(thickness))

	selfFin()
}

// AddNgonV parameter default value hint:
// thickness: 1.0f
func (self *DrawList) AddNgonV(center Vec2, radius float32, col uint32, num_segments int32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddNgon(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col), C.int(num_segments), C.float(thickness))

	selfFin()
}

func (self *DrawList) AddNgonFilled(center Vec2, radius float32, col uint32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddNgonFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col), C.int(num_segments))

	selfFin()
}

func (self *DrawList) AddPolyline(points *Vec2, num_points int32, col uint32, flags DrawFlags, thickness float32) {
	selfArg, selfFin := self.Handle()
	pointsArg, pointsFin := internal.Wrap(points)
	C.ImDrawList_AddPolyline(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[*C.ImVec2](pointsArg), C.int(num_points), C.ImU32(col), C.ImDrawFlags(flags), C.float(thickness))

	selfFin()
	pointsFin()
}

// AddQuadV parameter default value hint:
// thickness: 1.0f
func (self *DrawList) AddQuadV(p1, p2, p3, p4 Vec2, col uint32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddQuad(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.ImU32(col), C.float(thickness))

	selfFin()
}

func (self *DrawList) AddQuadFilled(p1, p2, p3, p4 Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddQuadFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.ImU32(col))

	selfFin()
}

// a: upper-left, b: lower-right (== upper-left + size)
// AddRectV parameter default value hint:
// rounding: 0.0f
// flags: 0
// thickness: 1.0f
func (self *DrawList) AddRectV(p_min, p_max Vec2, col uint32, rounding float32, flags DrawFlags, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(col), C.float(rounding), C.ImDrawFlags(flags), C.float(thickness))

	selfFin()
}

// a: upper-left, b: lower-right (== upper-left + size)
// AddRectFilledV parameter default value hint:
// rounding: 0.0f
// flags: 0
func (self *DrawList) AddRectFilledV(p_min, p_max Vec2, col uint32, rounding float32, flags DrawFlags) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddRectFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(col), C.float(rounding), C.ImDrawFlags(flags))

	selfFin()
}

func (self *DrawList) AddRectFilledMultiColor(p_min, p_max Vec2, col_upr_left, col_upr_right, col_bot_right, col_bot_left uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddRectFilledMultiColor(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(col_upr_left), C.ImU32(col_upr_right), C.ImU32(col_bot_right), C.ImU32(col_bot_left))

	selfFin()
}

// AddTextFontPtrV parameter default value hint:
// wrap_width: 0.0f
// cpu_fine_clip_rect: NULL
func (self *DrawList) AddTextFontPtrV(font *Font, font_size float32, pos Vec2, col uint32, text_begin string, wrap_width float32, cpu_fine_clip_rect *Vec4) {
	selfArg, selfFin := self.Handle()
	fontArg, fontFin := font.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	cpu_fine_clip_rectArg, cpu_fine_clip_rectFin := internal.Wrap(cpu_fine_clip_rect)
	C.wrap_ImDrawList_AddText_FontPtrV(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), text_beginArg, C.float(wrap_width), internal.ReinterpretCast[*C.ImVec4](cpu_fine_clip_rectArg))

	selfFin()
	fontFin()
	text_beginFin()
	cpu_fine_clip_rectFin()
}

// AddTextVec2V parameter default value hint:
func (self *DrawList) AddTextVec2V(pos Vec2, col uint32, text_begin string) {
	selfArg, selfFin := self.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImDrawList_AddText_Vec2V(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), text_beginArg)

	selfFin()
	text_beginFin()
}

// AddTriangleV parameter default value hint:
// thickness: 1.0f
func (self *DrawList) AddTriangleV(p1, p2, p3 Vec2, col uint32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddTriangle(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.ImU32(col), C.float(thickness))

	selfFin()
}

func (self *DrawList) AddTriangleFilled(p1, p2, p3 Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_AddTriangleFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) ChannelsMerge() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_ChannelsMerge(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) ChannelsSetCurrent(n int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_ChannelsSetCurrent(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.int(n))

	selfFin()
}

func (self *DrawList) ChannelsSplit(count int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_ChannelsSplit(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.int(count))

	selfFin()
}

// Create a clone of the CmdBuffer/IdxBuffer/VtxBuffer. For multi-threaded rendering, consider using `imgui_threaded_rendering` from https://github.com/ocornut/imgui_club instead.
func (self *DrawList) CloneOutput() *DrawList {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawListFromC(C.ImDrawList_CloneOutput(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) ClipRectMax() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImDrawList_GetClipRectMax(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImDrawList](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *DrawList) ClipRectMin() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImDrawList_GetClipRectMin(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImDrawList](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func NewDrawList(shared_data *DrawListSharedData) *DrawList {
	shared_dataArg, shared_dataFin := shared_data.Handle()

	defer func() {
		shared_dataFin()
	}()
	return NewDrawListFromC(C.ImDrawList_ImDrawList(internal.ReinterpretCast[*C.ImDrawListSharedData](shared_dataArg)))
}

// PathArcToV parameter default value hint:
// num_segments: 0
func (self *DrawList) PathArcToV(center Vec2, radius, a_min, a_max float32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathArcTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.float(a_min), C.float(a_max), C.int(num_segments))

	selfFin()
}

// Use precomputed angles for a 12 steps circle
func (self *DrawList) PathArcToFast(center Vec2, radius float32, a_min_of_12, a_max_of_12 int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathArcToFast(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.int(a_min_of_12), C.int(a_max_of_12))

	selfFin()
}

// Cubic Bezier (4 control points)
// PathBezierCubicCurveToV parameter default value hint:
// num_segments: 0
func (self *DrawList) PathBezierCubicCurveToV(p2, p3, p4 Vec2, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathBezierCubicCurveTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.int(num_segments))

	selfFin()
}

// Quadratic Bezier (3 control points)
// PathBezierQuadraticCurveToV parameter default value hint:
// num_segments: 0
func (self *DrawList) PathBezierQuadraticCurveToV(p2, p3 Vec2, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathBezierQuadraticCurveTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.int(num_segments))

	selfFin()
}

func (self *DrawList) PathClear() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathClear(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

// Ellipse
// PathEllipticalArcToV parameter default value hint:
// num_segments: 0
func (self *DrawList) PathEllipticalArcToV(center, radius Vec2, rot, a_min, a_max float32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathEllipticalArcTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), internal.ReinterpretCast[C.ImVec2](radius.ToC()), C.float(rot), C.float(a_min), C.float(a_max), C.int(num_segments))

	selfFin()
}

func (self *DrawList) PathFillConcave(col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathFillConcave(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PathFillConvex(col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathFillConvex(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PathLineTo(pos Vec2) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathLineTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()))

	selfFin()
}

func (self *DrawList) PathLineToMergeDuplicate(pos Vec2) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathLineToMergeDuplicate(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()))

	selfFin()
}

// PathRectV parameter default value hint:
// rounding: 0.0f
// flags: 0
func (self *DrawList) PathRectV(rect_min, rect_max Vec2, rounding float32, flags DrawFlags) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](rect_min.ToC()), internal.ReinterpretCast[C.ImVec2](rect_max.ToC()), C.float(rounding), C.ImDrawFlags(flags))

	selfFin()
}

// PathStrokeV parameter default value hint:
// flags: 0
// thickness: 1.0f
func (self *DrawList) PathStrokeV(col uint32, flags DrawFlags, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PathStroke(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.ImU32(col), C.ImDrawFlags(flags), C.float(thickness))

	selfFin()
}

func (self *DrawList) PopClipRect() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PopClipRect(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) PopTexture() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PopTexture(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) PrimQuadUV(a, b, c, d, uv_a, uv_b, uv_c, uv_d Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimQuadUV(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](c.ToC()), internal.ReinterpretCast[C.ImVec2](d.ToC()), internal.ReinterpretCast[C.ImVec2](uv_a.ToC()), internal.ReinterpretCast[C.ImVec2](uv_b.ToC()), internal.ReinterpretCast[C.ImVec2](uv_c.ToC()), internal.ReinterpretCast[C.ImVec2](uv_d.ToC()), C.ImU32(col))

	selfFin()
}

// Axis aligned rectangle (composed of two triangles)
func (self *DrawList) PrimRect(a, b Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PrimRectUV(a, b, uv_a, uv_b Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimRectUV(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](uv_a.ToC()), internal.ReinterpretCast[C.ImVec2](uv_b.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PrimReserve(idx_count, vtx_count int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimReserve(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.int(idx_count), C.int(vtx_count))

	selfFin()
}

func (self *DrawList) PrimUnreserve(idx_count, vtx_count int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimUnreserve(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.int(idx_count), C.int(vtx_count))

	selfFin()
}

// Write vertex with unique index
func (self *DrawList) PrimVtx(pos, uv Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimVtx(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[C.ImVec2](uv.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PrimWriteIdx(idx DrawIdx) {
	selfArg, selfFin := self.Handle()
	idxArg, idxFin := idx.C()
	C.ImDrawList_PrimWriteIdx(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImDrawIdx](idxArg))

	selfFin()
	idxFin()
}

func (self *DrawList) PrimWriteVtx(pos, uv Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PrimWriteVtx(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[C.ImVec2](uv.ToC()), C.ImU32(col))

	selfFin()
}

// Render-level scissoring. This is passed down to your render function but not used for CPU-side coarse clipping. Prefer using higher-level ImGui::PushClipRect() to affect logic (hit-testing and widget culling)
// PushClipRectV parameter default value hint:
// intersect_with_current_clip_rect: false
func (self *DrawList) PushClipRectV(clip_rect_min, clip_rect_max Vec2, intersect_with_current_clip_rect bool) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PushClipRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](clip_rect_min.ToC()), internal.ReinterpretCast[C.ImVec2](clip_rect_max.ToC()), C.bool(intersect_with_current_clip_rect))

	selfFin()
}

func (self *DrawList) PushClipRectFullScreen() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_PushClipRectFullScreen(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) PushTexture(tex_ref TextureRef) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.ImDrawList_PushTexture(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg))

	selfFin()
	tex_refFin()
}

func (self *DrawList) CalcCircleAutoSegmentCount(radius float32) int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImDrawList__CalcCircleAutoSegmentCount(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.float(radius)))
}

func (self *DrawList) ClearFreeMemory() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__ClearFreeMemory(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) OnChangedClipRect() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__OnChangedClipRect(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) OnChangedTexture() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__OnChangedTexture(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) OnChangedVtxOffset() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__OnChangedVtxOffset(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) PathArcToFastEx(center Vec2, radius float32, a_min_sample, a_max_sample, a_step int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__PathArcToFastEx(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.int(a_min_sample), C.int(a_max_sample), C.int(a_step))

	selfFin()
}

func (self *DrawList) PathArcToN(center Vec2, radius, a_min, a_max float32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__PathArcToN(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.float(a_min), C.float(a_max), C.int(num_segments))

	selfFin()
}

func (self *DrawList) PopUnusedDrawCmd() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__PopUnusedDrawCmd(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) ResetForNewFrame() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__ResetForNewFrame(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) SetDrawListSharedData(data *DrawListSharedData) {
	selfArg, selfFin := self.Handle()
	dataArg, dataFin := data.Handle()
	C.ImDrawList__SetDrawListSharedData(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[*C.ImDrawListSharedData](dataArg))

	selfFin()
	dataFin()
}

func (self *DrawList) SetTexture(tex_ref TextureRef) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.ImDrawList__SetTexture(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg))

	selfFin()
	tex_refFin()
}

func (self *DrawList) TryMergeDrawCmds() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList__TryMergeDrawCmds(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func (self *DrawList) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImDrawList_destroy(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	selfFin()
}

func InternalNewFontAtlasBuilder() *FontAtlasBuilder {
	return NewFontAtlasBuilderFromC(C.ImFontAtlasBuilder_ImFontAtlasBuilder())
}

func (self *FontAtlasBuilder) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlasBuilder_destroy(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	selfFin()
}

func NewFontAtlasRect() *FontAtlasRect {
	return NewFontAtlasRectFromC(C.ImFontAtlasRect_ImFontAtlasRect())
}

func (self *FontAtlasRect) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlasRect_destroy(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg))

	selfFin()
}

// Register a rectangle. Return -1 (ImFontAtlasRectId_Invalid) on error.
// AddCustomRectV parameter default value hint:
// out_r: NULL
func (self *FontAtlas) AddCustomRectV(width, height int32, out_r *FontAtlasRect) FontAtlasRectId {
	selfArg, selfFin := self.Handle()
	out_rArg, out_rFin := out_r.Handle()

	defer func() {
		selfFin()
		out_rFin()
	}()
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId {
		result := C.ImFontAtlas_AddCustomRect(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), C.int(width), C.int(height), internal.ReinterpretCast[*C.ImFontAtlasRect](out_rArg))
		return &result
	}())
}

func (self *FontAtlas) AddFont(font_cfg *FontConfig) *Font {
	selfArg, selfFin := self.Handle()
	font_cfgArg, font_cfgFin := font_cfg.Handle()

	defer func() {
		selfFin()
		font_cfgFin()
	}()
	return NewFontFromC(C.ImFontAtlas_AddFont(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), internal.ReinterpretCast[*C.ImFontConfig](font_cfgArg)))
}

// AddFontDefaultV parameter default value hint:
// font_cfg: NULL
func (self *FontAtlas) AddFontDefaultV(font_cfg *FontConfig) *Font {
	selfArg, selfFin := self.Handle()
	font_cfgArg, font_cfgFin := font_cfg.Handle()

	defer func() {
		selfFin()
		font_cfgFin()
	}()
	return NewFontFromC(C.ImFontAtlas_AddFontDefault(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), internal.ReinterpretCast[*C.ImFontConfig](font_cfgArg)))
}

// AddFontFromFileTTFV parameter default value hint:
// size_pixels: 0.0f
// font_cfg: NULL
// glyph_ranges: NULL
func (self *FontAtlas) AddFontFromFileTTFV(filename string, size_pixels float32, font_cfg *FontConfig, glyph_ranges *Wchar) *Font {
	selfArg, selfFin := self.Handle()
	filenameArg, filenameFin := internal.WrapString[C.char](filename)
	font_cfgArg, font_cfgFin := font_cfg.Handle()

	defer func() {
		selfFin()
		filenameFin()
		font_cfgFin()
	}()
	return NewFontFromC(C.ImFontAtlas_AddFontFromFileTTF(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), filenameArg, C.float(size_pixels), internal.ReinterpretCast[*C.ImFontConfig](font_cfgArg), (*C.ImWchar)(glyph_ranges)))
}

// 'compressed_font_data_base85' still owned by caller. Compress with binary_to_compressed_c.cpp with -base85 parameter.
// AddFontFromMemoryCompressedBase85TTFV parameter default value hint:
// size_pixels: 0.0f
// font_cfg: NULL
// glyph_ranges: NULL
func (self *FontAtlas) AddFontFromMemoryCompressedBase85TTFV(compressed_font_data_base85 string, size_pixels float32, font_cfg *FontConfig, glyph_ranges *Wchar) *Font {
	selfArg, selfFin := self.Handle()
	compressed_font_data_base85Arg, compressed_font_data_base85Fin := internal.WrapString[C.char](compressed_font_data_base85)
	font_cfgArg, font_cfgFin := font_cfg.Handle()

	defer func() {
		selfFin()
		compressed_font_data_base85Fin()
		font_cfgFin()
	}()
	return NewFontFromC(C.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), compressed_font_data_base85Arg, C.float(size_pixels), internal.ReinterpretCast[*C.ImFontConfig](font_cfgArg), (*C.ImWchar)(glyph_ranges)))
}

// 'compressed_font_data' still owned by caller. Compress with binary_to_compressed_c.cpp.
// AddFontFromMemoryCompressedTTFV parameter default value hint:
// size_pixels: 0.0f
// font_cfg: NULL
// glyph_ranges: NULL
func (self *FontAtlas) AddFontFromMemoryCompressedTTFV(compressed_font_data uintptr, compressed_font_data_size int32, size_pixels float32, font_cfg *FontConfig, glyph_ranges *Wchar) *Font {
	selfArg, selfFin := self.Handle()
	font_cfgArg, font_cfgFin := font_cfg.Handle()

	defer func() {
		selfFin()
		font_cfgFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontFromMemoryCompressedTTFV(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), C.uintptr_t(compressed_font_data), C.int(compressed_font_data_size), C.float(size_pixels), internal.ReinterpretCast[*C.ImFontConfig](font_cfgArg), (*C.ImWchar)(glyph_ranges)))
}

// Note: Transfer ownership of 'ttf_data' to ImFontAtlas! Will be deleted after destruction of the atlas. Set font_cfg->FontDataOwnedByAtlas=false to keep ownership of your data and it won't be freed.
// AddFontFromMemoryTTFV parameter default value hint:
// size_pixels: 0.0f
// font_cfg: NULL
// glyph_ranges: NULL
func (self *FontAtlas) AddFontFromMemoryTTFV(font_data uintptr, font_data_size int32, size_pixels float32, font_cfg *FontConfig, glyph_ranges *Wchar) *Font {
	selfArg, selfFin := self.Handle()
	font_cfgArg, font_cfgFin := font_cfg.Handle()

	defer func() {
		selfFin()
		font_cfgFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontFromMemoryTTFV(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), C.uintptr_t(font_data), C.int(font_data_size), C.float(size_pixels), internal.ReinterpretCast[*C.ImFontConfig](font_cfgArg), (*C.ImWchar)(glyph_ranges)))
}

// Clear everything (input fonts, output glyphs/textures)
func (self *FontAtlas) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlas_Clear(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	selfFin()
}

// [OBSOLETE] Clear input+output font data (same as ClearInputData() + glyphs storage, UV coordinates).
func (self *FontAtlas) ClearFonts() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlas_ClearFonts(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	selfFin()
}

// [OBSOLETE] Clear input data (all ImFontConfig structures including sizes, TTF data, glyph ranges, etc.) = all the data used to build the texture and fonts.
func (self *FontAtlas) ClearInputData() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlas_ClearInputData(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	selfFin()
}

// [OBSOLETE] Clear CPU-side copy of the texture data. Saves RAM once the texture has been copied to graphics memory.
func (self *FontAtlas) ClearTexData() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlas_ClearTexData(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	selfFin()
}

// Compact cached glyphs and texture.
func (self *FontAtlas) CompactCache() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlas_CompactCache(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	selfFin()
}

// Get rectangle coordinates for current texture. Valid immediately, never store this (read above)!
func (self *FontAtlas) CustomRect(id FontAtlasRectId, out_r *FontAtlasRect) bool {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()
	out_rArg, out_rFin := out_r.Handle()

	defer func() {
		selfFin()
		idFin()
		out_rFin()
	}()
	return C.ImFontAtlas_GetCustomRect(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), internal.ReinterpretCast[C.ImFontAtlasRectId](idArg), internal.ReinterpretCast[*C.ImFontAtlasRect](out_rArg)) == C.bool(true)
}

// Basic Latin, Extended Latin
func (self *FontAtlas) GlyphRangesDefault() *Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*Wchar)(C.ImFontAtlas_GetGlyphRangesDefault(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func NewFontAtlas() *FontAtlas {
	return NewFontAtlasFromC(C.ImFontAtlas_ImFontAtlas())
}

// Unregister a rectangle. Existing pixels will stay in texture until resized / garbage collected.
func (self *FontAtlas) RemoveCustomRect(id FontAtlasRectId) {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()
	C.ImFontAtlas_RemoveCustomRect(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), internal.ReinterpretCast[C.ImFontAtlasRectId](idArg))

	selfFin()
	idFin()
}

func (self *FontAtlas) RemoveFont(font *Font) {
	selfArg, selfFin := self.Handle()
	fontArg, fontFin := font.Handle()
	C.ImFontAtlas_RemoveFont(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), internal.ReinterpretCast[*C.ImFont](fontArg))

	selfFin()
	fontFin()
}

// Change font loader at runtime.
func (self *FontAtlas) SetFontLoader(font_loader *FontLoader) {
	selfArg, selfFin := self.Handle()
	font_loaderArg, font_loaderFin := font_loader.Handle()
	C.ImFontAtlas_SetFontLoader(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), internal.ReinterpretCast[*C.ImFontLoader](font_loaderArg))

	selfFin()
	font_loaderFin()
}

func (self *FontAtlas) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontAtlas_destroy(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	selfFin()
}

func (self *FontBaked) ClearOutputData() {
	selfArg, selfFin := self.Handle()
	C.ImFontBaked_ClearOutputData(internal.ReinterpretCast[*C.ImFontBaked](selfArg))

	selfFin()
}

// Return U+FFFD glyph if requested glyph doesn't exists.
func (self *FontBaked) FindGlyph(c Wchar) *FontGlyph {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontGlyphFromC(C.ImFontBaked_FindGlyph(internal.ReinterpretCast[*C.ImFontBaked](selfArg), C.ImWchar(c)))
}

// Return NULL if glyph doesn't exist
func (self *FontBaked) FindGlyphNoFallback(c Wchar) *FontGlyph {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontGlyphFromC(C.ImFontBaked_FindGlyphNoFallback(internal.ReinterpretCast[*C.ImFontBaked](selfArg), C.ImWchar(c)))
}

func (self *FontBaked) CharAdvance(c Wchar) float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.ImFontBaked_GetCharAdvance(internal.ReinterpretCast[*C.ImFontBaked](selfArg), C.ImWchar(c)))
}

func NewFontBaked() *FontBaked {
	return NewFontBakedFromC(C.ImFontBaked_ImFontBaked())
}

func (self *FontBaked) IsGlyphLoaded(c Wchar) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImFontBaked_IsGlyphLoaded(internal.ReinterpretCast[*C.ImFontBaked](selfArg), C.ImWchar(c)) == C.bool(true)
}

func (self *FontBaked) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontBaked_destroy(internal.ReinterpretCast[*C.ImFontBaked](selfArg))

	selfFin()
}

func NewFontConfig() *FontConfig {
	return NewFontConfigFromC(C.ImFontConfig_ImFontConfig())
}

func (self *FontConfig) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontConfig_destroy(internal.ReinterpretCast[*C.ImFontConfig](selfArg))

	selfFin()
}

// Add character
func (self *FontGlyphRangesBuilder) AddChar(c Wchar) {
	selfArg, selfFin := self.Handle()
	C.ImFontGlyphRangesBuilder_AddChar(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg), C.ImWchar(c))

	selfFin()
}

// Add ranges, e.g. builder.AddRanges(ImFontAtlas::GetGlyphRangesDefault()) to force add all of ASCII/Latin+Ext
func (self *FontGlyphRangesBuilder) AddRanges(ranges *Wchar) {
	selfArg, selfFin := self.Handle()
	C.ImFontGlyphRangesBuilder_AddRanges(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg), (*C.ImWchar)(ranges))

	selfFin()
}

// Add string (each character of the UTF-8 string are added)
// AddTextV parameter default value hint:
func (self *FontGlyphRangesBuilder) AddTextV(text string) {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_ImFontGlyphRangesBuilder_AddTextV(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg), textArg, C.int(len(text)))

	selfFin()
	textFin()
}

func (self *FontGlyphRangesBuilder) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImFontGlyphRangesBuilder_Clear(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg))

	selfFin()
}

// Get bit n in the array
func (self *FontGlyphRangesBuilder) Bit(n uint64) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImFontGlyphRangesBuilder_GetBit(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg), C.xulong(n)) == C.bool(true)
}

func NewFontGlyphRangesBuilder() *FontGlyphRangesBuilder {
	return NewFontGlyphRangesBuilderFromC(C.ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder())
}

// Set bit n in the array
func (self *FontGlyphRangesBuilder) SetBit(n uint64) {
	selfArg, selfFin := self.Handle()
	C.ImFontGlyphRangesBuilder_SetBit(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg), C.xulong(n))

	selfFin()
}

func (self *FontGlyphRangesBuilder) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontGlyphRangesBuilder_destroy(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg))

	selfFin()
}

func NewFontGlyph() *FontGlyph {
	return NewFontGlyphFromC(C.ImFontGlyph_ImFontGlyph())
}

func (self *FontGlyph) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontGlyph_destroy(internal.ReinterpretCast[*C.ImFontGlyph](selfArg))

	selfFin()
}

func InternalNewFontLoader() *FontLoader {
	return NewFontLoaderFromC(C.ImFontLoader_ImFontLoader())
}

func (self *FontLoader) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImFontLoader_destroy(internal.ReinterpretCast[*C.ImFontLoader](selfArg))

	selfFin()
}

// Makes 'from_codepoint' character points to 'to_codepoint' glyph.
func (self *Font) AddRemapChar(from_codepoint, to_codepoint Wchar) {
	selfArg, selfFin := self.Handle()
	C.ImFont_AddRemapChar(internal.ReinterpretCast[*C.ImFont](selfArg), C.ImWchar(from_codepoint), C.ImWchar(to_codepoint))

	selfFin()
}

// CalcTextSizeAV parameter default value hint:
// out_remaining: NULL
func (self *Font) CalcTextSizeAV(size, max_width, wrap_width float32, text_begin string, out_remaining []string) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	out_remainingArg, out_remainingFin := internal.WrapStringList[C.char](out_remaining)
	C.wrap_ImFont_CalcTextSizeAV(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImFont](selfArg), C.float(size), C.float(max_width), C.float(wrap_width), text_beginArg, out_remainingArg)

	pOutFin()
	selfFin()
	text_beginFin()
	out_remainingFin()

	return *pOut
}

func (self *Font) CalcWordWrapPosition(size float32, text string, wrap_width float32) string {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		selfFin()
		textFin()
	}()
	return C.GoString(C.wrap_ImFont_CalcWordWrapPosition(internal.ReinterpretCast[*C.ImFont](selfArg), C.float(size), textArg, C.int(len(text)), C.float(wrap_width)))
}

func (self *Font) ClearOutputData() {
	selfArg, selfFin := self.Handle()
	C.ImFont_ClearOutputData(internal.ReinterpretCast[*C.ImFont](selfArg))

	selfFin()
}

// Fill ImFontConfig::Name.
func (self *Font) DebugName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImFont_GetDebugName(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

// Get or create baked data for given size
// FontBakedV parameter default value hint:
// density: -1.0f
func (self *Font) FontBakedV(font_size, density float32) *FontBaked {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontBakedFromC(C.ImFont_GetFontBaked(internal.ReinterpretCast[*C.ImFont](selfArg), C.float(font_size), C.float(density)))
}

func NewFont() *Font {
	return NewFontFromC(C.ImFont_ImFont())
}

func (self *Font) IsGlyphInFont(c Wchar) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImFont_IsGlyphInFont(internal.ReinterpretCast[*C.ImFont](selfArg), C.ImWchar(c)) == C.bool(true)
}

func (self *Font) IsGlyphRangeUnused(c_begin, c_last uint32) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImFont_IsGlyphRangeUnused(internal.ReinterpretCast[*C.ImFont](selfArg), C.uint(c_begin), C.uint(c_last)) == C.bool(true)
}

func (self *Font) IsLoaded() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImFont_IsLoaded(internal.ReinterpretCast[*C.ImFont](selfArg)) == C.bool(true)
}

// RenderCharV parameter default value hint:
// cpu_fine_clip: NULL
func (self *Font) RenderCharV(draw_list *DrawList, size float32, pos Vec2, col uint32, c Wchar, cpu_fine_clip *Vec4) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	cpu_fine_clipArg, cpu_fine_clipFin := internal.Wrap(cpu_fine_clip)
	C.ImFont_RenderChar(internal.ReinterpretCast[*C.ImFont](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.float(size), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), C.ImWchar(c), internal.ReinterpretCast[*C.ImVec4](cpu_fine_clipArg))

	selfFin()
	draw_listFin()
	cpu_fine_clipFin()
}

// RenderTextV parameter default value hint:
// wrap_width: 0.0f
// flags: 0
func (self *Font) RenderTextV(draw_list *DrawList, size float32, pos Vec2, col uint32, clip_rect Vec4, text_begin string, wrap_width float32, flags DrawTextFlags) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImFont_RenderTextV(internal.ReinterpretCast[*C.ImFont](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.float(size), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), internal.ReinterpretCast[C.ImVec4](clip_rect.ToC()), text_beginArg, C.float(wrap_width), C.ImDrawTextFlags(flags))

	selfFin()
	draw_listFin()
	text_beginFin()
}

func (self *Font) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImFont_destroy(internal.ReinterpretCast[*C.ImFont](selfArg))

	selfFin()
}

func InternalNewBoxSelectState() *BoxSelectState {
	return NewBoxSelectStateFromC(C.ImGuiBoxSelectState_ImGuiBoxSelectState())
}

func (self *BoxSelectState) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiBoxSelectState_destroy(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))

	selfFin()
}

func InternalNewComboPreviewData() *ComboPreviewData {
	return NewComboPreviewDataFromC(C.ImGuiComboPreviewData_ImGuiComboPreviewData())
}

func (self *ComboPreviewData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiComboPreviewData_destroy(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg))

	selfFin()
}

func InternalNewContextHook() *ContextHook {
	return NewContextHookFromC(C.ImGuiContextHook_ImGuiContextHook())
}

func (self *ContextHook) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiContextHook_destroy(internal.ReinterpretCast[*C.ImGuiContextHook](selfArg))

	selfFin()
}

func InternalNewContext(shared_font_atlas *FontAtlas) *Context {
	shared_font_atlasArg, shared_font_atlasFin := shared_font_atlas.Handle()

	defer func() {
		shared_font_atlasFin()
	}()
	return NewContextFromC(C.ImGuiContext_ImGuiContext(internal.ReinterpretCast[*C.ImFontAtlas](shared_font_atlasArg)))
}

func (self *Context) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiContext_destroy(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	selfFin()
}

func InternalNewDebugAllocInfo() *DebugAllocInfo {
	return NewDebugAllocInfoFromC(C.ImGuiDebugAllocInfo_ImGuiDebugAllocInfo())
}

func (self *DebugAllocInfo) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiDebugAllocInfo_destroy(internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](selfArg))

	selfFin()
}

func InternalNewDockContext() *DockContext {
	return NewDockContextFromC(C.ImGuiDockContext_ImGuiDockContext())
}

func (self *DockContext) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiDockContext_destroy(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg))

	selfFin()
}

func InternalNewDockNode(id ID) *DockNode {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewDockNodeFromC(C.ImGuiDockNode_ImGuiDockNode(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func (self *DockNode) InternalIsCentralNode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsCentralNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalIsDockSpace() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsDockSpace(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalIsEmpty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsEmpty(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalIsFloatingNode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsFloatingNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

// Hidden tab bar can be shown back by clicking the small triangle
func (self *DockNode) InternalIsHiddenTabBar() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsHiddenTabBar(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalIsLeafNode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsLeafNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

// Never show a tab bar
func (self *DockNode) InternalIsNoTabBar() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsNoTabBar(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalIsRootNode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsRootNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalIsSplitNode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiDockNode_IsSplitNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) InternalRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiDockNode_Rect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *DockNode) InternalSetLocalFlags(flags DockNodeFlags) {
	selfArg, selfFin := self.Handle()
	C.ImGuiDockNode_SetLocalFlags(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg), C.ImGuiDockNodeFlags(flags))

	selfFin()
}

func (self *DockNode) InternalUpdateMergedFlags() {
	selfArg, selfFin := self.Handle()
	C.ImGuiDockNode_UpdateMergedFlags(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	selfFin()
}

func (self *DockNode) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiDockNode_destroy(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	selfFin()
}

func InternalNewErrorRecoveryState() *ErrorRecoveryState {
	return NewErrorRecoveryStateFromC(C.ImGuiErrorRecoveryState_ImGuiErrorRecoveryState())
}

func (self *ErrorRecoveryState) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiErrorRecoveryState_destroy(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg))

	selfFin()
}

func InternalNewIDStackTool() *IDStackTool {
	return NewIDStackToolFromC(C.ImGuiIDStackTool_ImGuiIDStackTool())
}

func (self *IDStackTool) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiIDStackTool_destroy(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg))

	selfFin()
}

// Queue a gain/loss of focus for the application (generally based on OS/platform focus of your window)
func (self *IO) AddFocusEvent(focused bool) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddFocusEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.bool(focused))

	selfFin()
}

// Queue a new character input
func (self *IO) AddInputCharacter(c uint32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddInputCharacter(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.uint(c))

	selfFin()
}

// Queue a new character input from a UTF-16 character, it can be a surrogate
func (self *IO) AddInputCharacterUTF16(c uint16) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddInputCharacterUTF16(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.ImWchar16(c))

	selfFin()
}

// Queue a new characters input from a UTF-8 string
func (self *IO) AddInputCharactersUTF8(str string) {
	selfArg, selfFin := self.Handle()
	strArg, strFin := internal.WrapString[C.char](str)
	C.ImGuiIO_AddInputCharactersUTF8(internal.ReinterpretCast[*C.ImGuiIO](selfArg), strArg)

	selfFin()
	strFin()
}

// Queue a new key down/up event for analog values (e.g. ImGuiKey_Gamepad_ values). Dead-zones should be handled by the backend.
func (self *IO) AddKeyAnalogEvent(key Key, down bool, v float32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddKeyAnalogEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.ImGuiKey(key), C.bool(down), C.float(v))

	selfFin()
}

// Queue a new key down/up event. Key should be "translated" (as in, generally ImGuiKey_A matches the key end-user would use to emit an 'A' character)
func (self *IO) AddKeyEvent(key Key, down bool) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddKeyEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.ImGuiKey(key), C.bool(down))

	selfFin()
}

// Queue a mouse button change
func (self *IO) AddMouseButtonEvent(button int32, down bool) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddMouseButtonEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.int(button), C.bool(down))

	selfFin()
}

// Queue a mouse position update. Use -FLT_MAX,-FLT_MAX to signify no mouse (e.g. app not focused and not hovered)
func (self *IO) AddMousePosEvent(x, y float32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddMousePosEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.float(x), C.float(y))

	selfFin()
}

// Queue a mouse source change (Mouse/TouchScreen/Pen)
func (self *IO) AddMouseSourceEvent(source MouseSource) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddMouseSourceEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.ImGuiMouseSource(source))

	selfFin()
}

// Queue a mouse hovered viewport. Requires backend to set ImGuiBackendFlags_HasMouseHoveredViewport to call this (for multi-viewport support).
func (self *IO) AddMouseViewportEvent(id ID) {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()
	C.ImGuiIO_AddMouseViewportEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), internal.ReinterpretCast[C.ImGuiID](idArg))

	selfFin()
	idFin()
}

// Queue a mouse wheel update. wheel_y<0: scroll down, wheel_y>0: scroll up, wheel_x<0: scroll right, wheel_x>0: scroll left.
func (self *IO) AddMouseWheelEvent(wheel_x, wheel_y float32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_AddMouseWheelEvent(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.float(wheel_x), C.float(wheel_y))

	selfFin()
}

// Clear all incoming events.
func (self *IO) ClearEventsQueue() {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_ClearEventsQueue(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	selfFin()
}

// Clear current keyboard/gamepad state + current frame text input buffer. Equivalent to releasing all keys/buttons.
func (self *IO) ClearInputKeys() {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_ClearInputKeys(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	selfFin()
}

// Clear current mouse state.
func (self *IO) ClearInputMouse() {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_ClearInputMouse(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	selfFin()
}

func NewIO() *IO {
	return NewIOFromC(C.ImGuiIO_ImGuiIO())
}

// Set master flag for accepting key/mouse/text events (default to true). Useful if you have native dialog boxes that are interrupting your application loop/refresh, and you want to disable events being queued while your app is frozen.
func (self *IO) SetAppAcceptingEvents(accepting_events bool) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_SetAppAcceptingEvents(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.bool(accepting_events))

	selfFin()
}

// [Optional] Specify index for legacy <1.87 IsKeyXXX() functions with native indices + specify native keycode, scancode.
// SetKeyEventNativeDataV parameter default value hint:
// native_legacy_index: -1
func (self *IO) SetKeyEventNativeDataV(key Key, native_keycode, native_scancode, native_legacy_index int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_SetKeyEventNativeData(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.ImGuiKey(key), C.int(native_keycode), C.int(native_scancode), C.int(native_legacy_index))

	selfFin()
}

func (self *IO) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiIO_destroy(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	selfFin()
}

func InternalNewInputEvent() *InputEvent {
	return NewInputEventFromC(C.ImGuiInputEvent_ImGuiInputEvent())
}

func (self *InputEvent) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputEvent_destroy(internal.ReinterpretCast[*C.ImGuiInputEvent](selfArg))

	selfFin()
}

func (self *InputTextCallbackData) ClearSelection() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextCallbackData_ClearSelection(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg))

	selfFin()
}

func (self *InputTextCallbackData) DeleteChars(pos, bytes_count int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextCallbackData_DeleteChars(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg), C.int(pos), C.int(bytes_count))

	selfFin()
}

func (self *InputTextCallbackData) HasSelection() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiInputTextCallbackData_HasSelection(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)) == C.bool(true)
}

func NewInputTextCallbackData() *InputTextCallbackData {
	return NewInputTextCallbackDataFromC(C.ImGuiInputTextCallbackData_ImGuiInputTextCallbackData())
}

// InsertCharsV parameter default value hint:
func (self *InputTextCallbackData) InsertCharsV(pos int32, text string) {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_ImGuiInputTextCallbackData_InsertCharsV(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg), C.int(pos), textArg, C.int(len(text)))

	selfFin()
	textFin()
}

func (self *InputTextCallbackData) SelectAll() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextCallbackData_SelectAll(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg))

	selfFin()
}

func (self *InputTextCallbackData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextCallbackData_destroy(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg))

	selfFin()
}

func (self *InputTextDeactivatedState) InternalClearFreeMemory() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextDeactivatedState_ClearFreeMemory(internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](selfArg))

	selfFin()
}

func InternalNewInputTextDeactivatedState() *InputTextDeactivatedState {
	return NewInputTextDeactivatedStateFromC(C.ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState())
}

func (self *InputTextDeactivatedState) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextDeactivatedState_destroy(internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalClearFreeMemory() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_ClearFreeMemory(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalClearSelection() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_ClearSelection(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalClearText() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_ClearText(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalCursorAnimReset() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_CursorAnimReset(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalCursorClamp() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_CursorClamp(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalCursorPos() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImGuiInputTextState_GetCursorPos(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) InternalPreferredOffsetX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.ImGuiInputTextState_GetPreferredOffsetX(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) InternalSelectionEnd() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImGuiInputTextState_GetSelectionEnd(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) InternalSelectionStart() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImGuiInputTextState_GetSelectionStart(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) InternalHasSelection() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiInputTextState_HasSelection(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)) == C.bool(true)
}

func InternalNewInputTextState() *InputTextState {
	return NewInputTextStateFromC(C.ImGuiInputTextState_ImGuiInputTextState())
}

func (self *InputTextState) InternalOnCharPressed(c uint32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_OnCharPressed(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg), C.uint(c))

	selfFin()
}

// Cannot be inline because we call in code in stb_textedit.h implementation
func (self *InputTextState) InternalOnKeyPressed(key int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_OnKeyPressed(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg), C.int(key))

	selfFin()
}

func (self *InputTextState) InternalReloadUserBufAndKeepSelection() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_ReloadUserBufAndKeepSelection(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalReloadUserBufAndMoveToEnd() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_ReloadUserBufAndMoveToEnd(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalReloadUserBufAndSelectAll() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_ReloadUserBufAndSelectAll(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalSelectAll() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_SelectAll(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func (self *InputTextState) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiInputTextState_destroy(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	selfFin()
}

func InternalNewKeyOwnerData() *KeyOwnerData {
	return NewKeyOwnerDataFromC(C.ImGuiKeyOwnerData_ImGuiKeyOwnerData())
}

func (self *KeyOwnerData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiKeyOwnerData_destroy(internal.ReinterpretCast[*C.ImGuiKeyOwnerData](selfArg))

	selfFin()
}

func InternalNewKeyRoutingData() *KeyRoutingData {
	return NewKeyRoutingDataFromC(C.ImGuiKeyRoutingData_ImGuiKeyRoutingData())
}

func (self *KeyRoutingData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiKeyRoutingData_destroy(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg))

	selfFin()
}

func (self *KeyRoutingTable) InternalClear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiKeyRoutingTable_Clear(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg))

	selfFin()
}

func InternalNewKeyRoutingTable() *KeyRoutingTable {
	return NewKeyRoutingTableFromC(C.ImGuiKeyRoutingTable_ImGuiKeyRoutingTable())
}

func (self *KeyRoutingTable) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiKeyRoutingTable_destroy(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg))

	selfFin()
}

func InternalNewLastItemData() *LastItemData {
	return NewLastItemDataFromC(C.ImGuiLastItemData_ImGuiLastItemData())
}

func (self *LastItemData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiLastItemData_destroy(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))

	selfFin()
}

func InternalNewListClipperData() *ListClipperData {
	return NewListClipperDataFromC(C.ImGuiListClipperData_ImGuiListClipperData())
}

func (self *ListClipperData) InternalReset(clipper *ListClipper) {
	selfArg, selfFin := self.Handle()
	clipperArg, clipperFin := clipper.Handle()
	C.ImGuiListClipperData_Reset(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg), internal.ReinterpretCast[*C.ImGuiListClipper](clipperArg))

	selfFin()
	clipperFin()
}

func (self *ListClipperData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipperData_destroy(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg))

	selfFin()
}

func InternalListClipperRangeFromIndices(min, max int32) ListClipperRange {
	return *NewListClipperRangeFromC(func() *C.ImGuiListClipperRange {
		result := C.ImGuiListClipperRange_FromIndices(C.int(min), C.int(max))
		return &result
	}())
}

func InternalListClipperRangeFromPositions(y1, y2 float32, off_min, off_max int32) ListClipperRange {
	return *NewListClipperRangeFromC(func() *C.ImGuiListClipperRange {
		result := C.ImGuiListClipperRange_FromPositions(C.float(y1), C.float(y2), C.int(off_min), C.int(off_max))
		return &result
	}())
}

// BeginV parameter default value hint:
// items_height: -1.0f
func (self *ListClipper) BeginV(items_count int32, items_height float32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipper_Begin(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg), C.int(items_count), C.float(items_height))

	selfFin()
}

// Automatically called on the last call of Step() that returns false.
func (self *ListClipper) End() {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipper_End(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg))

	selfFin()
}

func NewListClipper() *ListClipper {
	return NewListClipperFromC(C.ImGuiListClipper_ImGuiListClipper())
}

func (self *ListClipper) IncludeItemByIndex(item_index int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipper_IncludeItemByIndex(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg), C.int(item_index))

	selfFin()
}

// item_end is exclusive e.g. use (42, 42+1) to make item 42 never clipped.
func (self *ListClipper) IncludeItemsByIndex(item_begin, item_end int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipper_IncludeItemsByIndex(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg), C.int(item_begin), C.int(item_end))

	selfFin()
}

func (self *ListClipper) SeekCursorForItem(item_index int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipper_SeekCursorForItem(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg), C.int(item_index))

	selfFin()
}

// Call until it returns false. The DisplayStart/DisplayEnd fields will be set and you can process/draw those items.
func (self *ListClipper) Step() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiListClipper_Step(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)) == C.bool(true)
}

func (self *ListClipper) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiListClipper_destroy(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg))

	selfFin()
}

func (self *MenuColumns) InternalCalcNextTotalWidth(update_offsets bool) {
	selfArg, selfFin := self.Handle()
	C.ImGuiMenuColumns_CalcNextTotalWidth(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg), C.bool(update_offsets))

	selfFin()
}

func (self *MenuColumns) InternalDeclColumns(w_icon, w_label, w_shortcut, w_mark float32) float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.ImGuiMenuColumns_DeclColumns(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg), C.float(w_icon), C.float(w_label), C.float(w_shortcut), C.float(w_mark)))
}

func InternalNewMenuColumns() *MenuColumns {
	return NewMenuColumnsFromC(C.ImGuiMenuColumns_ImGuiMenuColumns())
}

func (self *MenuColumns) InternalUpdate(spacing float32, window_reappearing bool) {
	selfArg, selfFin := self.Handle()
	C.ImGuiMenuColumns_Update(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg), C.float(spacing), C.bool(window_reappearing))

	selfFin()
}

func (self *MenuColumns) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiMenuColumns_destroy(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg))

	selfFin()
}

func InternalNewMultiSelectState() *MultiSelectState {
	return NewMultiSelectStateFromC(C.ImGuiMultiSelectState_ImGuiMultiSelectState())
}

func (self *MultiSelectState) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiMultiSelectState_destroy(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg))

	selfFin()
}

// Zero-clear except IO as we preserve IO.Requests[] buffer allocation.
func (self *MultiSelectTempData) InternalClear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiMultiSelectTempData_Clear(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	selfFin()
}

func (self *MultiSelectTempData) InternalClearIO() {
	selfArg, selfFin := self.Handle()
	C.ImGuiMultiSelectTempData_ClearIO(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	selfFin()
}

func InternalNewMultiSelectTempData() *MultiSelectTempData {
	return NewMultiSelectTempDataFromC(C.ImGuiMultiSelectTempData_ImGuiMultiSelectTempData())
}

func (self *MultiSelectTempData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiMultiSelectTempData_destroy(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	selfFin()
}

func (self *NavItemData) InternalClear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiNavItemData_Clear(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg))

	selfFin()
}

func InternalNewNavItemData() *NavItemData {
	return NewNavItemDataFromC(C.ImGuiNavItemData_ImGuiNavItemData())
}

func (self *NavItemData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiNavItemData_destroy(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg))

	selfFin()
}

// Also cleared manually by ItemAdd()!
func (self *NextItemData) InternalClearFlags() {
	selfArg, selfFin := self.Handle()
	C.ImGuiNextItemData_ClearFlags(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	selfFin()
}

func InternalNewNextItemData() *NextItemData {
	return NewNextItemDataFromC(C.ImGuiNextItemData_ImGuiNextItemData())
}

func (self *NextItemData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiNextItemData_destroy(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	selfFin()
}

func (self *NextWindowData) InternalClearFlags() {
	selfArg, selfFin := self.Handle()
	C.ImGuiNextWindowData_ClearFlags(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))

	selfFin()
}

func InternalNewNextWindowData() *NextWindowData {
	return NewNextWindowDataFromC(C.ImGuiNextWindowData_ImGuiNextWindowData())
}

func (self *NextWindowData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiNextWindowData_destroy(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))

	selfFin()
}

func InternalNewOldColumnData() *OldColumnData {
	return NewOldColumnDataFromC(C.ImGuiOldColumnData_ImGuiOldColumnData())
}

func (self *OldColumnData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiOldColumnData_destroy(internal.ReinterpretCast[*C.ImGuiOldColumnData](selfArg))

	selfFin()
}

func InternalNewOldColumns() *OldColumns {
	return NewOldColumnsFromC(C.ImGuiOldColumns_ImGuiOldColumns())
}

func (self *OldColumns) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiOldColumns_destroy(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg))

	selfFin()
}

func NewOnceUponAFrame() *OnceUponAFrame {
	return NewOnceUponAFrameFromC(C.ImGuiOnceUponAFrame_ImGuiOnceUponAFrame())
}

func (self *OnceUponAFrame) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiOnceUponAFrame_destroy(internal.ReinterpretCast[*C.ImGuiOnceUponAFrame](selfArg))

	selfFin()
}

func (self *Payload) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPayload_Clear(internal.ReinterpretCast[*C.ImGuiPayload](selfArg))

	selfFin()
}

func NewPayload() *Payload {
	return NewPayloadFromC(C.ImGuiPayload_ImGuiPayload())
}

func (self *Payload) IsDataType(typeArg string) bool {
	selfArg, selfFin := self.Handle()
	typeArgArg, typeArgFin := internal.WrapString[C.char](typeArg)

	defer func() {
		selfFin()
		typeArgFin()
	}()
	return C.ImGuiPayload_IsDataType(internal.ReinterpretCast[*C.ImGuiPayload](selfArg), typeArgArg) == C.bool(true)
}

func (self *Payload) IsDelivery() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiPayload_IsDelivery(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)) == C.bool(true)
}

func (self *Payload) IsPreview() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiPayload_IsPreview(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)) == C.bool(true)
}

func (self *Payload) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPayload_destroy(internal.ReinterpretCast[*C.ImGuiPayload](selfArg))

	selfFin()
}

// Clear all Platform_XXX fields. Typically called on Platform Backend shutdown.
func (self *PlatformIO) ClearPlatformHandlers() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPlatformIO_ClearPlatformHandlers(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg))

	selfFin()
}

// Clear all Renderer_XXX fields. Typically called on Renderer Backend shutdown.
func (self *PlatformIO) ClearRendererHandlers() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPlatformIO_ClearRendererHandlers(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg))

	selfFin()
}

func NewPlatformIO() *PlatformIO {
	return NewPlatformIOFromC(C.ImGuiPlatformIO_ImGuiPlatformIO())
}

func (self *PlatformIO) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPlatformIO_destroy(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg))

	selfFin()
}

func NewPlatformImeData() *PlatformImeData {
	return NewPlatformImeDataFromC(C.ImGuiPlatformImeData_ImGuiPlatformImeData())
}

func (self *PlatformImeData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPlatformImeData_destroy(internal.ReinterpretCast[*C.ImGuiPlatformImeData](selfArg))

	selfFin()
}

func NewPlatformMonitor() *PlatformMonitor {
	return NewPlatformMonitorFromC(C.ImGuiPlatformMonitor_ImGuiPlatformMonitor())
}

func (self *PlatformMonitor) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPlatformMonitor_destroy(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg))

	selfFin()
}

func InternalNewPopupData() *PopupData {
	return NewPopupDataFromC(C.ImGuiPopupData_ImGuiPopupData())
}

func (self *PopupData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPopupData_destroy(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg))

	selfFin()
}

func InternalNewPtrOrIndexInt(index int32) *PtrOrIndex {
	return NewPtrOrIndexFromC(C.ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(C.int(index)))
}

func InternalNewPtrOrIndexPtr(ptr uintptr) *PtrOrIndex {
	return NewPtrOrIndexFromC(C.wrap_ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr(C.uintptr_t(ptr)))
}

func (self *PtrOrIndex) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiPtrOrIndex_destroy(internal.ReinterpretCast[*C.ImGuiPtrOrIndex](selfArg))

	selfFin()
}

// Apply selection requests coming from BeginMultiSelect() and EndMultiSelect() functions. It uses 'items_count' passed to BeginMultiSelect()
func (self *SelectionBasicStorage) ApplyRequests(ms_io *MultiSelectIO) {
	selfArg, selfFin := self.Handle()
	ms_ioArg, ms_ioFin := ms_io.Handle()
	C.ImGuiSelectionBasicStorage_ApplyRequests(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg), internal.ReinterpretCast[*C.ImGuiMultiSelectIO](ms_ioArg))

	selfFin()
	ms_ioFin()
}

// Clear selection
func (self *SelectionBasicStorage) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiSelectionBasicStorage_Clear(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg))

	selfFin()
}

// Query if an item id is in selection.
func (self *SelectionBasicStorage) Contains(id ID) bool {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()

	defer func() {
		selfFin()
		idFin()
	}()
	return C.ImGuiSelectionBasicStorage_Contains(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](idArg)) == C.bool(true)
}

// Convert index to item id based on provided adapter.
func (self *SelectionBasicStorage) StorageIdFromIndex(idx int32) ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.ImGuiSelectionBasicStorage_GetStorageIdFromIndex(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg), C.int(idx))
		return &result
	}())
}

func NewSelectionBasicStorage() *SelectionBasicStorage {
	return NewSelectionBasicStorageFromC(C.ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage())
}

// Add/remove an item from selection (generally done by ApplyRequests() function)
func (self *SelectionBasicStorage) SetItemSelected(id ID, selected bool) {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()
	C.ImGuiSelectionBasicStorage_SetItemSelected(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](idArg), C.bool(selected))

	selfFin()
	idFin()
}

// Swap two selections
func (self *SelectionBasicStorage) Swap(r *SelectionBasicStorage) {
	selfArg, selfFin := self.Handle()
	rArg, rFin := r.Handle()
	C.ImGuiSelectionBasicStorage_Swap(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg), internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](rArg))

	selfFin()
	rFin()
}

func (self *SelectionBasicStorage) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiSelectionBasicStorage_destroy(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg))

	selfFin()
}

// Apply selection requests by using AdapterSetItemSelected() calls
func (self *SelectionExternalStorage) ApplyRequests(ms_io *MultiSelectIO) {
	selfArg, selfFin := self.Handle()
	ms_ioArg, ms_ioFin := ms_io.Handle()
	C.ImGuiSelectionExternalStorage_ApplyRequests(internal.ReinterpretCast[*C.ImGuiSelectionExternalStorage](selfArg), internal.ReinterpretCast[*C.ImGuiMultiSelectIO](ms_ioArg))

	selfFin()
	ms_ioFin()
}

func NewSelectionExternalStorage() *SelectionExternalStorage {
	return NewSelectionExternalStorageFromC(C.ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage())
}

func (self *SelectionExternalStorage) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiSelectionExternalStorage_destroy(internal.ReinterpretCast[*C.ImGuiSelectionExternalStorage](selfArg))

	selfFin()
}

func InternalNewSettingsHandler() *SettingsHandler {
	return NewSettingsHandlerFromC(C.ImGuiSettingsHandler_ImGuiSettingsHandler())
}

func (self *SettingsHandler) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiSettingsHandler_destroy(internal.ReinterpretCast[*C.ImGuiSettingsHandler](selfArg))

	selfFin()
}

func InternalNewStackLevelInfo() *StackLevelInfo {
	return NewStackLevelInfoFromC(C.ImGuiStackLevelInfo_ImGuiStackLevelInfo())
}

func (self *StackLevelInfo) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiStackLevelInfo_destroy(internal.ReinterpretCast[*C.ImGuiStackLevelInfo](selfArg))

	selfFin()
}

func NewStoragePairFloat(_key ID, _val float32) *StoragePair {
	_keyArg, _keyFin := _key.C()

	defer func() {
		_keyFin()
	}()
	return NewStoragePairFromC(C.ImGuiStoragePair_ImGuiStoragePair_Float(internal.ReinterpretCast[C.ImGuiID](_keyArg), C.float(_val)))
}

func NewStoragePairInt(_key ID, _val int32) *StoragePair {
	_keyArg, _keyFin := _key.C()

	defer func() {
		_keyFin()
	}()
	return NewStoragePairFromC(C.ImGuiStoragePair_ImGuiStoragePair_Int(internal.ReinterpretCast[C.ImGuiID](_keyArg), C.int(_val)))
}

func NewStoragePairPtr(_key ID, _val uintptr) *StoragePair {
	_keyArg, _keyFin := _key.C()

	defer func() {
		_keyFin()
	}()
	return NewStoragePairFromC(C.wrap_ImGuiStoragePair_ImGuiStoragePair_Ptr(internal.ReinterpretCast[C.ImGuiID](_keyArg), C.uintptr_t(_val)))
}

func (self *StoragePair) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiStoragePair_destroy(internal.ReinterpretCast[*C.ImGuiStoragePair](selfArg))

	selfFin()
}

func (self *Storage) BuildSortByKey() {
	selfArg, selfFin := self.Handle()
	C.ImGuiStorage_BuildSortByKey(internal.ReinterpretCast[*C.ImGuiStorage](selfArg))

	selfFin()
}

func (self *Storage) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiStorage_Clear(internal.ReinterpretCast[*C.ImGuiStorage](selfArg))

	selfFin()
}

// BoolV parameter default value hint:
// default_val: false
func (self *Storage) BoolV(key ID, default_val bool) bool {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return C.ImGuiStorage_GetBool(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.bool(default_val)) == C.bool(true)
}

// BoolRefV parameter default value hint:
// default_val: false
func (self *Storage) BoolRefV(key ID, default_val bool) *bool {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return (*bool)(C.ImGuiStorage_GetBoolRef(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.bool(default_val)))
}

// FloatV parameter default value hint:
// default_val: 0.0f
func (self *Storage) FloatV(key ID, default_val float32) float32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return float32(C.ImGuiStorage_GetFloat(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.float(default_val)))
}

// FloatRefV parameter default value hint:
// default_val: 0.0f
func (self *Storage) FloatRefV(key ID, default_val float32) *float32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return (*float32)(C.ImGuiStorage_GetFloatRef(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.float(default_val)))
}

// IntV parameter default value hint:
// default_val: 0
func (self *Storage) IntV(key ID, default_val int32) int32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return int32(C.ImGuiStorage_GetInt(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.int(default_val)))
}

// IntRefV parameter default value hint:
// default_val: 0
func (self *Storage) IntRefV(key ID, default_val int32) *int32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return (*int32)(C.ImGuiStorage_GetIntRef(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.int(default_val)))
}

// default_val is NULL
func (self *Storage) VoidPtr(key ID) uintptr {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return uintptr(C.wrap_ImGuiStorage_GetVoidPtr(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func (self *Storage) SetAllInt(val int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiStorage_SetAllInt(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), C.int(val))

	selfFin()
}

func (self *Storage) SetBool(key ID, val bool) {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()
	C.ImGuiStorage_SetBool(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.bool(val))

	selfFin()
	keyFin()
}

func (self *Storage) SetFloat(key ID, val float32) {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()
	C.ImGuiStorage_SetFloat(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.float(val))

	selfFin()
	keyFin()
}

func (self *Storage) SetInt(key ID, val int32) {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()
	C.ImGuiStorage_SetInt(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.int(val))

	selfFin()
	keyFin()
}

func (self *Storage) SetVoidPtr(key ID, val uintptr) {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()
	C.wrap_ImGuiStorage_SetVoidPtr(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg), C.uintptr_t(val))

	selfFin()
	keyFin()
}

func InternalNewStyleModFloat(idx StyleVar, v float32) *StyleMod {
	return NewStyleModFromC(C.ImGuiStyleMod_ImGuiStyleMod_Float(C.ImGuiStyleVar(idx), C.float(v)))
}

func InternalNewStyleModInt(idx StyleVar, v int32) *StyleMod {
	return NewStyleModFromC(C.ImGuiStyleMod_ImGuiStyleMod_Int(C.ImGuiStyleVar(idx), C.int(v)))
}

func InternalNewStyleModVec2(idx StyleVar, v Vec2) *StyleMod {
	return NewStyleModFromC(C.ImGuiStyleMod_ImGuiStyleMod_Vec2(C.ImGuiStyleVar(idx), internal.ReinterpretCast[C.ImVec2](v.ToC())))
}

func (self *StyleMod) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiStyleMod_destroy(internal.ReinterpretCast[*C.ImGuiStyleMod](selfArg))

	selfFin()
}

func (self *StyleVarInfo) InternalVarPtr(parent uintptr) uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiStyleVarInfo_GetVarPtr(internal.ReinterpretCast[*C.ImGuiStyleVarInfo](selfArg), C.uintptr_t(parent)))
}

func NewStyle() *Style {
	return NewStyleFromC(C.ImGuiStyle_ImGuiStyle())
}

// Scale all spacing/padding/thickness values. Do not scale fonts.
func (self *Style) ScaleAllSizes(scale_factor float32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiStyle_ScaleAllSizes(internal.ReinterpretCast[*C.ImGuiStyle](selfArg), C.float(scale_factor))

	selfFin()
}

func (self *Style) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiStyle_destroy(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))

	selfFin()
}

func InternalNewTabBar() *TabBar {
	return NewTabBarFromC(C.ImGuiTabBar_ImGuiTabBar())
}

func (self *TabBar) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTabBar_destroy(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	selfFin()
}

func InternalNewTabItem() *TabItem {
	return NewTabItemFromC(C.ImGuiTabItem_ImGuiTabItem())
}

func (self *TabItem) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTabItem_destroy(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg))

	selfFin()
}

func InternalNewTableColumnSettings() *TableColumnSettings {
	return NewTableColumnSettingsFromC(C.ImGuiTableColumnSettings_ImGuiTableColumnSettings())
}

func (self *TableColumnSettings) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableColumnSettings_destroy(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg))

	selfFin()
}

func NewTableColumnSortSpecs() *TableColumnSortSpecs {
	return NewTableColumnSortSpecsFromC(C.ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs())
}

func (self *TableColumnSortSpecs) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableColumnSortSpecs_destroy(internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](selfArg))

	selfFin()
}

func InternalNewTableColumn() *TableColumn {
	return NewTableColumnFromC(C.ImGuiTableColumn_ImGuiTableColumn())
}

func (self *TableColumn) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableColumn_destroy(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	selfFin()
}

func InternalNewTableInstanceData() *TableInstanceData {
	return NewTableInstanceDataFromC(C.ImGuiTableInstanceData_ImGuiTableInstanceData())
}

func (self *TableInstanceData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableInstanceData_destroy(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg))

	selfFin()
}

func (self *TableSettings) InternalColumnSettings() *TableColumnSettings {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTableColumnSettingsFromC(C.ImGuiTableSettings_GetColumnSettings(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg)))
}

func InternalNewTableSettings() *TableSettings {
	return NewTableSettingsFromC(C.ImGuiTableSettings_ImGuiTableSettings())
}

func (self *TableSettings) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableSettings_destroy(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg))

	selfFin()
}

func NewTableSortSpecs() *TableSortSpecs {
	return NewTableSortSpecsFromC(C.ImGuiTableSortSpecs_ImGuiTableSortSpecs())
}

func (self *TableSortSpecs) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableSortSpecs_destroy(internal.ReinterpretCast[*C.ImGuiTableSortSpecs](selfArg))

	selfFin()
}

func InternalNewTableTempData() *TableTempData {
	return NewTableTempDataFromC(C.ImGuiTableTempData_ImGuiTableTempData())
}

func (self *TableTempData) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTableTempData_destroy(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))

	selfFin()
}

func InternalNewTable() *Table {
	return NewTableFromC(C.ImGuiTable_ImGuiTable())
}

func (self *Table) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTable_destroy(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	selfFin()
}

func NewTextBuffer() *TextBuffer {
	return NewTextBufferFromC(C.ImGuiTextBuffer_ImGuiTextBuffer())
}

// AppendV parameter default value hint:
// str_end: NULL
func (self *TextBuffer) AppendV(str, str_end string) {
	selfArg, selfFin := self.Handle()
	strArg, strFin := internal.WrapString[C.char](str)
	str_endArg, str_endFin := internal.WrapString[C.char](str_end)
	C.ImGuiTextBuffer_append(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg), strArg, str_endArg)

	selfFin()
	strFin()
	str_endFin()
}

func (self *TextBuffer) Begin() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImGuiTextBuffer_begin(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)))
}

func (self *TextBuffer) Cstr() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImGuiTextBuffer_c_str(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)))
}

func (self *TextBuffer) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextBuffer_clear(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg))

	selfFin()
}

func (self *TextBuffer) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextBuffer_destroy(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg))

	selfFin()
}

func (self *TextBuffer) Empty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiTextBuffer_empty(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)) == C.bool(true)
}

// Buf is zero-terminated, so end() will point on the zero-terminator
func (self *TextBuffer) End() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImGuiTextBuffer_end(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)))
}

func (self *TextBuffer) Reserve(capacity int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextBuffer_reserve(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg), C.int(capacity))

	selfFin()
}

// Similar to resize(0) on ImVector: empty string but don't free buffer.
func (self *TextBuffer) Resize(size int32) {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextBuffer_resize(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg), C.int(size))

	selfFin()
}

func (self *TextBuffer) Size() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImGuiTextBuffer_size(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)))
}

func (self *TextFilter) Build() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextFilter_Build(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg))

	selfFin()
}

func (self *TextFilter) Clear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextFilter_Clear(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg))

	selfFin()
}

// Helper calling InputText+Build
// DrawV parameter default value hint:
// label: "Filter(inc,-exc)"
// width: 0.0f
func (self *TextFilter) DrawV(label string, width float32) bool {
	selfArg, selfFin := self.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		selfFin()
		labelFin()
	}()
	return C.ImGuiTextFilter_Draw(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg), labelArg, C.float(width)) == C.bool(true)
}

// NewTextFilter parameter default value hint:
// default_filter: ""
func NewTextFilter(default_filter string) *TextFilter {
	default_filterArg, default_filterFin := internal.WrapString[C.char](default_filter)

	defer func() {
		default_filterFin()
	}()
	return NewTextFilterFromC(C.ImGuiTextFilter_ImGuiTextFilter(default_filterArg))
}

func (self *TextFilter) IsActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiTextFilter_IsActive(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg)) == C.bool(true)
}

// PassFilterV parameter default value hint:
func (self *TextFilter) PassFilterV(text string) bool {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		selfFin()
		textFin()
	}()
	return C.wrap_ImGuiTextFilter_PassFilterV(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg), textArg, C.int(len(text))) == C.bool(true)
}

func (self *TextFilter) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextFilter_destroy(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg))

	selfFin()
}

func (self *TextIndex) InternalAppend(base string, old_size, new_size int32) {
	selfArg, selfFin := self.Handle()
	baseArg, baseFin := internal.WrapString[C.char](base)
	C.ImGuiTextIndex_append(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg), baseArg, C.int(old_size), C.int(new_size))

	selfFin()
	baseFin()
}

func (self *TextIndex) InternalClear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextIndex_clear(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg))

	selfFin()
}

func (self *TextIndex) InternalGetlinebegin(base string, n int32) string {
	selfArg, selfFin := self.Handle()
	baseArg, baseFin := internal.WrapString[C.char](base)

	defer func() {
		selfFin()
		baseFin()
	}()
	return C.GoString(C.ImGuiTextIndex_get_line_begin(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg), baseArg, C.int(n)))
}

func (self *TextIndex) InternalGetlineend(base string, n int32) string {
	selfArg, selfFin := self.Handle()
	baseArg, baseFin := internal.WrapString[C.char](base)

	defer func() {
		selfFin()
		baseFin()
	}()
	return C.GoString(C.ImGuiTextIndex_get_line_end(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg), baseArg, C.int(n)))
}

func (self *TextIndex) InternalSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImGuiTextIndex_size(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg)))
}

func NewTextRangeNil() *TextRange {
	return NewTextRangeFromC(C.ImGuiTextRange_ImGuiTextRange_Nil())
}

func NewTextRangeStr(_b, _e string) *TextRange {
	_bArg, _bFin := internal.WrapString[C.char](_b)
	_eArg, _eFin := internal.WrapString[C.char](_e)

	defer func() {
		_bFin()
		_eFin()
	}()
	return NewTextRangeFromC(C.ImGuiTextRange_ImGuiTextRange_Str(_bArg, _eArg))
}

func (self *TextRange) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTextRange_destroy(internal.ReinterpretCast[*C.ImGuiTextRange](selfArg))

	selfFin()
}

func (self *TextRange) Empty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImGuiTextRange_empty(internal.ReinterpretCast[*C.ImGuiTextRange](selfArg)) == C.bool(true)
}

// We preserve remaining data for easier debugging
func (self *TypingSelectState) InternalClear() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTypingSelectState_Clear(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg))

	selfFin()
}

func InternalNewTypingSelectState() *TypingSelectState {
	return NewTypingSelectStateFromC(C.ImGuiTypingSelectState_ImGuiTypingSelectState())
}

func (self *TypingSelectState) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiTypingSelectState_destroy(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg))

	selfFin()
}

func (self *ViewportP) InternalCalcWorkRectPos(inset_min Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_CalcWorkRectPos(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiViewportP](selfArg), internal.ReinterpretCast[C.ImVec2](inset_min.ToC()))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *ViewportP) InternalCalcWorkRectSize(inset_min, inset_max Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_CalcWorkRectSize(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiViewportP](selfArg), internal.ReinterpretCast[C.ImVec2](inset_min.ToC()), internal.ReinterpretCast[C.ImVec2](inset_max.ToC()))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *ViewportP) InternalClearRequestFlags() {
	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_ClearRequestFlags(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	selfFin()
}

func (self *ViewportP) InternalBuildWorkRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_GetBuildWorkRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *ViewportP) InternalMainRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_GetMainRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *ViewportP) InternalWorkRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_GetWorkRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func InternalNewViewportP() *ViewportP {
	return NewViewportPFromC(C.ImGuiViewportP_ImGuiViewportP())
}

// Update public fields
func (self *ViewportP) InternalUpdateWorkRect() {
	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_UpdateWorkRect(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	selfFin()
}

func (self *ViewportP) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiViewportP_destroy(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	selfFin()
}

func (self *Viewport) Center() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewport_GetCenter(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiViewport](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Viewport) WorkCenter() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiViewport_GetWorkCenter(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiViewport](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func NewViewport() *Viewport {
	return NewViewportFromC(C.ImGuiViewport_ImGuiViewport())
}

func (self *Viewport) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiViewport_destroy(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))

	selfFin()
}

func NewWindowClass() *WindowClass {
	return NewWindowClassFromC(C.ImGuiWindowClass_ImGuiWindowClass())
}

func (self *WindowClass) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiWindowClass_destroy(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg))

	selfFin()
}

func (self *WindowSettings) InternalName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImGuiWindowSettings_GetName(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg)))
}

func InternalNewWindowSettings() *WindowSettings {
	return NewWindowSettingsFromC(C.ImGuiWindowSettings_ImGuiWindowSettings())
}

func (self *WindowSettings) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiWindowSettings_destroy(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg))

	selfFin()
}

func (self *Window) InternalIDFromPos(p_abs Vec2) ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.ImGuiWindow_GetIDFromPos(internal.ReinterpretCast[*C.ImGuiWindow](selfArg), internal.ReinterpretCast[C.ImVec2](p_abs.ToC()))
		return &result
	}())
}

func (self *Window) InternalIDFromRectangle(r_abs Rect) ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.ImGuiWindow_GetIDFromRectangle(internal.ReinterpretCast[*C.ImGuiWindow](selfArg), internal.ReinterpretCast[C.ImRect](r_abs.ToC()))
		return &result
	}())
}

func (self *Window) InternalIDInt(n int32) ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.ImGuiWindow_GetID_Int(internal.ReinterpretCast[*C.ImGuiWindow](selfArg), C.int(n))
		return &result
	}())
}

func (self *Window) InternalIDPtr(ptr uintptr) ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImGuiWindow_GetID_Ptr(internal.ReinterpretCast[*C.ImGuiWindow](selfArg), C.uintptr_t(ptr))
		return &result
	}())
}

// InternalIDStrV parameter default value hint:
// str_end: NULL
func (self *Window) InternalIDStrV(str, str_end string) ID {
	selfArg, selfFin := self.Handle()
	strArg, strFin := internal.WrapString[C.char](str)
	str_endArg, str_endFin := internal.WrapString[C.char](str_end)

	defer func() {
		selfFin()
		strFin()
		str_endFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.ImGuiWindow_GetID_Str(internal.ReinterpretCast[*C.ImGuiWindow](selfArg), strArg, str_endArg)
		return &result
	}())
}

func InternalNewWindow(context *Context, name string) *Window {
	contextArg, contextFin := context.Handle()
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		contextFin()
		nameFin()
	}()
	return NewWindowFromC(C.ImGuiWindow_ImGuiWindow(internal.ReinterpretCast[*C.ImGuiContext](contextArg), nameArg))
}

func (self *Window) InternalMenuBarRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiWindow_MenuBarRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Window) InternalRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiWindow_Rect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Window) InternalTitleBarRect() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImGuiWindow_TitleBarRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Window) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImGuiWindow_destroy(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	selfFin()
}

func (self *Rect) InternalAddRect(r Rect) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_Add_Rect(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImRect](r.ToC()))

	selfFin()
}

func (self *Rect) InternalAddVec2(p Vec2) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_Add_Vec2(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImVec2](p.ToC()))

	selfFin()
}

func (self *Rect) InternalAsVec4() *Vec4 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return (&Vec4{}).FromC(unsafe.Pointer(C.ImRect_AsVec4(internal.ReinterpretCast[*C.ImRect](selfArg))))
}

// Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
func (self *Rect) InternalClipWith(r Rect) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_ClipWith(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImRect](r.ToC()))

	selfFin()
}

// Full version, ensure both points are fully clipped.
func (self *Rect) InternalClipWithFull(r Rect) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_ClipWithFull(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImRect](r.ToC()))

	selfFin()
}

func (self *Rect) InternalContainsWithPad(p, pad Vec2) bool {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return C.ImRect_ContainsWithPad(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImVec2](p.ToC()), internal.ReinterpretCast[C.ImVec2](pad.ToC())) == C.bool(true)
}

func (self *Rect) InternalContainsRect(r Rect) bool {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return C.ImRect_Contains_Rect(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImRect](r.ToC())) == C.bool(true)
}

func (self *Rect) InternalContainsVec2(p Vec2) bool {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return C.ImRect_Contains_Vec2(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImVec2](p.ToC())) == C.bool(true)
}

func (self *Rect) InternalExpandFloat(amount float32) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_Expand_Float(internal.ReinterpretCast[*C.ImRect](selfArg), C.float(amount))

	selfFin()
}

func (self *Rect) InternalExpandVec2(amount Vec2) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_Expand_Vec2(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImVec2](amount.ToC()))

	selfFin()
}

func (self *Rect) InternalFloor() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_Floor(internal.ReinterpretCast[*C.ImRect](selfArg))

	selfFin()
}

func (self *Rect) InternalArea() float32 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return float32(C.ImRect_GetArea(internal.ReinterpretCast[*C.ImRect](selfArg)))
}

// Bottom-left
func (self *Rect) InternalBL() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_GetBL(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

// Bottom-right
func (self *Rect) InternalBR() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_GetBR(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) InternalCenter() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_GetCenter(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) InternalHeight() float32 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return float32(C.ImRect_GetHeight(internal.ReinterpretCast[*C.ImRect](selfArg)))
}

func (self *Rect) InternalSize() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_GetSize(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

// Top-left
func (self *Rect) InternalTL() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_GetTL(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

// Top-right
func (self *Rect) InternalTR() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_GetTR(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) InternalWidth() float32 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return float32(C.ImRect_GetWidth(internal.ReinterpretCast[*C.ImRect](selfArg)))
}

func (self *Rect) InternalIsInverted() bool {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return C.ImRect_IsInverted(internal.ReinterpretCast[*C.ImRect](selfArg)) == C.bool(true)
}

func (self *Rect) InternalOverlaps(r Rect) bool {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return C.ImRect_Overlaps(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImRect](r.ToC())) == C.bool(true)
}

func (self *Rect) InternalToVec4() Vec4 {
	pOut := new(Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_ToVec4(internal.ReinterpretCast[*C.ImVec4](pOutArg), internal.ReinterpretCast[*C.ImRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) InternalTranslate(d Vec2) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_Translate(internal.ReinterpretCast[*C.ImRect](selfArg), internal.ReinterpretCast[C.ImVec2](d.ToC()))

	selfFin()
}

func (self *Rect) InternalTranslateX(dx float32) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_TranslateX(internal.ReinterpretCast[*C.ImRect](selfArg), C.float(dx))

	selfFin()
}

func (self *Rect) InternalTranslateY(dy float32) {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_TranslateY(internal.ReinterpretCast[*C.ImRect](selfArg), C.float(dy))

	selfFin()
}

func (self *Rect) InternalDestroy() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImRect_destroy(internal.ReinterpretCast[*C.ImRect](selfArg))

	selfFin()
}

func (self *TextureData) Create(format TextureFormat, w, h int32) {
	selfArg, selfFin := self.Handle()
	C.ImTextureData_Create(internal.ReinterpretCast[*C.ImTextureData](selfArg), C.ImTextureFormat(format), C.int(w), C.int(h))

	selfFin()
}

func (self *TextureData) DestroyPixels() {
	selfArg, selfFin := self.Handle()
	C.ImTextureData_DestroyPixels(internal.ReinterpretCast[*C.ImTextureData](selfArg))

	selfFin()
}

func (self *TextureData) Pitch() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImTextureData_GetPitch(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) Pixels() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImTextureData_GetPixels(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) PixelsAt(x, y int32) uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImTextureData_GetPixelsAt(internal.ReinterpretCast[*C.ImTextureData](selfArg), C.int(x), C.int(y)))
}

func (self *TextureData) SizeInBytes() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImTextureData_GetSizeInBytes(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) TexID() TextureID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewTextureIDFromC(func() *C.ImTextureID {
		result := C.ImTextureData_GetTexID(internal.ReinterpretCast[*C.ImTextureData](selfArg))
		return &result
	}())
}

func (self *TextureData) TexRef() TextureRef {
	pOut := new(TextureRef)
	pOutArg, pOutFin := pOut.Handle()

	selfArg, selfFin := self.Handle()
	C.ImTextureData_GetTexRef(internal.ReinterpretCast[*C.ImTextureRef](pOutArg), internal.ReinterpretCast[*C.ImTextureData](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func NewTextureData() *TextureData {
	return NewTextureDataFromC(C.ImTextureData_ImTextureData())
}

// Call after honoring a request. Never modify Status directly!
func (self *TextureData) SetStatus(status TextureStatus) {
	selfArg, selfFin := self.Handle()
	C.ImTextureData_SetStatus(internal.ReinterpretCast[*C.ImTextureData](selfArg), C.ImTextureStatus(status))

	selfFin()
}

// Call after creating or destroying the texture. Never modify TexID directly!
func (self *TextureData) SetTexID(tex_id TextureID) {
	selfArg, selfFin := self.Handle()
	tex_idArg, tex_idFin := tex_id.C()
	C.ImTextureData_SetTexID(internal.ReinterpretCast[*C.ImTextureData](selfArg), internal.ReinterpretCast[C.ImTextureID](tex_idArg))

	selfFin()
	tex_idFin()
}

func (self *TextureData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImTextureData_destroy(internal.ReinterpretCast[*C.ImTextureData](selfArg))

	selfFin()
}

// == (_TexData ? _TexData->TexID : _TexID) // Implemented below in the file.
func (self *TextureRef) TexID() TextureID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewTextureIDFromC(func() *C.ImTextureID {
		result := C.ImTextureRef_GetTexID(internal.ReinterpretCast[*C.ImTextureRef](selfArg))
		return &result
	}())
}

func NewTextureRefNil() *TextureRef {
	return NewTextureRefFromC(C.ImTextureRef_ImTextureRef_Nil())
}

func NewTextureRefTextureID(tex_id TextureID) *TextureRef {
	tex_idArg, tex_idFin := tex_id.C()

	defer func() {
		tex_idFin()
	}()
	return NewTextureRefFromC(C.ImTextureRef_ImTextureRef_TextureID(internal.ReinterpretCast[C.ImTextureID](tex_idArg)))
}

func (self *TextureRef) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImTextureRef_destroy(internal.ReinterpretCast[*C.ImTextureRef](selfArg))

	selfFin()
}

func InternalNewVec1Float(_x float32) *Vec1 {
	return NewVec1FromC(C.ImVec1_ImVec1_Float(C.float(_x)))
}

func InternalNewVec1Nil() *Vec1 {
	return NewVec1FromC(C.ImVec1_ImVec1_Nil())
}

func (self *Vec1) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImVec1_destroy(internal.ReinterpretCast[*C.ImVec1](selfArg))

	selfFin()
}

func (self *Vec2) Destroy() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImVec2_destroy(internal.ReinterpretCast[*C.ImVec2](selfArg))

	selfFin()
}

func InternalNewVec2iInt(_x, _y int32) *Vec2i {
	return NewVec2iFromC(C.ImVec2i_ImVec2i_Int(C.int(_x), C.int(_y)))
}

func InternalNewVec2iNil() *Vec2i {
	return NewVec2iFromC(C.ImVec2i_ImVec2i_Nil())
}

func (self *Vec2i) InternalDestroy() {
	selfArg, selfFin := self.Handle()
	C.ImVec2i_destroy(internal.ReinterpretCast[*C.ImVec2i](selfArg))

	selfFin()
}

func NewVec4Float(_x, _y, _z, _w float32) *Vec4 {
	return (&Vec4{}).FromC(unsafe.Pointer(C.ImVec4_ImVec4_Float(C.float(_x), C.float(_y), C.float(_z), C.float(_w))))
}

func NewVec4Nil() *Vec4 {
	return (&Vec4{}).FromC(unsafe.Pointer(C.ImVec4_ImVec4_Nil()))
}

func (self *Vec4) Destroy() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImVec4_destroy(internal.ReinterpretCast[*C.ImVec4](selfArg))

	selfFin()
}

// accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.
// AcceptDragDropPayloadV parameter default value hint:
// flags: 0
func AcceptDragDropPayloadV(typeArg string, flags DragDropFlags) *Payload {
	typeArgArg, typeArgFin := internal.WrapString[C.char](typeArg)

	defer func() {
		typeArgFin()
	}()
	return NewPayloadFromC(C.igAcceptDragDropPayload(typeArgArg, C.ImGuiDragDropFlags(flags)))
}

// Activate an item by ID (button, checkbox, tree node etc.). Activation is queued and processed on the next frame when the item is encountered again. Was called 'ActivateItem()' before 1.89.7.
func InternalActivateItemByID(id ID) {
	idArg, idFin := id.C()
	C.igActivateItemByID(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func InternalAddContextHook(context *Context, hook *ContextHook) ID {
	contextArg, contextFin := context.Handle()
	hookArg, hookFin := hook.Handle()

	defer func() {
		contextFin()
		hookFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igAddContextHook(internal.ReinterpretCast[*C.ImGuiContext](contextArg), internal.ReinterpretCast[*C.ImGuiContextHook](hookArg))
		return &result
	}())
}

func InternalAddSettingsHandler(handler *SettingsHandler) {
	handlerArg, handlerFin := handler.Handle()
	C.igAddSettingsHandler(internal.ReinterpretCast[*C.ImGuiSettingsHandler](handlerArg))

	handlerFin()
}

// vertically align upcoming text baseline to FramePadding.y so that it will align properly to regularly framed items (call if you have text on a line before a framed item)
func AlignTextToFramePadding() {
	C.igAlignTextToFramePadding()
}

// square button with an arrow shape
func ArrowButton(str_id string, dir Dir) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igArrowButton(str_idArg, C.ImGuiDir(dir)) == C.bool(true)
}

// InternalArrowButtonExV parameter default value hint:
// flags: 0
func InternalArrowButtonExV(str_id string, dir Dir, size_arg Vec2, flags ButtonFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igArrowButtonEx(str_idArg, C.ImGuiDir(dir), internal.ReinterpretCast[C.ImVec2](size_arg.ToC()), C.ImGuiButtonFlags(flags)) == C.bool(true)
}

// BeginV parameter default value hint:
// p_open: NULL
// flags: 0
func BeginV(name string, p_open *bool, flags WindowFlags) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)

	defer func() {
		nameFin()
		p_openFin()
	}()
	return C.igBegin(nameArg, p_openArg, C.ImGuiWindowFlags(flags)) == C.bool(true)
}

func InternalBeginBoxSelect(scope_rect Rect, window *Window, box_select_id ID, ms_flags MultiSelectFlags) bool {
	windowArg, windowFin := window.Handle()
	box_select_idArg, box_select_idFin := box_select_id.C()

	defer func() {
		windowFin()
		box_select_idFin()
	}()
	return C.igBeginBoxSelect(internal.ReinterpretCast[C.ImRect](scope_rect.ToC()), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImGuiID](box_select_idArg), C.ImGuiMultiSelectFlags(ms_flags)) == C.bool(true)
}

func InternalBeginChildEx(name string, id ID, size_arg Vec2, child_flags ChildFlags, window_flags WindowFlags) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)
	idArg, idFin := id.C()

	defer func() {
		nameFin()
		idFin()
	}()
	return C.igBeginChildEx(nameArg, internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[C.ImVec2](size_arg.ToC()), C.ImGuiChildFlags(child_flags), C.ImGuiWindowFlags(window_flags)) == C.bool(true)
}

// BeginChildIDV parameter default value hint:
// size: ImVec2(0,0)
// child_flags: 0
// window_flags: 0
func BeginChildIDV(id ID, size Vec2, child_flags ChildFlags, window_flags WindowFlags) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igBeginChild_ID(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiChildFlags(child_flags), C.ImGuiWindowFlags(window_flags)) == C.bool(true)
}

// BeginChildStrV parameter default value hint:
// size: ImVec2(0,0)
// child_flags: 0
// window_flags: 0
func BeginChildStrV(str_id string, size Vec2, child_flags ChildFlags, window_flags WindowFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginChild_Str(str_idArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiChildFlags(child_flags), C.ImGuiWindowFlags(window_flags)) == C.bool(true)
}

// setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
// InternalBeginColumnsV parameter default value hint:
// flags: 0
func InternalBeginColumnsV(str_id string, count int32, flags OldColumnFlags) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.igBeginColumns(str_idArg, C.int(count), C.ImGuiOldColumnFlags(flags))

	str_idFin()
}

// BeginComboV parameter default value hint:
// flags: 0
func BeginComboV(label, preview_value string, flags ComboFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	preview_valueArg, preview_valueFin := internal.WrapString[C.char](preview_value)

	defer func() {
		labelFin()
		preview_valueFin()
	}()
	return C.igBeginCombo(labelArg, preview_valueArg, C.ImGuiComboFlags(flags)) == C.bool(true)
}

func InternalBeginComboPopup(popup_id ID, bb Rect, flags ComboFlags) bool {
	popup_idArg, popup_idFin := popup_id.C()

	defer func() {
		popup_idFin()
	}()
	return C.igBeginComboPopup(internal.ReinterpretCast[C.ImGuiID](popup_idArg), internal.ReinterpretCast[C.ImRect](bb.ToC()), C.ImGuiComboFlags(flags)) == C.bool(true)
}

func InternalBeginComboPreview() bool {
	return C.igBeginComboPreview() == C.bool(true)
}

// BeginDisabledV parameter default value hint:
// disabled: true
func BeginDisabledV(disabled bool) {
	C.igBeginDisabled(C.bool(disabled))
}

func InternalBeginDisabledOverrideReenable() {
	C.igBeginDisabledOverrideReenable()
}

func InternalBeginDockableDragDropSource(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igBeginDockableDragDropSource(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalBeginDockableDragDropTarget(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igBeginDockableDragDropTarget(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalBeginDocked(window *Window, p_open *bool) {
	windowArg, windowFin := window.Handle()
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.igBeginDocked(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), p_openArg)

	windowFin()
	p_openFin()
}

// call after submitting an item which may be dragged. when this return true, you can call SetDragDropPayload() + EndDragDropSource()
// BeginDragDropSourceV parameter default value hint:
// flags: 0
func BeginDragDropSourceV(flags DragDropFlags) bool {
	return C.igBeginDragDropSource(C.ImGuiDragDropFlags(flags)) == C.bool(true)
}

// call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget()
func BeginDragDropTarget() bool {
	return C.igBeginDragDropTarget() == C.bool(true)
}

func InternalBeginDragDropTargetCustom(bb Rect, id ID) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igBeginDragDropTargetCustom(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg)) == C.bool(true)
}

func InternalBeginErrorTooltip() bool {
	return C.igBeginErrorTooltip() == C.bool(true)
}

// lock horizontal starting position
func BeginGroup() {
	C.igBeginGroup()
}

// begin/append a tooltip window if preceding item was hovered.
func BeginItemTooltip() bool {
	return C.igBeginItemTooltip() == C.bool(true)
}

// open a framed scrolling region
// BeginListBoxV parameter default value hint:
// size: ImVec2(0,0)
func BeginListBoxV(label string, size Vec2) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igBeginListBox(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

// create and append to a full screen menu-bar.
func BeginMainMenuBar() bool {
	return C.igBeginMainMenuBar() == C.bool(true)
}

// create a sub-menu entry. only call EndMenu() if this returns true!
// BeginMenuV parameter default value hint:
// enabled: true
func BeginMenuV(label string, enabled bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igBeginMenu(labelArg, C.bool(enabled)) == C.bool(true)
}

// append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window).
func BeginMenuBar() bool {
	return C.igBeginMenuBar() == C.bool(true)
}

// InternalBeginMenuExV parameter default value hint:
// enabled: true
func InternalBeginMenuExV(label, icon string, enabled bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	iconArg, iconFin := internal.WrapString[C.char](icon)

	defer func() {
		labelFin()
		iconFin()
	}()
	return C.igBeginMenuEx(labelArg, iconArg, C.bool(enabled)) == C.bool(true)
}

// BeginMultiSelectV parameter default value hint:
// selection_size: -1
// items_count: -1
func BeginMultiSelectV(flags MultiSelectFlags, selection_size, items_count int32) *MultiSelectIO {
	return NewMultiSelectIOFromC(C.igBeginMultiSelect(C.ImGuiMultiSelectFlags(flags), C.int(selection_size), C.int(items_count)))
}

// return true if the popup is open, and you can start outputting to it.
// BeginPopupV parameter default value hint:
// flags: 0
func BeginPopupV(str_id string, flags WindowFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginPopup(str_idArg, C.ImGuiWindowFlags(flags)) == C.bool(true)
}

// open+begin popup when clicked on last item. Use str_id==NULL to associate the popup to previous item. If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!
// BeginPopupContextItemV parameter default value hint:
// str_id: NULL
// popup_flags: 1
func BeginPopupContextItemV(str_id string, popup_flags PopupFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginPopupContextItem(str_idArg, C.ImGuiPopupFlags(popup_flags)) == C.bool(true)
}

// open+begin popup when clicked in void (where there are no windows).
// BeginPopupContextVoidV parameter default value hint:
// str_id: NULL
// popup_flags: 1
func BeginPopupContextVoidV(str_id string, popup_flags PopupFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginPopupContextVoid(str_idArg, C.ImGuiPopupFlags(popup_flags)) == C.bool(true)
}

// open+begin popup when clicked on current window.
// BeginPopupContextWindowV parameter default value hint:
// str_id: NULL
// popup_flags: 1
func BeginPopupContextWindowV(str_id string, popup_flags PopupFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginPopupContextWindow(str_idArg, C.ImGuiPopupFlags(popup_flags)) == C.bool(true)
}

func InternalBeginPopupEx(id ID, extra_window_flags WindowFlags) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igBeginPopupEx(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiWindowFlags(extra_window_flags)) == C.bool(true)
}

func InternalBeginPopupMenuEx(id ID, label string, extra_window_flags WindowFlags) bool {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		idFin()
		labelFin()
	}()
	return C.igBeginPopupMenuEx(internal.ReinterpretCast[C.ImGuiID](idArg), labelArg, C.ImGuiWindowFlags(extra_window_flags)) == C.bool(true)
}

// return true if the modal is open, and you can start outputting to it.
// BeginPopupModalV parameter default value hint:
// p_open: NULL
// flags: 0
func BeginPopupModalV(name string, p_open *bool, flags WindowFlags) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)

	defer func() {
		nameFin()
		p_openFin()
	}()
	return C.igBeginPopupModal(nameArg, p_openArg, C.ImGuiWindowFlags(flags)) == C.bool(true)
}

// create and append into a TabBar
// BeginTabBarV parameter default value hint:
// flags: 0
func BeginTabBarV(str_id string, flags TabBarFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginTabBar(str_idArg, C.ImGuiTabBarFlags(flags)) == C.bool(true)
}

func InternalBeginTabBarEx(tab_bar *TabBar, bb Rect, flags TabBarFlags) bool {
	tab_barArg, tab_barFin := tab_bar.Handle()

	defer func() {
		tab_barFin()
	}()
	return C.igBeginTabBarEx(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[C.ImRect](bb.ToC()), C.ImGuiTabBarFlags(flags)) == C.bool(true)
}

// create a Tab. Returns true if the Tab is selected.
// BeginTabItemV parameter default value hint:
// p_open: NULL
// flags: 0
func BeginTabItemV(label string, p_open *bool, flags TabItemFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)

	defer func() {
		labelFin()
		p_openFin()
	}()
	return C.igBeginTabItem(labelArg, p_openArg, C.ImGuiTabItemFlags(flags)) == C.bool(true)
}

// BeginTableV parameter default value hint:
// flags: 0
// outer_size: ImVec2(0.0f,0.0f)
// inner_width: 0.0f
func BeginTableV(str_id string, columns int32, flags TableFlags, outer_size Vec2, inner_width float32) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igBeginTable(str_idArg, C.int(columns), C.ImGuiTableFlags(flags), internal.ReinterpretCast[C.ImVec2](outer_size.ToC()), C.float(inner_width)) == C.bool(true)
}

// InternalBeginTableExV parameter default value hint:
// flags: 0
// outer_size: ImVec2(0,0)
// inner_width: 0.0f
func InternalBeginTableExV(name string, id ID, columns_count int32, flags TableFlags, outer_size Vec2, inner_width float32) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)
	idArg, idFin := id.C()

	defer func() {
		nameFin()
		idFin()
	}()
	return C.igBeginTableEx(nameArg, internal.ReinterpretCast[C.ImGuiID](idArg), C.int(columns_count), C.ImGuiTableFlags(flags), internal.ReinterpretCast[C.ImVec2](outer_size.ToC()), C.float(inner_width)) == C.bool(true)
}

// begin/append a tooltip window.
func BeginTooltip() bool {
	return C.igBeginTooltip() == C.bool(true)
}

func InternalBeginTooltipEx(tooltip_flags TooltipFlags, extra_window_flags WindowFlags) bool {
	return C.igBeginTooltipEx(C.ImGuiTooltipFlags(tooltip_flags), C.ImGuiWindowFlags(extra_window_flags)) == C.bool(true)
}

func InternalBeginTooltipHidden() bool {
	return C.igBeginTooltipHidden() == C.bool(true)
}

func InternalBeginViewportSideBar(name string, viewport *Viewport, dir Dir, size float32, window_flags WindowFlags) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)
	viewportArg, viewportFin := viewport.Handle()

	defer func() {
		nameFin()
		viewportFin()
	}()
	return C.igBeginViewportSideBar(nameArg, internal.ReinterpretCast[*C.ImGuiViewport](viewportArg), C.ImGuiDir(dir), C.float(size), C.ImGuiWindowFlags(window_flags)) == C.bool(true)
}

func InternalBringWindowToDisplayBack(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igBringWindowToDisplayBack(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalBringWindowToDisplayBehind(window, above_window *Window) {
	windowArg, windowFin := window.Handle()
	above_windowArg, above_windowFin := above_window.Handle()
	C.igBringWindowToDisplayBehind(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiWindow](above_windowArg))

	windowFin()
	above_windowFin()
}

func InternalBringWindowToDisplayFront(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igBringWindowToDisplayFront(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalBringWindowToFocusFront(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igBringWindowToFocusFront(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

// draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
func Bullet() {
	C.igBullet()
}

// shortcut for Bullet()+Text()
func BulletText(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igBulletText(fmtArg)

	fmtFin()
}

// button
// ButtonV parameter default value hint:
// size: ImVec2(0,0)
func ButtonV(label string, size Vec2) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igButton(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

// InternalButtonBehaviorV parameter default value hint:
// flags: 0
func InternalButtonBehaviorV(bb Rect, id ID, out_hovered, out_held *bool, flags ButtonFlags) bool {
	idArg, idFin := id.C()
	out_hoveredArg, out_hoveredFin := internal.WrapNumberPtr[C.bool, bool](out_hovered)
	out_heldArg, out_heldFin := internal.WrapNumberPtr[C.bool, bool](out_held)

	defer func() {
		idFin()
		out_hoveredFin()
		out_heldFin()
	}()
	return C.igButtonBehavior(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), out_hoveredArg, out_heldArg, C.ImGuiButtonFlags(flags)) == C.bool(true)
}

// InternalButtonExV parameter default value hint:
// size_arg: ImVec2(0,0)
// flags: 0
func InternalButtonExV(label string, size_arg Vec2, flags ButtonFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igButtonEx(labelArg, internal.ReinterpretCast[C.ImVec2](size_arg.ToC()), C.ImGuiButtonFlags(flags)) == C.bool(true)
}

func InternalCalcClipRectVisibleItemsY(clip_rect Rect, pos Vec2, items_height float32, out_visible_start, out_visible_end *int32) {
	out_visible_startArg, out_visible_startFin := internal.WrapNumberPtr[C.int, int32](out_visible_start)
	out_visible_endArg, out_visible_endFin := internal.WrapNumberPtr[C.int, int32](out_visible_end)
	C.igCalcClipRectVisibleItemsY(internal.ReinterpretCast[C.ImRect](clip_rect.ToC()), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.float(items_height), out_visible_startArg, out_visible_endArg)

	out_visible_startFin()
	out_visible_endFin()
}

func InternalCalcItemSize(size Vec2, default_w, default_h float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igCalcItemSize(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](size.ToC()), C.float(default_w), C.float(default_h))

	pOutFin()

	return *pOut
}

// width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions.
func CalcItemWidth() float32 {
	return float32(C.igCalcItemWidth())
}

func InternalCalcRoundingFlagsForRectInRect(r_in, r_outer Rect, threshold float32) DrawFlags {
	return DrawFlags(C.igCalcRoundingFlagsForRectInRect(internal.ReinterpretCast[C.ImRect](r_in.ToC()), internal.ReinterpretCast[C.ImRect](r_outer.ToC()), C.float(threshold)))
}

// CalcTextSizeV parameter default value hint:
// hide_text_after_double_hash: false
// wrap_width: -1.0f
func CalcTextSizeV(text string, hide_text_after_double_hash bool, wrap_width float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igCalcTextSizeV(internal.ReinterpretCast[*C.ImVec2](pOutArg), textArg, C.int(len(text)), C.bool(hide_text_after_double_hash), C.float(wrap_width))

	pOutFin()
	textFin()

	return *pOut
}

func InternalCalcTypematicRepeatAmount(t0, t1, repeat_delay, repeat_rate float32) int32 {
	return int32(C.igCalcTypematicRepeatAmount(C.float(t0), C.float(t1), C.float(repeat_delay), C.float(repeat_rate)))
}

func InternalCalcWindowNextAutoFitSize(window *Window) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igCalcWindowNextAutoFitSize(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalCalcWrapWidthForPos(pos Vec2, wrap_pos_x float32) float32 {
	return float32(C.igCalcWrapWidthForPos(internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.float(wrap_pos_x)))
}

func InternalCallContextHooks(context *Context, typeArg ContextHookType) {
	contextArg, contextFin := context.Handle()
	C.igCallContextHooks(internal.ReinterpretCast[*C.ImGuiContext](contextArg), C.ImGuiContextHookType(typeArg))

	contextFin()
}

func Checkbox(label string, v *bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.bool, bool](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.igCheckbox(labelArg, vArg) == C.bool(true)
}

func CheckboxFlagsIntPtr(label string, flags *int32, flags_value int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	flagsArg, flagsFin := internal.WrapNumberPtr[C.int, int32](flags)

	defer func() {
		labelFin()
		flagsFin()
	}()
	return C.igCheckboxFlags_IntPtr(labelArg, flagsArg, C.int(flags_value)) == C.bool(true)
}

func InternalCheckboxFlagsS64Ptr(label string, flags *int64, flags_value int64) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	flagsArg, flagsFin := internal.WrapNumberPtr[C.ImS64, int64](flags)

	defer func() {
		labelFin()
		flagsFin()
	}()
	return C.igCheckboxFlags_S64Ptr(labelArg, flagsArg, C.ImS64(flags_value)) == C.bool(true)
}

func InternalCheckboxFlagsU64Ptr(label string, flags *uint64, flags_value uint64) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	flagsArg, flagsFin := internal.WrapNumberPtr[C.ImU64, uint64](flags)

	defer func() {
		labelFin()
		flagsFin()
	}()
	return C.igCheckboxFlags_U64Ptr(labelArg, flagsArg, C.ImU64(flags_value)) == C.bool(true)
}

func CheckboxFlagsUintPtr(label string, flags *uint32, flags_value uint32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	flagsArg, flagsFin := internal.WrapNumberPtr[C.uint, uint32](flags)

	defer func() {
		labelFin()
		flagsFin()
	}()
	return C.igCheckboxFlags_UintPtr(labelArg, flagsArg, C.uint(flags_value)) == C.bool(true)
}

func InternalClearActiveID() {
	C.igClearActiveID()
}

func InternalClearDragDrop() {
	C.igClearDragDrop()
}

func InternalClearIniSettings() {
	C.igClearIniSettings()
}

func InternalClearWindowSettings(name string) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.igClearWindowSettings(nameArg)

	nameFin()
}

func InternalCloseButton(id ID, pos Vec2) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igCloseButton(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[C.ImVec2](pos.ToC())) == C.bool(true)
}

// manually close the popup we have begin-ed into.
func CloseCurrentPopup() {
	C.igCloseCurrentPopup()
}

func InternalClosePopupToLevel(remaining int32, restore_focus_to_window_under_popup bool) {
	C.igClosePopupToLevel(C.int(remaining), C.bool(restore_focus_to_window_under_popup))
}

func InternalClosePopupsExceptModals() {
	C.igClosePopupsExceptModals()
}

func InternalClosePopupsOverWindow(ref_window *Window, restore_focus_to_window_under_popup bool) {
	ref_windowArg, ref_windowFin := ref_window.Handle()
	C.igClosePopupsOverWindow(internal.ReinterpretCast[*C.ImGuiWindow](ref_windowArg), C.bool(restore_focus_to_window_under_popup))

	ref_windowFin()
}

func InternalCollapseButton(id ID, pos Vec2, dock_node *DockNode) bool {
	idArg, idFin := id.C()
	dock_nodeArg, dock_nodeFin := dock_node.Handle()

	defer func() {
		idFin()
		dock_nodeFin()
	}()
	return C.igCollapseButton(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[*C.ImGuiDockNode](dock_nodeArg)) == C.bool(true)
}

// when 'p_visible != NULL': if '*p_visible==true' display an additional small close button on upper right of the header which will set the bool to false when clicked, if '*p_visible==false' don't display the header.
// CollapsingHeaderBoolPtrV parameter default value hint:
// flags: 0
func CollapsingHeaderBoolPtrV(label string, p_visible *bool, flags TreeNodeFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	p_visibleArg, p_visibleFin := internal.WrapNumberPtr[C.bool, bool](p_visible)

	defer func() {
		labelFin()
		p_visibleFin()
	}()
	return C.igCollapsingHeader_BoolPtr(labelArg, p_visibleArg, C.ImGuiTreeNodeFlags(flags)) == C.bool(true)
}

// if returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
// CollapsingHeaderTreeNodeFlagsV parameter default value hint:
// flags: 0
func CollapsingHeaderTreeNodeFlagsV(label string, flags TreeNodeFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igCollapsingHeader_TreeNodeFlags(labelArg, C.ImGuiTreeNodeFlags(flags)) == C.bool(true)
}

// display a color square/button, hover for details, return true when pressed.
// ColorButtonV parameter default value hint:
// flags: 0
// size: ImVec2(0,0)
func ColorButtonV(desc_id string, col Vec4, flags ColorEditFlags, size Vec2) bool {
	desc_idArg, desc_idFin := internal.WrapString[C.char](desc_id)

	defer func() {
		desc_idFin()
	}()
	return C.igColorButton(desc_idArg, internal.ReinterpretCast[C.ImVec4](col.ToC()), C.ImGuiColorEditFlags(flags), internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

func ColorConvertFloat4ToU32(in Vec4) uint32 {
	return (uint32)(C.igColorConvertFloat4ToU32(internal.ReinterpretCast[C.ImVec4](in.ToC())))
}

func ColorConvertHSVtoRGB(h, s, v float32, out_r, out_g, out_b *float32) {
	out_rArg, out_rFin := internal.WrapNumberPtr[C.float, float32](out_r)
	out_gArg, out_gFin := internal.WrapNumberPtr[C.float, float32](out_g)
	out_bArg, out_bFin := internal.WrapNumberPtr[C.float, float32](out_b)
	C.igColorConvertHSVtoRGB(C.float(h), C.float(s), C.float(v), out_rArg, out_gArg, out_bArg)

	out_rFin()
	out_gFin()
	out_bFin()
}

func ColorConvertRGBtoHSV(r, g, b float32, out_h, out_s, out_v *float32) {
	out_hArg, out_hFin := internal.WrapNumberPtr[C.float, float32](out_h)
	out_sArg, out_sFin := internal.WrapNumberPtr[C.float, float32](out_s)
	out_vArg, out_vFin := internal.WrapNumberPtr[C.float, float32](out_v)
	C.igColorConvertRGBtoHSV(C.float(r), C.float(g), C.float(b), out_hArg, out_sArg, out_vArg)

	out_hFin()
	out_sFin()
	out_vFin()
}

func ColorConvertU32ToFloat4(in uint32) Vec4 {
	pOut := new(Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igColorConvertU32ToFloat4(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.ImU32(in))

	pOutFin()

	return *pOut
}

// ColorEdit3V parameter default value hint:
// flags: 0
func ColorEdit3V(label string, col *[3]float32, flags ColorEditFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.igColorEdit3(labelArg, (*C.float)(&colArg[0]), C.ImGuiColorEditFlags(flags)) == C.bool(true)
}

// ColorEdit4V parameter default value hint:
// flags: 0
func ColorEdit4V(label string, col *[4]float32, flags ColorEditFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.igColorEdit4(labelArg, (*C.float)(&colArg[0]), C.ImGuiColorEditFlags(flags)) == C.bool(true)
}

func InternalColorEditOptionsPopup(col *float32, flags ColorEditFlags) {
	colArg, colFin := internal.WrapNumberPtr[C.float, float32](col)
	C.igColorEditOptionsPopup(colArg, C.ImGuiColorEditFlags(flags))

	colFin()
}

// ColorPicker3V parameter default value hint:
// flags: 0
func ColorPicker3V(label string, col *[3]float32, flags ColorEditFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.igColorPicker3(labelArg, (*C.float)(&colArg[0]), C.ImGuiColorEditFlags(flags)) == C.bool(true)
}

// ColorPicker4V parameter default value hint:
// flags: 0
// ref_col: NULL
func ColorPicker4V(label string, col *[4]float32, flags ColorEditFlags, ref_col *float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}
	ref_colArg, ref_colFin := internal.WrapNumberPtr[C.float, float32](ref_col)

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}

		ref_colFin()
	}()
	return C.igColorPicker4(labelArg, (*C.float)(&colArg[0]), C.ImGuiColorEditFlags(flags), ref_colArg) == C.bool(true)
}

func InternalColorPickerOptionsPopup(ref_col *float32, flags ColorEditFlags) {
	ref_colArg, ref_colFin := internal.WrapNumberPtr[C.float, float32](ref_col)
	C.igColorPickerOptionsPopup(ref_colArg, C.ImGuiColorEditFlags(flags))

	ref_colFin()
}

func InternalColorTooltip(text string, col *float32, flags ColorEditFlags) {
	textArg, textFin := internal.WrapString[C.char](text)
	colArg, colFin := internal.WrapNumberPtr[C.float, float32](col)
	C.igColorTooltip(textArg, colArg, C.ImGuiColorEditFlags(flags))

	textFin()
	colFin()
}

// ColumnsV parameter default value hint:
// count: 1
// id: NULL
// borders: true
func ColumnsV(count int32, id string, borders bool) {
	idArg, idFin := internal.WrapString[C.char](id)
	C.igColumns(C.int(count), idArg, C.bool(borders))

	idFin()
}

// Separate items with \0 within a string, end item-list with \0\0. e.g. "One\0Two\0Three\0"
// ComboStrV parameter default value hint:
// popup_max_height_in_items: -1
func ComboStrV(label string, current_item *int32, items_separated_by_zeros string, popup_max_height_in_items int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	current_itemArg, current_itemFin := internal.WrapNumberPtr[C.int, int32](current_item)
	items_separated_by_zerosArg, items_separated_by_zerosFin := internal.WrapString[C.char](items_separated_by_zeros)

	defer func() {
		labelFin()
		current_itemFin()
		items_separated_by_zerosFin()
	}()
	return C.igCombo_Str(labelArg, current_itemArg, items_separated_by_zerosArg, C.int(popup_max_height_in_items)) == C.bool(true)
}

// ComboStrarrV parameter default value hint:
// popup_max_height_in_items: -1
func ComboStrarrV(label string, current_item *int32, items []string, items_count, popup_max_height_in_items int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	current_itemArg, current_itemFin := internal.WrapNumberPtr[C.int, int32](current_item)
	itemsArg, itemsFin := internal.WrapStringList[C.char](items)

	defer func() {
		labelFin()
		current_itemFin()
		itemsFin()
	}()
	return C.igCombo_Str_arr(labelArg, current_itemArg, itemsArg, C.int(items_count), C.int(popup_max_height_in_items)) == C.bool(true)
}

func InternalConvertSingleModFlagToKey(key Key) Key {
	return Key(C.igConvertSingleModFlagToKey(C.ImGuiKey(key)))
}

// CreateContextV parameter default value hint:
// shared_font_atlas: NULL
func CreateContextV(shared_font_atlas *FontAtlas) *Context {
	shared_font_atlasArg, shared_font_atlasFin := shared_font_atlas.Handle()

	defer func() {
		shared_font_atlasFin()
	}()
	return NewContextFromC(C.igCreateContext(internal.ReinterpretCast[*C.ImFontAtlas](shared_font_atlasArg)))
}

func InternalCreateNewWindowSettings(name string) *WindowSettings {
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		nameFin()
	}()
	return NewWindowSettingsFromC(C.igCreateNewWindowSettings(nameArg))
}

// InternalDataTypeApplyFromTextV parameter default value hint:
// p_data_when_empty: NULL
func InternalDataTypeApplyFromTextV(buf string, data_type DataType, p_data uintptr, format string, p_data_when_empty uintptr) bool {
	bufArg, bufFin := internal.WrapString[C.char](buf)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		bufFin()
		formatFin()
	}()
	return C.wrap_igDataTypeApplyFromTextV(bufArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), formatArg, C.uintptr_t(p_data_when_empty)) == C.bool(true)
}

func InternalDataTypeApplyOp(data_type DataType, op int32, output, arg_1, arg_2 uintptr) {
	C.wrap_igDataTypeApplyOp(C.ImGuiDataType(data_type), C.int(op), C.uintptr_t(output), C.uintptr_t(arg_1), C.uintptr_t(arg_2))
}

func InternalDataTypeClamp(data_type DataType, p_data, p_min, p_max uintptr) bool {
	return C.wrap_igDataTypeClamp(C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.uintptr_t(p_min), C.uintptr_t(p_max)) == C.bool(true)
}

func InternalDataTypeCompare(data_type DataType, arg_1, arg_2 uintptr) int32 {
	return int32(C.wrap_igDataTypeCompare(C.ImGuiDataType(data_type), C.uintptr_t(arg_1), C.uintptr_t(arg_2)))
}

func InternalDataTypeFormatString(buf string, buf_size int32, data_type DataType, p_data uintptr, format string) int32 {
	bufArg, bufFin := internal.WrapString[C.char](buf)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		bufFin()
		formatFin()
	}()
	return int32(C.wrap_igDataTypeFormatString(bufArg, C.int(buf_size), C.ImGuiDataType(data_type), C.uintptr_t(p_data), formatArg))
}

func InternalDataTypeGetInfo(data_type DataType) *DataTypeInfo {
	return NewDataTypeInfoFromC(C.igDataTypeGetInfo(C.ImGuiDataType(data_type)))
}

func InternalDataTypeIsZero(data_type DataType, p_data uintptr) bool {
	return C.wrap_igDataTypeIsZero(C.ImGuiDataType(data_type), C.uintptr_t(p_data)) == C.bool(true)
}

// size >= 0 : alloc, size = -1 : free
func InternalDebugAllocHook(info *DebugAllocInfo, frame_count int32, ptr uintptr, size uint64) {
	infoArg, infoFin := info.Handle()
	C.wrap_igDebugAllocHook(internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](infoArg), C.int(frame_count), C.uintptr_t(ptr), C.xulong(size))

	infoFin()
}

func InternalDebugBreakButton(label, description_of_location string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	description_of_locationArg, description_of_locationFin := internal.WrapString[C.char](description_of_location)

	defer func() {
		labelFin()
		description_of_locationFin()
	}()
	return C.igDebugBreakButton(labelArg, description_of_locationArg) == C.bool(true)
}

func InternalDebugBreakButtonTooltip(keyboard_only bool, description_of_location string) {
	description_of_locationArg, description_of_locationFin := internal.WrapString[C.char](description_of_location)
	C.igDebugBreakButtonTooltip(C.bool(keyboard_only), description_of_locationArg)

	description_of_locationFin()
}

func InternalDebugBreakClearData() {
	C.igDebugBreakClearData()
}

// This is called by IMGUI_CHECKVERSION() macro.
func DebugCheckVersionAndDataLayout(version_str string, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx uint64) bool {
	version_strArg, version_strFin := internal.WrapString[C.char](version_str)

	defer func() {
		version_strFin()
	}()
	return C.igDebugCheckVersionAndDataLayout(version_strArg, C.xulong(sz_io), C.xulong(sz_style), C.xulong(sz_vec2), C.xulong(sz_vec4), C.xulong(sz_drawvert), C.xulong(sz_drawidx)) == C.bool(true)
}

// InternalDebugDrawCursorPosV parameter default value hint:
// col: 4278190335
func InternalDebugDrawCursorPosV(col uint32) {
	C.igDebugDrawCursorPos(C.ImU32(col))
}

// InternalDebugDrawItemRectV parameter default value hint:
// col: 4278190335
func InternalDebugDrawItemRectV(col uint32) {
	C.igDebugDrawItemRect(C.ImU32(col))
}

// InternalDebugDrawLineExtentsV parameter default value hint:
// col: 4278190335
func InternalDebugDrawLineExtentsV(col uint32) {
	C.igDebugDrawLineExtents(C.ImU32(col))
}

func DebugFlashStyleColor(idx Col) {
	C.igDebugFlashStyleColor(C.ImGuiCol(idx))
}

func InternalDebugHookIdInfo(id ID, data_type DataType, data_id, data_id_end uintptr) {
	idArg, idFin := id.C()
	C.wrap_igDebugHookIdInfo(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiDataType(data_type), C.uintptr_t(data_id), C.uintptr_t(data_id_end))

	idFin()
}

// Call sparingly: only 1 at the same time!
func InternalDebugLocateItem(target_id ID) {
	target_idArg, target_idFin := target_id.C()
	C.igDebugLocateItem(internal.ReinterpretCast[C.ImGuiID](target_idArg))

	target_idFin()
}

// Only call on reaction to a mouse Hover: because only 1 at the same time!
func InternalDebugLocateItemOnHover(target_id ID) {
	target_idArg, target_idFin := target_id.C()
	C.igDebugLocateItemOnHover(internal.ReinterpretCast[C.ImGuiID](target_idArg))

	target_idFin()
}

func InternalDebugLocateItemResolveWithLastItem() {
	C.igDebugLocateItemResolveWithLastItem()
}

// Call via IMGUI_DEBUG_LOG() for maximum stripping in caller code!
func DebugLog(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igDebugLog(fmtArg)

	fmtFin()
}

func InternalDebugNodeColumns(columns *OldColumns) {
	columnsArg, columnsFin := columns.Handle()
	C.igDebugNodeColumns(internal.ReinterpretCast[*C.ImGuiOldColumns](columnsArg))

	columnsFin()
}

func InternalDebugNodeDockNode(node *DockNode, label string) {
	nodeArg, nodeFin := node.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igDebugNodeDockNode(internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg), labelArg)

	nodeFin()
	labelFin()
}

func InternalDebugNodeDrawCmdShowMeshAndBoundingBox(out_draw_list, draw_list *DrawList, draw_cmd *DrawCmd, show_mesh, show_aabb bool) {
	out_draw_listArg, out_draw_listFin := out_draw_list.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	draw_cmdArg, draw_cmdFin := draw_cmd.Handle()
	C.igDebugNodeDrawCmdShowMeshAndBoundingBox(internal.ReinterpretCast[*C.ImDrawList](out_draw_listArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[*C.ImDrawCmd](draw_cmdArg), C.bool(show_mesh), C.bool(show_aabb))

	out_draw_listFin()
	draw_listFin()
	draw_cmdFin()
}

func InternalDebugNodeDrawList(window *Window, viewport *ViewportP, draw_list *DrawList, label string) {
	windowArg, windowFin := window.Handle()
	viewportArg, viewportFin := viewport.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igDebugNodeDrawList(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), labelArg)

	windowFin()
	viewportFin()
	draw_listFin()
	labelFin()
}

func InternalDebugNodeFont(font *Font) {
	fontArg, fontFin := font.Handle()
	C.igDebugNodeFont(internal.ReinterpretCast[*C.ImFont](fontArg))

	fontFin()
}

func InternalDebugNodeFontGlyph(font *Font, glyph *FontGlyph) {
	fontArg, fontFin := font.Handle()
	glyphArg, glyphFin := glyph.Handle()
	C.igDebugNodeFontGlyph(internal.ReinterpretCast[*C.ImFont](fontArg), internal.ReinterpretCast[*C.ImFontGlyph](glyphArg))

	fontFin()
	glyphFin()
}

func InternalDebugNodeFontGlyphesForSrcMask(font *Font, baked *FontBaked, src_mask int32) {
	fontArg, fontFin := font.Handle()
	bakedArg, bakedFin := baked.Handle()
	C.igDebugNodeFontGlyphesForSrcMask(internal.ReinterpretCast[*C.ImFont](fontArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg), C.int(src_mask))

	fontFin()
	bakedFin()
}

func InternalDebugNodeInputTextState(state *InputTextState) {
	stateArg, stateFin := state.Handle()
	C.igDebugNodeInputTextState(internal.ReinterpretCast[*C.ImGuiInputTextState](stateArg))

	stateFin()
}

func InternalDebugNodeMultiSelectState(state *MultiSelectState) {
	stateArg, stateFin := state.Handle()
	C.igDebugNodeMultiSelectState(internal.ReinterpretCast[*C.ImGuiMultiSelectState](stateArg))

	stateFin()
}

func InternalDebugNodePlatformMonitor(monitor *PlatformMonitor, label string, idx int32) {
	monitorArg, monitorFin := monitor.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igDebugNodePlatformMonitor(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](monitorArg), labelArg, C.int(idx))

	monitorFin()
	labelFin()
}

func InternalDebugNodeStorage(storage *Storage, label string) {
	storageArg, storageFin := storage.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igDebugNodeStorage(internal.ReinterpretCast[*C.ImGuiStorage](storageArg), labelArg)

	storageFin()
	labelFin()
}

func InternalDebugNodeTabBar(tab_bar *TabBar, label string) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igDebugNodeTabBar(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), labelArg)

	tab_barFin()
	labelFin()
}

func InternalDebugNodeTable(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igDebugNodeTable(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalDebugNodeTableSettings(settings *TableSettings) {
	settingsArg, settingsFin := settings.Handle()
	C.igDebugNodeTableSettings(internal.ReinterpretCast[*C.ImGuiTableSettings](settingsArg))

	settingsFin()
}

// ID used to facilitate persisting the "current" texture.
// InternalDebugNodeTextureV parameter default value hint:
// highlight_rect: NULL
func InternalDebugNodeTextureV(tex *TextureData, int_id int32, highlight_rect *FontAtlasRect) {
	texArg, texFin := tex.Handle()
	highlight_rectArg, highlight_rectFin := highlight_rect.Handle()
	C.igDebugNodeTexture(internal.ReinterpretCast[*C.ImTextureData](texArg), C.int(int_id), internal.ReinterpretCast[*C.ImFontAtlasRect](highlight_rectArg))

	texFin()
	highlight_rectFin()
}

func InternalDebugNodeTypingSelectState(state *TypingSelectState) {
	stateArg, stateFin := state.Handle()
	C.igDebugNodeTypingSelectState(internal.ReinterpretCast[*C.ImGuiTypingSelectState](stateArg))

	stateFin()
}

func InternalDebugNodeViewport(viewport *ViewportP) {
	viewportArg, viewportFin := viewport.Handle()
	C.igDebugNodeViewport(internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg))

	viewportFin()
}

func InternalDebugNodeWindow(window *Window, label string) {
	windowArg, windowFin := window.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igDebugNodeWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), labelArg)

	windowFin()
	labelFin()
}

func InternalDebugNodeWindowSettings(settings *WindowSettings) {
	settingsArg, settingsFin := settings.Handle()
	C.igDebugNodeWindowSettings(internal.ReinterpretCast[*C.ImGuiWindowSettings](settingsArg))

	settingsFin()
}

func InternalDebugRenderKeyboardPreview(draw_list *DrawList) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igDebugRenderKeyboardPreview(internal.ReinterpretCast[*C.ImDrawList](draw_listArg))

	draw_listFin()
}

func InternalDebugRenderViewportThumbnail(draw_list *DrawList, viewport *ViewportP, bb Rect) {
	draw_listArg, draw_listFin := draw_list.Handle()
	viewportArg, viewportFin := viewport.Handle()
	C.igDebugRenderViewportThumbnail(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg), internal.ReinterpretCast[C.ImRect](bb.ToC()))

	draw_listFin()
	viewportFin()
}

func DebugStartItemPicker() {
	C.igDebugStartItemPicker()
}

func DebugTextEncoding(text string) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.igDebugTextEncoding(textArg)

	textFin()
}

func InternalDebugTextUnformattedWithLocateItem(line_begin, line_end string) {
	line_beginArg, line_beginFin := internal.WrapString[C.char](line_begin)
	line_endArg, line_endFin := internal.WrapString[C.char](line_end)
	C.igDebugTextUnformattedWithLocateItem(line_beginArg, line_endArg)

	line_beginFin()
	line_endFin()
}

// NULL = destroy current context
// DestroyContextV parameter default value hint:
// ctx: NULL
func DestroyContextV(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDestroyContext(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDestroyPlatformWindow(viewport *ViewportP) {
	viewportArg, viewportFin := viewport.Handle()
	C.igDestroyPlatformWindow(internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg))

	viewportFin()
}

// call DestroyWindow platform functions for all viewports. call from backend Shutdown() if you need to close platform windows before imgui shutdown. otherwise will be called by DestroyContext().
func DestroyPlatformWindows() {
	C.igDestroyPlatformWindows()
}

// InternalDockBuilderAddNodeV parameter default value hint:
// node_id: 0
// flags: 0
func InternalDockBuilderAddNodeV(node_id ID, flags DockNodeFlags) ID {
	node_idArg, node_idFin := node_id.C()

	defer func() {
		node_idFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igDockBuilderAddNode(internal.ReinterpretCast[C.ImGuiID](node_idArg), C.ImGuiDockNodeFlags(flags))
		return &result
	}())
}

func InternalDockBuilderCopyWindowSettings(src_name, dst_name string) {
	src_nameArg, src_nameFin := internal.WrapString[C.char](src_name)
	dst_nameArg, dst_nameFin := internal.WrapString[C.char](dst_name)
	C.igDockBuilderCopyWindowSettings(src_nameArg, dst_nameArg)

	src_nameFin()
	dst_nameFin()
}

func InternalDockBuilderDockWindow(window_name string, node_id ID) {
	window_nameArg, window_nameFin := internal.WrapString[C.char](window_name)
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderDockWindow(window_nameArg, internal.ReinterpretCast[C.ImGuiID](node_idArg))

	window_nameFin()
	node_idFin()
}

func InternalDockBuilderFinish(node_id ID) {
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderFinish(internal.ReinterpretCast[C.ImGuiID](node_idArg))

	node_idFin()
}

func InternalDockBuilderGetCentralNode(node_id ID) *DockNode {
	node_idArg, node_idFin := node_id.C()

	defer func() {
		node_idFin()
	}()
	return NewDockNodeFromC(C.igDockBuilderGetCentralNode(internal.ReinterpretCast[C.ImGuiID](node_idArg)))
}

func InternalDockBuilderGetNode(node_id ID) *DockNode {
	node_idArg, node_idFin := node_id.C()

	defer func() {
		node_idFin()
	}()
	return NewDockNodeFromC(C.igDockBuilderGetNode(internal.ReinterpretCast[C.ImGuiID](node_idArg)))
}

// Remove node and all its child, undock all windows
func InternalDockBuilderRemoveNode(node_id ID) {
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderRemoveNode(internal.ReinterpretCast[C.ImGuiID](node_idArg))

	node_idFin()
}

// Remove all split/hierarchy. All remaining docked windows will be re-docked to the remaining root node (node_id).
func InternalDockBuilderRemoveNodeChildNodes(node_id ID) {
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderRemoveNodeChildNodes(internal.ReinterpretCast[C.ImGuiID](node_idArg))

	node_idFin()
}

// InternalDockBuilderRemoveNodeDockedWindowsV parameter default value hint:
// clear_settings_refs: true
func InternalDockBuilderRemoveNodeDockedWindowsV(node_id ID, clear_settings_refs bool) {
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderRemoveNodeDockedWindows(internal.ReinterpretCast[C.ImGuiID](node_idArg), C.bool(clear_settings_refs))

	node_idFin()
}

func InternalDockBuilderSetNodePos(node_id ID, pos Vec2) {
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderSetNodePos(internal.ReinterpretCast[C.ImGuiID](node_idArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()))

	node_idFin()
}

func InternalDockBuilderSetNodeSize(node_id ID, size Vec2) {
	node_idArg, node_idFin := node_id.C()
	C.igDockBuilderSetNodeSize(internal.ReinterpretCast[C.ImGuiID](node_idArg), internal.ReinterpretCast[C.ImVec2](size.ToC()))

	node_idFin()
}

// Create 2 child nodes in this parent node.
func InternalDockBuilderSplitNode(node_id ID, split_dir Dir, size_ratio_for_node_at_dir float32, out_id_at_dir, out_id_at_opposite_dir *ID) ID {
	node_idArg, node_idFin := node_id.C()
	out_id_at_dirArg, out_id_at_dirFin := out_id_at_dir.Handle()
	out_id_at_opposite_dirArg, out_id_at_opposite_dirFin := out_id_at_opposite_dir.Handle()

	defer func() {
		node_idFin()
		out_id_at_dirFin()
		out_id_at_opposite_dirFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igDockBuilderSplitNode(internal.ReinterpretCast[C.ImGuiID](node_idArg), C.ImGuiDir(split_dir), C.float(size_ratio_for_node_at_dir), internal.ReinterpretCast[*C.ImGuiID](out_id_at_dirArg), internal.ReinterpretCast[*C.ImGuiID](out_id_at_opposite_dirArg))
		return &result
	}())
}

func InternalDockContextCalcDropPosForDocking(target *Window, target_node *DockNode, payload_window *Window, payload_node *DockNode, split_dir Dir, split_outer bool, out_pos *Vec2) bool {
	targetArg, targetFin := target.Handle()
	target_nodeArg, target_nodeFin := target_node.Handle()
	payload_windowArg, payload_windowFin := payload_window.Handle()
	payload_nodeArg, payload_nodeFin := payload_node.Handle()
	out_posArg, out_posFin := internal.Wrap(out_pos)

	defer func() {
		targetFin()
		target_nodeFin()
		payload_windowFin()
		payload_nodeFin()
		out_posFin()
	}()
	return C.igDockContextCalcDropPosForDocking(internal.ReinterpretCast[*C.ImGuiWindow](targetArg), internal.ReinterpretCast[*C.ImGuiDockNode](target_nodeArg), internal.ReinterpretCast[*C.ImGuiWindow](payload_windowArg), internal.ReinterpretCast[*C.ImGuiDockNode](payload_nodeArg), C.ImGuiDir(split_dir), C.bool(split_outer), internal.ReinterpretCast[*C.ImVec2](out_posArg)) == C.bool(true)
}

// Use root_id==0 to clear all
func InternalDockContextClearNodes(ctx *Context, root_id ID, clear_settings_refs bool) {
	ctxArg, ctxFin := ctx.Handle()
	root_idArg, root_idFin := root_id.C()
	C.igDockContextClearNodes(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[C.ImGuiID](root_idArg), C.bool(clear_settings_refs))

	ctxFin()
	root_idFin()
}

func InternalDockContextEndFrame(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDockContextEndFrame(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDockContextFindNodeByID(ctx *Context, id ID) *DockNode {
	ctxArg, ctxFin := ctx.Handle()
	idArg, idFin := id.C()

	defer func() {
		ctxFin()
		idFin()
	}()
	return NewDockNodeFromC(C.igDockContextFindNodeByID(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalDockContextGenNodeID(ctx *Context) ID {
	ctxArg, ctxFin := ctx.Handle()

	defer func() {
		ctxFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igDockContextGenNodeID(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))
		return &result
	}())
}

func InternalDockContextInitialize(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDockContextInitialize(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDockContextNewFrameUpdateDocking(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDockContextNewFrameUpdateDocking(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDockContextNewFrameUpdateUndocking(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDockContextNewFrameUpdateUndocking(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDockContextProcessUndockNode(ctx *Context, node *DockNode) {
	ctxArg, ctxFin := ctx.Handle()
	nodeArg, nodeFin := node.Handle()
	C.igDockContextProcessUndockNode(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg))

	ctxFin()
	nodeFin()
}

// InternalDockContextProcessUndockWindowV parameter default value hint:
// clear_persistent_docking_ref: true
func InternalDockContextProcessUndockWindowV(ctx *Context, window *Window, clear_persistent_docking_ref bool) {
	ctxArg, ctxFin := ctx.Handle()
	windowArg, windowFin := window.Handle()
	C.igDockContextProcessUndockWindow(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.bool(clear_persistent_docking_ref))

	ctxFin()
	windowFin()
}

func InternalDockContextQueueDock(ctx *Context, target *Window, target_node *DockNode, payload *Window, split_dir Dir, split_ratio float32, split_outer bool) {
	ctxArg, ctxFin := ctx.Handle()
	targetArg, targetFin := target.Handle()
	target_nodeArg, target_nodeFin := target_node.Handle()
	payloadArg, payloadFin := payload.Handle()
	C.igDockContextQueueDock(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiWindow](targetArg), internal.ReinterpretCast[*C.ImGuiDockNode](target_nodeArg), internal.ReinterpretCast[*C.ImGuiWindow](payloadArg), C.ImGuiDir(split_dir), C.float(split_ratio), C.bool(split_outer))

	ctxFin()
	targetFin()
	target_nodeFin()
	payloadFin()
}

func InternalDockContextQueueUndockNode(ctx *Context, node *DockNode) {
	ctxArg, ctxFin := ctx.Handle()
	nodeArg, nodeFin := node.Handle()
	C.igDockContextQueueUndockNode(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg))

	ctxFin()
	nodeFin()
}

func InternalDockContextQueueUndockWindow(ctx *Context, window *Window) {
	ctxArg, ctxFin := ctx.Handle()
	windowArg, windowFin := window.Handle()
	C.igDockContextQueueUndockWindow(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	ctxFin()
	windowFin()
}

func InternalDockContextRebuildNodes(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDockContextRebuildNodes(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDockContextShutdown(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igDockContextShutdown(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalDockNodeBeginAmendTabBar(node *DockNode) bool {
	nodeArg, nodeFin := node.Handle()

	defer func() {
		nodeFin()
	}()
	return C.igDockNodeBeginAmendTabBar(internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg)) == C.bool(true)
}

func InternalDockNodeEndAmendTabBar() {
	C.igDockNodeEndAmendTabBar()
}

func InternalDockNodeGetDepth(node *DockNode) int32 {
	nodeArg, nodeFin := node.Handle()

	defer func() {
		nodeFin()
	}()
	return int32(C.igDockNodeGetDepth(internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg)))
}

func InternalDockNodeGetRootNode(node *DockNode) *DockNode {
	nodeArg, nodeFin := node.Handle()

	defer func() {
		nodeFin()
	}()
	return NewDockNodeFromC(C.igDockNodeGetRootNode(internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg)))
}

func InternalDockNodeGetWindowMenuButtonId(node *DockNode) ID {
	nodeArg, nodeFin := node.Handle()

	defer func() {
		nodeFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igDockNodeGetWindowMenuButtonId(internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg))
		return &result
	}())
}

func InternalDockNodeIsInHierarchyOf(node, parent *DockNode) bool {
	nodeArg, nodeFin := node.Handle()
	parentArg, parentFin := parent.Handle()

	defer func() {
		nodeFin()
		parentFin()
	}()
	return C.igDockNodeIsInHierarchyOf(internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg), internal.ReinterpretCast[*C.ImGuiDockNode](parentArg)) == C.bool(true)
}

func InternalDockNodeWindowMenuHandlerDefault(ctx *Context, node *DockNode, tab_bar *TabBar) {
	ctxArg, ctxFin := ctx.Handle()
	nodeArg, nodeFin := node.Handle()
	tab_barArg, tab_barFin := tab_bar.Handle()
	C.igDockNodeWindowMenuHandler_Default(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg), internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg))

	ctxFin()
	nodeFin()
	tab_barFin()
}

// DockSpaceV parameter default value hint:
// size: ImVec2(0,0)
// flags: 0
// window_class: NULL
func DockSpaceV(dockspace_id ID, size Vec2, flags DockNodeFlags, window_class *WindowClass) ID {
	dockspace_idArg, dockspace_idFin := dockspace_id.C()
	window_classArg, window_classFin := window_class.Handle()

	defer func() {
		dockspace_idFin()
		window_classFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igDockSpace(internal.ReinterpretCast[C.ImGuiID](dockspace_idArg), internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiDockNodeFlags(flags), internal.ReinterpretCast[*C.ImGuiWindowClass](window_classArg))
		return &result
	}())
}

// DockSpaceOverViewportV parameter default value hint:
// dockspace_id: 0
// viewport: NULL
// flags: 0
// window_class: NULL
func DockSpaceOverViewportV(dockspace_id ID, viewport *Viewport, flags DockNodeFlags, window_class *WindowClass) ID {
	dockspace_idArg, dockspace_idFin := dockspace_id.C()
	viewportArg, viewportFin := viewport.Handle()
	window_classArg, window_classFin := window_class.Handle()

	defer func() {
		dockspace_idFin()
		viewportFin()
		window_classFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igDockSpaceOverViewport(internal.ReinterpretCast[C.ImGuiID](dockspace_idArg), internal.ReinterpretCast[*C.ImGuiViewport](viewportArg), C.ImGuiDockNodeFlags(flags), internal.ReinterpretCast[*C.ImGuiWindowClass](window_classArg))
		return &result
	}())
}

func InternalDragBehavior(id ID, data_type DataType, p_v uintptr, v_speed float32, p_min, p_max uintptr, format string, flags SliderFlags) bool {
	idArg, idFin := id.C()
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		idFin()
		formatFin()
	}()
	return C.wrap_igDragBehavior(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiDataType(data_type), C.uintptr_t(p_v), C.float(v_speed), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// If v_min >= v_max we have no bound
// DragFloatV parameter default value hint:
// v_speed: 1.0f
// v_min: 0.0f
// v_max: 0.0f
// format: "%.3f"
// flags: 0
func DragFloatV(label string, v *float32, v_speed, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igDragFloat(labelArg, vArg, C.float(v_speed), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragFloat2V parameter default value hint:
// v_speed: 1.0f
// v_min: 0.0f
// v_max: 0.0f
// format: "%.3f"
// flags: 0
func DragFloat2V(label string, v *[2]float32, v_speed, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igDragFloat2(labelArg, (*C.float)(&vArg[0]), C.float(v_speed), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragFloat3V parameter default value hint:
// v_speed: 1.0f
// v_min: 0.0f
// v_max: 0.0f
// format: "%.3f"
// flags: 0
func DragFloat3V(label string, v *[3]float32, v_speed, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igDragFloat3(labelArg, (*C.float)(&vArg[0]), C.float(v_speed), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragFloat4V parameter default value hint:
// v_speed: 1.0f
// v_min: 0.0f
// v_max: 0.0f
// format: "%.3f"
// flags: 0
func DragFloat4V(label string, v *[4]float32, v_speed, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igDragFloat4(labelArg, (*C.float)(&vArg[0]), C.float(v_speed), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragFloatRange2V parameter default value hint:
// v_speed: 1.0f
// v_min: 0.0f
// v_max: 0.0f
// format: "%.3f"
// format_max: NULL
// flags: 0
func DragFloatRange2V(label string, v_current_min, v_current_max *float32, v_speed, v_min, v_max float32, format, format_max string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	v_current_minArg, v_current_minFin := internal.WrapNumberPtr[C.float, float32](v_current_min)
	v_current_maxArg, v_current_maxFin := internal.WrapNumberPtr[C.float, float32](v_current_max)
	formatArg, formatFin := internal.WrapString[C.char](format)
	format_maxArg, format_maxFin := internal.WrapString[C.char](format_max)

	defer func() {
		labelFin()
		v_current_minFin()
		v_current_maxFin()
		formatFin()
		format_maxFin()
	}()
	return C.igDragFloatRange2(labelArg, v_current_minArg, v_current_maxArg, C.float(v_speed), C.float(v_min), C.float(v_max), formatArg, format_maxArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// If v_min >= v_max we have no bound
// DragIntV parameter default value hint:
// v_speed: 1.0f
// v_min: 0
// v_max: 0
// format: "%d"
// flags: 0
func DragIntV(label string, v *int32, v_speed float32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igDragInt(labelArg, vArg, C.float(v_speed), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragInt2V parameter default value hint:
// v_speed: 1.0f
// v_min: 0
// v_max: 0
// format: "%d"
// flags: 0
func DragInt2V(label string, v *[2]int32, v_speed float32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}

		formatFin()
	}()
	return C.igDragInt2(labelArg, (*C.int)(&vArg[0]), C.float(v_speed), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragInt3V parameter default value hint:
// v_speed: 1.0f
// v_min: 0
// v_max: 0
// format: "%d"
// flags: 0
func DragInt3V(label string, v *[3]int32, v_speed float32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}

		formatFin()
	}()
	return C.igDragInt3(labelArg, (*C.int)(&vArg[0]), C.float(v_speed), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragInt4V parameter default value hint:
// v_speed: 1.0f
// v_min: 0
// v_max: 0
// format: "%d"
// flags: 0
func DragInt4V(label string, v *[4]int32, v_speed float32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}

		formatFin()
	}()
	return C.igDragInt4(labelArg, (*C.int)(&vArg[0]), C.float(v_speed), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragIntRange2V parameter default value hint:
// v_speed: 1.0f
// v_min: 0
// v_max: 0
// format: "%d"
// format_max: NULL
// flags: 0
func DragIntRange2V(label string, v_current_min, v_current_max *int32, v_speed float32, v_min, v_max int32, format, format_max string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	v_current_minArg, v_current_minFin := internal.WrapNumberPtr[C.int, int32](v_current_min)
	v_current_maxArg, v_current_maxFin := internal.WrapNumberPtr[C.int, int32](v_current_max)
	formatArg, formatFin := internal.WrapString[C.char](format)
	format_maxArg, format_maxFin := internal.WrapString[C.char](format_max)

	defer func() {
		labelFin()
		v_current_minFin()
		v_current_maxFin()
		formatFin()
		format_maxFin()
	}()
	return C.igDragIntRange2(labelArg, v_current_minArg, v_current_maxArg, C.float(v_speed), C.int(v_min), C.int(v_max), formatArg, format_maxArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragScalarV parameter default value hint:
// v_speed: 1.0f
// p_min: NULL
// p_max: NULL
// format: NULL
// flags: 0
func DragScalarV(label string, data_type DataType, p_data uintptr, v_speed float32, p_min, p_max uintptr, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igDragScalarV(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.float(v_speed), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// DragScalarNV parameter default value hint:
// v_speed: 1.0f
// p_min: NULL
// p_max: NULL
// format: NULL
// flags: 0
func DragScalarNV(label string, data_type DataType, p_data uintptr, components int32, v_speed float32, p_min, p_max uintptr, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igDragScalarNV(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.int(components), C.float(v_speed), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into.
func Dummy(size Vec2) {
	C.igDummy(internal.ReinterpretCast[C.ImVec2](size.ToC()))
}

func End() {
	C.igEnd()
}

func InternalEndBoxSelect(scope_rect Rect, ms_flags MultiSelectFlags) {
	C.igEndBoxSelect(internal.ReinterpretCast[C.ImRect](scope_rect.ToC()), C.ImGuiMultiSelectFlags(ms_flags))
}

func EndChild() {
	C.igEndChild()
}

// close columns
func InternalEndColumns() {
	C.igEndColumns()
}

// only call EndCombo() if BeginCombo() returns true!
func EndCombo() {
	C.igEndCombo()
}

func InternalEndComboPreview() {
	C.igEndComboPreview()
}

func EndDisabled() {
	C.igEndDisabled()
}

func InternalEndDisabledOverrideReenable() {
	C.igEndDisabledOverrideReenable()
}

// only call EndDragDropSource() if BeginDragDropSource() returns true!
func EndDragDropSource() {
	C.igEndDragDropSource()
}

// only call EndDragDropTarget() if BeginDragDropTarget() returns true!
func EndDragDropTarget() {
	C.igEndDragDropTarget()
}

func InternalEndErrorTooltip() {
	C.igEndErrorTooltip()
}

// ends the Dear ImGui frame. automatically called by Render(). If you don't need to render data (skipping rendering) you may call EndFrame() without Render()... but you'll have wasted CPU already! If you don't need to render, better to not create any windows and not call NewFrame() at all!
func EndFrame() {
	C.igEndFrame()
}

// unlock horizontal starting position + capture the whole group bounding box into one "item" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.)
func EndGroup() {
	C.igEndGroup()
}

// only call EndListBox() if BeginListBox() returned true!
func EndListBox() {
	C.igEndListBox()
}

// only call EndMainMenuBar() if BeginMainMenuBar() returns true!
func EndMainMenuBar() {
	C.igEndMainMenuBar()
}

// only call EndMenu() if BeginMenu() returns true!
func EndMenu() {
	C.igEndMenu()
}

// only call EndMenuBar() if BeginMenuBar() returns true!
func EndMenuBar() {
	C.igEndMenuBar()
}

func EndMultiSelect() *MultiSelectIO {
	return NewMultiSelectIOFromC(C.igEndMultiSelect())
}

// only call EndPopup() if BeginPopupXXX() returns true!
func EndPopup() {
	C.igEndPopup()
}

// only call EndTabBar() if BeginTabBar() returns true!
func EndTabBar() {
	C.igEndTabBar()
}

// only call EndTabItem() if BeginTabItem() returns true!
func EndTabItem() {
	C.igEndTabItem()
}

// only call EndTable() if BeginTable() returns true!
func EndTable() {
	C.igEndTable()
}

// only call EndTooltip() if BeginTooltip()/BeginItemTooltip() returns true!
func EndTooltip() {
	C.igEndTooltip()
}

func InternalErrorCheckEndFrameFinalizeErrorTooltip() {
	C.igErrorCheckEndFrameFinalizeErrorTooltip()
}

func InternalErrorCheckUsingSetCursorPosToExtendParentBoundaries() {
	C.igErrorCheckUsingSetCursorPosToExtendParentBoundaries()
}

func InternalErrorLog(msg string) bool {
	msgArg, msgFin := internal.WrapString[C.char](msg)

	defer func() {
		msgFin()
	}()
	return C.igErrorLog(msgArg) == C.bool(true)
}

func InternalErrorRecoveryStoreState(state_out *ErrorRecoveryState) {
	state_outArg, state_outFin := state_out.Handle()
	C.igErrorRecoveryStoreState(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](state_outArg))

	state_outFin()
}

func InternalErrorRecoveryTryToRecoverState(state_in *ErrorRecoveryState) {
	state_inArg, state_inFin := state_in.Handle()
	C.igErrorRecoveryTryToRecoverState(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](state_inArg))

	state_inFin()
}

func InternalErrorRecoveryTryToRecoverWindowState(state_in *ErrorRecoveryState) {
	state_inArg, state_inFin := state_in.Handle()
	C.igErrorRecoveryTryToRecoverWindowState(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](state_inArg))

	state_inFin()
}

func InternalFindBestWindowPosForPopup(window *Window) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igFindBestWindowPosForPopup(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalFindBestWindowPosForPopupEx(ref_pos, size Vec2, last_dir *Dir, r_outer, r_avoid Rect, policy PopupPositionPolicy) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igFindBestWindowPosForPopupEx(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](ref_pos.ToC()), internal.ReinterpretCast[C.ImVec2](size.ToC()), (*C.ImGuiDir)(last_dir), internal.ReinterpretCast[C.ImRect](r_outer.ToC()), internal.ReinterpretCast[C.ImRect](r_avoid.ToC()), C.ImGuiPopupPositionPolicy(policy))

	pOutFin()

	return *pOut
}

func InternalFindBlockingModal(window *Window) *Window {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return NewWindowFromC(C.igFindBlockingModal(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)))
}

func InternalFindBottomMostVisibleWindowWithinBeginStack(window *Window) *Window {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return NewWindowFromC(C.igFindBottomMostVisibleWindowWithinBeginStack(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)))
}

func InternalFindHoveredViewportFromPlatformWindowStack(mouse_platform_pos Vec2) *ViewportP {
	return NewViewportPFromC(C.igFindHoveredViewportFromPlatformWindowStack(internal.ReinterpretCast[C.ImVec2](mouse_platform_pos.ToC())))
}

func InternalFindOrCreateColumns(window *Window, id ID) *OldColumns {
	windowArg, windowFin := window.Handle()
	idArg, idFin := id.C()

	defer func() {
		windowFin()
		idFin()
	}()
	return NewOldColumnsFromC(C.igFindOrCreateColumns(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImGuiID](idArg)))
}

// Find the optional ## from which we stop displaying text.
// InternalFindRenderedTextEndV parameter default value hint:
func InternalFindRenderedTextEndV(text string) string {
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		textFin()
	}()
	return C.GoString(C.wrap_igFindRenderedTextEndV(textArg, C.int(len(text))))
}

func InternalFindSettingsHandler(type_name string) *SettingsHandler {
	type_nameArg, type_nameFin := internal.WrapString[C.char](type_name)

	defer func() {
		type_nameFin()
	}()
	return NewSettingsHandlerFromC(C.igFindSettingsHandler(type_nameArg))
}

// this is a helper for backends.
func FindViewportByID(id ID) *Viewport {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewViewportFromC(C.igFindViewportByID(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

// this is a helper for backends. the type platform_handle is decided by the backend (e.g. HWND, MyWindow*, GLFWwindow* etc.)
func FindViewportByPlatformHandle(platform_handle uintptr) *Viewport {
	return NewViewportFromC(C.wrap_igFindViewportByPlatformHandle(C.uintptr_t(platform_handle)))
}

func InternalFindWindowByID(id ID) *Window {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewWindowFromC(C.igFindWindowByID(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalFindWindowByName(name string) *Window {
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		nameFin()
	}()
	return NewWindowFromC(C.igFindWindowByName(nameArg))
}

func InternalFindWindowDisplayIndex(window *Window) int32 {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return int32(C.igFindWindowDisplayIndex(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)))
}

func InternalFindWindowSettingsByID(id ID) *WindowSettings {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewWindowSettingsFromC(C.igFindWindowSettingsByID(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalFindWindowSettingsByWindow(window *Window) *WindowSettings {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return NewWindowSettingsFromC(C.igFindWindowSettingsByWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)))
}

func InternalFixupKeyChord(key_chord KeyChord) KeyChord {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord {
		result := C.igFixupKeyChord(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg))
		return &result
	}())
}

// Focus last item (no selection/activation).
func InternalFocusItem() {
	C.igFocusItem()
}

func InternalFocusTopMostWindowUnderOne(under_this_window, ignore_window *Window, filter_viewport *Viewport, flags FocusRequestFlags) {
	under_this_windowArg, under_this_windowFin := under_this_window.Handle()
	ignore_windowArg, ignore_windowFin := ignore_window.Handle()
	filter_viewportArg, filter_viewportFin := filter_viewport.Handle()
	C.igFocusTopMostWindowUnderOne(internal.ReinterpretCast[*C.ImGuiWindow](under_this_windowArg), internal.ReinterpretCast[*C.ImGuiWindow](ignore_windowArg), internal.ReinterpretCast[*C.ImGuiViewport](filter_viewportArg), C.ImGuiFocusRequestFlags(flags))

	under_this_windowFin()
	ignore_windowFin()
	filter_viewportFin()
}

// InternalFocusWindowV parameter default value hint:
// flags: 0
func InternalFocusWindowV(window *Window, flags FocusRequestFlags) {
	windowArg, windowFin := window.Handle()
	C.igFocusWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiFocusRequestFlags(flags))

	windowFin()
}

func InternalGcAwakeTransientWindowBuffers(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igGcAwakeTransientWindowBuffers(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalGcCompactTransientMiscBuffers() {
	C.igGcCompactTransientMiscBuffers()
}

func InternalGcCompactTransientWindowBuffers(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igGcCompactTransientWindowBuffers(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalActiveID() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetActiveID(); return &result }())
}

// get background draw list for the given viewport or viewport associated to the current window. this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
// BackgroundDrawListV parameter default value hint:
// viewport: NULL
func BackgroundDrawListV(viewport *Viewport) *DrawList {
	viewportArg, viewportFin := viewport.Handle()

	defer func() {
		viewportFin()
	}()
	return NewDrawListFromC(C.igGetBackgroundDrawList(internal.ReinterpretCast[*C.ImGuiViewport](viewportArg)))
}

func InternalBoxSelectState(id ID) *BoxSelectState {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewBoxSelectStateFromC(C.igGetBoxSelectState(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func ClipboardText() string {
	return C.GoString(C.igGetClipboardText())
}

// retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value suitable for ImDrawList
// ColorU32ColV parameter default value hint:
// alpha_mul: 1.0f
func ColorU32ColV(idx Col, alpha_mul float32) uint32 {
	return (uint32)(C.igGetColorU32_Col(C.ImGuiCol(idx), C.float(alpha_mul)))
}

// retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList
// ColorU32U32V parameter default value hint:
// alpha_mul: 1.0f
func ColorU32U32V(col uint32, alpha_mul float32) uint32 {
	return (uint32)(C.igGetColorU32_U32(C.ImU32(col), C.float(alpha_mul)))
}

// retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList
func ColorU32Vec4(col Vec4) uint32 {
	return (uint32)(C.igGetColorU32_Vec4(internal.ReinterpretCast[C.ImVec4](col.ToC())))
}

// get current column index
func ColumnIndex() int32 {
	return int32(C.igGetColumnIndex())
}

func InternalColumnNormFromOffset(columns *OldColumns, offset float32) float32 {
	columnsArg, columnsFin := columns.Handle()

	defer func() {
		columnsFin()
	}()
	return float32(C.igGetColumnNormFromOffset(internal.ReinterpretCast[*C.ImGuiOldColumns](columnsArg), C.float(offset)))
}

// get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f
// ColumnOffsetV parameter default value hint:
// column_index: -1
func ColumnOffsetV(column_index int32) float32 {
	return float32(C.igGetColumnOffset(C.int(column_index)))
}

func InternalColumnOffsetFromNorm(columns *OldColumns, offset_norm float32) float32 {
	columnsArg, columnsFin := columns.Handle()

	defer func() {
		columnsFin()
	}()
	return float32(C.igGetColumnOffsetFromNorm(internal.ReinterpretCast[*C.ImGuiOldColumns](columnsArg), C.float(offset_norm)))
}

// get column width (in pixels). pass -1 to use current column
// ColumnWidthV parameter default value hint:
// column_index: -1
func ColumnWidthV(column_index int32) float32 {
	return float32(C.igGetColumnWidth(C.int(column_index)))
}

func ColumnsCount() int32 {
	return int32(C.igGetColumnsCount())
}

func InternalColumnsID(str_id string, count int32) ID {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetColumnsID(str_idArg, C.int(count)); return &result }())
}

// available space from current position. THIS IS YOUR BEST FRIEND.
func ContentRegionAvail() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetContentRegionAvail(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func CurrentContext() *Context {
	return NewContextFromC(C.igGetCurrentContext())
}

// Focus scope we are outputting into, set by PushFocusScope()
func InternalCurrentFocusScope() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetCurrentFocusScope(); return &result }())
}

func InternalCurrentTabBar() *TabBar {
	return NewTabBarFromC(C.igGetCurrentTabBar())
}

func InternalCurrentTable() *Table {
	return NewTableFromC(C.igGetCurrentTable())
}

func InternalCurrentWindow() *Window {
	return NewWindowFromC(C.igGetCurrentWindow())
}

func InternalCurrentWindowRead() *Window {
	return NewWindowFromC(C.igGetCurrentWindowRead())
}

// [window-local] cursor position in window-local coordinates. This is not your best friend.
func CursorPos() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetCursorPos(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// [window-local] "
func CursorPosX() float32 {
	return float32(C.igGetCursorPosX())
}

// [window-local] "
func CursorPosY() float32 {
	return float32(C.igGetCursorPosY())
}

// cursor position, absolute coordinates. THIS IS YOUR BEST FRIEND (prefer using this rather than GetCursorPos(), also more useful to work with ImDrawList API).
func CursorScreenPos() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetCursorScreenPos(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// [window-local] initial cursor position, in window-local coordinates. Call GetCursorScreenPos() after Begin() to get the absolute coordinates version.
func CursorStartPos() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetCursorStartPos(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func InternalDefaultFont() *Font {
	return NewFontFromC(C.igGetDefaultFont())
}

// peek directly into the current payload from anywhere. returns NULL when drag and drop is finished or inactive. use ImGuiPayload::IsDataType() to test for the payload type.
func DragDropPayload() *Payload {
	return NewPayloadFromC(C.igGetDragDropPayload())
}

// valid after Render() and until the next call to NewFrame(). Call ImGui_ImplXXXX_RenderDrawData() function in your Renderer Backend to render.
func CurrentDrawData() *DrawData {
	return NewDrawDataFromC(C.igGetDrawData())
}

// you may use this when creating your own ImDrawList instances.
func CurrentDrawListSharedData() *DrawListSharedData {
	return NewDrawListSharedDataFromC(C.igGetDrawListSharedData())
}

func InternalFocusID() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetFocusID(); return &result }())
}

// get current font
func CurrentFont() *Font {
	return NewFontFromC(C.igGetFont())
}

// get current font bound at current size // == GetFont()->GetFontBaked(GetFontSize())
func GetFontBaked() *FontBaked {
	return NewFontBakedFromC(C.igGetFontBaked())
}

func InternalFontRasterizerDensity() float32 {
	return float32(C.igGetFontRasterizerDensity())
}

// get current scaled font size (= height in pixels). AFTER global scale factors applied. *IMPORTANT* DO NOT PASS THIS VALUE TO PushFont()! Use ImGui::GetStyle().FontSizeBase to get value before global scale factors.
func FontSize() float32 {
	return float32(C.igGetFontSize())
}

// get UV coordinate for a white pixel, useful to draw custom shapes via the ImDrawList API
func FontTexUvWhitePixel() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetFontTexUvWhitePixel(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// get foreground draw list for the given viewport or viewport associated to the current window. this draw list will be the top-most rendered one. Useful to quickly draw shapes/text over dear imgui contents.
// ForegroundDrawListViewportPtrV parameter default value hint:
// viewport: NULL
func ForegroundDrawListViewportPtrV(viewport *Viewport) *DrawList {
	viewportArg, viewportFin := viewport.Handle()

	defer func() {
		viewportFin()
	}()
	return NewDrawListFromC(C.igGetForegroundDrawList_ViewportPtr(internal.ReinterpretCast[*C.ImGuiViewport](viewportArg)))
}

func InternalForegroundDrawListWindowPtr(window *Window) *DrawList {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return NewDrawListFromC(C.igGetForegroundDrawList_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)))
}

// get global imgui frame count. incremented by 1 every frame.
func FrameCount() int32 {
	return int32(C.igGetFrameCount())
}

// ~ FontSize + style.FramePadding.y * 2
func FrameHeight() float32 {
	return float32(C.igGetFrameHeight())
}

// ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets)
func FrameHeightWithSpacing() float32 {
	return float32(C.igGetFrameHeightWithSpacing())
}

func InternalHoveredID() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetHoveredID(); return &result }())
}

func InternalIDWithSeedInt(n int32, seed ID) ID {
	seedArg, seedFin := seed.C()

	defer func() {
		seedFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igGetIDWithSeed_Int(C.int(n), internal.ReinterpretCast[C.ImGuiID](seedArg))
		return &result
	}())
}

func InternalIDWithSeedStr(str_id_begin, str_id_end string, seed ID) ID {
	str_id_beginArg, str_id_beginFin := internal.WrapString[C.char](str_id_begin)
	str_id_endArg, str_id_endFin := internal.WrapString[C.char](str_id_end)
	seedArg, seedFin := seed.C()

	defer func() {
		str_id_beginFin()
		str_id_endFin()
		seedFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igGetIDWithSeed_Str(str_id_beginArg, str_id_endArg, internal.ReinterpretCast[C.ImGuiID](seedArg))
		return &result
	}())
}

func IDInt(int_id int32) ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetID_Int(C.int(int_id)); return &result }())
}

func IDPtr(ptr_id uintptr) ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.wrap_igGetID_Ptr(C.uintptr_t(ptr_id)); return &result }())
}

// calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
func IDStr(str_id string) ID {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetID_Str(str_idArg); return &result }())
}

func IDStrStr(str_id_begin, str_id_end string) ID {
	str_id_beginArg, str_id_beginFin := internal.WrapString[C.char](str_id_begin)
	str_id_endArg, str_id_endFin := internal.WrapString[C.char](str_id_end)

	defer func() {
		str_id_beginFin()
		str_id_endFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetID_StrStr(str_id_beginArg, str_id_endArg); return &result }())
}

func InternalIOContextPtr(ctx *Context) *IO {
	ctxArg, ctxFin := ctx.Handle()

	defer func() {
		ctxFin()
	}()
	return NewIOFromC(C.igGetIO_ContextPtr(internal.ReinterpretCast[*C.ImGuiContext](ctxArg)))
}

// access the ImGuiIO structure (mouse/keyboard/gamepad inputs, time, various configuration options/flags)
func CurrentIO() *IO {
	return NewIOFromC(C.igGetIO_Nil())
}

// Get input text state if active
func InternalInputTextState(id ID) *InputTextState {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewInputTextStateFromC(C.igGetInputTextState(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalItemFlags() ItemFlags {
	return ItemFlags(C.igGetItemFlags())
}

// get ID of last item (~~ often same ImGui::GetID(label) beforehand)
func ItemID() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetItemID(); return &result }())
}

// get lower-right bounding rectangle of the last item (screen space)
func ItemRectMax() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetItemRectMax(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// get upper-left bounding rectangle of the last item (screen space)
func ItemRectMin() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetItemRectMin(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// get size of last item
func ItemRectSize() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetItemRectSize(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func InternalItemStatusFlags() ItemStatusFlags {
	return ItemStatusFlags(C.igGetItemStatusFlags())
}

func InternalKeyChordName(key_chord KeyChord) string {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return C.GoString(C.igGetKeyChordName(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg)))
}

func InternalKeyDataContextPtr(ctx *Context, key Key) *KeyData {
	ctxArg, ctxFin := ctx.Handle()

	defer func() {
		ctxFin()
	}()
	return NewKeyDataFromC(C.igGetKeyData_ContextPtr(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), C.ImGuiKey(key)))
}

func InternalKeyDataKey(key Key) *KeyData {
	return NewKeyDataFromC(C.igGetKeyData_Key(C.ImGuiKey(key)))
}

func InternalKeyMagnitude2d(key_left, key_right, key_up, key_down Key) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetKeyMagnitude2d(internal.ReinterpretCast[*C.ImVec2](pOutArg), C.ImGuiKey(key_left), C.ImGuiKey(key_right), C.ImGuiKey(key_up), C.ImGuiKey(key_down))

	pOutFin()

	return *pOut
}

// [DEBUG] returns English name of the key. Those names are provided for debugging purpose and are not meant to be saved persistently nor compared.
func KeyName(key Key) string {
	return C.GoString(C.igGetKeyName(C.ImGuiKey(key)))
}

func InternalKeyOwner(key Key) ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetKeyOwner(C.ImGuiKey(key)); return &result }())
}

func InternalKeyOwnerData(ctx *Context, key Key) *KeyOwnerData {
	ctxArg, ctxFin := ctx.Handle()

	defer func() {
		ctxFin()
	}()
	return NewKeyOwnerDataFromC(C.igGetKeyOwnerData(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), C.ImGuiKey(key)))
}

// uses provided repeat rate/delay. return a count, most often 0 or 1 but might be >1 if RepeatRate is small enough that DeltaTime > RepeatRate
func KeyPressedAmount(key Key, repeat_delay, rate float32) int32 {
	return int32(C.igGetKeyPressedAmount(C.ImGuiKey(key), C.float(repeat_delay), C.float(rate)))
}

// return primary/default viewport. This can never be NULL.
func MainViewport() *Viewport {
	return NewViewportFromC(C.igGetMainViewport())
}

// return the number of successive mouse-clicks at the time where a click happen (otherwise 0).
func MouseClickedCount(button MouseButton) int32 {
	return int32(C.igGetMouseClickedCount(C.ImGuiMouseButton(button)))
}

// get desired mouse cursor shape. Important: reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you
func CurrentMouseCursor() MouseCursor {
	return MouseCursor(C.igGetMouseCursor())
}

// return the delta from the initial clicking position while the mouse button is pressed or was just released. This is locked and return 0.0f until the mouse moves past a distance threshold at least once (uses io.MouseDraggingThreshold if lock_threshold < 0.0f)
// MouseDragDeltaV parameter default value hint:
// button: 0
// lock_threshold: -1.0f
func MouseDragDeltaV(button MouseButton, lock_threshold float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetMouseDragDelta(internal.ReinterpretCast[*C.ImVec2](pOutArg), C.ImGuiMouseButton(button), C.float(lock_threshold))

	pOutFin()

	return *pOut
}

// shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
func MousePos() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetMousePos(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// retrieve mouse position at the time of opening popup we have BeginPopup() into (helper to avoid user backing that value themselves)
func MousePosOnOpeningCurrentPopup() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetMousePosOnOpeningCurrentPopup(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func InternalMultiSelectState(id ID) *MultiSelectState {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewMultiSelectStateFromC(C.igGetMultiSelectState(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalNavTweakPressedAmount(axis Axis) float32 {
	return float32(C.igGetNavTweakPressedAmount(C.ImGuiAxis(axis)))
}

func InternalPlatformIOContextPtr(ctx *Context) *PlatformIO {
	ctxArg, ctxFin := ctx.Handle()

	defer func() {
		ctxFin()
	}()
	return NewPlatformIOFromC(C.igGetPlatformIO_ContextPtr(internal.ReinterpretCast[*C.ImGuiContext](ctxArg)))
}

// access the ImGuiPlatformIO structure (mostly hooks/functions to connect to platform/renderer and OS Clipboard, IME etc.)
func CurrentPlatformIO() *PlatformIO {
	return NewPlatformIOFromC(C.igGetPlatformIO_Nil())
}

func InternalPopupAllowedExtentRect(window *Window) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igGetPopupAllowedExtentRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalRoundedFontSize(size float32) float32 {
	return float32(C.igGetRoundedFontSize(C.float(size)))
}

// get maximum scrolling amount ~~ ContentSize.x - WindowSize.x - DecorationsSize.x
func ScrollMaxX() float32 {
	return float32(C.igGetScrollMaxX())
}

// get maximum scrolling amount ~~ ContentSize.y - WindowSize.y - DecorationsSize.y
func ScrollMaxY() float32 {
	return float32(C.igGetScrollMaxY())
}

// get scrolling amount [0 .. GetScrollMaxX()]
func ScrollX() float32 {
	return float32(C.igGetScrollX())
}

// get scrolling amount [0 .. GetScrollMaxY()]
func ScrollY() float32 {
	return float32(C.igGetScrollY())
}

func InternalShortcutRoutingData(key_chord KeyChord) *KeyRoutingData {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return NewKeyRoutingDataFromC(C.igGetShortcutRoutingData(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg)))
}

func StateStorage() *Storage {
	return NewStorageFromC(C.igGetStateStorage())
}

// access the Style structure (colors, sizes). Always use PushStyleColor(), PushStyleVar() to modify style mid-frame!
func CurrentStyle() *Style {
	return NewStyleFromC(C.igGetStyle())
}

// get a string corresponding to the enum value (for display, saving, etc.).
func StyleColorName(idx Col) string {
	return C.GoString(C.igGetStyleColorName(C.ImGuiCol(idx)))
}

// retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(), otherwise use GetColorU32() to get style color with style alpha baked in.
func StyleColorVec4(idx Col) *Vec4 {
	return (&Vec4{}).FromC(unsafe.Pointer(C.igGetStyleColorVec4(C.ImGuiCol(idx))))
}

func InternalStyleVarInfo(idx StyleVar) *StyleVarInfo {
	return NewStyleVarInfoFromC(C.igGetStyleVarInfo(C.ImGuiStyleVar(idx)))
}

// ~ FontSize
func TextLineHeight() float32 {
	return float32(C.igGetTextLineHeight())
}

// ~ FontSize + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of text)
func TextLineHeightWithSpacing() float32 {
	return float32(C.igGetTextLineHeightWithSpacing())
}

// get global imgui time. incremented by io.DeltaTime every frame.
func Time() float64 {
	return float64(C.igGetTime())
}

func InternalTopMostAndVisiblePopupModal() *Window {
	return NewWindowFromC(C.igGetTopMostAndVisiblePopupModal())
}

func InternalTopMostPopupModal() *Window {
	return NewWindowFromC(C.igGetTopMostPopupModal())
}

// horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode
func TreeNodeToLabelSpacing() float32 {
	return float32(C.igGetTreeNodeToLabelSpacing())
}

func InternalTypematicRepeatRate(flags InputFlags, repeat_delay, repeat_rate *float32) {
	repeat_delayArg, repeat_delayFin := internal.WrapNumberPtr[C.float, float32](repeat_delay)
	repeat_rateArg, repeat_rateFin := internal.WrapNumberPtr[C.float, float32](repeat_rate)
	C.igGetTypematicRepeatRate(C.ImGuiInputFlags(flags), repeat_delayArg, repeat_rateArg)

	repeat_delayFin()
	repeat_rateFin()
}

// InternalTypingSelectRequestV parameter default value hint:
// flags: ImGuiTypingSelectFlags_None
func InternalTypingSelectRequestV(flags TypingSelectFlags) *TypingSelectRequest {
	return NewTypingSelectRequestFromC(C.igGetTypingSelectRequest(C.ImGuiTypingSelectFlags(flags)))
}

// get the compiled version string e.g. "1.80 WIP" (essentially the value for IMGUI_VERSION from the compiled version of imgui.cpp)
func Version() string {
	return C.GoString(C.igGetVersion())
}

func InternalViewportPlatformMonitor(viewport *Viewport) *PlatformMonitor {
	viewportArg, viewportFin := viewport.Handle()

	defer func() {
		viewportFin()
	}()
	return NewPlatformMonitorFromC(C.igGetViewportPlatformMonitor(internal.ReinterpretCast[*C.ImGuiViewport](viewportArg)))
}

func InternalWindowAlwaysWantOwnTabBar(window *Window) bool {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return C.igGetWindowAlwaysWantOwnTabBar(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)) == C.bool(true)
}

func WindowDockID() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.igGetWindowDockID(); return &result }())
}

func InternalWindowDockNode() *DockNode {
	return NewDockNodeFromC(C.igGetWindowDockNode())
}

// get DPI scale currently associated to the current window's viewport.
func WindowDpiScale() float32 {
	return float32(C.igGetWindowDpiScale())
}

// get draw list associated to the current window, to append your own drawing primitives
func WindowDrawList() *DrawList {
	return NewDrawListFromC(C.igGetWindowDrawList())
}

// get current window height (IT IS UNLIKELY YOU EVER NEED TO USE THIS). Shortcut for GetWindowSize().y.
func WindowHeight() float32 {
	return float32(C.igGetWindowHeight())
}

// get current window position in screen space (IT IS UNLIKELY YOU EVER NEED TO USE THIS. Consider always using GetCursorScreenPos() and GetContentRegionAvail() instead)
func WindowPos() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetWindowPos(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func InternalWindowResizeBorderID(window *Window, dir Dir) ID {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igGetWindowResizeBorderID(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiDir(dir))
		return &result
	}())
}

// 0..3: corners
func InternalWindowResizeCornerID(window *Window, n int32) ID {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igGetWindowResizeCornerID(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.int(n))
		return &result
	}())
}

func InternalWindowScrollbarID(window *Window, axis Axis) ID {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igGetWindowScrollbarID(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiAxis(axis))
		return &result
	}())
}

func InternalWindowScrollbarRect(window *Window, axis Axis) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igGetWindowScrollbarRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiAxis(axis))

	pOutFin()
	windowFin()

	return *pOut
}

// get current window size (IT IS UNLIKELY YOU EVER NEED TO USE THIS. Consider always using GetCursorScreenPos() and GetContentRegionAvail() instead)
func WindowSize() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igGetWindowSize(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// get viewport currently associated to the current window.
func WindowViewport() *Viewport {
	return NewViewportFromC(C.igGetWindowViewport())
}

// get current window width (IT IS UNLIKELY YOU EVER NEED TO USE THIS). Shortcut for GetWindowSize().x.
func WindowWidth() float32 {
	return float32(C.igGetWindowWidth())
}

func InternalImAbsFloat(x float32) float32 {
	return float32(C.igImAbs_Float(C.float(x)))
}

func InternalImAbsInt(x int32) int32 {
	return int32(C.igImAbs_Int(C.int(x)))
}

func InternalImAbsDouble(x float64) float64 {
	return float64(C.igImAbs_double(C.double(x)))
}

func InternalImAlphaBlendColors(col_a, col_b uint32) uint32 {
	return (uint32)(C.igImAlphaBlendColors(C.ImU32(col_a), C.ImU32(col_b)))
}

func InternalImBezierCubicCalc(p1, p2, p3, p4 Vec2, t float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImBezierCubicCalc(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.float(t))

	pOutFin()

	return *pOut
}

// For curves with explicit number of segments
func InternalImBezierCubicClosestPoint(p1, p2, p3, p4, p Vec2, num_segments int32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImBezierCubicClosestPoint(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), internal.ReinterpretCast[C.ImVec2](p.ToC()), C.int(num_segments))

	pOutFin()

	return *pOut
}

// For auto-tessellated curves you can use tess_tol = style.CurveTessellationTol
func InternalImBezierCubicClosestPointCasteljau(p1, p2, p3, p4, p Vec2, tess_tol float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImBezierCubicClosestPointCasteljau(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), internal.ReinterpretCast[C.ImVec2](p.ToC()), C.float(tess_tol))

	pOutFin()

	return *pOut
}

func InternalImBezierQuadraticCalc(p1, p2, p3 Vec2, t float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImBezierQuadraticCalc(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.float(t))

	pOutFin()

	return *pOut
}

func InternalImBitArrayClearAllBits(arr *uint32, bitcount int32) {
	arrArg, arrFin := internal.WrapNumberPtr[C.ImU32, uint32](arr)
	C.igImBitArrayClearAllBits(arrArg, C.int(bitcount))

	arrFin()
}

func InternalImBitArrayClearBit(arr *uint32, n int32) {
	arrArg, arrFin := internal.WrapNumberPtr[C.ImU32, uint32](arr)
	C.igImBitArrayClearBit(arrArg, C.int(n))

	arrFin()
}

func InternalImBitArrayGetStorageSizeInBytes(bitcount int32) uint64 {
	return uint64(C.igImBitArrayGetStorageSizeInBytes(C.int(bitcount)))
}

func InternalImBitArraySetBit(arr *uint32, n int32) {
	arrArg, arrFin := internal.WrapNumberPtr[C.ImU32, uint32](arr)
	C.igImBitArraySetBit(arrArg, C.int(n))

	arrFin()
}

func InternalImBitArraySetBitRange(arr *uint32, n, n2 int32) {
	arrArg, arrFin := internal.WrapNumberPtr[C.ImU32, uint32](arr)
	C.igImBitArraySetBitRange(arrArg, C.int(n), C.int(n2))

	arrFin()
}

func InternalImBitArrayTestBit(arr *uint32, n int32) bool {
	arrArg, arrFin := internal.WrapNumberPtr[C.ImU32, uint32](arr)

	defer func() {
		arrFin()
	}()
	return C.igImBitArrayTestBit(arrArg, C.int(n)) == C.bool(true)
}

func InternalImCharIsBlankA(c rune) bool {
	return C.igImCharIsBlankA(C.char(c)) == C.bool(true)
}

func InternalImCharIsBlankW(c uint32) bool {
	return C.igImCharIsBlankW(C.uint(c)) == C.bool(true)
}

func InternalImCharIsXdigitA(c rune) bool {
	return C.igImCharIsXdigitA(C.char(c)) == C.bool(true)
}

func InternalImClamp(v, mn, mx Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImClamp(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](v.ToC()), internal.ReinterpretCast[C.ImVec2](mn.ToC()), internal.ReinterpretCast[C.ImVec2](mx.ToC()))

	pOutFin()

	return *pOut
}

func InternalImCountSetBits(v uint32) uint32 {
	return uint32(C.igImCountSetBits(C.uint(v)))
}

func InternalImDot(a, b Vec2) float32 {
	return float32(C.igImDot(internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC())))
}

func InternalImExponentialMovingAverage(avg, sample float32, n int32) float32 {
	return float32(C.igImExponentialMovingAverage(C.float(avg), C.float(sample), C.int(n)))
}

// InternalImFileLoadToMemoryV parameter default value hint:
// out_file_size: NULL
// padding_bytes: 0
func InternalImFileLoadToMemoryV(filename, mode string, out_file_size *uint64, padding_bytes int32) uintptr {
	filenameArg, filenameFin := internal.WrapString[C.char](filename)
	modeArg, modeFin := internal.WrapString[C.char](mode)

	defer func() {
		filenameFin()
		modeFin()
	}()
	return uintptr(C.wrap_igImFileLoadToMemoryV(filenameArg, modeArg, (*C.xulong)(out_file_size), C.int(padding_bytes)))
}

// Decent replacement for floorf()
func InternalImFloorFloat(f float32) float32 {
	return float32(C.igImFloor_Float(C.float(f)))
}

func InternalImFloorVec2(v Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImFloor_Vec2(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](v.ToC()))

	pOutFin()

	return *pOut
}

func InternalImFontAtlasAddDrawListSharedData(atlas *FontAtlas, data *DrawListSharedData) {
	atlasArg, atlasFin := atlas.Handle()
	dataArg, dataFin := data.Handle()
	C.igImFontAtlasAddDrawListSharedData(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImDrawListSharedData](dataArg))

	atlasFin()
	dataFin()
}

func InternalImFontAtlasBakedAdd(atlas *FontAtlas, font *Font, font_size, font_rasterizer_density float32, baked_id ID) *FontBaked {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	baked_idArg, baked_idFin := baked_id.C()

	defer func() {
		atlasFin()
		fontFin()
		baked_idFin()
	}()
	return NewFontBakedFromC(C.igImFontAtlasBakedAdd(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size), C.float(font_rasterizer_density), internal.ReinterpretCast[C.ImGuiID](baked_idArg)))
}

func InternalImFontAtlasBakedAddFontGlyph(atlas *FontAtlas, baked *FontBaked, src *FontConfig, in_glyph *FontGlyph) *FontGlyph {
	atlasArg, atlasFin := atlas.Handle()
	bakedArg, bakedFin := baked.Handle()
	srcArg, srcFin := src.Handle()
	in_glyphArg, in_glyphFin := in_glyph.Handle()

	defer func() {
		atlasFin()
		bakedFin()
		srcFin()
		in_glyphFin()
	}()
	return NewFontGlyphFromC(C.igImFontAtlasBakedAddFontGlyph(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg), internal.ReinterpretCast[*C.ImFontGlyph](in_glyphArg)))
}

func InternalImFontAtlasBakedAddFontGlyphAdvancedX(atlas *FontAtlas, baked *FontBaked, src *FontConfig, codepoint Wchar, advance_x float32) {
	atlasArg, atlasFin := atlas.Handle()
	bakedArg, bakedFin := baked.Handle()
	srcArg, srcFin := src.Handle()
	C.igImFontAtlasBakedAddFontGlyphAdvancedX(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg), C.ImWchar(codepoint), C.float(advance_x))

	atlasFin()
	bakedFin()
	srcFin()
}

func InternalImFontAtlasBakedDiscard(atlas *FontAtlas, font *Font, baked *FontBaked) {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	bakedArg, bakedFin := baked.Handle()
	C.igImFontAtlasBakedDiscard(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg))

	atlasFin()
	fontFin()
	bakedFin()
}

func InternalImFontAtlasBakedDiscardFontGlyph(atlas *FontAtlas, font *Font, baked *FontBaked, glyph *FontGlyph) {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	bakedArg, bakedFin := baked.Handle()
	glyphArg, glyphFin := glyph.Handle()
	C.igImFontAtlasBakedDiscardFontGlyph(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg), internal.ReinterpretCast[*C.ImFontGlyph](glyphArg))

	atlasFin()
	fontFin()
	bakedFin()
	glyphFin()
}

func InternalImFontAtlasBakedGetClosestMatch(atlas *FontAtlas, font *Font, font_size, font_rasterizer_density float32) *FontBaked {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()

	defer func() {
		atlasFin()
		fontFin()
	}()
	return NewFontBakedFromC(C.igImFontAtlasBakedGetClosestMatch(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size), C.float(font_rasterizer_density)))
}

func InternalImFontAtlasBakedGetId(font_id ID, baked_size, rasterizer_density float32) ID {
	font_idArg, font_idFin := font_id.C()

	defer func() {
		font_idFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igImFontAtlasBakedGetId(internal.ReinterpretCast[C.ImGuiID](font_idArg), C.float(baked_size), C.float(rasterizer_density))
		return &result
	}())
}

func InternalImFontAtlasBakedGetOrAdd(atlas *FontAtlas, font *Font, font_size, font_rasterizer_density float32) *FontBaked {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()

	defer func() {
		atlasFin()
		fontFin()
	}()
	return NewFontBakedFromC(C.igImFontAtlasBakedGetOrAdd(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size), C.float(font_rasterizer_density)))
}

func InternalImFontAtlasBakedSetFontGlyphBitmap(atlas *FontAtlas, baked *FontBaked, src *FontConfig, glyph *FontGlyph, r *TextureRect, src_pixels *uint, src_fmt TextureFormat, src_pitch int32) {
	atlasArg, atlasFin := atlas.Handle()
	bakedArg, bakedFin := baked.Handle()
	srcArg, srcFin := src.Handle()
	glyphArg, glyphFin := glyph.Handle()
	rArg, rFin := r.Handle()
	src_pixelsArg, src_pixelsFin := internal.WrapNumberPtr[C.uchar, uint](src_pixels)
	C.igImFontAtlasBakedSetFontGlyphBitmap(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg), internal.ReinterpretCast[*C.ImFontGlyph](glyphArg), internal.ReinterpretCast[*C.ImTextureRect](rArg), src_pixelsArg, C.ImTextureFormat(src_fmt), C.int(src_pitch))

	atlasFin()
	bakedFin()
	srcFin()
	glyphFin()
	rFin()
	src_pixelsFin()
}

// Clear output and custom rects
func InternalImFontAtlasBuildClear(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildClear(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasBuildDestroy(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildDestroy(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasBuildDiscardBakes(atlas *FontAtlas, unused_frames int32) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildDiscardBakes(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(unused_frames))

	atlasFin()
}

func InternalImFontAtlasBuildGetOversampleFactors(src *FontConfig, baked *FontBaked, out_oversample_h, out_oversample_v *int32) {
	srcArg, srcFin := src.Handle()
	bakedArg, bakedFin := baked.Handle()
	out_oversample_hArg, out_oversample_hFin := internal.WrapNumberPtr[C.int, int32](out_oversample_h)
	out_oversample_vArg, out_oversample_vFin := internal.WrapNumberPtr[C.int, int32](out_oversample_v)
	C.igImFontAtlasBuildGetOversampleFactors(internal.ReinterpretCast[*C.ImFontConfig](srcArg), internal.ReinterpretCast[*C.ImFontBaked](bakedArg), out_oversample_hArg, out_oversample_vArg)

	srcFin()
	bakedFin()
	out_oversample_hFin()
	out_oversample_vFin()
}

func InternalImFontAtlasBuildInit(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildInit(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

// Legacy
func InternalImFontAtlasBuildLegacyPreloadAllGlyphRanges(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildLegacyPreloadAllGlyphRanges(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasBuildMain(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildMain(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasBuildRenderBitmapFromString(atlas *FontAtlas, x, y, w, h int32, in_str string, in_marker_char rune) {
	atlasArg, atlasFin := atlas.Handle()
	in_strArg, in_strFin := internal.WrapString[C.char](in_str)
	C.igImFontAtlasBuildRenderBitmapFromString(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(x), C.int(y), C.int(w), C.int(h), in_strArg, C.char(in_marker_char))

	atlasFin()
	in_strFin()
}

func InternalImFontAtlasBuildSetupFontLoader(atlas *FontAtlas, font_loader *FontLoader) {
	atlasArg, atlasFin := atlas.Handle()
	font_loaderArg, font_loaderFin := font_loader.Handle()
	C.igImFontAtlasBuildSetupFontLoader(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFontLoader](font_loaderArg))

	atlasFin()
	font_loaderFin()
}

func InternalImFontAtlasBuildSetupFontSpecialGlyphs(atlas *FontAtlas, font *Font, src *FontConfig) {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	srcArg, srcFin := src.Handle()
	C.igImFontAtlasBuildSetupFontSpecialGlyphs(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg))

	atlasFin()
	fontFin()
	srcFin()
}

func InternalImFontAtlasBuildUpdatePointers(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasBuildUpdatePointers(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasDebugLogTextureRequests(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasDebugLogTextureRequests(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasFontDestroyOutput(atlas *FontAtlas, font *Font) {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	C.igImFontAtlasFontDestroyOutput(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg))

	atlasFin()
	fontFin()
}

func InternalImFontAtlasFontDestroySourceData(atlas *FontAtlas, src *FontConfig) {
	atlasArg, atlasFin := atlas.Handle()
	srcArg, srcFin := src.Handle()
	C.igImFontAtlasFontDestroySourceData(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg))

	atlasFin()
	srcFin()
}

func InternalImFontAtlasFontDiscardBakes(atlas *FontAtlas, font *Font, unused_frames int32) {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	C.igImFontAtlasFontDiscardBakes(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.int(unused_frames))

	atlasFin()
	fontFin()
}

// Using FontDestroyOutput/FontInitOutput sequence useful notably if font loader params have changed
func InternalImFontAtlasFontInitOutput(atlas *FontAtlas, font *Font) bool {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()

	defer func() {
		atlasFin()
		fontFin()
	}()
	return C.igImFontAtlasFontInitOutput(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg)) == C.bool(true)
}

func InternalImFontAtlasFontSourceAddToFont(atlas *FontAtlas, font *Font, src *FontConfig) {
	atlasArg, atlasFin := atlas.Handle()
	fontArg, fontFin := font.Handle()
	srcArg, srcFin := src.Handle()
	C.igImFontAtlasFontSourceAddToFont(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFont](fontArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg))

	atlasFin()
	fontFin()
	srcFin()
}

func InternalImFontAtlasFontSourceInit(atlas *FontAtlas, src *FontConfig) bool {
	atlasArg, atlasFin := atlas.Handle()
	srcArg, srcFin := src.Handle()

	defer func() {
		atlasFin()
		srcFin()
	}()
	return C.igImFontAtlasFontSourceInit(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImFontConfig](srcArg)) == C.bool(true)
}

func InternalImFontAtlasGetFontLoaderForStbTruetype() *FontLoader {
	return NewFontLoaderFromC(C.igImFontAtlasGetFontLoaderForStbTruetype())
}

func InternalImFontAtlasGetMouseCursorTexData(atlas *FontAtlas, cursor_type MouseCursor, out_offset, out_size *Vec2, out_uv_border, out_uv_fill [2]*Vec2) bool {
	atlasArg, atlasFin := atlas.Handle()
	out_offsetArg, out_offsetFin := internal.Wrap(out_offset)
	out_sizeArg, out_sizeFin := internal.Wrap(out_size)
	out_uv_borderArg := make([]C.ImVec2, len(out_uv_border))
	out_uv_borderFin := make([]func(), len(out_uv_border))
	for i, out_uv_borderV := range out_uv_border {
		var tmp *C.ImVec2
		tmp, out_uv_borderFin[i] = internal.Wrap(out_uv_borderV)
		out_uv_borderArg[i] = *tmp
	}

	out_uv_fillArg := make([]C.ImVec2, len(out_uv_fill))
	out_uv_fillFin := make([]func(), len(out_uv_fill))
	for i, out_uv_fillV := range out_uv_fill {
		var tmp *C.ImVec2
		tmp, out_uv_fillFin[i] = internal.Wrap(out_uv_fillV)
		out_uv_fillArg[i] = *tmp
	}

	defer func() {
		atlasFin()
		out_offsetFin()
		out_sizeFin()

		for _, out_uv_borderV := range out_uv_borderFin {
			out_uv_borderV()
		}

		for _, out_uv_fillV := range out_uv_fillFin {
			out_uv_fillV()
		}
	}()
	return C.igImFontAtlasGetMouseCursorTexData(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.ImGuiMouseCursor(cursor_type), internal.ReinterpretCast[*C.ImVec2](out_offsetArg), internal.ReinterpretCast[*C.ImVec2](out_sizeArg), (*C.ImVec2)(&out_uv_borderArg[0]), (*C.ImVec2)(&out_uv_fillArg[0])) == C.bool(true)
}

// InternalImFontAtlasPackAddRectV parameter default value hint:
// overwrite_entry: NULL
func InternalImFontAtlasPackAddRectV(atlas *FontAtlas, w, h int32, overwrite_entry *FontAtlasRectEntry) FontAtlasRectId {
	atlasArg, atlasFin := atlas.Handle()
	overwrite_entryArg, overwrite_entryFin := overwrite_entry.Handle()

	defer func() {
		atlasFin()
		overwrite_entryFin()
	}()
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId {
		result := C.igImFontAtlasPackAddRect(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(w), C.int(h), internal.ReinterpretCast[*C.ImFontAtlasRectEntry](overwrite_entryArg))
		return &result
	}())
}

func InternalImFontAtlasPackDiscardRect(atlas *FontAtlas, id FontAtlasRectId) {
	atlasArg, atlasFin := atlas.Handle()
	idArg, idFin := id.C()
	C.igImFontAtlasPackDiscardRect(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[C.ImFontAtlasRectId](idArg))

	atlasFin()
	idFin()
}

func InternalImFontAtlasPackGetRect(atlas *FontAtlas, id FontAtlasRectId) *TextureRect {
	atlasArg, atlasFin := atlas.Handle()
	idArg, idFin := id.C()

	defer func() {
		atlasFin()
		idFin()
	}()
	return NewTextureRectFromC(C.igImFontAtlasPackGetRect(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[C.ImFontAtlasRectId](idArg)))
}

func InternalImFontAtlasPackGetRectSafe(atlas *FontAtlas, id FontAtlasRectId) *TextureRect {
	atlasArg, atlasFin := atlas.Handle()
	idArg, idFin := id.C()

	defer func() {
		atlasFin()
		idFin()
	}()
	return NewTextureRectFromC(C.igImFontAtlasPackGetRectSafe(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[C.ImFontAtlasRectId](idArg)))
}

func InternalImFontAtlasPackInit(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasPackInit(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasRectIdGetGeneration(id FontAtlasRectId) uint32 {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return uint32(C.igImFontAtlasRectId_GetGeneration(internal.ReinterpretCast[C.ImFontAtlasRectId](idArg)))
}

func InternalImFontAtlasRectIdGetIndex(id FontAtlasRectId) int32 {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return int32(C.igImFontAtlasRectId_GetIndex(internal.ReinterpretCast[C.ImFontAtlasRectId](idArg)))
}

func InternalImFontAtlasRectIdMake(index_idx, gen_idx int32) FontAtlasRectId {
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId {
		result := C.igImFontAtlasRectId_Make(C.int(index_idx), C.int(gen_idx))
		return &result
	}())
}

func InternalImFontAtlasRemoveDrawListSharedData(atlas *FontAtlas, data *DrawListSharedData) {
	atlasArg, atlasFin := atlas.Handle()
	dataArg, dataFin := data.Handle()
	C.igImFontAtlasRemoveDrawListSharedData(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImDrawListSharedData](dataArg))

	atlasFin()
	dataFin()
}

func InternalImFontAtlasTextureAdd(atlas *FontAtlas, w, h int32) *TextureData {
	atlasArg, atlasFin := atlas.Handle()

	defer func() {
		atlasFin()
	}()
	return NewTextureDataFromC(C.igImFontAtlasTextureAdd(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(w), C.int(h)))
}

func InternalImFontAtlasTextureBlockConvert(src_pixels *uint, src_fmt TextureFormat, src_pitch int32, dst_pixels *uint, dst_fmt TextureFormat, dst_pitch, w, h int32) {
	src_pixelsArg, src_pixelsFin := internal.WrapNumberPtr[C.uchar, uint](src_pixels)
	dst_pixelsArg, dst_pixelsFin := internal.WrapNumberPtr[C.uchar, uint](dst_pixels)
	C.igImFontAtlasTextureBlockConvert(src_pixelsArg, C.ImTextureFormat(src_fmt), C.int(src_pitch), dst_pixelsArg, C.ImTextureFormat(dst_fmt), C.int(dst_pitch), C.int(w), C.int(h))

	src_pixelsFin()
	dst_pixelsFin()
}

func InternalImFontAtlasTextureBlockCopy(src_tex *TextureData, src_x, src_y int32, dst_tex *TextureData, dst_x, dst_y, w, h int32) {
	src_texArg, src_texFin := src_tex.Handle()
	dst_texArg, dst_texFin := dst_tex.Handle()
	C.igImFontAtlasTextureBlockCopy(internal.ReinterpretCast[*C.ImTextureData](src_texArg), C.int(src_x), C.int(src_y), internal.ReinterpretCast[*C.ImTextureData](dst_texArg), C.int(dst_x), C.int(dst_y), C.int(w), C.int(h))

	src_texFin()
	dst_texFin()
}

func InternalImFontAtlasTextureBlockFill(dst_tex *TextureData, dst_x, dst_y, w, h int32, col uint32) {
	dst_texArg, dst_texFin := dst_tex.Handle()
	C.igImFontAtlasTextureBlockFill(internal.ReinterpretCast[*C.ImTextureData](dst_texArg), C.int(dst_x), C.int(dst_y), C.int(w), C.int(h), C.ImU32(col))

	dst_texFin()
}

func InternalImFontAtlasTextureBlockPostProcess(data *FontAtlasPostProcessData) {
	dataArg, dataFin := data.Handle()
	C.igImFontAtlasTextureBlockPostProcess(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](dataArg))

	dataFin()
}

func InternalImFontAtlasTextureBlockPostProcessMultiply(data *FontAtlasPostProcessData, multiply_factor float32) {
	dataArg, dataFin := data.Handle()
	C.igImFontAtlasTextureBlockPostProcessMultiply(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](dataArg), C.float(multiply_factor))

	dataFin()
}

func InternalImFontAtlasTextureBlockQueueUpload(atlas *FontAtlas, tex *TextureData, x, y, w, h int32) {
	atlasArg, atlasFin := atlas.Handle()
	texArg, texFin := tex.Handle()
	C.igImFontAtlasTextureBlockQueueUpload(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[*C.ImTextureData](texArg), C.int(x), C.int(y), C.int(w), C.int(h))

	atlasFin()
	texFin()
}

func InternalImFontAtlasTextureCompact(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasTextureCompact(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasTextureGetSizeEstimate(atlas *FontAtlas) Vec2i {
	pOut := new(Vec2i)
	pOutArg, pOutFin := pOut.Handle()

	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasTextureGetSizeEstimate(internal.ReinterpretCast[*C.ImVec2i](pOutArg), internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	pOutFin()
	atlasFin()

	return *pOut
}

// InternalImFontAtlasTextureGrowV parameter default value hint:
// old_w: -1
// old_h: -1
func InternalImFontAtlasTextureGrowV(atlas *FontAtlas, old_w, old_h int32) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasTextureGrow(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(old_w), C.int(old_h))

	atlasFin()
}

func InternalImFontAtlasTextureMakeSpace(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasTextureMakeSpace(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasTextureRepack(atlas *FontAtlas, w, h int32) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasTextureRepack(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(w), C.int(h))

	atlasFin()
}

func InternalImFontAtlasUpdateDrawListsSharedData(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasUpdateDrawListsSharedData(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontAtlasUpdateDrawListsTextures(atlas *FontAtlas, old_tex, new_tex TextureRef) {
	atlasArg, atlasFin := atlas.Handle()
	old_texArg, old_texFin := old_tex.C()
	new_texArg, new_texFin := new_tex.C()
	C.igImFontAtlasUpdateDrawListsTextures(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), internal.ReinterpretCast[C.ImTextureRef](old_texArg), internal.ReinterpretCast[C.ImTextureRef](new_texArg))

	atlasFin()
	old_texFin()
	new_texFin()
}

func InternalImFontAtlasUpdateNewFrame(atlas *FontAtlas, frame_count int32, renderer_has_textures bool) {
	atlasArg, atlasFin := atlas.Handle()
	C.igImFontAtlasUpdateNewFrame(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(frame_count), C.bool(renderer_has_textures))

	atlasFin()
}

func InternalImFontCalcTextSizeEx(font *Font, size, max_width, wrap_width float32, text_begin, text_end_display string, out_remaining []string, out_offset *Vec2, flags DrawTextFlags) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	fontArg, fontFin := font.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	text_end_displayArg, text_end_displayFin := internal.WrapString[C.char](text_end_display)
	out_remainingArg, out_remainingFin := internal.WrapStringList[C.char](out_remaining)
	out_offsetArg, out_offsetFin := internal.Wrap(out_offset)
	C.wrap_igImFontCalcTextSizeEx(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.float(size), C.float(max_width), C.float(wrap_width), text_beginArg, text_end_displayArg, out_remainingArg, internal.ReinterpretCast[*C.ImVec2](out_offsetArg), C.ImDrawTextFlags(flags))

	pOutFin()
	fontFin()
	text_beginFin()
	text_end_displayFin()
	out_remainingFin()
	out_offsetFin()

	return *pOut
}

// InternalImFontCalcWordWrapPositionExV parameter default value hint:
// flags: 0
func InternalImFontCalcWordWrapPositionExV(font *Font, size float32, text string, wrap_width float32, flags DrawTextFlags) string {
	fontArg, fontFin := font.Handle()
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		fontFin()
		textFin()
	}()
	return C.GoString(C.wrap_igImFontCalcWordWrapPositionExV(internal.ReinterpretCast[*C.ImFont](fontArg), C.float(size), textArg, C.int(len(text)), C.float(wrap_width), C.ImDrawTextFlags(flags)))
}

func InternalImFormatString(buf string, buf_size uint64, fmt string) int32 {
	bufArg, bufFin := internal.WrapString[C.char](buf)
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)

	defer func() {
		bufFin()
		fmtFin()
	}()
	return int32(C.wrap_igImFormatString(bufArg, C.xulong(buf_size), fmtArg))
}

func InternalImFormatStringToTempBuffer(out_buf, out_buf_end []string, fmt string) {
	out_bufArg, out_bufFin := internal.WrapStringList[C.char](out_buf)
	out_buf_endArg, out_buf_endFin := internal.WrapStringList[C.char](out_buf_end)
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igImFormatStringToTempBuffer(out_bufArg, out_buf_endArg, fmtArg)

	out_bufFin()
	out_buf_endFin()
	fmtFin()
}

// InternalImHashDataV parameter default value hint:
// seed: 0
func InternalImHashDataV(data uintptr, data_size uint64, seed ID) ID {
	seedArg, seedFin := seed.C()

	defer func() {
		seedFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_igImHashDataV(C.uintptr_t(data), C.xulong(data_size), internal.ReinterpretCast[C.ImGuiID](seedArg))
		return &result
	}())
}

func InternalImHashSkipUncontributingPrefix(label string) string {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.GoString(C.igImHashSkipUncontributingPrefix(labelArg))
}

// InternalImHashStrV parameter default value hint:
// data_size: 0
// seed: 0
func InternalImHashStrV(data string, data_size uint64, seed ID) ID {
	dataArg, dataFin := internal.WrapString[C.char](data)
	seedArg, seedFin := seed.C()

	defer func() {
		dataFin()
		seedFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igImHashStr(dataArg, C.xulong(data_size), internal.ReinterpretCast[C.ImGuiID](seedArg))
		return &result
	}())
}

func InternalImInvLength(lhs Vec2, fail_value float32) float32 {
	return float32(C.igImInvLength(internal.ReinterpretCast[C.ImVec2](lhs.ToC()), C.float(fail_value)))
}

func InternalImIsFloatAboveGuaranteedIntegerPrecision(f float32) bool {
	return C.igImIsFloatAboveGuaranteedIntegerPrecision(C.float(f)) == C.bool(true)
}

func InternalImIsPowerOfTwoInt(v int32) bool {
	return C.igImIsPowerOfTwo_Int(C.int(v)) == C.bool(true)
}

func InternalImIsPowerOfTwoU64(v uint64) bool {
	return C.igImIsPowerOfTwo_U64(C.ImU64(v)) == C.bool(true)
}

func InternalImLengthSqrVec2(lhs Vec2) float32 {
	return float32(C.igImLengthSqr_Vec2(internal.ReinterpretCast[C.ImVec2](lhs.ToC())))
}

func InternalImLengthSqrVec4(lhs Vec4) float32 {
	return float32(C.igImLengthSqr_Vec4(internal.ReinterpretCast[C.ImVec4](lhs.ToC())))
}

func InternalImLerpVec2Float(a, b Vec2, t float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImLerp_Vec2Float(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), C.float(t))

	pOutFin()

	return *pOut
}

func InternalImLerpVec2Vec2(a, b, t Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImLerp_Vec2Vec2(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](t.ToC()))

	pOutFin()

	return *pOut
}

func InternalImLerpVec4(a, b Vec4, t float32) Vec4 {
	pOut := new(Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImLerp_Vec4(internal.ReinterpretCast[*C.ImVec4](pOutArg), internal.ReinterpretCast[C.ImVec4](a.ToC()), internal.ReinterpretCast[C.ImVec4](b.ToC()), C.float(t))

	pOutFin()

	return *pOut
}

func InternalImLineClosestPoint(a, b, p Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImLineClosestPoint(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](p.ToC()))

	pOutFin()

	return *pOut
}

func InternalImLinearRemapClamp(s0, s1, d0, d1, x float32) float32 {
	return float32(C.igImLinearRemapClamp(C.float(s0), C.float(s1), C.float(d0), C.float(d1), C.float(x)))
}

func InternalImLinearSweep(current, target, speed float32) float32 {
	return float32(C.igImLinearSweep(C.float(current), C.float(target), C.float(speed)))
}

// DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision
func InternalImLogFloat(x float32) float32 {
	return float32(C.igImLog_Float(C.float(x)))
}

func InternalImLogDouble(x float64) float64 {
	return float64(C.igImLog_double(C.double(x)))
}

func InternalImLowerBound(in_begin, in_end *StoragePair, key ID) *StoragePair {
	in_beginArg, in_beginFin := in_begin.Handle()
	in_endArg, in_endFin := in_end.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		in_beginFin()
		in_endFin()
		keyFin()
	}()
	return NewStoragePairFromC(C.igImLowerBound(internal.ReinterpretCast[*C.ImGuiStoragePair](in_beginArg), internal.ReinterpretCast[*C.ImGuiStoragePair](in_endArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func InternalImMax(lhs, rhs Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImMax(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](lhs.ToC()), internal.ReinterpretCast[C.ImVec2](rhs.ToC()))

	pOutFin()

	return *pOut
}

// Duplicate a chunk of memory.
func InternalImMemdup(src uintptr, size uint64) uintptr {
	return uintptr(C.wrap_igImMemdup(C.uintptr_t(src), C.xulong(size)))
}

func InternalImMin(lhs, rhs Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImMin(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](lhs.ToC()), internal.ReinterpretCast[C.ImVec2](rhs.ToC()))

	pOutFin()

	return *pOut
}

func InternalImModPositive(a, b int32) int32 {
	return int32(C.igImModPositive(C.int(a), C.int(b)))
}

func InternalImMul(lhs, rhs Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImMul(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](lhs.ToC()), internal.ReinterpretCast[C.ImVec2](rhs.ToC()))

	pOutFin()

	return *pOut
}

func InternalImParseFormatFindEnd(format string) string {
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		formatFin()
	}()
	return C.GoString(C.igImParseFormatFindEnd(formatArg))
}

func InternalImParseFormatFindStart(format string) string {
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		formatFin()
	}()
	return C.GoString(C.igImParseFormatFindStart(formatArg))
}

func InternalImParseFormatPrecision(format string, default_value int32) int32 {
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		formatFin()
	}()
	return int32(C.igImParseFormatPrecision(formatArg, C.int(default_value)))
}

func InternalImParseFormatSanitizeForPrinting(fmt_in, fmt_out string, fmt_out_size uint64) {
	fmt_inArg, fmt_inFin := internal.WrapString[C.char](fmt_in)
	fmt_outArg, fmt_outFin := internal.WrapString[C.char](fmt_out)
	C.igImParseFormatSanitizeForPrinting(fmt_inArg, fmt_outArg, C.xulong(fmt_out_size))

	fmt_inFin()
	fmt_outFin()
}

func InternalImParseFormatSanitizeForScanning(fmt_in, fmt_out string, fmt_out_size uint64) string {
	fmt_inArg, fmt_inFin := internal.WrapString[C.char](fmt_in)
	fmt_outArg, fmt_outFin := internal.WrapString[C.char](fmt_out)

	defer func() {
		fmt_inFin()
		fmt_outFin()
	}()
	return C.GoString(C.igImParseFormatSanitizeForScanning(fmt_inArg, fmt_outArg, C.xulong(fmt_out_size)))
}

func InternalImParseFormatTrimDecorations(format, buf string, buf_size uint64) string {
	formatArg, formatFin := internal.WrapString[C.char](format)
	bufArg, bufFin := internal.WrapString[C.char](buf)

	defer func() {
		formatFin()
		bufFin()
	}()
	return C.GoString(C.igImParseFormatTrimDecorations(formatArg, bufArg, C.xulong(buf_size)))
}

// DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision
func InternalImPowFloat(x, y float32) float32 {
	return float32(C.igImPow_Float(C.float(x), C.float(y)))
}

func InternalImPowDouble(x, y float64) float64 {
	return float64(C.igImPow_double(C.double(x), C.double(y)))
}

func InternalImRotate(v Vec2, cos_a, sin_a float32) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImRotate(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](v.ToC()), C.float(cos_a), C.float(sin_a))

	pOutFin()

	return *pOut
}

func InternalImRound64(f float32) float32 {
	return float32(C.igImRound64(C.float(f)))
}

func InternalImRsqrtFloat(x float32) float32 {
	return float32(C.igImRsqrt_Float(C.float(x)))
}

func InternalImRsqrtDouble(x float64) float64 {
	return float64(C.igImRsqrt_double(C.double(x)))
}

func InternalImSaturate(f float32) float32 {
	return float32(C.igImSaturate(C.float(f)))
}

// Sign operator - returns -1, 0 or 1 based on sign of argument
func InternalImSignFloat(x float32) float32 {
	return float32(C.igImSign_Float(C.float(x)))
}

func InternalImSignDouble(x float64) float64 {
	return float64(C.igImSign_double(C.double(x)))
}

// Find first non-blank character.
func InternalImStrSkipBlank(str string) string {
	strArg, strFin := internal.WrapString[C.char](str)

	defer func() {
		strFin()
	}()
	return C.GoString(C.igImStrSkipBlank(strArg))
}

// Remove leading and trailing blanks from a buffer.
func InternalImStrTrimBlanks(str string) {
	strArg, strFin := internal.WrapString[C.char](str)
	C.igImStrTrimBlanks(strArg)

	strFin()
}

// Find beginning-of-line
func InternalImStrbol(buf_mid_line, buf_begin string) string {
	buf_mid_lineArg, buf_mid_lineFin := internal.WrapString[C.char](buf_mid_line)
	buf_beginArg, buf_beginFin := internal.WrapString[C.char](buf_begin)

	defer func() {
		buf_mid_lineFin()
		buf_beginFin()
	}()
	return C.GoString(C.igImStrbol(buf_mid_lineArg, buf_beginArg))
}

// Find first occurrence of 'c' in string range.
func InternalImStrchrRange(str_begin, str_end string, c rune) string {
	str_beginArg, str_beginFin := internal.WrapString[C.char](str_begin)
	str_endArg, str_endFin := internal.WrapString[C.char](str_end)

	defer func() {
		str_beginFin()
		str_endFin()
	}()
	return C.GoString(C.igImStrchrRange(str_beginArg, str_endArg, C.char(c)))
}

// Duplicate a string.
func InternalImStrdup(str string) string {
	strArg, strFin := internal.WrapString[C.char](str)

	defer func() {
		strFin()
	}()
	return C.GoString(C.igImStrdup(strArg))
}

// Copy in provided buffer, recreate buffer if needed.
func InternalImStrdupcpy(dst string, p_dst_size *uint64, str string) string {
	dstArg, dstFin := internal.WrapString[C.char](dst)
	strArg, strFin := internal.WrapString[C.char](str)

	defer func() {
		dstFin()
		strFin()
	}()
	return C.GoString(C.igImStrdupcpy(dstArg, (*C.xulong)(p_dst_size), strArg))
}

// End end-of-line
func InternalImStreolRange(str, str_end string) string {
	strArg, strFin := internal.WrapString[C.char](str)
	str_endArg, str_endFin := internal.WrapString[C.char](str_end)

	defer func() {
		strFin()
		str_endFin()
	}()
	return C.GoString(C.igImStreolRange(strArg, str_endArg))
}

// Case insensitive compare.
func InternalImStricmp(str1, str2 string) int32 {
	str1Arg, str1Fin := internal.WrapString[C.char](str1)
	str2Arg, str2Fin := internal.WrapString[C.char](str2)

	defer func() {
		str1Fin()
		str2Fin()
	}()
	return int32(C.igImStricmp(str1Arg, str2Arg))
}

// Find a substring in a string range.
func InternalImStristr(haystack, haystack_end, needle, needle_end string) string {
	haystackArg, haystackFin := internal.WrapString[C.char](haystack)
	haystack_endArg, haystack_endFin := internal.WrapString[C.char](haystack_end)
	needleArg, needleFin := internal.WrapString[C.char](needle)
	needle_endArg, needle_endFin := internal.WrapString[C.char](needle_end)

	defer func() {
		haystackFin()
		haystack_endFin()
		needleFin()
		needle_endFin()
	}()
	return C.GoString(C.igImStristr(haystackArg, haystack_endArg, needleArg, needle_endArg))
}

// Computer string length (ImWchar string)
func InternalImStrlenW(str *Wchar) int32 {
	return int32(C.igImStrlenW((*C.ImWchar)(str)))
}

// Copy to a certain count and always zero terminate (strncpy doesn't).
func InternalImStrncpy(dst, src string, count uint64) {
	dstArg, dstFin := internal.WrapString[C.char](dst)
	srcArg, srcFin := internal.WrapString[C.char](src)
	C.igImStrncpy(dstArg, srcArg, C.xulong(count))

	dstFin()
	srcFin()
}

// Case insensitive compare to a certain count.
func InternalImStrnicmp(str1, str2 string, count uint64) int32 {
	str1Arg, str1Fin := internal.WrapString[C.char](str1)
	str2Arg, str2Fin := internal.WrapString[C.char](str2)

	defer func() {
		str1Fin()
		str2Fin()
	}()
	return int32(C.igImStrnicmp(str1Arg, str2Arg, C.xulong(count)))
}

// trim trailing space and find beginning of next line
// InternalImTextCalcWordWrapNextLineStartV parameter default value hint:
// flags: 0
func InternalImTextCalcWordWrapNextLineStartV(text string, flags DrawTextFlags) string {
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		textFin()
	}()
	return C.GoString(C.wrap_igImTextCalcWordWrapNextLineStartV(textArg, C.int(len(text)), C.ImDrawTextFlags(flags)))
}

// read one character. return input UTF-8 bytes count
func InternalImTextCharFromUtf8(out_char *uint32, in_text, in_text_end string) int32 {
	out_charArg, out_charFin := internal.WrapNumberPtr[C.uint, uint32](out_char)
	in_textArg, in_textFin := internal.WrapString[C.char](in_text)
	in_text_endArg, in_text_endFin := internal.WrapString[C.char](in_text_end)

	defer func() {
		out_charFin()
		in_textFin()
		in_text_endFin()
	}()
	return int32(C.igImTextCharFromUtf8(out_charArg, in_textArg, in_text_endArg))
}

// return output UTF-8 bytes count
func InternalImTextCharToUtf8(out_buf *[5]rune, c uint32) int32 {
	out_bufArg := make([]C.char, len(out_buf))
	for i, out_bufV := range out_buf {
		out_bufArg[i] = C.char(out_bufV)
	}

	defer func() {
		for i, out_bufV := range out_bufArg {
			(*out_buf)[i] = rune(out_bufV)
		}
	}()
	return int32(C.igImTextCharToUtf8((*C.char)(&out_bufArg[0]), C.uint(c)))
}

// return number of UTF-8 code-points (NOT bytes count)
func InternalImTextCountCharsFromUtf8(in_text, in_text_end string) int32 {
	in_textArg, in_textFin := internal.WrapString[C.char](in_text)
	in_text_endArg, in_text_endFin := internal.WrapString[C.char](in_text_end)

	defer func() {
		in_textFin()
		in_text_endFin()
	}()
	return int32(C.igImTextCountCharsFromUtf8(in_textArg, in_text_endArg))
}

// return number of lines taken by text. trailing carriage return doesn't count as an extra line.
func InternalImTextCountLines(in_text, in_text_end string) int32 {
	in_textArg, in_textFin := internal.WrapString[C.char](in_text)
	in_text_endArg, in_text_endFin := internal.WrapString[C.char](in_text_end)

	defer func() {
		in_textFin()
		in_text_endFin()
	}()
	return int32(C.igImTextCountLines(in_textArg, in_text_endArg))
}

// return number of bytes to express one char in UTF-8
func InternalImTextCountUtf8BytesFromChar(in_text, in_text_end string) int32 {
	in_textArg, in_textFin := internal.WrapString[C.char](in_text)
	in_text_endArg, in_text_endFin := internal.WrapString[C.char](in_text_end)

	defer func() {
		in_textFin()
		in_text_endFin()
	}()
	return int32(C.igImTextCountUtf8BytesFromChar(in_textArg, in_text_endArg))
}

// return number of bytes to express string in UTF-8
func InternalImTextCountUtf8BytesFromStr(in_text, in_text_end *Wchar) int32 {
	return int32(C.igImTextCountUtf8BytesFromStr((*C.ImWchar)(in_text), (*C.ImWchar)(in_text_end)))
}

// return previous UTF-8 code-point.
func InternalImTextFindPreviousUtf8Codepoint(in_text_start, in_text_curr string) string {
	in_text_startArg, in_text_startFin := internal.WrapString[C.char](in_text_start)
	in_text_currArg, in_text_currFin := internal.WrapString[C.char](in_text_curr)

	defer func() {
		in_text_startFin()
		in_text_currFin()
	}()
	return C.GoString(C.igImTextFindPreviousUtf8Codepoint(in_text_startArg, in_text_currArg))
}

// return input UTF-8 bytes count
// InternalImTextStrFromUtf8V parameter default value hint:
// in_remaining: NULL
func InternalImTextStrFromUtf8V(out_buf *Wchar, out_buf_size int32, in_text, in_text_end string, in_remaining []string) int32 {
	in_textArg, in_textFin := internal.WrapString[C.char](in_text)
	in_text_endArg, in_text_endFin := internal.WrapString[C.char](in_text_end)
	in_remainingArg, in_remainingFin := internal.WrapStringList[C.char](in_remaining)

	defer func() {
		in_textFin()
		in_text_endFin()
		in_remainingFin()
	}()
	return int32(C.igImTextStrFromUtf8((*C.ImWchar)(out_buf), C.int(out_buf_size), in_textArg, in_text_endArg, in_remainingArg))
}

// return output UTF-8 bytes count
func InternalImTextStrToUtf8(out_buf string, out_buf_size int32, in_text, in_text_end *Wchar) int32 {
	out_bufArg, out_bufFin := internal.WrapString[C.char](out_buf)

	defer func() {
		out_bufFin()
	}()
	return int32(C.igImTextStrToUtf8(out_bufArg, C.int(out_buf_size), (*C.ImWchar)(in_text), (*C.ImWchar)(in_text_end)))
}

func InternalImTextureDataGetFormatBytesPerPixel(format TextureFormat) int32 {
	return int32(C.igImTextureDataGetFormatBytesPerPixel(C.ImTextureFormat(format)))
}

func InternalImTextureDataGetFormatName(format TextureFormat) string {
	return C.GoString(C.igImTextureDataGetFormatName(C.ImTextureFormat(format)))
}

func InternalImTextureDataGetStatusName(status TextureStatus) string {
	return C.GoString(C.igImTextureDataGetStatusName(C.ImTextureStatus(status)))
}

func InternalImToUpper(c rune) rune {
	return rune(C.igImToUpper(C.char(c)))
}

func InternalImTriangleArea(a, b, c Vec2) float32 {
	return float32(C.igImTriangleArea(internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](c.ToC())))
}

func InternalImTriangleBarycentricCoords(a, b, c, p Vec2, out_u, out_v, out_w *float32) {
	out_uArg, out_uFin := internal.WrapNumberPtr[C.float, float32](out_u)
	out_vArg, out_vFin := internal.WrapNumberPtr[C.float, float32](out_v)
	out_wArg, out_wFin := internal.WrapNumberPtr[C.float, float32](out_w)
	C.igImTriangleBarycentricCoords(internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](c.ToC()), internal.ReinterpretCast[C.ImVec2](p.ToC()), out_uArg, out_vArg, out_wArg)

	out_uFin()
	out_vFin()
	out_wFin()
}

func InternalImTriangleClosestPoint(a, b, c, p Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImTriangleClosestPoint(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](c.ToC()), internal.ReinterpretCast[C.ImVec2](p.ToC()))

	pOutFin()

	return *pOut
}

func InternalImTriangleContainsPoint(a, b, c, p Vec2) bool {
	return C.igImTriangleContainsPoint(internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](c.ToC()), internal.ReinterpretCast[C.ImVec2](p.ToC())) == C.bool(true)
}

func InternalImTriangleIsClockwise(a, b, c Vec2) bool {
	return C.igImTriangleIsClockwise(internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](c.ToC())) == C.bool(true)
}

func InternalImTrunc64(f float32) float32 {
	return float32(C.igImTrunc64(C.float(f)))
}

func InternalImTruncFloat(f float32) float32 {
	return float32(C.igImTrunc_Float(C.float(f)))
}

func InternalImTruncVec2(v Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.igImTrunc_Vec2(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](v.ToC()))

	pOutFin()

	return *pOut
}

func InternalImUpperPowerOfTwo(v int32) int32 {
	return int32(C.igImUpperPowerOfTwo(C.int(v)))
}

// ImageV parameter default value hint:
// uv0: ImVec2(0,0)
// uv1: ImVec2(1,1)
func ImageV(tex_ref TextureRef, image_size, uv0, uv1 Vec2) {
	tex_refArg, tex_refFin := tex_ref.C()
	C.igImage(internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()), internal.ReinterpretCast[C.ImVec2](uv0.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()))

	tex_refFin()
}

// ImageButtonV parameter default value hint:
// uv0: ImVec2(0,0)
// uv1: ImVec2(1,1)
// bg_col: ImVec4(0,0,0,0)
// tint_col: ImVec4(1,1,1,1)
func ImageButtonV(str_id string, tex_ref TextureRef, image_size, uv0, uv1 Vec2, bg_col, tint_col Vec4) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	tex_refArg, tex_refFin := tex_ref.C()

	defer func() {
		str_idFin()
		tex_refFin()
	}()
	return C.igImageButton(str_idArg, internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()), internal.ReinterpretCast[C.ImVec2](uv0.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()), internal.ReinterpretCast[C.ImVec4](bg_col.ToC()), internal.ReinterpretCast[C.ImVec4](tint_col.ToC())) == C.bool(true)
}

// InternalImageButtonExV parameter default value hint:
// flags: 0
func InternalImageButtonExV(id ID, tex_ref TextureRef, image_size, uv0, uv1 Vec2, bg_col, tint_col Vec4, flags ButtonFlags) bool {
	idArg, idFin := id.C()
	tex_refArg, tex_refFin := tex_ref.C()

	defer func() {
		idFin()
		tex_refFin()
	}()
	return C.igImageButtonEx(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()), internal.ReinterpretCast[C.ImVec2](uv0.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()), internal.ReinterpretCast[C.ImVec4](bg_col.ToC()), internal.ReinterpretCast[C.ImVec4](tint_col.ToC()), C.ImGuiButtonFlags(flags)) == C.bool(true)
}

// ImageWithBgV parameter default value hint:
// uv0: ImVec2(0,0)
// uv1: ImVec2(1,1)
// bg_col: ImVec4(0,0,0,0)
// tint_col: ImVec4(1,1,1,1)
func ImageWithBgV(tex_ref TextureRef, image_size, uv0, uv1 Vec2, bg_col, tint_col Vec4) {
	tex_refArg, tex_refFin := tex_ref.C()
	C.igImageWithBg(internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()), internal.ReinterpretCast[C.ImVec2](uv0.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()), internal.ReinterpretCast[C.ImVec4](bg_col.ToC()), internal.ReinterpretCast[C.ImVec4](tint_col.ToC()))

	tex_refFin()
}

// move content position toward the right, by indent_w, or style.IndentSpacing if indent_w <= 0
// IndentV parameter default value hint:
// indent_w: 0.0f
func IndentV(indent_w float32) {
	C.igIndent(C.float(indent_w))
}

func InternalInitialize() {
	C.igInitialize()
}

// InputDoubleV parameter default value hint:
// step: 0.0
// step_fast: 0.0
// format: "%.6f"
// flags: 0
func InputDoubleV(label string, v *float64, step, step_fast float64, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.double, float64](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igInputDouble(labelArg, vArg, C.double(step), C.double(step_fast), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputFloatV parameter default value hint:
// step: 0.0f
// step_fast: 0.0f
// format: "%.3f"
// flags: 0
func InputFloatV(label string, v *float32, step, step_fast float32, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igInputFloat(labelArg, vArg, C.float(step), C.float(step_fast), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputFloat2V parameter default value hint:
// format: "%.3f"
// flags: 0
func InputFloat2V(label string, v *[2]float32, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igInputFloat2(labelArg, (*C.float)(&vArg[0]), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputFloat3V parameter default value hint:
// format: "%.3f"
// flags: 0
func InputFloat3V(label string, v *[3]float32, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igInputFloat3(labelArg, (*C.float)(&vArg[0]), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputFloat4V parameter default value hint:
// format: "%.3f"
// flags: 0
func InputFloat4V(label string, v *[4]float32, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igInputFloat4(labelArg, (*C.float)(&vArg[0]), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputIntV parameter default value hint:
// step: 1
// step_fast: 100
// flags: 0
func InputIntV(label string, v *int32, step, step_fast int32, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.igInputInt(labelArg, vArg, C.int(step), C.int(step_fast), C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputInt2V parameter default value hint:
// flags: 0
func InputInt2V(label string, v *[2]int32, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.igInputInt2(labelArg, (*C.int)(&vArg[0]), C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputInt3V parameter default value hint:
// flags: 0
func InputInt3V(label string, v *[3]int32, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.igInputInt3(labelArg, (*C.int)(&vArg[0]), C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputInt4V parameter default value hint:
// flags: 0
func InputInt4V(label string, v *[4]int32, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.igInputInt4(labelArg, (*C.int)(&vArg[0]), C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputScalarV parameter default value hint:
// p_step: NULL
// p_step_fast: NULL
// format: NULL
// flags: 0
func InputScalarV(label string, data_type DataType, p_data, p_step, p_step_fast uintptr, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igInputScalarV(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.uintptr_t(p_step), C.uintptr_t(p_step_fast), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// InputScalarNV parameter default value hint:
// p_step: NULL
// p_step_fast: NULL
// format: NULL
// flags: 0
func InputScalarNV(label string, data_type DataType, p_data uintptr, components int32, p_step, p_step_fast uintptr, format string, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igInputScalarNV(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.int(components), C.uintptr_t(p_step), C.uintptr_t(p_step_fast), formatArg, C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

func InternalInputTextDeactivateHook(id ID) {
	idArg, idFin := id.C()
	C.igInputTextDeactivateHook(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

// flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
// InvisibleButtonV parameter default value hint:
// flags: 0
func InvisibleButtonV(str_id string, size Vec2, flags ButtonFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igInvisibleButton(str_idArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiButtonFlags(flags)) == C.bool(true)
}

func InternalIsActiveIdUsingNavDir(dir Dir) bool {
	return C.igIsActiveIdUsingNavDir(C.ImGuiDir(dir)) == C.bool(true)
}

func InternalIsAliasKey(key Key) bool {
	return C.igIsAliasKey(C.ImGuiKey(key)) == C.bool(true)
}

// is any item active?
func IsAnyItemActive() bool {
	return C.igIsAnyItemActive() == C.bool(true)
}

// is any item focused?
func IsAnyItemFocused() bool {
	return C.igIsAnyItemFocused() == C.bool(true)
}

// is any item hovered?
func IsAnyItemHovered() bool {
	return C.igIsAnyItemHovered() == C.bool(true)
}

// [WILL OBSOLETE] is any mouse button held? This was designed for backends, but prefer having backend maintain a mask of held mouse buttons, because upcoming input queue system will make this invalid.
func IsAnyMouseDown() bool {
	return C.igIsAnyMouseDown() == C.bool(true)
}

func InternalIsClippedEx(bb Rect, id ID) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igIsClippedEx(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg)) == C.bool(true)
}

func InternalIsDragDropActive() bool {
	return C.igIsDragDropActive() == C.bool(true)
}

func InternalIsDragDropPayloadBeingAccepted() bool {
	return C.igIsDragDropPayloadBeingAccepted() == C.bool(true)
}

func InternalIsGamepadKey(key Key) bool {
	return C.igIsGamepadKey(C.ImGuiKey(key)) == C.bool(true)
}

// was the last item just made active (item was previously inactive).
func IsItemActivated() bool {
	return C.igIsItemActivated() == C.bool(true)
}

// is the last item active? (e.g. button being held, text field being edited. This will continuously return true while holding mouse button on an item. Items that don't interact will always return false)
func IsItemActive() bool {
	return C.igIsItemActive() == C.bool(true)
}

// This may be useful to apply workaround that a based on distinguish whenever an item is active as a text input field.
func InternalIsItemActiveAsInputText() bool {
	return C.igIsItemActiveAsInputText() == C.bool(true)
}

// is the last item hovered and mouse clicked on? (**)  == IsMouseClicked(mouse_button) && IsItemHovered()Important. (**) this is NOT equivalent to the behavior of e.g. Button(). Read comments in function definition.
// IsItemClickedV parameter default value hint:
// mouse_button: 0
func IsItemClickedV(mouse_button MouseButton) bool {
	return C.igIsItemClicked(C.ImGuiMouseButton(mouse_button)) == C.bool(true)
}

// was the last item just made inactive (item was previously active). Useful for Undo/Redo patterns with widgets that require continuous editing.
func IsItemDeactivated() bool {
	return C.igIsItemDeactivated() == C.bool(true)
}

// was the last item just made inactive and made a value change when it was active? (e.g. Slider/Drag moved). Useful for Undo/Redo patterns with widgets that require continuous editing. Note that you may get false positives (some widgets such as Combo()/ListBox()/Selectable() will return true even when clicking an already selected item).
func IsItemDeactivatedAfterEdit() bool {
	return C.igIsItemDeactivatedAfterEdit() == C.bool(true)
}

// did the last item modify its underlying value this frame? or was pressed? This is generally the same as the "bool" return value of many widgets.
func IsItemEdited() bool {
	return C.igIsItemEdited() == C.bool(true)
}

// is the last item focused for keyboard/gamepad navigation?
func IsItemFocused() bool {
	return C.igIsItemFocused() == C.bool(true)
}

// is the last item hovered? (and usable, aka not blocked by a popup, etc.). See ImGuiHoveredFlags for more options.
// IsItemHoveredV parameter default value hint:
// flags: 0
func IsItemHoveredV(flags HoveredFlags) bool {
	return C.igIsItemHovered(C.ImGuiHoveredFlags(flags)) == C.bool(true)
}

// was the last item open state toggled? set by TreeNode().
func IsItemToggledOpen() bool {
	return C.igIsItemToggledOpen() == C.bool(true)
}

// Was the last item selection state toggled? Useful if you need the per-item information _before_ reaching EndMultiSelect(). We only returns toggle _event_ in order to handle clipping correctly.
func IsItemToggledSelection() bool {
	return C.igIsItemToggledSelection() == C.bool(true)
}

// is the last item visible? (items may be out of sight because of clipping/scrolling)
func IsItemVisible() bool {
	return C.igIsItemVisible() == C.bool(true)
}

// InternalIsKeyChordPressedInputFlagsV parameter default value hint:
// owner_id: 0
func InternalIsKeyChordPressedInputFlagsV(key_chord KeyChord, flags InputFlags, owner_id ID) bool {
	key_chordArg, key_chordFin := key_chord.C()
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		key_chordFin()
		owner_idFin()
	}()
	return C.igIsKeyChordPressed_InputFlags(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), C.ImGuiInputFlags(flags), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// was key chord (mods + key) pressed, e.g. you can pass 'ImGuiMod_Ctrl | ImGuiKey_S' as a key-chord. This doesn't do any routing or focus check, please consider using Shortcut() function instead.
func IsKeyChordPressed(key_chord KeyChord) bool {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return C.igIsKeyChordPressed_Nil(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg)) == C.bool(true)
}

func InternalIsKeyDownID(key Key, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsKeyDown_ID(C.ImGuiKey(key), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// is key being held.
func IsKeyDown(key Key) bool {
	return C.igIsKeyDown_Nil(C.ImGuiKey(key)) == C.bool(true)
}

// was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
// IsKeyPressedBoolV parameter default value hint:
// repeat: true
func IsKeyPressedBoolV(key Key, repeat bool) bool {
	return C.igIsKeyPressed_Bool(C.ImGuiKey(key), C.bool(repeat)) == C.bool(true)
}

// Important: when transitioning from old to new IsKeyPressed(): old API has "bool repeat = true", so would default to repeat. New API requiress explicit ImGuiInputFlags_Repeat.
// InternalIsKeyPressedInputFlagsV parameter default value hint:
// owner_id: 0
func InternalIsKeyPressedInputFlagsV(key Key, flags InputFlags, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsKeyPressed_InputFlags(C.ImGuiKey(key), C.ImGuiInputFlags(flags), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

func InternalIsKeyReleasedID(key Key, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsKeyReleased_ID(C.ImGuiKey(key), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// was key released (went from Down to !Down)?
func IsKeyReleased(key Key) bool {
	return C.igIsKeyReleased_Nil(C.ImGuiKey(key)) == C.bool(true)
}

func InternalIsKeyboardKey(key Key) bool {
	return C.igIsKeyboardKey(C.ImGuiKey(key)) == C.bool(true)
}

func InternalIsLRModKey(key Key) bool {
	return C.igIsLRModKey(C.ImGuiKey(key)) == C.bool(true)
}

func InternalIsLegacyKey(key Key) bool {
	return C.igIsLegacyKey(C.ImGuiKey(key)) == C.bool(true)
}

// did mouse button clicked? (went from !Down to Down). Same as GetMouseClickedCount() == 1.
// IsMouseClickedBoolV parameter default value hint:
// repeat: false
func IsMouseClickedBoolV(button MouseButton, repeat bool) bool {
	return C.igIsMouseClicked_Bool(C.ImGuiMouseButton(button), C.bool(repeat)) == C.bool(true)
}

// InternalIsMouseClickedInputFlagsV parameter default value hint:
// owner_id: 0
func InternalIsMouseClickedInputFlagsV(button MouseButton, flags InputFlags, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsMouseClicked_InputFlags(C.ImGuiMouseButton(button), C.ImGuiInputFlags(flags), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

func InternalIsMouseDoubleClickedID(button MouseButton, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsMouseDoubleClicked_ID(C.ImGuiMouseButton(button), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// did mouse button double-clicked? Same as GetMouseClickedCount() == 2. (note that a double-click will also report IsMouseClicked() == true)
func IsMouseDoubleClicked(button MouseButton) bool {
	return C.igIsMouseDoubleClicked_Nil(C.ImGuiMouseButton(button)) == C.bool(true)
}

func InternalIsMouseDownID(button MouseButton, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsMouseDown_ID(C.ImGuiMouseButton(button), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// is mouse button held?
func IsMouseDown(button MouseButton) bool {
	return C.igIsMouseDown_Nil(C.ImGuiMouseButton(button)) == C.bool(true)
}

// InternalIsMouseDragPastThresholdV parameter default value hint:
// lock_threshold: -1.0f
func InternalIsMouseDragPastThresholdV(button MouseButton, lock_threshold float32) bool {
	return C.igIsMouseDragPastThreshold(C.ImGuiMouseButton(button), C.float(lock_threshold)) == C.bool(true)
}

// is mouse dragging? (uses io.MouseDraggingThreshold if lock_threshold < 0.0f)
// IsMouseDraggingV parameter default value hint:
// lock_threshold: -1.0f
func IsMouseDraggingV(button MouseButton, lock_threshold float32) bool {
	return C.igIsMouseDragging(C.ImGuiMouseButton(button), C.float(lock_threshold)) == C.bool(true)
}

// is mouse hovering given bounding rect (in screen space). clipped by current clipping settings, but disregarding of other consideration of focus/window ordering/popup-block.
// IsMouseHoveringRectV parameter default value hint:
// clip: true
func IsMouseHoveringRectV(r_min, r_max Vec2, clip bool) bool {
	return C.igIsMouseHoveringRect(internal.ReinterpretCast[C.ImVec2](r_min.ToC()), internal.ReinterpretCast[C.ImVec2](r_max.ToC()), C.bool(clip)) == C.bool(true)
}

func InternalIsMouseKey(key Key) bool {
	return C.igIsMouseKey(C.ImGuiKey(key)) == C.bool(true)
}

// by convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse available
// IsMousePosValidV parameter default value hint:
// mouse_pos: NULL
func IsMousePosValidV(mouse_pos *Vec2) bool {
	mouse_posArg, mouse_posFin := internal.Wrap(mouse_pos)

	defer func() {
		mouse_posFin()
	}()
	return C.igIsMousePosValid(internal.ReinterpretCast[*C.ImVec2](mouse_posArg)) == C.bool(true)
}

// delayed mouse release (use very sparingly!). Generally used with 'delay >= io.MouseDoubleClickTime' + combined with a 'io.MouseClickedLastCount==1' test. This is a very rarely used UI idiom, but some apps use this: e.g. MS Explorer single click on an icon to rename.
func IsMouseReleasedWithDelay(button MouseButton, delay float32) bool {
	return C.igIsMouseReleasedWithDelay(C.ImGuiMouseButton(button), C.float(delay)) == C.bool(true)
}

func InternalIsMouseReleasedID(button MouseButton, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igIsMouseReleased_ID(C.ImGuiMouseButton(button), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// did mouse button released? (went from Down to !Down)
func IsMouseReleased(button MouseButton) bool {
	return C.igIsMouseReleased_Nil(C.ImGuiMouseButton(button)) == C.bool(true)
}

func InternalIsNamedKey(key Key) bool {
	return C.igIsNamedKey(C.ImGuiKey(key)) == C.bool(true)
}

func InternalIsNamedKeyOrMod(key Key) bool {
	return C.igIsNamedKeyOrMod(C.ImGuiKey(key)) == C.bool(true)
}

func InternalIsPopupOpenID(id ID, popup_flags PopupFlags) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igIsPopupOpen_ID(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiPopupFlags(popup_flags)) == C.bool(true)
}

// return true if the popup is open.
// IsPopupOpenStrV parameter default value hint:
// flags: 0
func IsPopupOpenStrV(str_id string, flags PopupFlags) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.igIsPopupOpen_Str(str_idArg, C.ImGuiPopupFlags(flags)) == C.bool(true)
}

// test if rectangle (of given size, starting from cursor position) is visible / not clipped.
func IsRectVisible(size Vec2) bool {
	return C.igIsRectVisible_Nil(internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

// test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.
func IsRectVisibleVec2(rect_min, rect_max Vec2) bool {
	return C.igIsRectVisible_Vec2(internal.ReinterpretCast[C.ImVec2](rect_min.ToC()), internal.ReinterpretCast[C.ImVec2](rect_max.ToC())) == C.bool(true)
}

func InternalIsWindowAbove(potential_above, potential_below *Window) bool {
	potential_aboveArg, potential_aboveFin := potential_above.Handle()
	potential_belowArg, potential_belowFin := potential_below.Handle()

	defer func() {
		potential_aboveFin()
		potential_belowFin()
	}()
	return C.igIsWindowAbove(internal.ReinterpretCast[*C.ImGuiWindow](potential_aboveArg), internal.ReinterpretCast[*C.ImGuiWindow](potential_belowArg)) == C.bool(true)
}

func IsWindowAppearing() bool {
	return C.igIsWindowAppearing() == C.bool(true)
}

func InternalIsWindowChildOf(window, potential_parent *Window, popup_hierarchy, dock_hierarchy bool) bool {
	windowArg, windowFin := window.Handle()
	potential_parentArg, potential_parentFin := potential_parent.Handle()

	defer func() {
		windowFin()
		potential_parentFin()
	}()
	return C.igIsWindowChildOf(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiWindow](potential_parentArg), C.bool(popup_hierarchy), C.bool(dock_hierarchy)) == C.bool(true)
}

func IsWindowCollapsed() bool {
	return C.igIsWindowCollapsed() == C.bool(true)
}

// InternalIsWindowContentHoverableV parameter default value hint:
// flags: 0
func InternalIsWindowContentHoverableV(window *Window, flags HoveredFlags) bool {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return C.igIsWindowContentHoverable(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiHoveredFlags(flags)) == C.bool(true)
}

// is current window docked into another window?
func IsWindowDocked() bool {
	return C.igIsWindowDocked() == C.bool(true)
}

// is current window focused? or its root/child, depending on flags. see flags for options.
// IsWindowFocusedV parameter default value hint:
// flags: 0
func IsWindowFocusedV(flags FocusedFlags) bool {
	return C.igIsWindowFocused(C.ImGuiFocusedFlags(flags)) == C.bool(true)
}

// is current window hovered and hoverable (e.g. not blocked by a popup/modal)? See ImGuiHoveredFlags_ for options. IMPORTANT: If you are trying to check whether your mouse should be dispatched to Dear ImGui or to your underlying app, you should not use this function! Use the 'io.WantCaptureMouse' boolean for that! Refer to FAQ entry "How can I tell whether to dispatch mouse/keyboard to Dear ImGui or my application?" for details.
// IsWindowHoveredV parameter default value hint:
// flags: 0
func IsWindowHoveredV(flags HoveredFlags) bool {
	return C.igIsWindowHovered(C.ImGuiHoveredFlags(flags)) == C.bool(true)
}

func InternalIsWindowNavFocusable(window *Window) bool {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return C.igIsWindowNavFocusable(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)) == C.bool(true)
}

func InternalIsWindowWithinBeginStackOf(window, potential_parent *Window) bool {
	windowArg, windowFin := window.Handle()
	potential_parentArg, potential_parentFin := potential_parent.Handle()

	defer func() {
		windowFin()
		potential_parentFin()
	}()
	return C.igIsWindowWithinBeginStackOf(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiWindow](potential_parentArg)) == C.bool(true)
}

// InternalItemAddV parameter default value hint:
// nav_bb: NULL
// extra_flags: 0
func InternalItemAddV(bb Rect, id ID, nav_bb *Rect, extra_flags ItemFlags) bool {
	idArg, idFin := id.C()
	nav_bbArg, nav_bbFin := internal.Wrap(nav_bb)

	defer func() {
		idFin()
		nav_bbFin()
	}()
	return C.igItemAdd(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[*C.ImRect](nav_bbArg), C.ImGuiItemFlags(extra_flags)) == C.bool(true)
}

func InternalItemHoverable(bb Rect, id ID, item_flags ItemFlags) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igItemHoverable(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiItemFlags(item_flags)) == C.bool(true)
}

// FIXME: This is a misleading API since we expect CursorPos to be bb.Min.
// InternalItemSizeRectV parameter default value hint:
// text_baseline_y: -1.0f
func InternalItemSizeRectV(bb Rect, text_baseline_y float32) {
	C.igItemSize_Rect(internal.ReinterpretCast[C.ImRect](bb.ToC()), C.float(text_baseline_y))
}

// InternalItemSizeVec2V parameter default value hint:
// text_baseline_y: -1.0f
func InternalItemSizeVec2V(size Vec2, text_baseline_y float32) {
	C.igItemSize_Vec2(internal.ReinterpretCast[C.ImVec2](size.ToC()), C.float(text_baseline_y))
}

func InternalKeepAliveID(id ID) {
	idArg, idFin := id.C()
	C.igKeepAliveID(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

// display text+label aligned the same way as value+label widgets
func LabelText(label, fmt string) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igLabelText(labelArg, fmtArg)

	labelFin()
	fmtFin()
}

// ListBoxStrarrV parameter default value hint:
// height_in_items: -1
func ListBoxStrarrV(label string, current_item *int32, items []string, items_count, height_in_items int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	current_itemArg, current_itemFin := internal.WrapNumberPtr[C.int, int32](current_item)
	itemsArg, itemsFin := internal.WrapStringList[C.char](items)

	defer func() {
		labelFin()
		current_itemFin()
		itemsFin()
	}()
	return C.igListBox_Str_arr(labelArg, current_itemArg, itemsArg, C.int(items_count), C.int(height_in_items)) == C.bool(true)
}

// call after CreateContext() and before the first call to NewFrame(). NewFrame() automatically calls LoadIniSettingsFromDisk(io.IniFilename).
func LoadIniSettingsFromDisk(ini_filename string) {
	ini_filenameArg, ini_filenameFin := internal.WrapString[C.char](ini_filename)
	C.igLoadIniSettingsFromDisk(ini_filenameArg)

	ini_filenameFin()
}

// call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source.
// LoadIniSettingsFromMemoryV parameter default value hint:
// ini_size: 0
func LoadIniSettingsFromMemoryV(ini_data string, ini_size uint64) {
	ini_dataArg, ini_dataFin := internal.WrapString[C.char](ini_data)
	C.igLoadIniSettingsFromMemory(ini_dataArg, C.xulong(ini_size))

	ini_dataFin()
}

func InternalLocalizeGetMsg(key LocKey) string {
	return C.GoString(C.igLocalizeGetMsg(C.ImGuiLocKey(key)))
}

func InternalLocalizeRegisterEntries(entries *LocEntry, count int32) {
	entriesArg, entriesFin := entries.Handle()
	C.igLocalizeRegisterEntries(internal.ReinterpretCast[*C.ImGuiLocEntry](entriesArg), C.int(count))

	entriesFin()
}

// -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name.
func InternalLogBegin(flags LogFlags, auto_open_depth int32) {
	C.igLogBegin(C.ImGuiLogFlags(flags), C.int(auto_open_depth))
}

// helper to display buttons for logging to tty/file/clipboard
func LogButtons() {
	C.igLogButtons()
}

// stop logging (close file, etc.)
func LogFinish() {
	C.igLogFinish()
}

// InternalLogRenderedTextV parameter default value hint:
func InternalLogRenderedTextV(ref_pos *Vec2, text string) {
	ref_posArg, ref_posFin := internal.Wrap(ref_pos)
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igLogRenderedTextV(internal.ReinterpretCast[*C.ImVec2](ref_posArg), textArg, C.int(len(text)))

	ref_posFin()
	textFin()
}

func InternalLogSetNextTextDecoration(prefix, suffix string) {
	prefixArg, prefixFin := internal.WrapString[C.char](prefix)
	suffixArg, suffixFin := internal.WrapString[C.char](suffix)
	C.igLogSetNextTextDecoration(prefixArg, suffixArg)

	prefixFin()
	suffixFin()
}

// pass text data straight to log (without being displayed)
func LogText(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igLogText(fmtArg)

	fmtFin()
}

// Start logging/capturing to internal buffer
// InternalLogToBufferV parameter default value hint:
// auto_open_depth: -1
func InternalLogToBufferV(auto_open_depth int32) {
	C.igLogToBuffer(C.int(auto_open_depth))
}

// start logging to OS clipboard
// LogToClipboardV parameter default value hint:
// auto_open_depth: -1
func LogToClipboardV(auto_open_depth int32) {
	C.igLogToClipboard(C.int(auto_open_depth))
}

// start logging to file
// LogToFileV parameter default value hint:
// auto_open_depth: -1
// filename: NULL
func LogToFileV(auto_open_depth int32, filename string) {
	filenameArg, filenameFin := internal.WrapString[C.char](filename)
	C.igLogToFile(C.int(auto_open_depth), filenameArg)

	filenameFin()
}

// start logging to tty (stdout)
// LogToTTYV parameter default value hint:
// auto_open_depth: -1
func LogToTTYV(auto_open_depth int32) {
	C.igLogToTTY(C.int(auto_open_depth))
}

func InternalMarkIniSettingsDirty() {
	C.igMarkIniSettingsDirty_Nil()
}

func InternalMarkIniSettingsDirtyWindowPtr(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igMarkIniSettingsDirty_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

// Mark data associated to given item as "edited", used by IsItemDeactivatedAfterEdit() function.
func InternalMarkItemEdited(id ID) {
	idArg, idFin := id.C()
	C.igMarkItemEdited(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func MemAlloc(size uint64) uintptr {
	return uintptr(C.wrap_igMemAlloc(C.xulong(size)))
}

func MemFree(ptr uintptr) {
	C.wrap_igMemFree(C.uintptr_t(ptr))
}

// InternalMenuItemExV parameter default value hint:
// shortcut: NULL
// selected: false
// enabled: true
func InternalMenuItemExV(label, icon, shortcut string, selected, enabled bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	iconArg, iconFin := internal.WrapString[C.char](icon)
	shortcutArg, shortcutFin := internal.WrapString[C.char](shortcut)

	defer func() {
		labelFin()
		iconFin()
		shortcutFin()
	}()
	return C.igMenuItemEx(labelArg, iconArg, shortcutArg, C.bool(selected), C.bool(enabled)) == C.bool(true)
}

// return true when activated.
// MenuItemBoolV parameter default value hint:
// shortcut: NULL
// selected: false
// enabled: true
func MenuItemBoolV(label, shortcut string, selected, enabled bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	shortcutArg, shortcutFin := internal.WrapString[C.char](shortcut)

	defer func() {
		labelFin()
		shortcutFin()
	}()
	return C.igMenuItem_Bool(labelArg, shortcutArg, C.bool(selected), C.bool(enabled)) == C.bool(true)
}

// return true when activated + toggle (*p_selected) if p_selected != NULL
// MenuItemBoolPtrV parameter default value hint:
// enabled: true
func MenuItemBoolPtrV(label, shortcut string, p_selected *bool, enabled bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	shortcutArg, shortcutFin := internal.WrapString[C.char](shortcut)
	p_selectedArg, p_selectedFin := internal.WrapNumberPtr[C.bool, bool](p_selected)

	defer func() {
		labelFin()
		shortcutFin()
		p_selectedFin()
	}()
	return C.igMenuItem_BoolPtr(labelArg, shortcutArg, p_selectedArg, C.bool(enabled)) == C.bool(true)
}

func InternalMouseButtonToKey(button MouseButton) Key {
	return Key(C.igMouseButtonToKey(C.ImGuiMouseButton(button)))
}

func InternalMultiSelectAddSetAll(ms *MultiSelectTempData, selected bool) {
	msArg, msFin := ms.Handle()
	C.igMultiSelectAddSetAll(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](msArg), C.bool(selected))

	msFin()
}

func InternalMultiSelectAddSetRange(ms *MultiSelectTempData, selected bool, range_dir int32, first_item, last_item SelectionUserData) {
	msArg, msFin := ms.Handle()
	first_itemArg, first_itemFin := first_item.C()
	last_itemArg, last_itemFin := last_item.C()
	C.igMultiSelectAddSetRange(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](msArg), C.bool(selected), C.int(range_dir), internal.ReinterpretCast[C.ImGuiSelectionUserData](first_itemArg), internal.ReinterpretCast[C.ImGuiSelectionUserData](last_itemArg))

	msFin()
	first_itemFin()
	last_itemFin()
}

func InternalMultiSelectItemFooter(id ID, p_selected, p_pressed *bool) {
	idArg, idFin := id.C()
	p_selectedArg, p_selectedFin := internal.WrapNumberPtr[C.bool, bool](p_selected)
	p_pressedArg, p_pressedFin := internal.WrapNumberPtr[C.bool, bool](p_pressed)
	C.igMultiSelectItemFooter(internal.ReinterpretCast[C.ImGuiID](idArg), p_selectedArg, p_pressedArg)

	idFin()
	p_selectedFin()
	p_pressedFin()
}

func InternalMultiSelectItemHeader(id ID, p_selected *bool, p_button_flags *ButtonFlags) {
	idArg, idFin := id.C()
	p_selectedArg, p_selectedFin := internal.WrapNumberPtr[C.bool, bool](p_selected)
	C.igMultiSelectItemHeader(internal.ReinterpretCast[C.ImGuiID](idArg), p_selectedArg, (*C.ImGuiButtonFlags)(p_button_flags))

	idFin()
	p_selectedFin()
}

func InternalNavClearPreferredPosForAxis(axis Axis) {
	C.igNavClearPreferredPosForAxis(C.ImGuiAxis(axis))
}

func InternalNavHighlightActivated(id ID) {
	idArg, idFin := id.C()
	C.igNavHighlightActivated(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func InternalNavInitRequestApplyResult() {
	C.igNavInitRequestApplyResult()
}

func InternalNavInitWindow(window *Window, force_reinit bool) {
	windowArg, windowFin := window.Handle()
	C.igNavInitWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.bool(force_reinit))

	windowFin()
}

func InternalNavMoveRequestApplyResult() {
	C.igNavMoveRequestApplyResult()
}

func InternalNavMoveRequestButNoResultYet() bool {
	return C.igNavMoveRequestButNoResultYet() == C.bool(true)
}

func InternalNavMoveRequestCancel() {
	C.igNavMoveRequestCancel()
}

func InternalNavMoveRequestForward(move_dir, clip_dir Dir, move_flags NavMoveFlags, scroll_flags ScrollFlags) {
	C.igNavMoveRequestForward(C.ImGuiDir(move_dir), C.ImGuiDir(clip_dir), C.ImGuiNavMoveFlags(move_flags), C.ImGuiScrollFlags(scroll_flags))
}

func InternalNavMoveRequestResolveWithLastItem(result *NavItemData) {
	resultArg, resultFin := result.Handle()
	C.igNavMoveRequestResolveWithLastItem(internal.ReinterpretCast[*C.ImGuiNavItemData](resultArg))

	resultFin()
}

func InternalNavMoveRequestResolveWithPastTreeNode(result *NavItemData, tree_node_data *TreeNodeStackData) {
	resultArg, resultFin := result.Handle()
	tree_node_dataArg, tree_node_dataFin := tree_node_data.Handle()
	C.igNavMoveRequestResolveWithPastTreeNode(internal.ReinterpretCast[*C.ImGuiNavItemData](resultArg), internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](tree_node_dataArg))

	resultFin()
	tree_node_dataFin()
}

func InternalNavMoveRequestSubmit(move_dir, clip_dir Dir, move_flags NavMoveFlags, scroll_flags ScrollFlags) {
	C.igNavMoveRequestSubmit(C.ImGuiDir(move_dir), C.ImGuiDir(clip_dir), C.ImGuiNavMoveFlags(move_flags), C.ImGuiScrollFlags(scroll_flags))
}

func InternalNavMoveRequestTryWrapping(window *Window, move_flags NavMoveFlags) {
	windowArg, windowFin := window.Handle()
	C.igNavMoveRequestTryWrapping(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiNavMoveFlags(move_flags))

	windowFin()
}

func InternalNavUpdateCurrentWindowIsScrollPushableX() {
	C.igNavUpdateCurrentWindowIsScrollPushableX()
}

// start a new Dear ImGui frame, you can submit any command from this point until Render()/EndFrame().
func NewFrame() {
	C.igNewFrame()
}

// undo a SameLine() or force a new line when in a horizontal-layout context.
func NewLine() {
	C.igNewLine()
}

// next column, defaults to current row or next row if the current row is finished
func NextColumn() {
	C.igNextColumn()
}

// InternalOpenPopupExV parameter default value hint:
// popup_flags: ImGuiPopupFlags_None
func InternalOpenPopupExV(id ID, popup_flags PopupFlags) {
	idArg, idFin := id.C()
	C.igOpenPopupEx(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiPopupFlags(popup_flags))

	idFin()
}

// helper to open popup when clicked on last item. Default to ImGuiPopupFlags_MouseButtonRight == 1. (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors)
// OpenPopupOnItemClickV parameter default value hint:
// str_id: NULL
// popup_flags: 1
func OpenPopupOnItemClickV(str_id string, popup_flags PopupFlags) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.igOpenPopupOnItemClick(str_idArg, C.ImGuiPopupFlags(popup_flags))

	str_idFin()
}

// id overload to facilitate calling from nested stacks
// OpenPopupIDV parameter default value hint:
// popup_flags: 0
func OpenPopupIDV(id ID, popup_flags PopupFlags) {
	idArg, idFin := id.C()
	C.igOpenPopup_ID(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiPopupFlags(popup_flags))

	idFin()
}

// call to mark popup as open (don't call every frame!).
// OpenPopupStrV parameter default value hint:
// popup_flags: 0
func OpenPopupStrV(str_id string, popup_flags PopupFlags) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.igOpenPopup_Str(str_idArg, C.ImGuiPopupFlags(popup_flags))

	str_idFin()
}

// PlotHistogramFloatPtrV parameter default value hint:
// values_offset: 0
// overlay_text: NULL
// scale_min: FLT_MAX
// scale_max: FLT_MAX
// graph_size: ImVec2(0,0)
// stride: sizeof(float)
func PlotHistogramFloatPtrV(label string, values *float32, values_count, values_offset int32, overlay_text string, scale_min, scale_max float32, graph_size Vec2, stride int32) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	overlay_textArg, overlay_textFin := internal.WrapString[C.char](overlay_text)
	C.igPlotHistogram_FloatPtr(labelArg, valuesArg, C.int(values_count), C.int(values_offset), overlay_textArg, C.float(scale_min), C.float(scale_max), internal.ReinterpretCast[C.ImVec2](graph_size.ToC()), C.int(stride))

	labelFin()
	valuesFin()
	overlay_textFin()
}

// PlotLinesFloatPtrV parameter default value hint:
// values_offset: 0
// overlay_text: NULL
// scale_min: FLT_MAX
// scale_max: FLT_MAX
// graph_size: ImVec2(0,0)
// stride: sizeof(float)
func PlotLinesFloatPtrV(label string, values *float32, values_count, values_offset int32, overlay_text string, scale_min, scale_max float32, graph_size Vec2, stride int32) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	overlay_textArg, overlay_textFin := internal.WrapString[C.char](overlay_text)
	C.igPlotLines_FloatPtr(labelArg, valuesArg, C.int(values_count), C.int(values_offset), overlay_textArg, C.float(scale_min), C.float(scale_max), internal.ReinterpretCast[C.ImVec2](graph_size.ToC()), C.int(stride))

	labelFin()
	valuesFin()
	overlay_textFin()
}

func PopClipRect() {
	C.igPopClipRect()
}

func InternalPopColumnsBackground() {
	C.igPopColumnsBackground()
}

func InternalPopFocusScope() {
	C.igPopFocusScope()
}

func PopFont() {
	C.igPopFont()
}

// pop from the ID stack.
func PopID() {
	C.igPopID()
}

func PopItemFlag() {
	C.igPopItemFlag()
}

func PopItemWidth() {
	C.igPopItemWidth()
}

func InternalPopPasswordFont() {
	C.igPopPasswordFont()
}

// PopStyleColorV parameter default value hint:
// count: 1
func PopStyleColorV(count int32) {
	C.igPopStyleColor(C.int(count))
}

// PopStyleVarV parameter default value hint:
// count: 1
func PopStyleVarV(count int32) {
	C.igPopStyleVar(C.int(count))
}

func PopTextWrapPos() {
	C.igPopTextWrapPos()
}

// ProgressBarV parameter default value hint:
// size_arg: ImVec2(-FLT_MIN,0)
// overlay: NULL
func ProgressBarV(fraction float32, size_arg Vec2, overlay string) {
	overlayArg, overlayFin := internal.WrapString[C.char](overlay)
	C.igProgressBar(C.float(fraction), internal.ReinterpretCast[C.ImVec2](size_arg.ToC()), overlayArg)

	overlayFin()
}

func PushClipRect(clip_rect_min, clip_rect_max Vec2, intersect_with_current_clip_rect bool) {
	C.igPushClipRect(internal.ReinterpretCast[C.ImVec2](clip_rect_min.ToC()), internal.ReinterpretCast[C.ImVec2](clip_rect_max.ToC()), C.bool(intersect_with_current_clip_rect))
}

func InternalPushColumnClipRect(column_index int32) {
	C.igPushColumnClipRect(C.int(column_index))
}

func InternalPushColumnsBackground() {
	C.igPushColumnsBackground()
}

func InternalPushFocusScope(id ID) {
	idArg, idFin := id.C()
	C.igPushFocusScope(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

// Use NULL as a shortcut to keep current font. Use 0.0f to keep current size.
func PushFont(font *Font, font_size_base_unscaled float32) {
	fontArg, fontFin := font.Handle()
	C.igPushFont(internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size_base_unscaled))

	fontFin()
}

// push integer into the ID stack (will hash integer).
func PushIDInt(int_id int32) {
	C.igPushID_Int(C.int(int_id))
}

// push pointer into the ID stack (will hash pointer).
func PushIDPtr(ptr_id uintptr) {
	C.wrap_igPushID_Ptr(C.uintptr_t(ptr_id))
}

// push string into the ID stack (will hash string).
func PushIDStr(str_id string) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.igPushID_Str(str_idArg)

	str_idFin()
}

// push string into the ID stack (will hash string).
func PushIDStrStr(str_id_begin, str_id_end string) {
	str_id_beginArg, str_id_beginFin := internal.WrapString[C.char](str_id_begin)
	str_id_endArg, str_id_endFin := internal.WrapString[C.char](str_id_end)
	C.igPushID_StrStr(str_id_beginArg, str_id_endArg)

	str_id_beginFin()
	str_id_endFin()
}

// modify specified shared item flag, e.g. PushItemFlag(ImGuiItemFlags_NoTabStop, true)
func PushItemFlag(option ItemFlags, enabled bool) {
	C.igPushItemFlag(C.ImGuiItemFlags(option), C.bool(enabled))
}

// push width of items for common large "item+label" widgets. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side).
func PushItemWidth(item_width float32) {
	C.igPushItemWidth(C.float(item_width))
}

func InternalPushMultiItemsWidths(components int32, width_full float32) {
	C.igPushMultiItemsWidths(C.int(components), C.float(width_full))
}

// Push given value as-is at the top of the ID stack (whereas PushID combines old and new hashes)
func InternalPushOverrideID(id ID) {
	idArg, idFin := id.C()
	C.igPushOverrideID(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func InternalPushPasswordFont() {
	C.igPushPasswordFont()
}

// modify a style color. always use this if you modify the style after NewFrame().
func PushStyleColorU32(idx Col, col uint32) {
	C.igPushStyleColor_U32(C.ImGuiCol(idx), C.ImU32(col))
}

func PushStyleColorVec4(idx Col, col Vec4) {
	C.igPushStyleColor_Vec4(C.ImGuiCol(idx), internal.ReinterpretCast[C.ImVec4](col.ToC()))
}

// modify X component of a style ImVec2 variable. "
func PushStyleVarX(idx StyleVar, val_x float32) {
	C.igPushStyleVarX(C.ImGuiStyleVar(idx), C.float(val_x))
}

// modify Y component of a style ImVec2 variable. "
func PushStyleVarY(idx StyleVar, val_y float32) {
	C.igPushStyleVarY(C.ImGuiStyleVar(idx), C.float(val_y))
}

// modify a style float variable. always use this if you modify the style after NewFrame()!
func PushStyleVarFloat(idx StyleVar, val float32) {
	C.igPushStyleVar_Float(C.ImGuiStyleVar(idx), C.float(val))
}

// modify a style ImVec2 variable. "
func PushStyleVarVec2(idx StyleVar, val Vec2) {
	C.igPushStyleVar_Vec2(C.ImGuiStyleVar(idx), internal.ReinterpretCast[C.ImVec2](val.ToC()))
}

// push word-wrapping position for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space
// PushTextWrapPosV parameter default value hint:
// wrap_local_pos_x: 0.0f
func PushTextWrapPosV(wrap_local_pos_x float32) {
	C.igPushTextWrapPos(C.float(wrap_local_pos_x))
}

// use with e.g. if (RadioButton("one", my_value==1))  my_value = 1;
func RadioButtonBool(label string, active bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igRadioButton_Bool(labelArg, C.bool(active)) == C.bool(true)
}

// shortcut to handle the above pattern when value is an integer
func RadioButtonIntPtr(label string, v *int32, v_button int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.igRadioButton_IntPtr(labelArg, vArg, C.int(v_button)) == C.bool(true)
}

func InternalRegisterFontAtlas(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igRegisterFontAtlas(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

// Register external texture. EXPERIMENTAL: DO NOT USE YET.
func InternalRegisterUserTexture(tex *TextureData) {
	texArg, texFin := tex.Handle()
	C.igRegisterUserTexture(internal.ReinterpretCast[*C.ImTextureData](texArg))

	texFin()
}

func InternalRemoveContextHook(context *Context, hook_to_remove ID) {
	contextArg, contextFin := context.Handle()
	hook_to_removeArg, hook_to_removeFin := hook_to_remove.C()
	C.igRemoveContextHook(internal.ReinterpretCast[*C.ImGuiContext](contextArg), internal.ReinterpretCast[C.ImGuiID](hook_to_removeArg))

	contextFin()
	hook_to_removeFin()
}

func InternalRemoveSettingsHandler(type_name string) {
	type_nameArg, type_nameFin := internal.WrapString[C.char](type_name)
	C.igRemoveSettingsHandler(type_nameArg)

	type_nameFin()
}

// ends the Dear ImGui frame, finalize the draw data. You can then get call GetDrawData().
func Render() {
	C.igRender()
}

// InternalRenderArrowV parameter default value hint:
// scale: 1.0f
func InternalRenderArrowV(draw_list *DrawList, pos Vec2, col uint32, dir Dir, scale float32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderArrow(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), C.ImGuiDir(dir), C.float(scale))

	draw_listFin()
}

func InternalRenderArrowDockMenu(draw_list *DrawList, p_min Vec2, sz float32, col uint32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderArrowDockMenu(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), C.float(sz), C.ImU32(col))

	draw_listFin()
}

func InternalRenderArrowPointingAt(draw_list *DrawList, pos, half_sz Vec2, direction Dir, col uint32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderArrowPointingAt(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[C.ImVec2](half_sz.ToC()), C.ImGuiDir(direction), C.ImU32(col))

	draw_listFin()
}

func InternalRenderBullet(draw_list *DrawList, pos Vec2, col uint32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderBullet(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col))

	draw_listFin()
}

func InternalRenderCheckMark(draw_list *DrawList, pos Vec2, col uint32, sz float32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderCheckMark(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), C.float(sz))

	draw_listFin()
}

// InternalRenderColorRectWithAlphaCheckerboardV parameter default value hint:
// rounding: 0.0f
// flags: 0
func InternalRenderColorRectWithAlphaCheckerboardV(draw_list *DrawList, p_min, p_max Vec2, fill_col uint32, grid_step float32, grid_off Vec2, rounding float32, flags DrawFlags) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderColorRectWithAlphaCheckerboard(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(fill_col), C.float(grid_step), internal.ReinterpretCast[C.ImVec2](grid_off.ToC()), C.float(rounding), C.ImDrawFlags(flags))

	draw_listFin()
}

func InternalRenderDragDropTargetRect(bb, item_clip_rect Rect) {
	C.igRenderDragDropTargetRect(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImRect](item_clip_rect.ToC()))
}

// InternalRenderFrameV parameter default value hint:
// borders: true
// rounding: 0.0f
func InternalRenderFrameV(p_min, p_max Vec2, fill_col uint32, borders bool, rounding float32) {
	C.igRenderFrame(internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(fill_col), C.bool(borders), C.float(rounding))
}

// InternalRenderFrameBorderV parameter default value hint:
// rounding: 0.0f
func InternalRenderFrameBorderV(p_min, p_max Vec2, rounding float32) {
	C.igRenderFrameBorder(internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.float(rounding))
}

func InternalRenderMouseCursor(pos Vec2, scale float32, mouse_cursor MouseCursor, col_fill, col_border, col_shadow uint32) {
	C.igRenderMouseCursor(internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.float(scale), C.ImGuiMouseCursor(mouse_cursor), C.ImU32(col_fill), C.ImU32(col_border), C.ImU32(col_shadow))
}

// Navigation highlight
// InternalRenderNavCursorV parameter default value hint:
// flags: ImGuiNavRenderCursorFlags_None
func InternalRenderNavCursorV(bb Rect, id ID, flags NavRenderCursorFlags) {
	idArg, idFin := id.C()
	C.igRenderNavCursor(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiNavRenderCursorFlags(flags))

	idFin()
}

// call in main loop. will call RenderWindow/SwapBuffers platform functions for each secondary viewport which doesn't have the ImGuiViewportFlags_Minimized flag set. May be reimplemented by user for custom rendering needs.
// RenderPlatformWindowsDefaultV parameter default value hint:
// platform_render_arg: NULL
// renderer_render_arg: NULL
func RenderPlatformWindowsDefaultV(platform_render_arg, renderer_render_arg uintptr) {
	C.wrap_igRenderPlatformWindowsDefaultV(C.uintptr_t(platform_render_arg), C.uintptr_t(renderer_render_arg))
}

func InternalRenderRectFilledRangeH(draw_list *DrawList, rect Rect, col uint32, x_start_norm, x_end_norm, rounding float32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderRectFilledRangeH(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImRect](rect.ToC()), C.ImU32(col), C.float(x_start_norm), C.float(x_end_norm), C.float(rounding))

	draw_listFin()
}

func InternalRenderRectFilledWithHole(draw_list *DrawList, outer, inner Rect, col uint32, rounding float32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igRenderRectFilledWithHole(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImRect](outer.ToC()), internal.ReinterpretCast[C.ImRect](inner.ToC()), C.ImU32(col), C.float(rounding))

	draw_listFin()
}

// InternalRenderTextV parameter default value hint:
// hide_text_after_hash: true
func InternalRenderTextV(pos Vec2, text string, hide_text_after_hash bool) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igRenderTextV(internal.ReinterpretCast[C.ImVec2](pos.ToC()), textArg, C.int(len(text)), C.bool(hide_text_after_hash))

	textFin()
}

// InternalRenderTextClippedV parameter default value hint:
// align: ImVec2(0,0)
// clip_rect: NULL
func InternalRenderTextClippedV(pos_min, pos_max Vec2, text string, text_size_if_known *Vec2, align Vec2, clip_rect *Rect) {
	textArg, textFin := internal.WrapString[C.char](text)
	text_size_if_knownArg, text_size_if_knownFin := internal.Wrap(text_size_if_known)
	clip_rectArg, clip_rectFin := internal.Wrap(clip_rect)
	C.wrap_igRenderTextClippedV(internal.ReinterpretCast[C.ImVec2](pos_min.ToC()), internal.ReinterpretCast[C.ImVec2](pos_max.ToC()), textArg, C.int(len(text)), internal.ReinterpretCast[*C.ImVec2](text_size_if_knownArg), internal.ReinterpretCast[C.ImVec2](align.ToC()), internal.ReinterpretCast[*C.ImRect](clip_rectArg))

	textFin()
	text_size_if_knownFin()
	clip_rectFin()
}

// InternalRenderTextClippedExV parameter default value hint:
// align: ImVec2(0,0)
// clip_rect: NULL
func InternalRenderTextClippedExV(draw_list *DrawList, pos_min, pos_max Vec2, text string, text_size_if_known *Vec2, align Vec2, clip_rect *Rect) {
	draw_listArg, draw_listFin := draw_list.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	text_size_if_knownArg, text_size_if_knownFin := internal.Wrap(text_size_if_known)
	clip_rectArg, clip_rectFin := internal.Wrap(clip_rect)
	C.wrap_igRenderTextClippedExV(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos_min.ToC()), internal.ReinterpretCast[C.ImVec2](pos_max.ToC()), textArg, C.int(len(text)), internal.ReinterpretCast[*C.ImVec2](text_size_if_knownArg), internal.ReinterpretCast[C.ImVec2](align.ToC()), internal.ReinterpretCast[*C.ImRect](clip_rectArg))

	draw_listFin()
	textFin()
	text_size_if_knownFin()
	clip_rectFin()
}

func InternalRenderTextEllipsis(draw_list *DrawList, pos_min, pos_max Vec2, ellipsis_max_x float32, text string, text_size_if_known *Vec2) {
	draw_listArg, draw_listFin := draw_list.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	text_size_if_knownArg, text_size_if_knownFin := internal.Wrap(text_size_if_known)
	C.wrap_igRenderTextEllipsis(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos_min.ToC()), internal.ReinterpretCast[C.ImVec2](pos_max.ToC()), C.float(ellipsis_max_x), textArg, C.int(len(text)), internal.ReinterpretCast[*C.ImVec2](text_size_if_knownArg))

	draw_listFin()
	textFin()
	text_size_if_knownFin()
}

func InternalRenderTextWrapped(pos Vec2, text string, wrap_width float32) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igRenderTextWrapped(internal.ReinterpretCast[C.ImVec2](pos.ToC()), textArg, C.int(len(text)), C.float(wrap_width))

	textFin()
}

// ResetMouseDragDeltaV parameter default value hint:
// button: 0
func ResetMouseDragDeltaV(button MouseButton) {
	C.igResetMouseDragDelta(C.ImGuiMouseButton(button))
}

// call between widgets or groups to layout them horizontally. X position given in window coordinates.
// SameLineV parameter default value hint:
// offset_from_start_x: 0.0f
// spacing: -1.0f
func SameLineV(offset_from_start_x, spacing float32) {
	C.igSameLine(C.float(offset_from_start_x), C.float(spacing))
}

// this is automatically called (if io.IniFilename is not empty) a few seconds after any modification that should be reflected in the .ini file (and also by DestroyContext).
func SaveIniSettingsToDisk(ini_filename string) {
	ini_filenameArg, ini_filenameFin := internal.WrapString[C.char](ini_filename)
	C.igSaveIniSettingsToDisk(ini_filenameArg)

	ini_filenameFin()
}

// return a zero-terminated string with the .ini data which you can save by your own mean. call when io.WantSaveIniSettings is set, then save data by your own mean and clear io.WantSaveIniSettings.
// SaveIniSettingsToMemoryV parameter default value hint:
// out_ini_size: NULL
func SaveIniSettingsToMemoryV(out_ini_size *uint64) string {
	return C.GoString(C.igSaveIniSettingsToMemory((*C.xulong)(out_ini_size)))
}

func InternalScaleWindowsInViewport(viewport *ViewportP, scale float32) {
	viewportArg, viewportFin := viewport.Handle()
	C.igScaleWindowsInViewport(internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg), C.float(scale))

	viewportFin()
}

func InternalScrollToBringRectIntoView(window *Window, rect Rect) {
	windowArg, windowFin := window.Handle()
	C.igScrollToBringRectIntoView(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](rect.ToC()))

	windowFin()
}

// InternalScrollToItemV parameter default value hint:
// flags: 0
func InternalScrollToItemV(flags ScrollFlags) {
	C.igScrollToItem(C.ImGuiScrollFlags(flags))
}

// InternalScrollToRectV parameter default value hint:
// flags: 0
func InternalScrollToRectV(window *Window, rect Rect, flags ScrollFlags) {
	windowArg, windowFin := window.Handle()
	C.igScrollToRect(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](rect.ToC()), C.ImGuiScrollFlags(flags))

	windowFin()
}

// InternalScrollToRectExV parameter default value hint:
// flags: 0
func InternalScrollToRectExV(window *Window, rect Rect, flags ScrollFlags) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igScrollToRectEx(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](rect.ToC()), C.ImGuiScrollFlags(flags))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalScrollbar(axis Axis) {
	C.igScrollbar(C.ImGuiAxis(axis))
}

// InternalScrollbarExV parameter default value hint:
// draw_rounding_flags: 0
func InternalScrollbarExV(bb Rect, id ID, axis Axis, p_scroll_v *int64, avail_v, contents_v int64, draw_rounding_flags DrawFlags) bool {
	idArg, idFin := id.C()
	p_scroll_vArg, p_scroll_vFin := internal.WrapNumberPtr[C.ImS64, int64](p_scroll_v)

	defer func() {
		idFin()
		p_scroll_vFin()
	}()
	return C.igScrollbarEx(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiAxis(axis), p_scroll_vArg, C.ImS64(avail_v), C.ImS64(contents_v), C.ImDrawFlags(draw_rounding_flags)) == C.bool(true)
}

// "bool selected" carry the selection state (read-only). Selectable() is clicked is returns true so you can modify your selection state. size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height
// SelectableBoolV parameter default value hint:
// selected: false
// flags: 0
// size: ImVec2(0,0)
func SelectableBoolV(label string, selected bool, flags SelectableFlags, size Vec2) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igSelectable_Bool(labelArg, C.bool(selected), C.ImGuiSelectableFlags(flags), internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

// "bool* p_selected" point to the selection state (read-write), as a convenient helper.
// SelectableBoolPtrV parameter default value hint:
// flags: 0
// size: ImVec2(0,0)
func SelectableBoolPtrV(label string, p_selected *bool, flags SelectableFlags, size Vec2) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	p_selectedArg, p_selectedFin := internal.WrapNumberPtr[C.bool, bool](p_selected)

	defer func() {
		labelFin()
		p_selectedFin()
	}()
	return C.igSelectable_BoolPtr(labelArg, p_selectedArg, C.ImGuiSelectableFlags(flags), internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

// separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.
func Separator() {
	C.igSeparator()
}

// InternalSeparatorExV parameter default value hint:
// thickness: 1.0f
func InternalSeparatorExV(flags SeparatorFlags, thickness float32) {
	C.igSeparatorEx(C.ImGuiSeparatorFlags(flags), C.float(thickness))
}

// currently: formatted text with a horizontal line
func SeparatorText(label string) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igSeparatorText(labelArg)

	labelFin()
}

func InternalSeparatorTextEx(id ID, label, label_end string, extra_width float32) {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)
	label_endArg, label_endFin := internal.WrapString[C.char](label_end)
	C.igSeparatorTextEx(internal.ReinterpretCast[C.ImGuiID](idArg), labelArg, label_endArg, C.float(extra_width))

	idFin()
	labelFin()
	label_endFin()
}

func InternalSetActiveID(id ID, window *Window) {
	idArg, idFin := id.C()
	windowArg, windowFin := window.Handle()
	C.igSetActiveID(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	idFin()
	windowFin()
}

func InternalSetActiveIdUsingAllKeyboardKeys() {
	C.igSetActiveIdUsingAllKeyboardKeys()
}

// SetAllocatorFunctionsV parameter default value hint:
// user_data: NULL
func SetAllocatorFunctionsV(alloc_func MemAllocFunc, free_func MemFreeFunc, user_data uintptr) {
	alloc_funcArg, alloc_funcFin := alloc_func.C()
	free_funcArg, free_funcFin := free_func.C()
	C.wrap_igSetAllocatorFunctionsV(internal.ReinterpretCast[C.ImGuiMemAllocFunc](alloc_funcArg), internal.ReinterpretCast[C.ImGuiMemFreeFunc](free_funcArg), C.uintptr_t(user_data))

	alloc_funcFin()
	free_funcFin()
}

func SetClipboardText(text string) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.igSetClipboardText(textArg)

	textFin()
}

// initialize current options (generally on application startup) if you want to select a default format, picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls.
func SetColorEditOptions(flags ColorEditFlags) {
	C.igSetColorEditOptions(C.ImGuiColorEditFlags(flags))
}

// set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column
func SetColumnOffset(column_index int32, offset_x float32) {
	C.igSetColumnOffset(C.int(column_index), C.float(offset_x))
}

// set column width (in pixels). pass -1 to use current column
func SetColumnWidth(column_index int32, width float32) {
	C.igSetColumnWidth(C.int(column_index), C.float(width))
}

func SetCurrentContext(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.igSetCurrentContext(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

func InternalSetCurrentFont(font *Font, font_size_before_scaling, font_size_after_scaling float32) {
	fontArg, fontFin := font.Handle()
	C.igSetCurrentFont(internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size_before_scaling), C.float(font_size_after_scaling))

	fontFin()
}

func InternalSetCurrentViewport(window *Window, viewport *ViewportP) {
	windowArg, windowFin := window.Handle()
	viewportArg, viewportFin := viewport.Handle()
	C.igSetCurrentViewport(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg))

	windowFin()
	viewportFin()
}

// [window-local] "
func SetCursorPos(local_pos Vec2) {
	C.igSetCursorPos(internal.ReinterpretCast[C.ImVec2](local_pos.ToC()))
}

// [window-local] "
func SetCursorPosX(local_x float32) {
	C.igSetCursorPosX(C.float(local_x))
}

// [window-local] "
func SetCursorPosY(local_y float32) {
	C.igSetCursorPosY(C.float(local_y))
}

// cursor position, absolute coordinates. THIS IS YOUR BEST FRIEND.
func SetCursorScreenPos(pos Vec2) {
	C.igSetCursorScreenPos(internal.ReinterpretCast[C.ImVec2](pos.ToC()))
}

// type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types. Data is copied and held by imgui. Return true when payload has been accepted.
// SetDragDropPayloadV parameter default value hint:
// cond: 0
func SetDragDropPayloadV(typeArg string, data uintptr, sz uint64, cond Cond) bool {
	typeArgArg, typeArgFin := internal.WrapString[C.char](typeArg)

	defer func() {
		typeArgFin()
	}()
	return C.wrap_igSetDragDropPayloadV(typeArgArg, C.uintptr_t(data), C.xulong(sz), C.ImGuiCond(cond)) == C.bool(true)
}

func InternalSetFocusID(id ID, window *Window) {
	idArg, idFin := id.C()
	windowArg, windowFin := window.Handle()
	C.igSetFocusID(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	idFin()
	windowFin()
}

func InternalSetFontRasterizerDensity(rasterizer_density float32) {
	C.igSetFontRasterizerDensity(C.float(rasterizer_density))
}

func InternalSetHoveredID(id ID) {
	idArg, idFin := id.C()
	C.igSetHoveredID(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

// make last item the default focused item of a newly appearing window.
func SetItemDefaultFocus() {
	C.igSetItemDefaultFocus()
}

// Set key owner to last item if it is hovered or active. Equivalent to 'if (IsItemHovered() || IsItemActive())  SetKeyOwner(key, GetItemID());'.
func InternalSetItemKeyOwnerInputFlags(key Key, flags InputFlags) {
	C.igSetItemKeyOwner_InputFlags(C.ImGuiKey(key), C.ImGuiInputFlags(flags))
}

// Set key owner to last item ID if it is hovered or active. Equivalent to 'if (IsItemHovered() || IsItemActive())  SetKeyOwner(key, GetItemID());'.
func SetItemKeyOwner(key Key) {
	C.igSetItemKeyOwner_Nil(C.ImGuiKey(key))
}

// set a text-only tooltip if preceding item was hovered. override any previous call to SetTooltip().
func SetItemTooltip(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igSetItemTooltip(fmtArg)

	fmtFin()
}

// InternalSetKeyOwnerV parameter default value hint:
// flags: 0
func InternalSetKeyOwnerV(key Key, owner_id ID, flags InputFlags) {
	owner_idArg, owner_idFin := owner_id.C()
	C.igSetKeyOwner(C.ImGuiKey(key), internal.ReinterpretCast[C.ImGuiID](owner_idArg), C.ImGuiInputFlags(flags))

	owner_idFin()
}

// InternalSetKeyOwnersForKeyChordV parameter default value hint:
// flags: 0
func InternalSetKeyOwnersForKeyChordV(key KeyChord, owner_id ID, flags InputFlags) {
	keyArg, keyFin := key.C()
	owner_idArg, owner_idFin := owner_id.C()
	C.igSetKeyOwnersForKeyChord(internal.ReinterpretCast[C.ImGuiKeyChord](keyArg), internal.ReinterpretCast[C.ImGuiID](owner_idArg), C.ImGuiInputFlags(flags))

	keyFin()
	owner_idFin()
}

// focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.
// SetKeyboardFocusHereV parameter default value hint:
// offset: 0
func SetKeyboardFocusHereV(offset int32) {
	C.igSetKeyboardFocusHere(C.int(offset))
}

func InternalSetLastItemData(item_id ID, item_flags ItemFlags, status_flags ItemStatusFlags, item_rect Rect) {
	item_idArg, item_idFin := item_id.C()
	C.igSetLastItemData(internal.ReinterpretCast[C.ImGuiID](item_idArg), C.ImGuiItemFlags(item_flags), C.ImGuiItemStatusFlags(status_flags), internal.ReinterpretCast[C.ImRect](item_rect.ToC()))

	item_idFin()
}

// set desired mouse cursor shape
func SetMouseCursor(cursor_type MouseCursor) {
	C.igSetMouseCursor(C.ImGuiMouseCursor(cursor_type))
}

// alter visibility of keyboard/gamepad cursor. by default: show when using an arrow key, hide when clicking with mouse.
func SetNavCursorVisible(visible bool) {
	C.igSetNavCursorVisible(C.bool(visible))
}

func InternalSetNavCursorVisibleAfterMove() {
	C.igSetNavCursorVisibleAfterMove()
}

func InternalSetNavFocusScope(focus_scope_id ID) {
	focus_scope_idArg, focus_scope_idFin := focus_scope_id.C()
	C.igSetNavFocusScope(internal.ReinterpretCast[C.ImGuiID](focus_scope_idArg))

	focus_scope_idFin()
}

func InternalSetNavID(id ID, nav_layer NavLayer, focus_scope_id ID, rect_rel Rect) {
	idArg, idFin := id.C()
	focus_scope_idArg, focus_scope_idFin := focus_scope_id.C()
	C.igSetNavID(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiNavLayer(nav_layer), internal.ReinterpretCast[C.ImGuiID](focus_scope_idArg), internal.ReinterpretCast[C.ImRect](rect_rel.ToC()))

	idFin()
	focus_scope_idFin()
}

func InternalSetNavWindow(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igSetNavWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

// Override io.WantCaptureKeyboard flag next frame (said flag is left for your application to handle, typically when true it instructs your app to ignore inputs). e.g. force capture keyboard when your widget is being hovered. This is equivalent to setting "io.WantCaptureKeyboard = want_capture_keyboard"; after the next NewFrame() call.
func SetNextFrameWantCaptureKeyboard(want_capture_keyboard bool) {
	C.igSetNextFrameWantCaptureKeyboard(C.bool(want_capture_keyboard))
}

// Override io.WantCaptureMouse flag next frame (said flag is left for your application to handle, typical when true it instructs your app to ignore inputs). This is equivalent to setting "io.WantCaptureMouse = want_capture_mouse;" after the next NewFrame() call.
func SetNextFrameWantCaptureMouse(want_capture_mouse bool) {
	C.igSetNextFrameWantCaptureMouse(C.bool(want_capture_mouse))
}

// allow next item to be overlapped by a subsequent item. Useful with invisible buttons, selectable, treenode covering an area where subsequent items may need to be added. Note that both Selectable() and TreeNode() have dedicated flags doing this.
func SetNextItemAllowOverlap() {
	C.igSetNextItemAllowOverlap()
}

// set next TreeNode/CollapsingHeader open state.
// SetNextItemOpenV parameter default value hint:
// cond: 0
func SetNextItemOpenV(is_open bool, cond Cond) {
	C.igSetNextItemOpen(C.bool(is_open), C.ImGuiCond(cond))
}

func InternalSetNextItemRefVal(data_type DataType, p_data uintptr) {
	C.wrap_igSetNextItemRefVal(C.ImGuiDataType(data_type), C.uintptr_t(p_data))
}

func SetNextItemSelectionUserData(selection_user_data SelectionUserData) {
	selection_user_dataArg, selection_user_dataFin := selection_user_data.C()
	C.igSetNextItemSelectionUserData(internal.ReinterpretCast[C.ImGuiSelectionUserData](selection_user_dataArg))

	selection_user_dataFin()
}

// SetNextItemShortcutV parameter default value hint:
// flags: 0
func SetNextItemShortcutV(key_chord KeyChord, flags InputFlags) {
	key_chordArg, key_chordFin := key_chord.C()
	C.igSetNextItemShortcut(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), C.ImGuiInputFlags(flags))

	key_chordFin()
}

// set id to use for open/close storage (default to same as item id).
func SetNextItemStorageID(storage_id ID) {
	storage_idArg, storage_idFin := storage_id.C()
	C.igSetNextItemStorageID(internal.ReinterpretCast[C.ImGuiID](storage_idArg))

	storage_idFin()
}

// set width of the _next_ common large "item+label" widget. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side)
func SetNextItemWidth(item_width float32) {
	C.igSetNextItemWidth(C.float(item_width))
}

// set next window background color alpha. helper to easily override the Alpha component of ImGuiCol_WindowBg/ChildBg/PopupBg. you may also use ImGuiWindowFlags_NoBackground.
func SetNextWindowBgAlpha(alpha float32) {
	C.igSetNextWindowBgAlpha(C.float(alpha))
}

// set next window class (control docking compatibility + provide hints to platform backend via custom viewport flags and platform parent/child relationship)
func SetNextWindowClass(window_class *WindowClass) {
	window_classArg, window_classFin := window_class.Handle()
	C.igSetNextWindowClass(internal.ReinterpretCast[*C.ImGuiWindowClass](window_classArg))

	window_classFin()
}

// set next window collapsed state. call before Begin()
// SetNextWindowCollapsedV parameter default value hint:
// cond: 0
func SetNextWindowCollapsedV(collapsed bool, cond Cond) {
	C.igSetNextWindowCollapsed(C.bool(collapsed), C.ImGuiCond(cond))
}

// set next window content size (~ scrollable client area, which enforce the range of scrollbars). Not including window decorations (title bar, menu bar, etc.) nor WindowPadding. set an axis to 0.0f to leave it automatic. call before Begin()
func SetNextWindowContentSize(size Vec2) {
	C.igSetNextWindowContentSize(internal.ReinterpretCast[C.ImVec2](size.ToC()))
}

// set next window dock id
// SetNextWindowDockIDV parameter default value hint:
// cond: 0
func SetNextWindowDockIDV(dock_id ID, cond Cond) {
	dock_idArg, dock_idFin := dock_id.C()
	C.igSetNextWindowDockID(internal.ReinterpretCast[C.ImGuiID](dock_idArg), C.ImGuiCond(cond))

	dock_idFin()
}

// set next window to be focused / top-most. call before Begin()
func SetNextWindowFocus() {
	C.igSetNextWindowFocus()
}

// set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
// SetNextWindowPosV parameter default value hint:
// cond: 0
// pivot: ImVec2(0,0)
func SetNextWindowPosV(pos Vec2, cond Cond, pivot Vec2) {
	C.igSetNextWindowPos(internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImGuiCond(cond), internal.ReinterpretCast[C.ImVec2](pivot.ToC()))
}

func InternalSetNextWindowRefreshPolicy(flags WindowRefreshFlags) {
	C.igSetNextWindowRefreshPolicy(C.ImGuiWindowRefreshFlags(flags))
}

// set next window scrolling value (use < 0.0f to not affect a given axis).
func SetNextWindowScroll(scroll Vec2) {
	C.igSetNextWindowScroll(internal.ReinterpretCast[C.ImVec2](scroll.ToC()))
}

// set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
// SetNextWindowSizeV parameter default value hint:
// cond: 0
func SetNextWindowSizeV(size Vec2, cond Cond) {
	C.igSetNextWindowSize(internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiCond(cond))
}

// set next window size limits. use 0.0f or FLT_MAX if you don't want limits. Use -1 for both min and max of same axis to preserve current size (which itself is a constraint). Use callback to apply non-trivial programmatic constraints.
// SetNextWindowSizeConstraintsV parameter default value hint:
// custom_callback: NULL
// custom_callback_data: NULL
func SetNextWindowSizeConstraintsV(size_min, size_max Vec2, custom_callback SizeCallback, custom_callback_data uintptr) {
	custom_callbackArg, custom_callbackFin := custom_callback.C()
	C.wrap_igSetNextWindowSizeConstraintsV(internal.ReinterpretCast[C.ImVec2](size_min.ToC()), internal.ReinterpretCast[C.ImVec2](size_max.ToC()), internal.ReinterpretCast[C.ImGuiSizeCallback](custom_callbackArg), C.uintptr_t(custom_callback_data))

	custom_callbackFin()
}

// set next window viewport
func SetNextWindowViewport(viewport_id ID) {
	viewport_idArg, viewport_idFin := viewport_id.C()
	C.igSetNextWindowViewport(internal.ReinterpretCast[C.ImGuiID](viewport_idArg))

	viewport_idFin()
}

// adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
// SetScrollFromPosXFloatV parameter default value hint:
// center_x_ratio: 0.5f
func SetScrollFromPosXFloatV(local_x, center_x_ratio float32) {
	C.igSetScrollFromPosX_Float(C.float(local_x), C.float(center_x_ratio))
}

func InternalSetScrollFromPosXWindowPtr(window *Window, local_x, center_x_ratio float32) {
	windowArg, windowFin := window.Handle()
	C.igSetScrollFromPosX_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.float(local_x), C.float(center_x_ratio))

	windowFin()
}

// adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
// SetScrollFromPosYFloatV parameter default value hint:
// center_y_ratio: 0.5f
func SetScrollFromPosYFloatV(local_y, center_y_ratio float32) {
	C.igSetScrollFromPosY_Float(C.float(local_y), C.float(center_y_ratio))
}

func InternalSetScrollFromPosYWindowPtr(window *Window, local_y, center_y_ratio float32) {
	windowArg, windowFin := window.Handle()
	C.igSetScrollFromPosY_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.float(local_y), C.float(center_y_ratio))

	windowFin()
}

// adjust scrolling amount to make current cursor position visible. center_x_ratio=0.0: left, 0.5: center, 1.0: right. When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
// SetScrollHereXV parameter default value hint:
// center_x_ratio: 0.5f
func SetScrollHereXV(center_x_ratio float32) {
	C.igSetScrollHereX(C.float(center_x_ratio))
}

// adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom. When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
// SetScrollHereYV parameter default value hint:
// center_y_ratio: 0.5f
func SetScrollHereYV(center_y_ratio float32) {
	C.igSetScrollHereY(C.float(center_y_ratio))
}

// set scrolling amount [0 .. GetScrollMaxX()]
func SetScrollXFloat(scroll_x float32) {
	C.igSetScrollX_Float(C.float(scroll_x))
}

func InternalSetScrollXWindowPtr(window *Window, scroll_x float32) {
	windowArg, windowFin := window.Handle()
	C.igSetScrollX_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.float(scroll_x))

	windowFin()
}

// set scrolling amount [0 .. GetScrollMaxY()]
func SetScrollYFloat(scroll_y float32) {
	C.igSetScrollY_Float(C.float(scroll_y))
}

func InternalSetScrollYWindowPtr(window *Window, scroll_y float32) {
	windowArg, windowFin := window.Handle()
	C.igSetScrollY_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.float(scroll_y))

	windowFin()
}

// owner_id needs to be explicit and cannot be 0
func InternalSetShortcutRouting(key_chord KeyChord, flags InputFlags, owner_id ID) bool {
	key_chordArg, key_chordFin := key_chord.C()
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		key_chordFin()
		owner_idFin()
	}()
	return C.igSetShortcutRouting(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), C.ImGuiInputFlags(flags), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// replace current window storage with our own (if you want to manipulate it yourself, typically clear subsection of it)
func SetStateStorage(storage *Storage) {
	storageArg, storageFin := storage.Handle()
	C.igSetStateStorage(internal.ReinterpretCast[*C.ImGuiStorage](storageArg))

	storageFin()
}

// notify TabBar or Docking system of a closed tab/window ahead (useful to reduce visual flicker on reorderable tab bars). For tab-bar: call after BeginTabBar() and before Tab submissions. Otherwise call with a window name.
func SetTabItemClosed(tab_or_docked_window_label string) {
	tab_or_docked_window_labelArg, tab_or_docked_window_labelFin := internal.WrapString[C.char](tab_or_docked_window_label)
	C.igSetTabItemClosed(tab_or_docked_window_labelArg)

	tab_or_docked_window_labelFin()
}

// set a text-only tooltip. Often used after a ImGui::IsItemHovered() check. Override any previous call to SetTooltip().
func SetTooltip(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igSetTooltip(fmtArg)

	fmtFin()
}

func InternalSetWindowClipRectBeforeSetChannel(window *Window, clip_rect Rect) {
	windowArg, windowFin := window.Handle()
	C.igSetWindowClipRectBeforeSetChannel(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](clip_rect.ToC()))

	windowFin()
}

// (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
// SetWindowCollapsedBoolV parameter default value hint:
// cond: 0
func SetWindowCollapsedBoolV(collapsed bool, cond Cond) {
	C.igSetWindowCollapsed_Bool(C.bool(collapsed), C.ImGuiCond(cond))
}

// set named window collapsed state
// SetWindowCollapsedStrV parameter default value hint:
// cond: 0
func SetWindowCollapsedStrV(name string, collapsed bool, cond Cond) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.igSetWindowCollapsed_Str(nameArg, C.bool(collapsed), C.ImGuiCond(cond))

	nameFin()
}

// InternalSetWindowCollapsedWindowPtrV parameter default value hint:
// cond: 0
func InternalSetWindowCollapsedWindowPtrV(window *Window, collapsed bool, cond Cond) {
	windowArg, windowFin := window.Handle()
	C.igSetWindowCollapsed_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.bool(collapsed), C.ImGuiCond(cond))

	windowFin()
}

func InternalSetWindowDock(window *Window, dock_id ID, cond Cond) {
	windowArg, windowFin := window.Handle()
	dock_idArg, dock_idFin := dock_id.C()
	C.igSetWindowDock(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImGuiID](dock_idArg), C.ImGuiCond(cond))

	windowFin()
	dock_idFin()
}

// (not recommended) set current window to be focused / top-most. prefer using SetNextWindowFocus().
func SetWindowFocus() {
	C.igSetWindowFocus_Nil()
}

// set named window to be focused / top-most. use NULL to remove focus.
func SetWindowFocusStr(name string) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.igSetWindowFocus_Str(nameArg)

	nameFin()
}

func InternalSetWindowHiddenAndSkipItemsForCurrentFrame(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igSetWindowHiddenAndSkipItemsForCurrentFrame(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalSetWindowHitTestHole(window *Window, pos, size Vec2) {
	windowArg, windowFin := window.Handle()
	C.igSetWindowHitTestHole(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[C.ImVec2](size.ToC()))

	windowFin()
}

// You may also use SetNextWindowClass()'s FocusRouteParentWindowId field.
func InternalSetWindowParentWindowForFocusRoute(window, parent_window *Window) {
	windowArg, windowFin := window.Handle()
	parent_windowArg, parent_windowFin := parent_window.Handle()
	C.igSetWindowParentWindowForFocusRoute(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiWindow](parent_windowArg))

	windowFin()
	parent_windowFin()
}

// set named window position.
// SetWindowPosStrV parameter default value hint:
// cond: 0
func SetWindowPosStrV(name string, pos Vec2, cond Cond) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.igSetWindowPos_Str(nameArg, internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImGuiCond(cond))

	nameFin()
}

// (not recommended) set current window position - call within Begin()/End(). prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
// SetWindowPosVec2V parameter default value hint:
// cond: 0
func SetWindowPosVec2V(pos Vec2, cond Cond) {
	C.igSetWindowPos_Vec2(internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImGuiCond(cond))
}

// InternalSetWindowPosWindowPtrV parameter default value hint:
// cond: 0
func InternalSetWindowPosWindowPtrV(window *Window, pos Vec2, cond Cond) {
	windowArg, windowFin := window.Handle()
	C.igSetWindowPos_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImGuiCond(cond))

	windowFin()
}

// set named window size. set axis to 0.0f to force an auto-fit on this axis.
// SetWindowSizeStrV parameter default value hint:
// cond: 0
func SetWindowSizeStrV(name string, size Vec2, cond Cond) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.igSetWindowSize_Str(nameArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiCond(cond))

	nameFin()
}

// (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0, 0) to force an auto-fit. prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects.
// SetWindowSizeVec2V parameter default value hint:
// cond: 0
func SetWindowSizeVec2V(size Vec2, cond Cond) {
	C.igSetWindowSize_Vec2(internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiCond(cond))
}

// InternalSetWindowSizeWindowPtrV parameter default value hint:
// cond: 0
func InternalSetWindowSizeWindowPtrV(window *Window, size Vec2, cond Cond) {
	windowArg, windowFin := window.Handle()
	C.igSetWindowSize_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiCond(cond))

	windowFin()
}

func InternalSetWindowViewport(window *Window, viewport *ViewportP) {
	windowArg, windowFin := window.Handle()
	viewportArg, viewportFin := viewport.Handle()
	C.igSetWindowViewport(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg))

	windowFin()
	viewportFin()
}

func InternalShadeVertsLinearColorGradientKeepAlpha(draw_list *DrawList, vert_start_idx, vert_end_idx int32, gradient_p0, gradient_p1 Vec2, col0, col1 uint32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igShadeVertsLinearColorGradientKeepAlpha(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.int(vert_start_idx), C.int(vert_end_idx), internal.ReinterpretCast[C.ImVec2](gradient_p0.ToC()), internal.ReinterpretCast[C.ImVec2](gradient_p1.ToC()), C.ImU32(col0), C.ImU32(col1))

	draw_listFin()
}

func InternalShadeVertsLinearUV(draw_list *DrawList, vert_start_idx, vert_end_idx int32, a, b, uv_a, uv_b Vec2, clamp bool) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igShadeVertsLinearUV(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.int(vert_start_idx), C.int(vert_end_idx), internal.ReinterpretCast[C.ImVec2](a.ToC()), internal.ReinterpretCast[C.ImVec2](b.ToC()), internal.ReinterpretCast[C.ImVec2](uv_a.ToC()), internal.ReinterpretCast[C.ImVec2](uv_b.ToC()), C.bool(clamp))

	draw_listFin()
}

func InternalShadeVertsTransformPos(draw_list *DrawList, vert_start_idx, vert_end_idx int32, pivot_in Vec2, cos_a, sin_a float32, pivot_out Vec2) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igShadeVertsTransformPos(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.int(vert_start_idx), C.int(vert_end_idx), internal.ReinterpretCast[C.ImVec2](pivot_in.ToC()), C.float(cos_a), C.float(sin_a), internal.ReinterpretCast[C.ImVec2](pivot_out.ToC()))

	draw_listFin()
}

func InternalShortcutID(key_chord KeyChord, flags InputFlags, owner_id ID) bool {
	key_chordArg, key_chordFin := key_chord.C()
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		key_chordFin()
		owner_idFin()
	}()
	return C.igShortcut_ID(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), C.ImGuiInputFlags(flags), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// ShortcutNilV parameter default value hint:
// flags: 0
func ShortcutNilV(key_chord KeyChord, flags InputFlags) bool {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return C.igShortcut_Nil(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), C.ImGuiInputFlags(flags)) == C.bool(true)
}

// create About window. display Dear ImGui version, credits and build/system information.
// ShowAboutWindowV parameter default value hint:
// p_open: NULL
func ShowAboutWindowV(p_open *bool) {
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.igShowAboutWindow(p_openArg)

	p_openFin()
}

// create Debug Log window. display a simplified log of important dear imgui events.
// ShowDebugLogWindowV parameter default value hint:
// p_open: NULL
func ShowDebugLogWindowV(p_open *bool) {
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.igShowDebugLogWindow(p_openArg)

	p_openFin()
}

// create Demo window. demonstrate most ImGui features. call this to learn about the library! try to make it always available in your application!
// ShowDemoWindowV parameter default value hint:
// p_open: NULL
func ShowDemoWindowV(p_open *bool) {
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.igShowDemoWindow(p_openArg)

	p_openFin()
}

func InternalShowFontAtlas(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igShowFontAtlas(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

// add font selector block (not a window), essentially a combo listing the loaded fonts.
func ShowFontSelector(label string) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igShowFontSelector(labelArg)

	labelFin()
}

// create Stack Tool window. hover items with mouse to query information about the source of their unique ID.
// ShowIDStackToolWindowV parameter default value hint:
// p_open: NULL
func ShowIDStackToolWindowV(p_open *bool) {
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.igShowIDStackToolWindow(p_openArg)

	p_openFin()
}

// create Metrics/Debugger window. display Dear ImGui internals: windows, draw commands, various internal state, etc.
// ShowMetricsWindowV parameter default value hint:
// p_open: NULL
func ShowMetricsWindowV(p_open *bool) {
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.igShowMetricsWindow(p_openArg)

	p_openFin()
}

// add style editor block (not a window). you can pass in a reference ImGuiStyle structure to compare to, revert to and save to (else it uses the default style)
// ShowStyleEditorV parameter default value hint:
// ref: NULL
func ShowStyleEditorV(ref *Style) {
	refArg, refFin := ref.Handle()
	C.igShowStyleEditor(internal.ReinterpretCast[*C.ImGuiStyle](refArg))

	refFin()
}

// add style selector block (not a window), essentially a combo listing the default styles.
func ShowStyleSelector(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igShowStyleSelector(labelArg) == C.bool(true)
}

// add basic help/info block (not a window): how to manipulate ImGui as an end-user (mouse/keyboard controls).
func ShowUserGuide() {
	C.igShowUserGuide()
}

func InternalShrinkWidths(items *ShrinkWidthItem, count int32, width_excess, width_min float32) {
	itemsArg, itemsFin := items.Handle()
	C.igShrinkWidths(internal.ReinterpretCast[*C.ImGuiShrinkWidthItem](itemsArg), C.int(count), C.float(width_excess), C.float(width_min))

	itemsFin()
}

// Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
func InternalShutdown() {
	C.igShutdown()
}

// SliderAngleV parameter default value hint:
// v_degrees_min: -360.0f
// v_degrees_max: +360.0f
// format: "%.0f deg"
// flags: 0
func SliderAngleV(label string, v_rad *float32, v_degrees_min, v_degrees_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	v_radArg, v_radFin := internal.WrapNumberPtr[C.float, float32](v_rad)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		v_radFin()
		formatFin()
	}()
	return C.igSliderAngle(labelArg, v_radArg, C.float(v_degrees_min), C.float(v_degrees_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

func InternalSliderBehavior(bb Rect, id ID, data_type DataType, p_v, p_min, p_max uintptr, format string, flags SliderFlags, out_grab_bb *Rect) bool {
	idArg, idFin := id.C()
	formatArg, formatFin := internal.WrapString[C.char](format)
	out_grab_bbArg, out_grab_bbFin := internal.Wrap(out_grab_bb)

	defer func() {
		idFin()
		formatFin()
		out_grab_bbFin()
	}()
	return C.wrap_igSliderBehavior(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiDataType(data_type), C.uintptr_t(p_v), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags), internal.ReinterpretCast[*C.ImRect](out_grab_bbArg)) == C.bool(true)
}

// adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display.
// SliderFloatV parameter default value hint:
// format: "%.3f"
// flags: 0
func SliderFloatV(label string, v *float32, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igSliderFloat(labelArg, vArg, C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderFloat2V parameter default value hint:
// format: "%.3f"
// flags: 0
func SliderFloat2V(label string, v *[2]float32, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igSliderFloat2(labelArg, (*C.float)(&vArg[0]), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderFloat3V parameter default value hint:
// format: "%.3f"
// flags: 0
func SliderFloat3V(label string, v *[3]float32, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igSliderFloat3(labelArg, (*C.float)(&vArg[0]), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderFloat4V parameter default value hint:
// format: "%.3f"
// flags: 0
func SliderFloat4V(label string, v *[4]float32, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}

		formatFin()
	}()
	return C.igSliderFloat4(labelArg, (*C.float)(&vArg[0]), C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderIntV parameter default value hint:
// format: "%d"
// flags: 0
func SliderIntV(label string, v *int32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igSliderInt(labelArg, vArg, C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderInt2V parameter default value hint:
// format: "%d"
// flags: 0
func SliderInt2V(label string, v *[2]int32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}

		formatFin()
	}()
	return C.igSliderInt2(labelArg, (*C.int)(&vArg[0]), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderInt3V parameter default value hint:
// format: "%d"
// flags: 0
func SliderInt3V(label string, v *[3]int32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}

		formatFin()
	}()
	return C.igSliderInt3(labelArg, (*C.int)(&vArg[0]), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderInt4V parameter default value hint:
// format: "%d"
// flags: 0
func SliderInt4V(label string, v *[4]int32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}

		formatFin()
	}()
	return C.igSliderInt4(labelArg, (*C.int)(&vArg[0]), C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderScalarV parameter default value hint:
// format: NULL
// flags: 0
func SliderScalarV(label string, data_type DataType, p_data, p_min, p_max uintptr, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igSliderScalarV(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// SliderScalarNV parameter default value hint:
// format: NULL
// flags: 0
func SliderScalarNV(label string, data_type DataType, p_data uintptr, components int32, p_min, p_max uintptr, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igSliderScalarNV(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.int(components), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// button with (FramePadding.y == 0) to easily embed within text
func SmallButton(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igSmallButton(labelArg) == C.bool(true)
}

// add vertical spacing.
func Spacing() {
	C.igSpacing()
}

// InternalSplitterBehaviorV parameter default value hint:
// hover_extend: 0.0f
// hover_visibility_delay: 0.0f
// bg_col: 0
func InternalSplitterBehaviorV(bb Rect, id ID, axis Axis, size1, size2 *float32, min_size1, min_size2, hover_extend, hover_visibility_delay float32, bg_col uint32) bool {
	idArg, idFin := id.C()
	size1Arg, size1Fin := internal.WrapNumberPtr[C.float, float32](size1)
	size2Arg, size2Fin := internal.WrapNumberPtr[C.float, float32](size2)

	defer func() {
		idFin()
		size1Fin()
		size2Fin()
	}()
	return C.igSplitterBehavior(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiAxis(axis), size1Arg, size2Arg, C.float(min_size1), C.float(min_size2), C.float(hover_extend), C.float(hover_visibility_delay), C.ImU32(bg_col)) == C.bool(true)
}

func InternalStartMouseMovingWindow(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igStartMouseMovingWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func InternalStartMouseMovingWindowOrNode(window *Window, node *DockNode, undock bool) {
	windowArg, windowFin := window.Handle()
	nodeArg, nodeFin := node.Handle()
	C.igStartMouseMovingWindowOrNode(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[*C.ImGuiDockNode](nodeArg), C.bool(undock))

	windowFin()
	nodeFin()
}

func InternalStopMouseMovingWindow() {
	C.igStopMouseMovingWindow()
}

// classic imgui style
// StyleColorsClassicV parameter default value hint:
// dst: NULL
func StyleColorsClassicV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.igStyleColorsClassic(internal.ReinterpretCast[*C.ImGuiStyle](dstArg))

	dstFin()
}

// new, recommended style (default)
// StyleColorsDarkV parameter default value hint:
// dst: NULL
func StyleColorsDarkV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.igStyleColorsDark(internal.ReinterpretCast[*C.ImGuiStyle](dstArg))

	dstFin()
}

// best used with borders and a custom, thicker font
// StyleColorsLightV parameter default value hint:
// dst: NULL
func StyleColorsLightV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.igStyleColorsLight(internal.ReinterpretCast[*C.ImGuiStyle](dstArg))

	dstFin()
}

func InternalTabBarAddTab(tab_bar *TabBar, tab_flags TabItemFlags, window *Window) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	windowArg, windowFin := window.Handle()
	C.igTabBarAddTab(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), C.ImGuiTabItemFlags(tab_flags), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	tab_barFin()
	windowFin()
}

func InternalTabBarCloseTab(tab_bar *TabBar, tab *TabItem) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tabArg, tabFin := tab.Handle()
	C.igTabBarCloseTab(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[*C.ImGuiTabItem](tabArg))

	tab_barFin()
	tabFin()
}

func InternalTabBarFindByID(id ID) *TabBar {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewTabBarFromC(C.igTabBarFindByID(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalTabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar *TabBar) *TabItem {
	tab_barArg, tab_barFin := tab_bar.Handle()

	defer func() {
		tab_barFin()
	}()
	return NewTabItemFromC(C.igTabBarFindMostRecentlySelectedTabForActiveWindow(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg)))
}

func InternalTabBarFindTabByID(tab_bar *TabBar, tab_id ID) *TabItem {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tab_idArg, tab_idFin := tab_id.C()

	defer func() {
		tab_barFin()
		tab_idFin()
	}()
	return NewTabItemFromC(C.igTabBarFindTabByID(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[C.ImGuiID](tab_idArg)))
}

func InternalTabBarFindTabByOrder(tab_bar *TabBar, order int32) *TabItem {
	tab_barArg, tab_barFin := tab_bar.Handle()

	defer func() {
		tab_barFin()
	}()
	return NewTabItemFromC(C.igTabBarFindTabByOrder(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), C.int(order)))
}

func InternalTabBarGetCurrentTab(tab_bar *TabBar) *TabItem {
	tab_barArg, tab_barFin := tab_bar.Handle()

	defer func() {
		tab_barFin()
	}()
	return NewTabItemFromC(C.igTabBarGetCurrentTab(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg)))
}

func InternalTabBarGetTabName(tab_bar *TabBar, tab *TabItem) string {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tabArg, tabFin := tab.Handle()

	defer func() {
		tab_barFin()
		tabFin()
	}()
	return C.GoString(C.igTabBarGetTabName(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[*C.ImGuiTabItem](tabArg)))
}

func InternalTabBarGetTabOrder(tab_bar *TabBar, tab *TabItem) int32 {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tabArg, tabFin := tab.Handle()

	defer func() {
		tab_barFin()
		tabFin()
	}()
	return int32(C.igTabBarGetTabOrder(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[*C.ImGuiTabItem](tabArg)))
}

func InternalTabBarProcessReorder(tab_bar *TabBar) bool {
	tab_barArg, tab_barFin := tab_bar.Handle()

	defer func() {
		tab_barFin()
	}()
	return C.igTabBarProcessReorder(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg)) == C.bool(true)
}

func InternalTabBarQueueFocusStr(tab_bar *TabBar, tab_name string) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tab_nameArg, tab_nameFin := internal.WrapString[C.char](tab_name)
	C.igTabBarQueueFocus_Str(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), tab_nameArg)

	tab_barFin()
	tab_nameFin()
}

func InternalTabBarQueueFocusTabItemPtr(tab_bar *TabBar, tab *TabItem) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tabArg, tabFin := tab.Handle()
	C.igTabBarQueueFocus_TabItemPtr(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[*C.ImGuiTabItem](tabArg))

	tab_barFin()
	tabFin()
}

func InternalTabBarQueueReorder(tab_bar *TabBar, tab *TabItem, offset int32) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tabArg, tabFin := tab.Handle()
	C.igTabBarQueueReorder(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[*C.ImGuiTabItem](tabArg), C.int(offset))

	tab_barFin()
	tabFin()
}

func InternalTabBarQueueReorderFromMousePos(tab_bar *TabBar, tab *TabItem, mouse_pos Vec2) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tabArg, tabFin := tab.Handle()
	C.igTabBarQueueReorderFromMousePos(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[*C.ImGuiTabItem](tabArg), internal.ReinterpretCast[C.ImVec2](mouse_pos.ToC()))

	tab_barFin()
	tabFin()
}

func InternalTabBarRemove(tab_bar *TabBar) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	C.igTabBarRemove(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg))

	tab_barFin()
}

func InternalTabBarRemoveTab(tab_bar *TabBar, tab_id ID) {
	tab_barArg, tab_barFin := tab_bar.Handle()
	tab_idArg, tab_idFin := tab_id.C()
	C.igTabBarRemoveTab(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), internal.ReinterpretCast[C.ImGuiID](tab_idArg))

	tab_barFin()
	tab_idFin()
}

func InternalTabItemBackground(draw_list *DrawList, bb Rect, flags TabItemFlags, col uint32) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.igTabItemBackground(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImRect](bb.ToC()), C.ImGuiTabItemFlags(flags), C.ImU32(col))

	draw_listFin()
}

// create a Tab behaving like a button. return true when clicked. cannot be selected in the tab bar.
// TabItemButtonV parameter default value hint:
// flags: 0
func TabItemButtonV(label string, flags TabItemFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igTabItemButton(labelArg, C.ImGuiTabItemFlags(flags)) == C.bool(true)
}

func InternalTabItemCalcSizeStr(label string, has_close_button_or_unsaved_marker bool) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igTabItemCalcSize_Str(internal.ReinterpretCast[*C.ImVec2](pOutArg), labelArg, C.bool(has_close_button_or_unsaved_marker))

	pOutFin()
	labelFin()

	return *pOut
}

func InternalTabItemCalcSizeWindowPtr(window *Window) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igTabItemCalcSize_WindowPtr(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalTabItemEx(tab_bar *TabBar, label string, p_open *bool, flags TabItemFlags, docked_window *Window) bool {
	tab_barArg, tab_barFin := tab_bar.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	docked_windowArg, docked_windowFin := docked_window.Handle()

	defer func() {
		tab_barFin()
		labelFin()
		p_openFin()
		docked_windowFin()
	}()
	return C.igTabItemEx(internal.ReinterpretCast[*C.ImGuiTabBar](tab_barArg), labelArg, p_openArg, C.ImGuiTabItemFlags(flags), internal.ReinterpretCast[*C.ImGuiWindow](docked_windowArg)) == C.bool(true)
}

func InternalTabItemLabelAndCloseButton(draw_list *DrawList, bb Rect, flags TabItemFlags, frame_padding Vec2, label string, tab_id, close_button_id ID, is_contents_visible bool, out_just_closed, out_text_clipped *bool) {
	draw_listArg, draw_listFin := draw_list.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	tab_idArg, tab_idFin := tab_id.C()
	close_button_idArg, close_button_idFin := close_button_id.C()
	out_just_closedArg, out_just_closedFin := internal.WrapNumberPtr[C.bool, bool](out_just_closed)
	out_text_clippedArg, out_text_clippedFin := internal.WrapNumberPtr[C.bool, bool](out_text_clipped)
	C.igTabItemLabelAndCloseButton(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImRect](bb.ToC()), C.ImGuiTabItemFlags(flags), internal.ReinterpretCast[C.ImVec2](frame_padding.ToC()), labelArg, internal.ReinterpretCast[C.ImGuiID](tab_idArg), internal.ReinterpretCast[C.ImGuiID](close_button_idArg), C.bool(is_contents_visible), out_just_closedArg, out_text_clippedArg)

	draw_listFin()
	labelFin()
	tab_idFin()
	close_button_idFin()
	out_just_closedFin()
	out_text_clippedFin()
}

func InternalTabItemSpacing(str_id string, flags TabItemFlags, width float32) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.igTabItemSpacing(str_idArg, C.ImGuiTabItemFlags(flags), C.float(width))

	str_idFin()
}

// submit a row with angled headers for every column with the ImGuiTableColumnFlags_AngledHeader flag. MUST BE FIRST ROW.
func TableAngledHeadersRow() {
	C.igTableAngledHeadersRow()
}

func InternalTableAngledHeadersRowEx(row_id ID, angle, max_label_width float32, data *TableHeaderData, data_count int32) {
	row_idArg, row_idFin := row_id.C()
	dataArg, dataFin := data.Handle()
	C.igTableAngledHeadersRowEx(internal.ReinterpretCast[C.ImGuiID](row_idArg), C.float(angle), C.float(max_label_width), internal.ReinterpretCast[*C.ImGuiTableHeaderData](dataArg), C.int(data_count))

	row_idFin()
	dataFin()
}

func InternalTableBeginApplyRequests(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableBeginApplyRequests(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableBeginCell(table *Table, column_n int32) {
	tableArg, tableFin := table.Handle()
	C.igTableBeginCell(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n))

	tableFin()
}

func InternalTableBeginContextMenuPopup(table *Table) bool {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return C.igTableBeginContextMenuPopup(internal.ReinterpretCast[*C.ImGuiTable](tableArg)) == C.bool(true)
}

func InternalTableBeginInitMemory(table *Table, columns_count int32) {
	tableArg, tableFin := table.Handle()
	C.igTableBeginInitMemory(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(columns_count))

	tableFin()
}

func InternalTableBeginRow(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableBeginRow(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableCalcMaxColumnWidth(table *Table, column_n int32) float32 {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return float32(C.igTableCalcMaxColumnWidth(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n)))
}

func InternalTableDrawBorders(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableDrawBorders(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableDrawDefaultContextMenu(table *Table, flags_for_section_to_display TableFlags) {
	tableArg, tableFin := table.Handle()
	C.igTableDrawDefaultContextMenu(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.ImGuiTableFlags(flags_for_section_to_display))

	tableFin()
}

func InternalTableEndCell(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableEndCell(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableEndRow(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableEndRow(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableFindByID(id ID) *Table {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewTableFromC(C.igTableFindByID(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func InternalTableFixColumnSortDirection(table *Table, column *TableColumn) {
	tableArg, tableFin := table.Handle()
	columnArg, columnFin := column.Handle()
	C.igTableFixColumnSortDirection(internal.ReinterpretCast[*C.ImGuiTable](tableArg), internal.ReinterpretCast[*C.ImGuiTableColumn](columnArg))

	tableFin()
	columnFin()
}

func InternalTableGcCompactSettings() {
	C.igTableGcCompactSettings()
}

func InternalTableGcCompactTransientBuffersTablePtr(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableGcCompactTransientBuffers_TablePtr(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableGcCompactTransientBuffersTableTempDataPtr(table *TableTempData) {
	tableArg, tableFin := table.Handle()
	C.igTableGcCompactTransientBuffers_TableTempDataPtr(internal.ReinterpretCast[*C.ImGuiTableTempData](tableArg))

	tableFin()
}

func InternalTableGetBoundSettings(table *Table) *TableSettings {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return NewTableSettingsFromC(C.igTableGetBoundSettings(internal.ReinterpretCast[*C.ImGuiTable](tableArg)))
}

func InternalTableGetCellBgRect(table *Table, column_n int32) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	tableArg, tableFin := table.Handle()
	C.igTableGetCellBgRect(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n))

	pOutFin()
	tableFin()

	return *pOut
}

// return number of columns (value passed to BeginTable)
func TableGetColumnCount() int32 {
	return int32(C.igTableGetColumnCount())
}

// return column flags so you can query their Enabled/Visible/Sorted/Hovered status flags. Pass -1 to use current column.
// TableGetColumnFlagsV parameter default value hint:
// column_n: -1
func TableGetColumnFlagsV(column_n int32) TableColumnFlags {
	return TableColumnFlags(C.igTableGetColumnFlags(C.int(column_n)))
}

// return current column index.
func TableGetColumnIndex() int32 {
	return int32(C.igTableGetColumnIndex())
}

// return "" if column didn't have a name declared by TableSetupColumn(). Pass -1 to use current column.
// TableGetColumnNameIntV parameter default value hint:
// column_n: -1
func TableGetColumnNameIntV(column_n int32) string {
	return C.GoString(C.igTableGetColumnName_Int(C.int(column_n)))
}

func InternalTableGetColumnNameTablePtr(table *Table, column_n int32) string {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return C.GoString(C.igTableGetColumnName_TablePtr(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n)))
}

func InternalTableGetColumnNextSortDirection(column *TableColumn) SortDirection {
	columnArg, columnFin := column.Handle()

	defer func() {
		columnFin()
	}()
	return SortDirection(C.igTableGetColumnNextSortDirection(internal.ReinterpretCast[*C.ImGuiTableColumn](columnArg)))
}

// InternalTableGetColumnResizeIDV parameter default value hint:
// instance_no: 0
func InternalTableGetColumnResizeIDV(table *Table, column_n, instance_no int32) ID {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igTableGetColumnResizeID(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n), C.int(instance_no))
		return &result
	}())
}

func InternalTableGetColumnWidthAuto(table *Table, column *TableColumn) float32 {
	tableArg, tableFin := table.Handle()
	columnArg, columnFin := column.Handle()

	defer func() {
		tableFin()
		columnFin()
	}()
	return float32(C.igTableGetColumnWidthAuto(internal.ReinterpretCast[*C.ImGuiTable](tableArg), internal.ReinterpretCast[*C.ImGuiTableColumn](columnArg)))
}

func InternalTableGetHeaderAngledMaxLabelWidth() float32 {
	return float32(C.igTableGetHeaderAngledMaxLabelWidth())
}

func InternalTableGetHeaderRowHeight() float32 {
	return float32(C.igTableGetHeaderRowHeight())
}

// return hovered column. return -1 when table is not hovered. return columns_count if the unused space at the right of visible columns is hovered. Can also use (TableGetColumnFlags() & ImGuiTableColumnFlags_IsHovered) instead.
func TableGetHoveredColumn() int32 {
	return int32(C.igTableGetHoveredColumn())
}

// Retrieve *PREVIOUS FRAME* hovered row. This difference with TableGetHoveredColumn() is the reason why this is not public yet.
func InternalTableGetHoveredRow() int32 {
	return int32(C.igTableGetHoveredRow())
}

func InternalTableGetInstanceData(table *Table, instance_no int32) *TableInstanceData {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return NewTableInstanceDataFromC(C.igTableGetInstanceData(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(instance_no)))
}

func InternalTableGetInstanceID(table *Table, instance_no int32) ID {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.igTableGetInstanceID(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(instance_no))
		return &result
	}())
}

// return current row index (header rows are accounted for)
func TableGetRowIndex() int32 {
	return int32(C.igTableGetRowIndex())
}

// get latest sort specs for the table (NULL if not sorting).  Lifetime: don't hold on this pointer over multiple frames or past any subsequent call to BeginTable().
func TableGetSortSpecs() *TableSortSpecs {
	return NewTableSortSpecsFromC(C.igTableGetSortSpecs())
}

// submit one header cell manually (rarely used)
func TableHeader(label string) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.igTableHeader(labelArg)

	labelFin()
}

// submit a row with headers cells based on data provided to TableSetupColumn() + submit context menu
func TableHeadersRow() {
	C.igTableHeadersRow()
}

func InternalTableLoadSettings(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableLoadSettings(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableMergeDrawChannels(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableMergeDrawChannels(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

// append into the next column (or first column of next row if currently in last column). Return true when column is visible.
func TableNextColumn() bool {
	return C.igTableNextColumn() == C.bool(true)
}

// append into the first cell of a new row.
// TableNextRowV parameter default value hint:
// row_flags: 0
// min_row_height: 0.0f
func TableNextRowV(row_flags TableRowFlags, min_row_height float32) {
	C.igTableNextRow(C.ImGuiTableRowFlags(row_flags), C.float(min_row_height))
}

// InternalTableOpenContextMenuV parameter default value hint:
// column_n: -1
func InternalTableOpenContextMenuV(column_n int32) {
	C.igTableOpenContextMenu(C.int(column_n))
}

func InternalTablePopBackgroundChannel() {
	C.igTablePopBackgroundChannel()
}

func InternalTablePopColumnChannel() {
	C.igTablePopColumnChannel()
}

func InternalTablePushBackgroundChannel() {
	C.igTablePushBackgroundChannel()
}

func InternalTablePushColumnChannel(column_n int32) {
	C.igTablePushColumnChannel(C.int(column_n))
}

func InternalTableRemove(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableRemove(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableResetSettings(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableResetSettings(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableSaveSettings(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableSaveSettings(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

// change the color of a cell, row, or column. See ImGuiTableBgTarget_ flags for details.
// TableSetBgColorV parameter default value hint:
// column_n: -1
func TableSetBgColorV(target TableBgTarget, color uint32, column_n int32) {
	C.igTableSetBgColor(C.ImGuiTableBgTarget(target), C.ImU32(color), C.int(column_n))
}

// change user accessible enabled/disabled state of a column. Set to false to hide the column. User can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)
func TableSetColumnEnabled(column_n int32, v bool) {
	C.igTableSetColumnEnabled(C.int(column_n), C.bool(v))
}

// append into the specified column. Return true when column is visible.
func TableSetColumnIndex(column_n int32) bool {
	return C.igTableSetColumnIndex(C.int(column_n)) == C.bool(true)
}

func InternalTableSetColumnSortDirection(column_n int32, sort_direction SortDirection, append_to_sort_specs bool) {
	C.igTableSetColumnSortDirection(C.int(column_n), C.ImGuiSortDirection(sort_direction), C.bool(append_to_sort_specs))
}

func InternalTableSetColumnWidth(column_n int32, width float32) {
	C.igTableSetColumnWidth(C.int(column_n), C.float(width))
}

func InternalTableSetColumnWidthAutoAll(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableSetColumnWidthAutoAll(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableSetColumnWidthAutoSingle(table *Table, column_n int32) {
	tableArg, tableFin := table.Handle()
	C.igTableSetColumnWidthAutoSingle(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n))

	tableFin()
}

func InternalTableSettingsAddSettingsHandler() {
	C.igTableSettingsAddSettingsHandler()
}

func InternalTableSettingsCreate(id ID, columns_count int32) *TableSettings {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewTableSettingsFromC(C.igTableSettingsCreate(internal.ReinterpretCast[C.ImGuiID](idArg), C.int(columns_count)))
}

func InternalTableSettingsFindByID(id ID) *TableSettings {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return NewTableSettingsFromC(C.igTableSettingsFindByID(internal.ReinterpretCast[C.ImGuiID](idArg)))
}

// TableSetupColumnV parameter default value hint:
// flags: 0
// init_width_or_weight: 0.0f
// user_id: 0
func TableSetupColumnV(label string, flags TableColumnFlags, init_width_or_weight float32, user_id ID) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	user_idArg, user_idFin := user_id.C()
	C.igTableSetupColumn(labelArg, C.ImGuiTableColumnFlags(flags), C.float(init_width_or_weight), internal.ReinterpretCast[C.ImGuiID](user_idArg))

	labelFin()
	user_idFin()
}

func InternalTableSetupDrawChannels(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableSetupDrawChannels(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

// lock columns/rows so they stay visible when scrolled.
func TableSetupScrollFreeze(cols, rows int32) {
	C.igTableSetupScrollFreeze(C.int(cols), C.int(rows))
}

func InternalTableSortSpecsBuild(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableSortSpecsBuild(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableSortSpecsSanitize(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableSortSpecsSanitize(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableUpdateBorders(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableUpdateBorders(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableUpdateColumnsWeightFromWidth(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableUpdateColumnsWeightFromWidth(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTableUpdateLayout(table *Table) {
	tableArg, tableFin := table.Handle()
	C.igTableUpdateLayout(internal.ReinterpretCast[*C.ImGuiTable](tableArg))

	tableFin()
}

func InternalTeleportMousePos(pos Vec2) {
	C.igTeleportMousePos(internal.ReinterpretCast[C.ImVec2](pos.ToC()))
}

func InternalTempInputIsActive(id ID) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.igTempInputIsActive(internal.ReinterpretCast[C.ImGuiID](idArg)) == C.bool(true)
}

// InternalTempInputScalarV parameter default value hint:
// p_clamp_min: NULL
// p_clamp_max: NULL
func InternalTempInputScalarV(bb Rect, id ID, label string, data_type DataType, p_data uintptr, format string, p_clamp_min, p_clamp_max uintptr) bool {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		idFin()
		labelFin()
		formatFin()
	}()
	return C.wrap_igTempInputScalarV(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), formatArg, C.uintptr_t(p_clamp_min), C.uintptr_t(p_clamp_max)) == C.bool(true)
}

func InternalTempInputText(bb Rect, id ID, label, buf string, buf_size int32, flags InputTextFlags) bool {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)
	bufArg, bufFin := internal.WrapString[C.char](buf)

	defer func() {
		idFin()
		labelFin()
		bufFin()
	}()
	return C.igTempInputText(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), labelArg, bufArg, C.int(buf_size), C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

// Test that key is either not owned, either owned by 'owner_id'
func InternalTestKeyOwner(key Key, owner_id ID) bool {
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		owner_idFin()
	}()
	return C.igTestKeyOwner(C.ImGuiKey(key), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

func InternalTestShortcutRouting(key_chord KeyChord, owner_id ID) bool {
	key_chordArg, key_chordFin := key_chord.C()
	owner_idArg, owner_idFin := owner_id.C()

	defer func() {
		key_chordFin()
		owner_idFin()
	}()
	return C.igTestShortcutRouting(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), internal.ReinterpretCast[C.ImGuiID](owner_idArg)) == C.bool(true)
}

// formatted text
func Text(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igText(fmtArg)

	fmtFin()
}

// FIXME-WIP: Works but API is likely to be reworked. This is designed for 1 item on the line. (#7024)
func InternalTextAligned(align_x, size_x float32, fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igTextAligned(C.float(align_x), C.float(size_x), fmtArg)

	fmtFin()
}

// shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
func TextColored(col Vec4, fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igTextColored(internal.ReinterpretCast[C.ImVec4](col.ToC()), fmtArg)

	fmtFin()
}

// shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();
func TextDisabled(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igTextDisabled(fmtArg)

	fmtFin()
}

// InternalTextExV parameter default value hint:
// flags: 0
func InternalTextExV(text string, flags TextFlags) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igTextExV(textArg, C.int(len(text)), C.ImGuiTextFlags(flags))

	textFin()
}

// hyperlink text button, return true when clicked
func TextLink(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igTextLink(labelArg) == C.bool(true)
}

// hyperlink text button, automatically open file/url when clicked
// TextLinkOpenURLV parameter default value hint:
// url: NULL
func TextLinkOpenURLV(label, url string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	urlArg, urlFin := internal.WrapString[C.char](url)

	defer func() {
		labelFin()
		urlFin()
	}()
	return C.igTextLinkOpenURL(labelArg, urlArg) == C.bool(true)
}

// raw text without formatting. Roughly equivalent to Text("%s", text) but: A) doesn't require null terminated string if 'text_end' is specified, B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.
// TextUnformattedV parameter default value hint:
func TextUnformattedV(text string) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igTextUnformattedV(textArg, C.int(len(text)))

	textFin()
}

// shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();. Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width, yoy may need to set a size using SetNextWindowSize().
func TextWrapped(fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_igTextWrapped(fmtArg)

	fmtFin()
}

func InternalTranslateWindowsInViewport(viewport *ViewportP, old_pos, new_pos, old_size, new_size Vec2) {
	viewportArg, viewportFin := viewport.Handle()
	C.igTranslateWindowsInViewport(internal.ReinterpretCast[*C.ImGuiViewportP](viewportArg), internal.ReinterpretCast[C.ImVec2](old_pos.ToC()), internal.ReinterpretCast[C.ImVec2](new_pos.ToC()), internal.ReinterpretCast[C.ImVec2](old_size.ToC()), internal.ReinterpretCast[C.ImVec2](new_size.ToC()))

	viewportFin()
}

// InternalTreeNodeBehaviorV parameter default value hint:
// label_end: NULL
func InternalTreeNodeBehaviorV(id ID, flags TreeNodeFlags, label, label_end string) bool {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)
	label_endArg, label_endFin := internal.WrapString[C.char](label_end)

	defer func() {
		idFin()
		labelFin()
		label_endFin()
	}()
	return C.igTreeNodeBehavior(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiTreeNodeFlags(flags), labelArg, label_endArg) == C.bool(true)
}

func InternalTreeNodeDrawLineToChildNode(target_pos Vec2) {
	C.igTreeNodeDrawLineToChildNode(internal.ReinterpretCast[C.ImVec2](target_pos.ToC()))
}

func InternalTreeNodeDrawLineToTreePop(data *TreeNodeStackData) {
	dataArg, dataFin := data.Handle()
	C.igTreeNodeDrawLineToTreePop(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](dataArg))

	dataFin()
}

func TreeNodeExPtr(ptr_id uintptr, flags TreeNodeFlags, fmt string) bool {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)

	defer func() {
		fmtFin()
	}()
	return C.wrap_igTreeNodeEx_Ptr(C.uintptr_t(ptr_id), C.ImGuiTreeNodeFlags(flags), fmtArg) == C.bool(true)
}

// TreeNodeExStrV parameter default value hint:
// flags: 0
func TreeNodeExStrV(label string, flags TreeNodeFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igTreeNodeEx_Str(labelArg, C.ImGuiTreeNodeFlags(flags)) == C.bool(true)
}

func TreeNodeExStrStr(str_id string, flags TreeNodeFlags, fmt string) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)

	defer func() {
		str_idFin()
		fmtFin()
	}()
	return C.wrap_igTreeNodeEx_StrStr(str_idArg, C.ImGuiTreeNodeFlags(flags), fmtArg) == C.bool(true)
}

func InternalTreeNodeGetOpen(storage_id ID) bool {
	storage_idArg, storage_idFin := storage_id.C()

	defer func() {
		storage_idFin()
	}()
	return C.igTreeNodeGetOpen(internal.ReinterpretCast[C.ImGuiID](storage_idArg)) == C.bool(true)
}

func InternalTreeNodeSetOpen(storage_id ID, open bool) {
	storage_idArg, storage_idFin := storage_id.C()
	C.igTreeNodeSetOpen(internal.ReinterpretCast[C.ImGuiID](storage_idArg), C.bool(open))

	storage_idFin()
}

// Return open state. Consume previous SetNextItemOpen() data, if any. May return true when logging.
func InternalTreeNodeUpdateNextOpen(storage_id ID, flags TreeNodeFlags) bool {
	storage_idArg, storage_idFin := storage_id.C()

	defer func() {
		storage_idFin()
	}()
	return C.igTreeNodeUpdateNextOpen(internal.ReinterpretCast[C.ImGuiID](storage_idArg), C.ImGuiTreeNodeFlags(flags)) == C.bool(true)
}

// "
func TreeNodePtr(ptr_id uintptr, fmt string) bool {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)

	defer func() {
		fmtFin()
	}()
	return C.wrap_igTreeNode_Ptr(C.uintptr_t(ptr_id), fmtArg) == C.bool(true)
}

func TreeNodeStr(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.igTreeNode_Str(labelArg) == C.bool(true)
}

// helper variation to easily decorelate the id from the displayed string. Read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
func TreeNodeStrStr(str_id, fmt string) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)

	defer func() {
		str_idFin()
		fmtFin()
	}()
	return C.wrap_igTreeNode_StrStr(str_idArg, fmtArg) == C.bool(true)
}

// ~ Unindent()+PopID()
func TreePop() {
	C.igTreePop()
}

func InternalTreePushOverrideID(id ID) {
	idArg, idFin := id.C()
	C.igTreePushOverrideID(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

// "
func TreePushPtr(ptr_id uintptr) {
	C.wrap_igTreePush_Ptr(C.uintptr_t(ptr_id))
}

// ~ Indent()+PushID(). Already called by TreeNode() when returning true, but you can call TreePush/TreePop yourself if desired.
func TreePushStr(str_id string) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.igTreePush_Str(str_idArg)

	str_idFin()
}

// move content position back to the left, by indent_w, or style.IndentSpacing if indent_w <= 0
// UnindentV parameter default value hint:
// indent_w: 0.0f
func UnindentV(indent_w float32) {
	C.igUnindent(C.float(indent_w))
}

func InternalUnregisterFontAtlas(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.igUnregisterFontAtlas(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalUnregisterUserTexture(tex *TextureData) {
	texArg, texFin := tex.Handle()
	C.igUnregisterUserTexture(internal.ReinterpretCast[*C.ImTextureData](texArg))

	texFin()
}

func InternalUpdateCurrentFontSize(restore_font_size_after_scaling float32) {
	C.igUpdateCurrentFontSize(C.float(restore_font_size_after_scaling))
}

func InternalUpdateHoveredWindowAndCaptureFlags(mouse_pos Vec2) {
	C.igUpdateHoveredWindowAndCaptureFlags(internal.ReinterpretCast[C.ImVec2](mouse_pos.ToC()))
}

func InternalUpdateInputEvents(trickle_fast_inputs bool) {
	C.igUpdateInputEvents(C.bool(trickle_fast_inputs))
}

func InternalUpdateMouseMovingWindowEndFrame() {
	C.igUpdateMouseMovingWindowEndFrame()
}

func InternalUpdateMouseMovingWindowNewFrame() {
	C.igUpdateMouseMovingWindowNewFrame()
}

// call in main loop. will call CreateWindow/ResizeWindow/etc. platform functions for each secondary viewport, and DestroyWindow for each inactive viewport.
func UpdatePlatformWindows() {
	C.igUpdatePlatformWindows()
}

func InternalUpdateWindowParentAndRootLinks(window *Window, flags WindowFlags, parent_window *Window) {
	windowArg, windowFin := window.Handle()
	parent_windowArg, parent_windowFin := parent_window.Handle()
	C.igUpdateWindowParentAndRootLinks(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.ImGuiWindowFlags(flags), internal.ReinterpretCast[*C.ImGuiWindow](parent_windowArg))

	windowFin()
	parent_windowFin()
}

func InternalUpdateWindowSkipRefresh(window *Window) {
	windowArg, windowFin := window.Handle()
	C.igUpdateWindowSkipRefresh(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

// VSliderFloatV parameter default value hint:
// format: "%.3f"
// flags: 0
func VSliderFloatV(label string, size Vec2, v *float32, v_min, v_max float32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igVSliderFloat(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), vArg, C.float(v_min), C.float(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// VSliderIntV parameter default value hint:
// format: "%d"
// flags: 0
func VSliderIntV(label string, size Vec2, v *int32, v_min, v_max int32, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		vFin()
		formatFin()
	}()
	return C.igVSliderInt(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), vArg, C.int(v_min), C.int(v_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

// VSliderScalarV parameter default value hint:
// format: NULL
// flags: 0
func VSliderScalarV(label string, size Vec2, data_type DataType, p_data, p_min, p_max uintptr, format string, flags SliderFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		formatFin()
	}()
	return C.wrap_igVSliderScalarV(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.uintptr_t(p_min), C.uintptr_t(p_max), formatArg, C.ImGuiSliderFlags(flags)) == C.bool(true)
}

func ValueBool(prefix string, b bool) {
	prefixArg, prefixFin := internal.WrapString[C.char](prefix)
	C.igValue_Bool(prefixArg, C.bool(b))

	prefixFin()
}

// ValueFloatV parameter default value hint:
// float_format: NULL
func ValueFloatV(prefix string, v float32, float_format string) {
	prefixArg, prefixFin := internal.WrapString[C.char](prefix)
	float_formatArg, float_formatFin := internal.WrapString[C.char](float_format)
	C.igValue_Float(prefixArg, C.float(v), float_formatArg)

	prefixFin()
	float_formatFin()
}

func ValueInt(prefix string, v int32) {
	prefixArg, prefixFin := internal.WrapString[C.char](prefix)
	C.igValue_Int(prefixArg, C.int(v))

	prefixFin()
}

func ValueUint(prefix string, v uint32) {
	prefixArg, prefixFin := internal.WrapString[C.char](prefix)
	C.igValue_Uint(prefixArg, C.uint(v))

	prefixFin()
}

func InternalWindowPosAbsToRel(window *Window, p Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igWindowPosAbsToRel(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](p.ToC()))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalWindowPosRelToAbs(window *Window, p Vec2) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igWindowPosRelToAbs(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](p.ToC()))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalWindowRectAbsToRel(window *Window, r Rect) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igWindowRectAbsToRel(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](r.ToC()))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalWindowRectRelToAbs(window *Window, r Rect) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.igWindowRectRelToAbs(internal.ReinterpretCast[*C.ImRect](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](r.ToC()))

	pOutFin()
	windowFin()

	return *pOut
}

func ColorHSV(h, s, v float32) Color {
	pOut := new(Color)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImColor_HSV(internal.ReinterpretCast[*C.ImColor](pOutArg), C.float(h), C.float(s), C.float(v))

	pOutFin()

	return *pOut
}

func (self *Color) SetHSV(h, s, v float32) {
	selfArg, selfFin := internal.Wrap(self)
	C.wrap_ImColor_SetHSV(internal.ReinterpretCast[*C.ImColor](selfArg), C.float(h), C.float(s), C.float(v))

	selfFin()
}

func (self *DrawList) AddBezierCubic(p1, p2, p3, p4 Vec2, col uint32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddBezierCubic(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.ImU32(col), C.float(thickness))

	selfFin()
}

func (self *DrawList) AddBezierQuadratic(p1, p2, p3 Vec2, col uint32, thickness float32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddBezierQuadratic(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.ImU32(col), C.float(thickness))

	selfFin()
}

func (self *DrawList) AddCallback(callback DrawCallback, userdata uintptr) {
	selfArg, selfFin := self.Handle()
	callbackArg, callbackFin := callback.C()
	C.wrap_ImDrawList_AddCallback(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImDrawCallback](callbackArg), C.uintptr_t(userdata))

	selfFin()
	callbackFin()
}

func (self *DrawList) AddCircle(center Vec2, radius float32, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddCircle(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddCircleFilled(center Vec2, radius float32, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddCircleFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddEllipse(center, radius Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddEllipse(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), internal.ReinterpretCast[C.ImVec2](radius.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddEllipseFilled(center, radius Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddEllipseFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), internal.ReinterpretCast[C.ImVec2](radius.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddImage(tex_ref TextureRef, p_min, p_max Vec2) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.wrap_ImDrawList_AddImage(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()))

	selfFin()
	tex_refFin()
}

func (self *DrawList) AddImageQuad(tex_ref TextureRef, p1, p2, p3, p4 Vec2) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.wrap_ImDrawList_AddImageQuad(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()))

	selfFin()
	tex_refFin()
}

func (self *DrawList) AddImageRounded(tex_ref TextureRef, p_min, p_max, uv_min, uv_max Vec2, col uint32, rounding float32) {
	selfArg, selfFin := self.Handle()
	tex_refArg, tex_refFin := tex_ref.C()
	C.wrap_ImDrawList_AddImageRounded(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), internal.ReinterpretCast[C.ImVec2](uv_min.ToC()), internal.ReinterpretCast[C.ImVec2](uv_max.ToC()), C.ImU32(col), C.float(rounding))

	selfFin()
	tex_refFin()
}

func (self *DrawList) AddLine(p1, p2 Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddLine(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddNgon(center Vec2, radius float32, col uint32, num_segments int32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddNgon(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.ImU32(col), C.int(num_segments))

	selfFin()
}

func (self *DrawList) AddQuad(p1, p2, p3, p4 Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddQuad(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddRect(p_min, p_max Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddRectFilled(p_min, p_max Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddRectFilled(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) AddTextFontPtr(font *Font, font_size float32, pos Vec2, col uint32, text_begin string) {
	selfArg, selfFin := self.Handle()
	fontArg, fontFin := font.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImDrawList_AddText_FontPtr(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[*C.ImFont](fontArg), C.float(font_size), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), text_beginArg)

	selfFin()
	fontFin()
	text_beginFin()
}

func (self *DrawList) AddTextVec2(pos Vec2, col uint32, text_begin string) {
	selfArg, selfFin := self.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImDrawList_AddText_Vec2(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), text_beginArg)

	selfFin()
	text_beginFin()
}

func (self *DrawList) AddTriangle(p1, p2, p3 Vec2, col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_AddTriangle(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p1.ToC()), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PathArcTo(center Vec2, radius, a_min, a_max float32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PathArcTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), C.float(radius), C.float(a_min), C.float(a_max))

	selfFin()
}

func (self *DrawList) PathBezierCubicCurveTo(p2, p3, p4 Vec2) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PathBezierCubicCurveTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()), internal.ReinterpretCast[C.ImVec2](p4.ToC()))

	selfFin()
}

func (self *DrawList) PathBezierQuadraticCurveTo(p2, p3 Vec2) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PathBezierQuadraticCurveTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](p2.ToC()), internal.ReinterpretCast[C.ImVec2](p3.ToC()))

	selfFin()
}

func (self *DrawList) PathEllipticalArcTo(center, radius Vec2, rot, a_min, a_max float32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PathEllipticalArcTo(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](center.ToC()), internal.ReinterpretCast[C.ImVec2](radius.ToC()), C.float(rot), C.float(a_min), C.float(a_max))

	selfFin()
}

func (self *DrawList) PathRect(rect_min, rect_max Vec2) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PathRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](rect_min.ToC()), internal.ReinterpretCast[C.ImVec2](rect_max.ToC()))

	selfFin()
}

func (self *DrawList) PathStroke(col uint32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PathStroke(internal.ReinterpretCast[*C.ImDrawList](selfArg), C.ImU32(col))

	selfFin()
}

func (self *DrawList) PushClipRect(clip_rect_min, clip_rect_max Vec2) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImDrawList_PushClipRect(internal.ReinterpretCast[*C.ImDrawList](selfArg), internal.ReinterpretCast[C.ImVec2](clip_rect_min.ToC()), internal.ReinterpretCast[C.ImVec2](clip_rect_max.ToC()))

	selfFin()
}

func (self *FontAtlas) AddCustomRect(width, height int32) FontAtlasRectId {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId {
		result := C.wrap_ImFontAtlas_AddCustomRect(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), C.int(width), C.int(height))
		return &result
	}())
}

func (self *FontAtlas) AddFontDefault() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontDefault(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) AddFontFromFileTTF(filename string) *Font {
	selfArg, selfFin := self.Handle()
	filenameArg, filenameFin := internal.WrapString[C.char](filename)

	defer func() {
		selfFin()
		filenameFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontFromFileTTF(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), filenameArg))
}

func (self *FontAtlas) AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85 string) *Font {
	selfArg, selfFin := self.Handle()
	compressed_font_data_base85Arg, compressed_font_data_base85Fin := internal.WrapString[C.char](compressed_font_data_base85)

	defer func() {
		selfFin()
		compressed_font_data_base85Fin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), compressed_font_data_base85Arg))
}

func (self *FontAtlas) AddFontFromMemoryCompressedTTF(compressed_font_data uintptr, compressed_font_data_size int32) *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontFromMemoryCompressedTTF(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), C.uintptr_t(compressed_font_data), C.int(compressed_font_data_size)))
}

func (self *FontAtlas) AddFontFromMemoryTTF(font_data uintptr, font_data_size int32) *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlas_AddFontFromMemoryTTF(internal.ReinterpretCast[*C.ImFontAtlas](selfArg), C.uintptr_t(font_data), C.int(font_data_size)))
}

func (self *FontGlyphRangesBuilder) AddText(text string) {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_ImFontGlyphRangesBuilder_AddText(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg), textArg, C.int(len(text)))

	selfFin()
	textFin()
}

func (self *Font) CalcTextSizeA(size, max_width, wrap_width float32, text_begin string) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImFont_CalcTextSizeA(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImFont](selfArg), C.float(size), C.float(max_width), C.float(wrap_width), text_beginArg)

	pOutFin()
	selfFin()
	text_beginFin()

	return *pOut
}

func (self *Font) FontBaked(font_size float32) *FontBaked {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontBakedFromC(C.wrap_ImFont_GetFontBaked(internal.ReinterpretCast[*C.ImFont](selfArg), C.float(font_size)))
}

func (self *Font) RenderChar(draw_list *DrawList, size float32, pos Vec2, col uint32, c Wchar) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	C.wrap_ImFont_RenderChar(internal.ReinterpretCast[*C.ImFont](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.float(size), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), C.ImWchar(c))

	selfFin()
	draw_listFin()
}

func (self *Font) RenderText(draw_list *DrawList, size float32, pos Vec2, col uint32, clip_rect Vec4, text_begin string) {
	selfArg, selfFin := self.Handle()
	draw_listArg, draw_listFin := draw_list.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImFont_RenderText(internal.ReinterpretCast[*C.ImFont](selfArg), internal.ReinterpretCast[*C.ImDrawList](draw_listArg), C.float(size), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), internal.ReinterpretCast[C.ImVec4](clip_rect.ToC()), text_beginArg)

	selfFin()
	draw_listFin()
	text_beginFin()
}

func (self *IO) SetKeyEventNativeData(key Key, native_keycode, native_scancode int32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImGuiIO_SetKeyEventNativeData(internal.ReinterpretCast[*C.ImGuiIO](selfArg), C.ImGuiKey(key), C.int(native_keycode), C.int(native_scancode))

	selfFin()
}

func (self *InputTextCallbackData) InsertChars(pos int32, text string) {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_ImGuiInputTextCallbackData_InsertChars(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg), C.int(pos), textArg, C.int(len(text)))

	selfFin()
	textFin()
}

func (self *ListClipper) Begin(items_count int32) {
	selfArg, selfFin := self.Handle()
	C.wrap_ImGuiListClipper_Begin(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg), C.int(items_count))

	selfFin()
}

func (self *Storage) Bool(key ID) bool {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return C.wrap_ImGuiStorage_GetBool(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)) == C.bool(true)
}

func (self *Storage) BoolRef(key ID) *bool {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return (*bool)(C.wrap_ImGuiStorage_GetBoolRef(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func (self *Storage) Float(key ID) float32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return float32(C.wrap_ImGuiStorage_GetFloat(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func (self *Storage) FloatRef(key ID) *float32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return (*float32)(C.wrap_ImGuiStorage_GetFloatRef(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func (self *Storage) Int(key ID) int32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return int32(C.wrap_ImGuiStorage_GetInt(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func (self *Storage) IntRef(key ID) *int32 {
	selfArg, selfFin := self.Handle()
	keyArg, keyFin := key.C()

	defer func() {
		selfFin()
		keyFin()
	}()
	return (*int32)(C.wrap_ImGuiStorage_GetIntRef(internal.ReinterpretCast[*C.ImGuiStorage](selfArg), internal.ReinterpretCast[C.ImGuiID](keyArg)))
}

func (self *TextBuffer) Append(str string) {
	selfArg, selfFin := self.Handle()
	strArg, strFin := internal.WrapString[C.char](str)
	C.wrap_ImGuiTextBuffer_Append(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg), strArg)

	selfFin()
	strFin()
}

func (self *TextFilter) Draw() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTextFilter_Draw(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg)) == C.bool(true)
}

func (self *TextFilter) PassFilter(text string) bool {
	selfArg, selfFin := self.Handle()
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		selfFin()
		textFin()
	}()
	return C.wrap_ImGuiTextFilter_PassFilter(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg), textArg, C.int(len(text))) == C.bool(true)
}

func (self *Window) InternalIDStr(str string) ID {
	selfArg, selfFin := self.Handle()
	strArg, strFin := internal.WrapString[C.char](str)

	defer func() {
		selfFin()
		strFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImGuiWindow_GetID_Str(internal.ReinterpretCast[*C.ImGuiWindow](selfArg), strArg)
		return &result
	}())
}

func AcceptDragDropPayload(typeArg string) *Payload {
	typeArgArg, typeArgFin := internal.WrapString[C.char](typeArg)

	defer func() {
		typeArgFin()
	}()
	return NewPayloadFromC(C.wrap_igAcceptDragDropPayload(typeArgArg))
}

func InternalArrowButtonEx(str_id string, dir Dir, size_arg Vec2) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igArrowButtonEx(str_idArg, C.ImGuiDir(dir), internal.ReinterpretCast[C.ImVec2](size_arg.ToC())) == C.bool(true)
}

func Begin(name string) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		nameFin()
	}()
	return C.wrap_igBegin(nameArg) == C.bool(true)
}

func BeginChildID(id ID) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.wrap_igBeginChild_ID(internal.ReinterpretCast[C.ImGuiID](idArg)) == C.bool(true)
}

func BeginChildStr(str_id string) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igBeginChild_Str(str_idArg) == C.bool(true)
}

func InternalBeginColumns(str_id string, count int32) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.wrap_igBeginColumns(str_idArg, C.int(count))

	str_idFin()
}

func BeginCombo(label, preview_value string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	preview_valueArg, preview_valueFin := internal.WrapString[C.char](preview_value)

	defer func() {
		labelFin()
		preview_valueFin()
	}()
	return C.wrap_igBeginCombo(labelArg, preview_valueArg) == C.bool(true)
}

func BeginDisabled() {
	C.wrap_igBeginDisabled()
}

func BeginDragDropSource() bool {
	return C.wrap_igBeginDragDropSource() == C.bool(true)
}

func BeginListBox(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igBeginListBox(labelArg) == C.bool(true)
}

func BeginMenu(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igBeginMenu(labelArg) == C.bool(true)
}

func InternalBeginMenuEx(label, icon string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	iconArg, iconFin := internal.WrapString[C.char](icon)

	defer func() {
		labelFin()
		iconFin()
	}()
	return C.wrap_igBeginMenuEx(labelArg, iconArg) == C.bool(true)
}

func BeginMultiSelect(flags MultiSelectFlags) *MultiSelectIO {
	return NewMultiSelectIOFromC(C.wrap_igBeginMultiSelect(C.ImGuiMultiSelectFlags(flags)))
}

func BeginPopup(str_id string) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igBeginPopup(str_idArg) == C.bool(true)
}

func BeginPopupContextItem() bool {
	return C.wrap_igBeginPopupContextItem() == C.bool(true)
}

func BeginPopupContextVoid() bool {
	return C.wrap_igBeginPopupContextVoid() == C.bool(true)
}

func BeginPopupContextWindow() bool {
	return C.wrap_igBeginPopupContextWindow() == C.bool(true)
}

func BeginPopupModal(name string) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		nameFin()
	}()
	return C.wrap_igBeginPopupModal(nameArg) == C.bool(true)
}

func BeginTabBar(str_id string) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igBeginTabBar(str_idArg) == C.bool(true)
}

func BeginTabItem(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igBeginTabItem(labelArg) == C.bool(true)
}

func BeginTable(str_id string, columns int32) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igBeginTable(str_idArg, C.int(columns)) == C.bool(true)
}

func InternalBeginTableEx(name string, id ID, columns_count int32) bool {
	nameArg, nameFin := internal.WrapString[C.char](name)
	idArg, idFin := id.C()

	defer func() {
		nameFin()
		idFin()
	}()
	return C.wrap_igBeginTableEx(nameArg, internal.ReinterpretCast[C.ImGuiID](idArg), C.int(columns_count)) == C.bool(true)
}

func Button(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igButton(labelArg) == C.bool(true)
}

func InternalButtonBehavior(bb Rect, id ID, out_hovered, out_held *bool) bool {
	idArg, idFin := id.C()
	out_hoveredArg, out_hoveredFin := internal.WrapNumberPtr[C.bool, bool](out_hovered)
	out_heldArg, out_heldFin := internal.WrapNumberPtr[C.bool, bool](out_held)

	defer func() {
		idFin()
		out_hoveredFin()
		out_heldFin()
	}()
	return C.wrap_igButtonBehavior(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), out_hoveredArg, out_heldArg) == C.bool(true)
}

func InternalButtonEx(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igButtonEx(labelArg) == C.bool(true)
}

func CalcTextSize(text string) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igCalcTextSize(internal.ReinterpretCast[*C.ImVec2](pOutArg), textArg, C.int(len(text)))

	pOutFin()
	textFin()

	return *pOut
}

func CollapsingHeaderBoolPtr(label string, p_visible *bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	p_visibleArg, p_visibleFin := internal.WrapNumberPtr[C.bool, bool](p_visible)

	defer func() {
		labelFin()
		p_visibleFin()
	}()
	return C.wrap_igCollapsingHeader_BoolPtr(labelArg, p_visibleArg) == C.bool(true)
}

func CollapsingHeaderTreeNodeFlags(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igCollapsingHeader_TreeNodeFlags(labelArg) == C.bool(true)
}

func ColorButton(desc_id string, col Vec4) bool {
	desc_idArg, desc_idFin := internal.WrapString[C.char](desc_id)

	defer func() {
		desc_idFin()
	}()
	return C.wrap_igColorButton(desc_idArg, internal.ReinterpretCast[C.ImVec4](col.ToC())) == C.bool(true)
}

func ColorEdit3(label string, col *[3]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.wrap_igColorEdit3(labelArg, (*C.float)(&colArg[0])) == C.bool(true)
}

func ColorEdit4(label string, col *[4]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.wrap_igColorEdit4(labelArg, (*C.float)(&colArg[0])) == C.bool(true)
}

func ColorPicker3(label string, col *[3]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.wrap_igColorPicker3(labelArg, (*C.float)(&colArg[0])) == C.bool(true)
}

func ColorPicker4(label string, col *[4]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	colArg := make([]C.float, len(col))
	for i, colV := range col {
		colArg[i] = C.float(colV)
	}

	defer func() {
		labelFin()

		for i, colV := range colArg {
			(*col)[i] = float32(colV)
		}
	}()
	return C.wrap_igColorPicker4(labelArg, (*C.float)(&colArg[0])) == C.bool(true)
}

func Columns() {
	C.wrap_igColumns()
}

func ComboStr(label string, current_item *int32, items_separated_by_zeros string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	current_itemArg, current_itemFin := internal.WrapNumberPtr[C.int, int32](current_item)
	items_separated_by_zerosArg, items_separated_by_zerosFin := internal.WrapString[C.char](items_separated_by_zeros)

	defer func() {
		labelFin()
		current_itemFin()
		items_separated_by_zerosFin()
	}()
	return C.wrap_igCombo_Str(labelArg, current_itemArg, items_separated_by_zerosArg) == C.bool(true)
}

func ComboStrarr(label string, current_item *int32, items []string, items_count int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	current_itemArg, current_itemFin := internal.WrapNumberPtr[C.int, int32](current_item)
	itemsArg, itemsFin := internal.WrapStringList[C.char](items)

	defer func() {
		labelFin()
		current_itemFin()
		itemsFin()
	}()
	return C.wrap_igCombo_Str_arr(labelArg, current_itemArg, itemsArg, C.int(items_count)) == C.bool(true)
}

func CreateContext() *Context {
	return NewContextFromC(C.wrap_igCreateContext())
}

func InternalDataTypeApplyFromText(buf string, data_type DataType, p_data uintptr, format string) bool {
	bufArg, bufFin := internal.WrapString[C.char](buf)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		bufFin()
		formatFin()
	}()
	return C.wrap_igDataTypeApplyFromText(bufArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), formatArg) == C.bool(true)
}

func InternalDebugDrawCursorPos() {
	C.wrap_igDebugDrawCursorPos()
}

func InternalDebugDrawItemRect() {
	C.wrap_igDebugDrawItemRect()
}

func InternalDebugDrawLineExtents() {
	C.wrap_igDebugDrawLineExtents()
}

func InternalDebugNodeTexture(tex *TextureData, int_id int32) {
	texArg, texFin := tex.Handle()
	C.wrap_igDebugNodeTexture(internal.ReinterpretCast[*C.ImTextureData](texArg), C.int(int_id))

	texFin()
}

func DestroyContext() {
	C.wrap_igDestroyContext()
}

func InternalDockBuilderAddNode() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.wrap_igDockBuilderAddNode(); return &result }())
}

func InternalDockBuilderRemoveNodeDockedWindows(node_id ID) {
	node_idArg, node_idFin := node_id.C()
	C.wrap_igDockBuilderRemoveNodeDockedWindows(internal.ReinterpretCast[C.ImGuiID](node_idArg))

	node_idFin()
}

func InternalDockContextProcessUndockWindow(ctx *Context, window *Window) {
	ctxArg, ctxFin := ctx.Handle()
	windowArg, windowFin := window.Handle()
	C.wrap_igDockContextProcessUndockWindow(internal.ReinterpretCast[*C.ImGuiContext](ctxArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	ctxFin()
	windowFin()
}

func DockSpace(dockspace_id ID) ID {
	dockspace_idArg, dockspace_idFin := dockspace_id.C()

	defer func() {
		dockspace_idFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_igDockSpace(internal.ReinterpretCast[C.ImGuiID](dockspace_idArg))
		return &result
	}())
}

func DockSpaceOverViewport() ID {
	return *NewIDFromC(func() *C.ImGuiID { result := C.wrap_igDockSpaceOverViewport(); return &result }())
}

func DragFloat(label string, v *float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igDragFloat(labelArg, vArg) == C.bool(true)
}

func DragFloat2(label string, v *[2]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igDragFloat2(labelArg, (*C.float)(&vArg[0])) == C.bool(true)
}

func DragFloat3(label string, v *[3]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igDragFloat3(labelArg, (*C.float)(&vArg[0])) == C.bool(true)
}

func DragFloat4(label string, v *[4]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igDragFloat4(labelArg, (*C.float)(&vArg[0])) == C.bool(true)
}

func DragFloatRange2(label string, v_current_min, v_current_max *float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	v_current_minArg, v_current_minFin := internal.WrapNumberPtr[C.float, float32](v_current_min)
	v_current_maxArg, v_current_maxFin := internal.WrapNumberPtr[C.float, float32](v_current_max)

	defer func() {
		labelFin()
		v_current_minFin()
		v_current_maxFin()
	}()
	return C.wrap_igDragFloatRange2(labelArg, v_current_minArg, v_current_maxArg) == C.bool(true)
}

func DragInt(label string, v *int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igDragInt(labelArg, vArg) == C.bool(true)
}

func DragInt2(label string, v *[2]int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igDragInt2(labelArg, (*C.int)(&vArg[0])) == C.bool(true)
}

func DragInt3(label string, v *[3]int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igDragInt3(labelArg, (*C.int)(&vArg[0])) == C.bool(true)
}

func DragInt4(label string, v *[4]int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igDragInt4(labelArg, (*C.int)(&vArg[0])) == C.bool(true)
}

func DragIntRange2(label string, v_current_min, v_current_max *int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	v_current_minArg, v_current_minFin := internal.WrapNumberPtr[C.int, int32](v_current_min)
	v_current_maxArg, v_current_maxFin := internal.WrapNumberPtr[C.int, int32](v_current_max)

	defer func() {
		labelFin()
		v_current_minFin()
		v_current_maxFin()
	}()
	return C.wrap_igDragIntRange2(labelArg, v_current_minArg, v_current_maxArg) == C.bool(true)
}

func DragScalar(label string, data_type DataType, p_data uintptr) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igDragScalar(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data)) == C.bool(true)
}

func DragScalarN(label string, data_type DataType, p_data uintptr, components int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igDragScalarN(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.int(components)) == C.bool(true)
}

func InternalFindRenderedTextEnd(text string) string {
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		textFin()
	}()
	return C.GoString(C.wrap_igFindRenderedTextEnd(textArg, C.int(len(text))))
}

func InternalFocusWindow(window *Window) {
	windowArg, windowFin := window.Handle()
	C.wrap_igFocusWindow(internal.ReinterpretCast[*C.ImGuiWindow](windowArg))

	windowFin()
}

func BackgroundDrawList() *DrawList {
	return NewDrawListFromC(C.wrap_igGetBackgroundDrawList())
}

func ColorU32Col(idx Col) uint32 {
	return (uint32)(C.wrap_igGetColorU32_Col(C.ImGuiCol(idx)))
}

func ColorU32U32(col uint32) uint32 {
	return (uint32)(C.wrap_igGetColorU32_U32(C.ImU32(col)))
}

func ColumnOffset() float32 {
	return float32(C.wrap_igGetColumnOffset())
}

func ColumnWidth() float32 {
	return float32(C.wrap_igGetColumnWidth())
}

func ForegroundDrawListViewportPtr() *DrawList {
	return NewDrawListFromC(C.wrap_igGetForegroundDrawList_ViewportPtr())
}

func MouseDragDelta() Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_igGetMouseDragDelta(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func InternalTypingSelectRequest() *TypingSelectRequest {
	return NewTypingSelectRequestFromC(C.wrap_igGetTypingSelectRequest())
}

func InternalImFileLoadToMemory(filename, mode string) uintptr {
	filenameArg, filenameFin := internal.WrapString[C.char](filename)
	modeArg, modeFin := internal.WrapString[C.char](mode)

	defer func() {
		filenameFin()
		modeFin()
	}()
	return uintptr(C.wrap_igImFileLoadToMemory(filenameArg, modeArg))
}

func InternalImFontAtlasPackAddRect(atlas *FontAtlas, w, h int32) FontAtlasRectId {
	atlasArg, atlasFin := atlas.Handle()

	defer func() {
		atlasFin()
	}()
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId {
		result := C.wrap_igImFontAtlasPackAddRect(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg), C.int(w), C.int(h))
		return &result
	}())
}

func InternalImFontAtlasTextureGrow(atlas *FontAtlas) {
	atlasArg, atlasFin := atlas.Handle()
	C.wrap_igImFontAtlasTextureGrow(internal.ReinterpretCast[*C.ImFontAtlas](atlasArg))

	atlasFin()
}

func InternalImFontCalcWordWrapPositionEx(font *Font, size float32, text string, wrap_width float32) string {
	fontArg, fontFin := font.Handle()
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		fontFin()
		textFin()
	}()
	return C.GoString(C.wrap_igImFontCalcWordWrapPositionEx(internal.ReinterpretCast[*C.ImFont](fontArg), C.float(size), textArg, C.int(len(text)), C.float(wrap_width)))
}

func InternalImHashData(data uintptr, data_size uint64) ID {
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_igImHashData(C.uintptr_t(data), C.xulong(data_size))
		return &result
	}())
}

func InternalImHashStr(data string) ID {
	dataArg, dataFin := internal.WrapString[C.char](data)

	defer func() {
		dataFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := C.wrap_igImHashStr(dataArg); return &result }())
}

func InternalImTextCalcWordWrapNextLineStart(text string) string {
	textArg, textFin := internal.WrapString[C.char](text)

	defer func() {
		textFin()
	}()
	return C.GoString(C.wrap_igImTextCalcWordWrapNextLineStart(textArg, C.int(len(text))))
}

func InternalImTextStrFromUtf8(out_buf *Wchar, out_buf_size int32, in_text, in_text_end string) int32 {
	in_textArg, in_textFin := internal.WrapString[C.char](in_text)
	in_text_endArg, in_text_endFin := internal.WrapString[C.char](in_text_end)

	defer func() {
		in_textFin()
		in_text_endFin()
	}()
	return int32(C.wrap_igImTextStrFromUtf8((*C.ImWchar)(out_buf), C.int(out_buf_size), in_textArg, in_text_endArg))
}

func Image(tex_ref TextureRef, image_size Vec2) {
	tex_refArg, tex_refFin := tex_ref.C()
	C.wrap_igImage(internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()))

	tex_refFin()
}

func ImageButton(str_id string, tex_ref TextureRef, image_size Vec2) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	tex_refArg, tex_refFin := tex_ref.C()

	defer func() {
		str_idFin()
		tex_refFin()
	}()
	return C.wrap_igImageButton(str_idArg, internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC())) == C.bool(true)
}

func InternalImageButtonEx(id ID, tex_ref TextureRef, image_size, uv0, uv1 Vec2, bg_col, tint_col Vec4) bool {
	idArg, idFin := id.C()
	tex_refArg, tex_refFin := tex_ref.C()

	defer func() {
		idFin()
		tex_refFin()
	}()
	return C.wrap_igImageButtonEx(internal.ReinterpretCast[C.ImGuiID](idArg), internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()), internal.ReinterpretCast[C.ImVec2](uv0.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()), internal.ReinterpretCast[C.ImVec4](bg_col.ToC()), internal.ReinterpretCast[C.ImVec4](tint_col.ToC())) == C.bool(true)
}

func ImageWithBg(tex_ref TextureRef, image_size Vec2) {
	tex_refArg, tex_refFin := tex_ref.C()
	C.wrap_igImageWithBg(internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImVec2](image_size.ToC()))

	tex_refFin()
}

func Indent() {
	C.wrap_igIndent()
}

func InputDouble(label string, v *float64) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.double, float64](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igInputDouble(labelArg, vArg) == C.bool(true)
}

func InputFloat(label string, v *float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igInputFloat(labelArg, vArg) == C.bool(true)
}

func InputFloat2(label string, v *[2]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igInputFloat2(labelArg, (*C.float)(&vArg[0])) == C.bool(true)
}

func InputFloat3(label string, v *[3]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igInputFloat3(labelArg, (*C.float)(&vArg[0])) == C.bool(true)
}

func InputFloat4(label string, v *[4]float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igInputFloat4(labelArg, (*C.float)(&vArg[0])) == C.bool(true)
}

func InputInt(label string, v *int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igInputInt(labelArg, vArg) == C.bool(true)
}

func InputInt2(label string, v *[2]int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igInputInt2(labelArg, (*C.int)(&vArg[0])) == C.bool(true)
}

func InputInt3(label string, v *[3]int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igInputInt3(labelArg, (*C.int)(&vArg[0])) == C.bool(true)
}

func InputInt4(label string, v *[4]int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igInputInt4(labelArg, (*C.int)(&vArg[0])) == C.bool(true)
}

func InputScalar(label string, data_type DataType, p_data uintptr) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igInputScalar(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data)) == C.bool(true)
}

func InputScalarN(label string, data_type DataType, p_data uintptr, components int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igInputScalarN(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.int(components)) == C.bool(true)
}

func InternalInputTextEx(label, hint, buf string, buf_size int32, size_arg Vec2, flags InputTextFlags) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	hintArg, hintFin := internal.WrapString[C.char](hint)
	bufArg, bufFin := internal.WrapString[C.char](buf)

	defer func() {
		labelFin()
		hintFin()
		bufFin()
	}()
	return C.wrap_igInputTextEx(labelArg, hintArg, bufArg, C.int(buf_size), internal.ReinterpretCast[C.ImVec2](size_arg.ToC()), C.ImGuiInputTextFlags(flags)) == C.bool(true)
}

func InvisibleButton(str_id string, size Vec2) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igInvisibleButton(str_idArg, internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

func IsItemClicked() bool {
	return C.wrap_igIsItemClicked() == C.bool(true)
}

func IsItemHovered() bool {
	return C.wrap_igIsItemHovered() == C.bool(true)
}

func InternalIsKeyChordPressedInputFlags(key_chord KeyChord, flags InputFlags) bool {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return C.wrap_igIsKeyChordPressed_InputFlags(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg), C.ImGuiInputFlags(flags)) == C.bool(true)
}

func IsKeyPressedBool(key Key) bool {
	return C.wrap_igIsKeyPressed_Bool(C.ImGuiKey(key)) == C.bool(true)
}

func InternalIsKeyPressedInputFlags(key Key, flags InputFlags) bool {
	return C.wrap_igIsKeyPressed_InputFlags(C.ImGuiKey(key), C.ImGuiInputFlags(flags)) == C.bool(true)
}

func IsMouseClickedBool(button MouseButton) bool {
	return C.wrap_igIsMouseClicked_Bool(C.ImGuiMouseButton(button)) == C.bool(true)
}

func InternalIsMouseClickedInputFlags(button MouseButton, flags InputFlags) bool {
	return C.wrap_igIsMouseClicked_InputFlags(C.ImGuiMouseButton(button), C.ImGuiInputFlags(flags)) == C.bool(true)
}

func InternalIsMouseDragPastThreshold(button MouseButton) bool {
	return C.wrap_igIsMouseDragPastThreshold(C.ImGuiMouseButton(button)) == C.bool(true)
}

func IsMouseDragging(button MouseButton) bool {
	return C.wrap_igIsMouseDragging(C.ImGuiMouseButton(button)) == C.bool(true)
}

func IsMouseHoveringRect(r_min, r_max Vec2) bool {
	return C.wrap_igIsMouseHoveringRect(internal.ReinterpretCast[C.ImVec2](r_min.ToC()), internal.ReinterpretCast[C.ImVec2](r_max.ToC())) == C.bool(true)
}

func IsMousePosValid() bool {
	return C.wrap_igIsMousePosValid() == C.bool(true)
}

func IsPopupOpenStr(str_id string) bool {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)

	defer func() {
		str_idFin()
	}()
	return C.wrap_igIsPopupOpen_Str(str_idArg) == C.bool(true)
}

func InternalIsWindowContentHoverable(window *Window) bool {
	windowArg, windowFin := window.Handle()

	defer func() {
		windowFin()
	}()
	return C.wrap_igIsWindowContentHoverable(internal.ReinterpretCast[*C.ImGuiWindow](windowArg)) == C.bool(true)
}

func IsWindowFocused() bool {
	return C.wrap_igIsWindowFocused() == C.bool(true)
}

func IsWindowHovered() bool {
	return C.wrap_igIsWindowHovered() == C.bool(true)
}

func InternalItemAdd(bb Rect, id ID) bool {
	idArg, idFin := id.C()

	defer func() {
		idFin()
	}()
	return C.wrap_igItemAdd(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg)) == C.bool(true)
}

func InternalItemSizeRect(bb Rect) {
	C.wrap_igItemSize_Rect(internal.ReinterpretCast[C.ImRect](bb.ToC()))
}

func InternalItemSizeVec2(size Vec2) {
	C.wrap_igItemSize_Vec2(internal.ReinterpretCast[C.ImVec2](size.ToC()))
}

func ListBoxStrarr(label string, current_item *int32, items []string, items_count int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	current_itemArg, current_itemFin := internal.WrapNumberPtr[C.int, int32](current_item)
	itemsArg, itemsFin := internal.WrapStringList[C.char](items)

	defer func() {
		labelFin()
		current_itemFin()
		itemsFin()
	}()
	return C.wrap_igListBox_Str_arr(labelArg, current_itemArg, itemsArg, C.int(items_count)) == C.bool(true)
}

func LoadIniSettingsFromMemory(ini_data string) {
	ini_dataArg, ini_dataFin := internal.WrapString[C.char](ini_data)
	C.wrap_igLoadIniSettingsFromMemory(ini_dataArg)

	ini_dataFin()
}

func InternalLogRenderedText(ref_pos *Vec2, text string) {
	ref_posArg, ref_posFin := internal.Wrap(ref_pos)
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igLogRenderedText(internal.ReinterpretCast[*C.ImVec2](ref_posArg), textArg, C.int(len(text)))

	ref_posFin()
	textFin()
}

func InternalLogToBuffer() {
	C.wrap_igLogToBuffer()
}

func LogToClipboard() {
	C.wrap_igLogToClipboard()
}

func LogToFile() {
	C.wrap_igLogToFile()
}

func LogToTTY() {
	C.wrap_igLogToTTY()
}

func InternalMenuItemEx(label, icon string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	iconArg, iconFin := internal.WrapString[C.char](icon)

	defer func() {
		labelFin()
		iconFin()
	}()
	return C.wrap_igMenuItemEx(labelArg, iconArg) == C.bool(true)
}

func MenuItemBool(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igMenuItem_Bool(labelArg) == C.bool(true)
}

func MenuItemBoolPtr(label, shortcut string, p_selected *bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	shortcutArg, shortcutFin := internal.WrapString[C.char](shortcut)
	p_selectedArg, p_selectedFin := internal.WrapNumberPtr[C.bool, bool](p_selected)

	defer func() {
		labelFin()
		shortcutFin()
		p_selectedFin()
	}()
	return C.wrap_igMenuItem_BoolPtr(labelArg, shortcutArg, p_selectedArg) == C.bool(true)
}

func InternalOpenPopupEx(id ID) {
	idArg, idFin := id.C()
	C.wrap_igOpenPopupEx(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func OpenPopupOnItemClick() {
	C.wrap_igOpenPopupOnItemClick()
}

func OpenPopupID(id ID) {
	idArg, idFin := id.C()
	C.wrap_igOpenPopup_ID(internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func OpenPopupStr(str_id string) {
	str_idArg, str_idFin := internal.WrapString[C.char](str_id)
	C.wrap_igOpenPopup_Str(str_idArg)

	str_idFin()
}

func PlotHistogramFloatPtr(label string, values *float32, values_count int32) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_igPlotHistogram_FloatPtr(labelArg, valuesArg, C.int(values_count))

	labelFin()
	valuesFin()
}

func PlotLinesFloatPtr(label string, values *float32, values_count int32) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_igPlotLines_FloatPtr(labelArg, valuesArg, C.int(values_count))

	labelFin()
	valuesFin()
}

func PopStyleColor() {
	C.wrap_igPopStyleColor()
}

func PopStyleVar() {
	C.wrap_igPopStyleVar()
}

func ProgressBar(fraction float32) {
	C.wrap_igProgressBar(C.float(fraction))
}

func PushTextWrapPos() {
	C.wrap_igPushTextWrapPos()
}

func InternalRenderArrow(draw_list *DrawList, pos Vec2, col uint32, dir Dir) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.wrap_igRenderArrow(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), C.ImGuiDir(dir))

	draw_listFin()
}

func InternalRenderColorRectWithAlphaCheckerboard(draw_list *DrawList, p_min, p_max Vec2, fill_col uint32, grid_step float32, grid_off Vec2) {
	draw_listArg, draw_listFin := draw_list.Handle()
	C.wrap_igRenderColorRectWithAlphaCheckerboard(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(fill_col), C.float(grid_step), internal.ReinterpretCast[C.ImVec2](grid_off.ToC()))

	draw_listFin()
}

func InternalRenderFrame(p_min, p_max Vec2, fill_col uint32) {
	C.wrap_igRenderFrame(internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()), C.ImU32(fill_col))
}

func InternalRenderFrameBorder(p_min, p_max Vec2) {
	C.wrap_igRenderFrameBorder(internal.ReinterpretCast[C.ImVec2](p_min.ToC()), internal.ReinterpretCast[C.ImVec2](p_max.ToC()))
}

func InternalRenderNavCursor(bb Rect, id ID) {
	idArg, idFin := id.C()
	C.wrap_igRenderNavCursor(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg))

	idFin()
}

func RenderPlatformWindowsDefault() {
	C.wrap_igRenderPlatformWindowsDefault()
}

func InternalRenderText(pos Vec2, text string) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igRenderText(internal.ReinterpretCast[C.ImVec2](pos.ToC()), textArg, C.int(len(text)))

	textFin()
}

func InternalRenderTextClipped(pos_min, pos_max Vec2, text string, text_size_if_known *Vec2) {
	textArg, textFin := internal.WrapString[C.char](text)
	text_size_if_knownArg, text_size_if_knownFin := internal.Wrap(text_size_if_known)
	C.wrap_igRenderTextClipped(internal.ReinterpretCast[C.ImVec2](pos_min.ToC()), internal.ReinterpretCast[C.ImVec2](pos_max.ToC()), textArg, C.int(len(text)), internal.ReinterpretCast[*C.ImVec2](text_size_if_knownArg))

	textFin()
	text_size_if_knownFin()
}

func InternalRenderTextClippedEx(draw_list *DrawList, pos_min, pos_max Vec2, text string, text_size_if_known *Vec2) {
	draw_listArg, draw_listFin := draw_list.Handle()
	textArg, textFin := internal.WrapString[C.char](text)
	text_size_if_knownArg, text_size_if_knownFin := internal.Wrap(text_size_if_known)
	C.wrap_igRenderTextClippedEx(internal.ReinterpretCast[*C.ImDrawList](draw_listArg), internal.ReinterpretCast[C.ImVec2](pos_min.ToC()), internal.ReinterpretCast[C.ImVec2](pos_max.ToC()), textArg, C.int(len(text)), internal.ReinterpretCast[*C.ImVec2](text_size_if_knownArg))

	draw_listFin()
	textFin()
	text_size_if_knownFin()
}

func ResetMouseDragDelta() {
	C.wrap_igResetMouseDragDelta()
}

func SameLine() {
	C.wrap_igSameLine()
}

func SaveIniSettingsToMemory() string {
	return C.GoString(C.wrap_igSaveIniSettingsToMemory())
}

func InternalScrollToItem() {
	C.wrap_igScrollToItem()
}

func InternalScrollToRect(window *Window, rect Rect) {
	windowArg, windowFin := window.Handle()
	C.wrap_igScrollToRect(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](rect.ToC()))

	windowFin()
}

func InternalScrollToRectEx(window *Window, rect Rect) Vec2 {
	pOut := new(Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	windowArg, windowFin := window.Handle()
	C.wrap_igScrollToRectEx(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImRect](rect.ToC()))

	pOutFin()
	windowFin()

	return *pOut
}

func InternalScrollbarEx(bb Rect, id ID, axis Axis, p_scroll_v *int64, avail_v, contents_v int64) bool {
	idArg, idFin := id.C()
	p_scroll_vArg, p_scroll_vFin := internal.WrapNumberPtr[C.ImS64, int64](p_scroll_v)

	defer func() {
		idFin()
		p_scroll_vFin()
	}()
	return C.wrap_igScrollbarEx(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiAxis(axis), p_scroll_vArg, C.ImS64(avail_v), C.ImS64(contents_v)) == C.bool(true)
}

func SelectableBool(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igSelectable_Bool(labelArg) == C.bool(true)
}

func SelectableBoolPtr(label string, p_selected *bool) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	p_selectedArg, p_selectedFin := internal.WrapNumberPtr[C.bool, bool](p_selected)

	defer func() {
		labelFin()
		p_selectedFin()
	}()
	return C.wrap_igSelectable_BoolPtr(labelArg, p_selectedArg) == C.bool(true)
}

func InternalSeparatorEx(flags SeparatorFlags) {
	C.wrap_igSeparatorEx(C.ImGuiSeparatorFlags(flags))
}

func SetAllocatorFunctions(alloc_func MemAllocFunc, free_func MemFreeFunc) {
	alloc_funcArg, alloc_funcFin := alloc_func.C()
	free_funcArg, free_funcFin := free_func.C()
	C.wrap_igSetAllocatorFunctions(internal.ReinterpretCast[C.ImGuiMemAllocFunc](alloc_funcArg), internal.ReinterpretCast[C.ImGuiMemFreeFunc](free_funcArg))

	alloc_funcFin()
	free_funcFin()
}

func SetDragDropPayload(typeArg string, data uintptr, sz uint64) bool {
	typeArgArg, typeArgFin := internal.WrapString[C.char](typeArg)

	defer func() {
		typeArgFin()
	}()
	return C.wrap_igSetDragDropPayload(typeArgArg, C.uintptr_t(data), C.xulong(sz)) == C.bool(true)
}

func InternalSetKeyOwner(key Key, owner_id ID) {
	owner_idArg, owner_idFin := owner_id.C()
	C.wrap_igSetKeyOwner(C.ImGuiKey(key), internal.ReinterpretCast[C.ImGuiID](owner_idArg))

	owner_idFin()
}

func InternalSetKeyOwnersForKeyChord(key KeyChord, owner_id ID) {
	keyArg, keyFin := key.C()
	owner_idArg, owner_idFin := owner_id.C()
	C.wrap_igSetKeyOwnersForKeyChord(internal.ReinterpretCast[C.ImGuiKeyChord](keyArg), internal.ReinterpretCast[C.ImGuiID](owner_idArg))

	keyFin()
	owner_idFin()
}

func SetKeyboardFocusHere() {
	C.wrap_igSetKeyboardFocusHere()
}

func SetNextItemOpen(is_open bool) {
	C.wrap_igSetNextItemOpen(C.bool(is_open))
}

func SetNextItemShortcut(key_chord KeyChord) {
	key_chordArg, key_chordFin := key_chord.C()
	C.wrap_igSetNextItemShortcut(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg))

	key_chordFin()
}

func SetNextWindowCollapsed(collapsed bool) {
	C.wrap_igSetNextWindowCollapsed(C.bool(collapsed))
}

func SetNextWindowDockID(dock_id ID) {
	dock_idArg, dock_idFin := dock_id.C()
	C.wrap_igSetNextWindowDockID(internal.ReinterpretCast[C.ImGuiID](dock_idArg))

	dock_idFin()
}

func SetNextWindowPos(pos Vec2) {
	C.wrap_igSetNextWindowPos(internal.ReinterpretCast[C.ImVec2](pos.ToC()))
}

func SetNextWindowSize(size Vec2) {
	C.wrap_igSetNextWindowSize(internal.ReinterpretCast[C.ImVec2](size.ToC()))
}

func SetNextWindowSizeConstraints(size_min, size_max Vec2) {
	C.wrap_igSetNextWindowSizeConstraints(internal.ReinterpretCast[C.ImVec2](size_min.ToC()), internal.ReinterpretCast[C.ImVec2](size_max.ToC()))
}

func SetScrollFromPosXFloat(local_x float32) {
	C.wrap_igSetScrollFromPosX_Float(C.float(local_x))
}

func SetScrollFromPosYFloat(local_y float32) {
	C.wrap_igSetScrollFromPosY_Float(C.float(local_y))
}

func SetScrollHereX() {
	C.wrap_igSetScrollHereX()
}

func SetScrollHereY() {
	C.wrap_igSetScrollHereY()
}

func SetWindowCollapsedBool(collapsed bool) {
	C.wrap_igSetWindowCollapsed_Bool(C.bool(collapsed))
}

func SetWindowCollapsedStr(name string, collapsed bool) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.wrap_igSetWindowCollapsed_Str(nameArg, C.bool(collapsed))

	nameFin()
}

func InternalSetWindowCollapsedWindowPtr(window *Window, collapsed bool) {
	windowArg, windowFin := window.Handle()
	C.wrap_igSetWindowCollapsed_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), C.bool(collapsed))

	windowFin()
}

func SetWindowPosStr(name string, pos Vec2) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.wrap_igSetWindowPos_Str(nameArg, internal.ReinterpretCast[C.ImVec2](pos.ToC()))

	nameFin()
}

func SetWindowPosVec2(pos Vec2) {
	C.wrap_igSetWindowPos_Vec2(internal.ReinterpretCast[C.ImVec2](pos.ToC()))
}

func InternalSetWindowPosWindowPtr(window *Window, pos Vec2) {
	windowArg, windowFin := window.Handle()
	C.wrap_igSetWindowPos_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()))

	windowFin()
}

func SetWindowSizeStr(name string, size Vec2) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.wrap_igSetWindowSize_Str(nameArg, internal.ReinterpretCast[C.ImVec2](size.ToC()))

	nameFin()
}

func SetWindowSizeVec2(size Vec2) {
	C.wrap_igSetWindowSize_Vec2(internal.ReinterpretCast[C.ImVec2](size.ToC()))
}

func InternalSetWindowSizeWindowPtr(window *Window, size Vec2) {
	windowArg, windowFin := window.Handle()
	C.wrap_igSetWindowSize_WindowPtr(internal.ReinterpretCast[*C.ImGuiWindow](windowArg), internal.ReinterpretCast[C.ImVec2](size.ToC()))

	windowFin()
}

func Shortcut(key_chord KeyChord) bool {
	key_chordArg, key_chordFin := key_chord.C()

	defer func() {
		key_chordFin()
	}()
	return C.wrap_igShortcut_Nil(internal.ReinterpretCast[C.ImGuiKeyChord](key_chordArg)) == C.bool(true)
}

func ShowAboutWindow() {
	C.wrap_igShowAboutWindow()
}

func ShowDebugLogWindow() {
	C.wrap_igShowDebugLogWindow()
}

func ShowDemoWindow() {
	C.wrap_igShowDemoWindow()
}

func ShowIDStackToolWindow() {
	C.wrap_igShowIDStackToolWindow()
}

func ShowMetricsWindow() {
	C.wrap_igShowMetricsWindow()
}

func ShowStyleEditor() {
	C.wrap_igShowStyleEditor()
}

func SliderAngle(label string, v_rad *float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	v_radArg, v_radFin := internal.WrapNumberPtr[C.float, float32](v_rad)

	defer func() {
		labelFin()
		v_radFin()
	}()
	return C.wrap_igSliderAngle(labelArg, v_radArg) == C.bool(true)
}

func SliderFloat(label string, v *float32, v_min, v_max float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igSliderFloat(labelArg, vArg, C.float(v_min), C.float(v_max)) == C.bool(true)
}

func SliderFloat2(label string, v *[2]float32, v_min, v_max float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igSliderFloat2(labelArg, (*C.float)(&vArg[0]), C.float(v_min), C.float(v_max)) == C.bool(true)
}

func SliderFloat3(label string, v *[3]float32, v_min, v_max float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igSliderFloat3(labelArg, (*C.float)(&vArg[0]), C.float(v_min), C.float(v_max)) == C.bool(true)
}

func SliderFloat4(label string, v *[4]float32, v_min, v_max float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = float32(vV)
		}
	}()
	return C.wrap_igSliderFloat4(labelArg, (*C.float)(&vArg[0]), C.float(v_min), C.float(v_max)) == C.bool(true)
}

func SliderInt(label string, v *int32, v_min, v_max int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igSliderInt(labelArg, vArg, C.int(v_min), C.int(v_max)) == C.bool(true)
}

func SliderInt2(label string, v *[2]int32, v_min, v_max int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igSliderInt2(labelArg, (*C.int)(&vArg[0]), C.int(v_min), C.int(v_max)) == C.bool(true)
}

func SliderInt3(label string, v *[3]int32, v_min, v_max int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igSliderInt3(labelArg, (*C.int)(&vArg[0]), C.int(v_min), C.int(v_max)) == C.bool(true)
}

func SliderInt4(label string, v *[4]int32, v_min, v_max int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	defer func() {
		labelFin()

		for i, vV := range vArg {
			(*v)[i] = int32(vV)
		}
	}()
	return C.wrap_igSliderInt4(labelArg, (*C.int)(&vArg[0]), C.int(v_min), C.int(v_max)) == C.bool(true)
}

func SliderScalar(label string, data_type DataType, p_data, p_min, p_max uintptr) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igSliderScalar(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.uintptr_t(p_min), C.uintptr_t(p_max)) == C.bool(true)
}

func SliderScalarN(label string, data_type DataType, p_data uintptr, components int32, p_min, p_max uintptr) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igSliderScalarN(labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.int(components), C.uintptr_t(p_min), C.uintptr_t(p_max)) == C.bool(true)
}

func InternalSplitterBehavior(bb Rect, id ID, axis Axis, size1, size2 *float32, min_size1, min_size2 float32) bool {
	idArg, idFin := id.C()
	size1Arg, size1Fin := internal.WrapNumberPtr[C.float, float32](size1)
	size2Arg, size2Fin := internal.WrapNumberPtr[C.float, float32](size2)

	defer func() {
		idFin()
		size1Fin()
		size2Fin()
	}()
	return C.wrap_igSplitterBehavior(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiAxis(axis), size1Arg, size2Arg, C.float(min_size1), C.float(min_size2)) == C.bool(true)
}

func StyleColorsClassic() {
	C.wrap_igStyleColorsClassic()
}

func StyleColorsDark() {
	C.wrap_igStyleColorsDark()
}

func StyleColorsLight() {
	C.wrap_igStyleColorsLight()
}

func TabItemButton(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igTabItemButton(labelArg) == C.bool(true)
}

func TableGetColumnFlags() TableColumnFlags {
	return TableColumnFlags(C.wrap_igTableGetColumnFlags())
}

func TableGetColumnNameInt() string {
	return C.GoString(C.wrap_igTableGetColumnName_Int())
}

func InternalTableGetColumnResizeID(table *Table, column_n int32) ID {
	tableArg, tableFin := table.Handle()

	defer func() {
		tableFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_igTableGetColumnResizeID(internal.ReinterpretCast[*C.ImGuiTable](tableArg), C.int(column_n))
		return &result
	}())
}

func TableNextRow() {
	C.wrap_igTableNextRow()
}

func InternalTableOpenContextMenu() {
	C.wrap_igTableOpenContextMenu()
}

func TableSetBgColor(target TableBgTarget, color uint32) {
	C.wrap_igTableSetBgColor(C.ImGuiTableBgTarget(target), C.ImU32(color))
}

func TableSetupColumn(label string) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.wrap_igTableSetupColumn(labelArg)

	labelFin()
}

func InternalTempInputScalar(bb Rect, id ID, label string, data_type DataType, p_data uintptr, format string) bool {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		idFin()
		labelFin()
		formatFin()
	}()
	return C.wrap_igTempInputScalar(internal.ReinterpretCast[C.ImRect](bb.ToC()), internal.ReinterpretCast[C.ImGuiID](idArg), labelArg, C.ImGuiDataType(data_type), C.uintptr_t(p_data), formatArg) == C.bool(true)
}

func InternalTextEx(text string) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igTextEx(textArg, C.int(len(text)))

	textFin()
}

func TextLinkOpenURL(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igTextLinkOpenURL(labelArg) == C.bool(true)
}

func TextUnformatted(text string) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_igTextUnformatted(textArg, C.int(len(text)))

	textFin()
}

func InternalTreeNodeBehavior(id ID, flags TreeNodeFlags, label string) bool {
	idArg, idFin := id.C()
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		idFin()
		labelFin()
	}()
	return C.wrap_igTreeNodeBehavior(internal.ReinterpretCast[C.ImGuiID](idArg), C.ImGuiTreeNodeFlags(flags), labelArg) == C.bool(true)
}

func TreeNodeExStr(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igTreeNodeEx_Str(labelArg) == C.bool(true)
}

func Unindent() {
	C.wrap_igUnindent()
}

func VSliderFloat(label string, size Vec2, v *float32, v_min, v_max float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.float, float32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igVSliderFloat(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), vArg, C.float(v_min), C.float(v_max)) == C.bool(true)
}

func VSliderInt(label string, size Vec2, v *int32, v_min, v_max int32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	vArg, vFin := internal.WrapNumberPtr[C.int, int32](v)

	defer func() {
		labelFin()
		vFin()
	}()
	return C.wrap_igVSliderInt(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), vArg, C.int(v_min), C.int(v_max)) == C.bool(true)
}

func VSliderScalar(label string, size Vec2, data_type DataType, p_data, p_min, p_max uintptr) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_igVSliderScalar(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImGuiDataType(data_type), C.uintptr_t(p_data), C.uintptr_t(p_min), C.uintptr_t(p_max)) == C.bool(true)
}

func ValueFloat(prefix string, v float32) {
	prefixArg, prefixFin := internal.WrapString[C.char](prefix)
	C.wrap_igValue_Float(prefixArg, C.float(v))

	prefixFin()
}

func (self BitVector) SetStorage(v vectors.Vector[uint32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.ImU32, uint32](vData)
	vVecArg := new(C.ImVector_ImU32)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImBitVector_SetStorage(selfArg, *vVecArg)
}

func (self *BitVector) Storage() vectors.Vector[uint32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImBitVector_GetStorage(internal.ReinterpretCast[*C.ImBitVector](selfArg)).Size, C.wrap_ImBitVector_GetStorage(internal.ReinterpretCast[*C.ImBitVector](selfArg)).Capacity, (*uint32)(C.wrap_ImBitVector_GetStorage(internal.ReinterpretCast[*C.ImBitVector](selfArg)).Data))
}

func (self *Color) Value() Vec4 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImColor_GetValue(internal.ReinterpretCast[*C.ImColor](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self DrawChannel) SetCmdBuffer(v vectors.Vector[DrawCmd]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawCmd)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawCmd](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawChannel_Set_CmdBuffer(selfArg, *vVecArg)
}

func (self DrawChannel) SetIdxBuffer(v vectors.Vector[DrawIdx]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawIdx)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawIdx](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawChannel_Set_IdxBuffer(selfArg, *vVecArg)
}

func (self *DrawChannel) CmdBuffer() vectors.Vector[DrawCmd] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawChannel_Get_CmdBuffer(internal.ReinterpretCast[*C.ImDrawChannel](selfArg)).Size, C.wrap_ImDrawChannel_Get_CmdBuffer(internal.ReinterpretCast[*C.ImDrawChannel](selfArg)).Capacity, NewDrawCmdFromC(C.wrap_ImDrawChannel_Get_CmdBuffer(internal.ReinterpretCast[*C.ImDrawChannel](selfArg)).Data))
}

func (self *DrawChannel) IdxBuffer() vectors.Vector[DrawIdx] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawChannel_Get_IdxBuffer(internal.ReinterpretCast[*C.ImDrawChannel](selfArg)).Size, C.wrap_ImDrawChannel_Get_IdxBuffer(internal.ReinterpretCast[*C.ImDrawChannel](selfArg)).Capacity, NewDrawIdxFromC(C.wrap_ImDrawChannel_Get_IdxBuffer(internal.ReinterpretCast[*C.ImDrawChannel](selfArg)).Data))
}

func (self DrawCmd) SetClipRect(v Vec4) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetClipRect(selfArg, internal.ReinterpretCast[C.ImVec4](v.ToC()))
}

func (self DrawCmd) SetTexRef(v TextureRef) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetTexRef(selfArg, internal.ReinterpretCast[C.ImTextureRef](vArg))
}

func (self DrawCmd) SetVtxOffset(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetVtxOffset(selfArg, C.uint(v))
}

func (self DrawCmd) SetIdxOffset(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetIdxOffset(selfArg, C.uint(v))
}

func (self DrawCmd) SetElemCount(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetElemCount(selfArg, C.uint(v))
}

func (self DrawCmd) SetUserCallback(v DrawCallback) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetUserCallback(selfArg, internal.ReinterpretCast[C.ImDrawCallback](vArg))
}

func (self DrawCmd) SetUserCallbackData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetUserCallbackData(selfArg, C.uintptr_t(v))
}

func (self DrawCmd) SetUserCallbackDataSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetUserCallbackDataSize(selfArg, C.int(v))
}

func (self DrawCmd) SetUserCallbackDataOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmd_SetUserCallbackDataOffset(selfArg, C.int(v))
}

func (self *DrawCmd) ClipRect() Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImDrawCmd_GetClipRect(internal.ReinterpretCast[*C.ImDrawCmd](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawCmd) TexRef() TextureRef {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImDrawCmd_GetTexRef(internal.ReinterpretCast[*C.ImDrawCmd](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextureRefFromC(func() *C.ImTextureRef { result := result; return &result }())
}

func (self *DrawCmd) VtxOffset() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImDrawCmd_GetVtxOffset(internal.ReinterpretCast[*C.ImDrawCmd](selfArg)))
}

func (self *DrawCmd) IdxOffset() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImDrawCmd_GetIdxOffset(internal.ReinterpretCast[*C.ImDrawCmd](selfArg)))
}

func (self *DrawCmd) ElemCount() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImDrawCmd_GetElemCount(internal.ReinterpretCast[*C.ImDrawCmd](selfArg)))
}

func (self *DrawCmd) UserCallback() DrawCallback {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImDrawCmd_GetUserCallback(internal.ReinterpretCast[*C.ImDrawCmd](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawCallbackFromC(func() *C.ImDrawCallback { result := result; return &result }())
}

func (self *DrawCmd) UserCallbackData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImDrawCmd_GetUserCallbackData(internal.ReinterpretCast[*C.ImDrawCmd](selfArg)))
}

func (self *DrawCmd) UserCallbackDataSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawCmd_GetUserCallbackDataSize(internal.ReinterpretCast[*C.ImDrawCmd](selfArg)))
}

func (self *DrawCmd) UserCallbackDataOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawCmd_GetUserCallbackDataOffset(internal.ReinterpretCast[*C.ImDrawCmd](selfArg)))
}

func (self DrawCmdHeader) SetClipRect(v Vec4) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmdHeader_SetClipRect(selfArg, internal.ReinterpretCast[C.ImVec4](v.ToC()))
}

func (self DrawCmdHeader) SetTexRef(v TextureRef) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmdHeader_SetTexRef(selfArg, internal.ReinterpretCast[C.ImTextureRef](vArg))
}

func (self DrawCmdHeader) SetVtxOffset(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawCmdHeader_SetVtxOffset(selfArg, C.uint(v))
}

func (self *DrawCmdHeader) ClipRect() Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImDrawCmdHeader_GetClipRect(internal.ReinterpretCast[*C.ImDrawCmdHeader](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawCmdHeader) TexRef() TextureRef {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImDrawCmdHeader_GetTexRef(internal.ReinterpretCast[*C.ImDrawCmdHeader](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextureRefFromC(func() *C.ImTextureRef { result := result; return &result }())
}

func (self *DrawCmdHeader) VtxOffset() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImDrawCmdHeader_GetVtxOffset(internal.ReinterpretCast[*C.ImDrawCmdHeader](selfArg)))
}

func (self DrawData) SetValid(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetValid(selfArg, C.bool(v))
}

func (self DrawData) SetCmdListsCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetCmdListsCount(selfArg, C.int(v))
}

func (self DrawData) SetTotalIdxCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetTotalIdxCount(selfArg, C.int(v))
}

func (self DrawData) SetTotalVtxCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetTotalVtxCount(selfArg, C.int(v))
}

func (self DrawData) SetDisplayPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetDisplayPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DrawData) SetDisplaySize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetDisplaySize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DrawData) SetFramebufferScale(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetFramebufferScale(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DrawData) SetOwnerViewport(v *Viewport) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawData_SetOwnerViewport(selfArg, internal.ReinterpretCast[*C.ImGuiViewport](vArg))
}

func (self *DrawData) Valid() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImDrawData_GetValid(internal.ReinterpretCast[*C.ImDrawData](selfArg)) == C.bool(true)
}

func (self *DrawData) CmdListsCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawData_GetCmdListsCount(internal.ReinterpretCast[*C.ImDrawData](selfArg)))
}

func (self *DrawData) TotalIdxCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawData_GetTotalIdxCount(internal.ReinterpretCast[*C.ImDrawData](selfArg)))
}

func (self *DrawData) TotalVtxCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawData_GetTotalVtxCount(internal.ReinterpretCast[*C.ImDrawData](selfArg)))
}

func (self *DrawData) CmdLists() vectors.Vector[DrawList] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawData_GetCmdLists(internal.ReinterpretCast[*C.ImDrawData](selfArg)).Size, C.wrap_ImDrawData_GetCmdLists(internal.ReinterpretCast[*C.ImDrawData](selfArg)).Capacity, NewDrawListFromC(C.wrap_ImDrawData_GetCmdLists(internal.ReinterpretCast[*C.ImDrawData](selfArg)).Data))
}

func (self *DrawData) DisplayPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImDrawData_GetDisplayPos(internal.ReinterpretCast[*C.ImDrawData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawData) DisplaySize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImDrawData_GetDisplaySize(internal.ReinterpretCast[*C.ImDrawData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawData) FramebufferScale() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImDrawData_GetFramebufferScale(internal.ReinterpretCast[*C.ImDrawData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawData) OwnerViewport() *Viewport {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewViewportFromC(C.wrap_ImDrawData_GetOwnerViewport(internal.ReinterpretCast[*C.ImDrawData](selfArg)))
}

func (self *DrawData) Textures() vectors.Vector[TextureData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawData_GetTextures(internal.ReinterpretCast[*C.ImDrawData](selfArg)).Size, C.wrap_ImDrawData_GetTextures(internal.ReinterpretCast[*C.ImDrawData](selfArg)).Capacity, NewTextureDataFromC((*C.wrap_ImDrawData_GetTextures(internal.ReinterpretCast[*C.ImDrawData](selfArg)).Data)))
}

func (self *DrawDataBuilder) Layers() [2]vectors.Vector[DrawList] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]vectors.Vector[DrawList] {
		result := [2]vectors.Vector[DrawList]{}
		resultMirr := C.wrap_ImDrawDataBuilder_GetLayers(internal.ReinterpretCast[*C.ImDrawDataBuilder](selfArg))
		for i := range result {
			result[i] = vectors.NewVectorFromC(C.imgui_ImVector_ImDrawListPtrPtr_GetAtIdx(resultMirr, C.int(i)).Size, C.imgui_ImVector_ImDrawListPtrPtr_GetAtIdx(resultMirr, C.int(i)).Capacity, NewDrawListFromC((*C.imgui_ImVector_ImDrawListPtrPtr_GetAtIdx(resultMirr, C.int(i)).Data)))
		}

		return result
	}()
}

func (self *DrawDataBuilder) LayerData1() vectors.Vector[DrawList] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawDataBuilder_GetLayerData1(internal.ReinterpretCast[*C.ImDrawDataBuilder](selfArg)).Size, C.wrap_ImDrawDataBuilder_GetLayerData1(internal.ReinterpretCast[*C.ImDrawDataBuilder](selfArg)).Capacity, NewDrawListFromC(C.wrap_ImDrawDataBuilder_GetLayerData1(internal.ReinterpretCast[*C.ImDrawDataBuilder](selfArg)).Data))
}

func (self DrawList) SetCmdBuffer(v vectors.Vector[DrawCmd]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawCmd)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawCmd](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_SetCmdBuffer(selfArg, *vVecArg)
}

func (self DrawList) SetIdxBuffer(v vectors.Vector[DrawIdx]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawIdx)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawIdx](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_SetIdxBuffer(selfArg, *vVecArg)
}

func (self DrawList) SetVtxBuffer(v vectors.Vector[DrawVert]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawVert)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawVert](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_SetVtxBuffer(selfArg, *vVecArg)
}

func (self DrawList) SetFlags(v DrawListFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_SetFlags(selfArg, C.ImDrawListFlags(v))
}

func (self DrawList) SetVtxCurrentIdx(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_VtxCurrentIdx(selfArg, C.uint(v))
}

func (self DrawList) SetData(v *DrawListSharedData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_Data(selfArg, internal.ReinterpretCast[*C.ImDrawListSharedData](vArg))
}

func (self DrawList) SetVtxWritePtr(v *DrawVert) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_VtxWritePtr(selfArg, internal.ReinterpretCast[*C.ImDrawVert](vArg))
}

func (self DrawList) SetIdxWritePtr(v *DrawIdx) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_IdxWritePtr(selfArg, internal.ReinterpretCast[*C.ImDrawIdx](vArg))
}

func (self DrawList) SetPath(v vectors.Vector[Vec2]) {
	vData := v.Data
	vDataArg, _ := internal.Wrap(vData)
	vVecArg := new(C.ImVector_ImVec2)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImVec2](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_Path(selfArg, *vVecArg)
}

func (self DrawList) SetCmdHeader(v DrawCmdHeader) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_CmdHeader(selfArg, internal.ReinterpretCast[C.ImDrawCmdHeader](vArg))
}

func (self DrawList) SetSplitter(v DrawListSplitter) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_Splitter(selfArg, internal.ReinterpretCast[C.ImDrawListSplitter](vArg))
}

func (self DrawList) SetClipRectStack(v vectors.Vector[Vec4]) {
	vData := v.Data
	vDataArg, _ := internal.Wrap(vData)
	vVecArg := new(C.ImVector_ImVec4)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImVec4](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_ClipRectStack(selfArg, *vVecArg)
}

func (self DrawList) SetTextureStack(v vectors.Vector[TextureRef]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImTextureRef)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImTextureRef](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_TextureStack(selfArg, *vVecArg)
}

func (self DrawList) SetCallbacksDataBuf(v vectors.Vector[byte]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.ImU8, byte](vData)
	vVecArg := new(C.ImVector_ImU8)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_CallbacksDataBuf(selfArg, *vVecArg)
}

func (self DrawList) SetFringeScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_FringeScale(selfArg, C.float(v))
}

func (self DrawList) SetOwnerName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawList_Set_OwnerName(selfArg, vArg)
}

func (self *DrawList) CmdBuffer() vectors.Vector[DrawCmd] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawList_GetCmdBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Size, C.wrap_ImDrawList_GetCmdBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Capacity, NewDrawCmdFromC(C.wrap_ImDrawList_GetCmdBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Data))
}

func (self *DrawList) IdxBuffer() vectors.Vector[DrawIdx] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawList_GetIdxBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Size, C.wrap_ImDrawList_GetIdxBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Capacity, NewDrawIdxFromC(C.wrap_ImDrawList_GetIdxBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Data))
}

func (self *DrawList) VtxBuffer() vectors.Vector[DrawVert] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawList_GetVtxBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Size, C.wrap_ImDrawList_GetVtxBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Capacity, NewDrawVertFromC(C.wrap_ImDrawList_GetVtxBuffer(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Data))
}

func (self *DrawList) Flags() DrawListFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DrawListFlags(C.wrap_ImDrawList_GetFlags(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) VtxCurrentIdx() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImDrawList_Get_VtxCurrentIdx(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) Data() *DrawListSharedData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawListSharedDataFromC(C.wrap_ImDrawList_Get_Data(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) VtxWritePtr() *DrawVert {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawVertFromC(C.wrap_ImDrawList_Get_VtxWritePtr(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) IdxWritePtr() *DrawIdx {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawIdxFromC(C.wrap_ImDrawList_Get_IdxWritePtr(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) CmdHeader() DrawCmdHeader {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImDrawList_Get_CmdHeader(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawCmdHeaderFromC(func() *C.ImDrawCmdHeader { result := result; return &result }())
}

func (self *DrawList) Splitter() DrawListSplitter {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImDrawList_Get_Splitter(internal.ReinterpretCast[*C.ImDrawList](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawListSplitterFromC(func() *C.ImDrawListSplitter { result := result; return &result }())
}

func (self *DrawList) ClipRectStack() vectors.Vector[Vec4] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawList_Get_ClipRectStack(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Size, C.wrap_ImDrawList_Get_ClipRectStack(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Capacity, (&Vec4{}).FromC(unsafe.Pointer(C.wrap_ImDrawList_Get_ClipRectStack(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Data)))
}

func (self *DrawList) TextureStack() vectors.Vector[TextureRef] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawList_Get_TextureStack(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Size, C.wrap_ImDrawList_Get_TextureStack(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Capacity, NewTextureRefFromC(C.wrap_ImDrawList_Get_TextureStack(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Data))
}

func (self *DrawList) CallbacksDataBuf() vectors.Vector[byte] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawList_Get_CallbacksDataBuf(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Size, C.wrap_ImDrawList_Get_CallbacksDataBuf(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Capacity, (*byte)(C.wrap_ImDrawList_Get_CallbacksDataBuf(internal.ReinterpretCast[*C.ImDrawList](selfArg)).Data))
}

func (self *DrawList) FringeScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawList_Get_FringeScale(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self *DrawList) OwnerName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImDrawList_Get_OwnerName(internal.ReinterpretCast[*C.ImDrawList](selfArg)))
}

func (self DrawListSharedData) SetTexUvWhitePixel(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetTexUvWhitePixel(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DrawListSharedData) SetTexUvLines(v *Vec4) {
	vArg, _ := internal.Wrap(v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetTexUvLines(selfArg, internal.ReinterpretCast[*C.ImVec4](vArg))
}

func (self DrawListSharedData) SetFontAtlas(v *FontAtlas) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetFontAtlas(selfArg, internal.ReinterpretCast[*C.ImFontAtlas](vArg))
}

func (self DrawListSharedData) SetFont(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetFont(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self DrawListSharedData) SetFontSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetFontSize(selfArg, C.float(v))
}

func (self DrawListSharedData) SetFontScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetFontScale(selfArg, C.float(v))
}

func (self DrawListSharedData) SetCurveTessellationTol(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetCurveTessellationTol(selfArg, C.float(v))
}

func (self DrawListSharedData) SetCircleSegmentMaxError(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetCircleSegmentMaxError(selfArg, C.float(v))
}

func (self DrawListSharedData) SetInitialFringeScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetInitialFringeScale(selfArg, C.float(v))
}

func (self DrawListSharedData) SetInitialFlags(v DrawListFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetInitialFlags(selfArg, C.ImDrawListFlags(v))
}

func (self DrawListSharedData) SetClipRectFullscreen(v Vec4) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetClipRectFullscreen(selfArg, internal.ReinterpretCast[C.ImVec4](v.ToC()))
}

func (self DrawListSharedData) SetTempBuffer(v vectors.Vector[Vec2]) {
	vData := v.Data
	vDataArg, _ := internal.Wrap(vData)
	vVecArg := new(C.ImVector_ImVec2)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImVec2](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetTempBuffer(selfArg, *vVecArg)
}

func (self DrawListSharedData) SetContext(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetContext(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self DrawListSharedData) SetArcFastVtx(v *[48]Vec2) {
	vArg := make([]C.ImVec2, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec2](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetArcFastVtx(selfArg, (*C.ImVec2)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() Vec2 { out := vV; return *(&Vec2{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self DrawListSharedData) SetArcFastRadiusCutoff(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetArcFastRadiusCutoff(selfArg, C.float(v))
}

func (self DrawListSharedData) SetCircleSegmentCounts(v *[64]byte) {
	vArg := make([]C.ImU8, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU8(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSharedData_SetCircleSegmentCounts(selfArg, (*C.ImU8)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (byte)(vV)
	}
}

func (self *DrawListSharedData) TexUvWhitePixel() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImDrawListSharedData_GetTexUvWhitePixel(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawListSharedData) TexUvLines() *Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (&Vec4{}).FromC(unsafe.Pointer(C.wrap_ImDrawListSharedData_GetTexUvLines(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg))))
}

func (self *DrawListSharedData) FontAtlas() *FontAtlas {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontAtlasFromC(C.wrap_ImDrawListSharedData_GetFontAtlas(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) Font() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImDrawListSharedData_GetFont(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) FontSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawListSharedData_GetFontSize(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) FontScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawListSharedData_GetFontScale(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) CurveTessellationTol() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawListSharedData_GetCurveTessellationTol(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) CircleSegmentMaxError() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawListSharedData_GetCircleSegmentMaxError(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) InitialFringeScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawListSharedData_GetInitialFringeScale(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) InitialFlags() DrawListFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DrawListFlags(C.wrap_ImDrawListSharedData_GetInitialFlags(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) ClipRectFullscreen() Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImDrawListSharedData_GetClipRectFullscreen(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawListSharedData) DrawLists() vectors.Vector[DrawList] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawListSharedData_GetDrawLists(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)).Size, C.wrap_ImDrawListSharedData_GetDrawLists(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)).Capacity, NewDrawListFromC(C.wrap_ImDrawListSharedData_GetDrawLists(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)).Data))
}

func (self *DrawListSharedData) Context() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImDrawListSharedData_GetContext(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) ArcFastVtx() [48]Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [48]Vec2 {
		result := [48]Vec2{}
		resultMirr := C.wrap_ImDrawListSharedData_GetArcFastVtx(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg))
		for i := range result {
			result[i] = func() Vec2 {
				out := C.imgui_ImVec2_GetAtIdx(resultMirr, C.int(i))
				return *(&Vec2{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *DrawListSharedData) ArcFastRadiusCutoff() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImDrawListSharedData_GetArcFastRadiusCutoff(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg)))
}

func (self *DrawListSharedData) CircleSegmentCounts() [64](byte) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [64](byte) {
		result := [64](byte){}
		resultMirr := C.wrap_ImDrawListSharedData_GetCircleSegmentCounts(internal.ReinterpretCast[*C.ImDrawListSharedData](selfArg))
		for i := range result {
			result[i] = (byte)(C.imgui_ImU8_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self DrawListSplitter) SetCurrent(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSplitter_Set_Current(selfArg, C.int(v))
}

func (self DrawListSplitter) SetCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSplitter_Set_Count(selfArg, C.int(v))
}

func (self DrawListSplitter) SetChannels(v vectors.Vector[DrawChannel]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawChannel)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawChannel](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawListSplitter_Set_Channels(selfArg, *vVecArg)
}

func (self *DrawListSplitter) Current() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawListSplitter_Get_Current(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg)))
}

func (self *DrawListSplitter) Count() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImDrawListSplitter_Get_Count(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg)))
}

func (self *DrawListSplitter) Channels() vectors.Vector[DrawChannel] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImDrawListSplitter_Get_Channels(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg)).Size, C.wrap_ImDrawListSplitter_Get_Channels(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg)).Capacity, NewDrawChannelFromC(C.wrap_ImDrawListSplitter_Get_Channels(internal.ReinterpretCast[*C.ImDrawListSplitter](selfArg)).Data))
}

func (self DrawVert) SetPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawVert_SetPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DrawVert) SetUv(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawVert_SetUv(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DrawVert) SetCol(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImDrawVert_SetCol(selfArg, C.ImU32(v))
}

func (self *DrawVert) Pos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImDrawVert_GetPos(internal.ReinterpretCast[*C.ImDrawVert](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawVert) Uv() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImDrawVert_GetUv(internal.ReinterpretCast[*C.ImDrawVert](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DrawVert) Col() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImDrawVert_GetCol(internal.ReinterpretCast[*C.ImDrawVert](selfArg)))
}

func (self Font) SetLastBaked(v *FontBaked) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetLastBaked(selfArg, internal.ReinterpretCast[*C.ImFontBaked](vArg))
}

func (self Font) SetContainerAtlas(v *FontAtlas) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetContainerAtlas(selfArg, internal.ReinterpretCast[*C.ImFontAtlas](vArg))
}

func (self Font) SetFlags(v FontFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetFlags(selfArg, C.ImFontFlags(v))
}

func (self Font) SetCurrentRasterizerDensity(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetCurrentRasterizerDensity(selfArg, C.float(v))
}

func (self Font) SetFontId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetFontId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Font) SetLegacySize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetLegacySize(selfArg, C.float(v))
}

func (self Font) SetEllipsisChar(v Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetEllipsisChar(selfArg, C.ImWchar(v))
}

func (self Font) SetFallbackChar(v Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetFallbackChar(selfArg, C.ImWchar(v))
}

func (self Font) SetUsed8kPagesMap(v *[1]byte) {
	vArg := make([]C.ImU8, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU8(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetUsed8kPagesMap(selfArg, (*C.ImU8)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (byte)(vV)
	}
}

func (self Font) SetEllipsisAutoBake(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetEllipsisAutoBake(selfArg, C.bool(v))
}

func (self Font) SetRemapPairs(v Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFont_SetRemapPairs(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self *Font) LastBaked() *FontBaked {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontBakedFromC(C.wrap_ImFont_GetLastBaked(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) ContainerAtlas() *FontAtlas {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontAtlasFromC(C.wrap_ImFont_GetContainerAtlas(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) Flags() FontFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return FontFlags(C.wrap_ImFont_GetFlags(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) CurrentRasterizerDensity() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFont_GetCurrentRasterizerDensity(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) FontId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFont_GetFontId(internal.ReinterpretCast[*C.ImFont](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Font) LegacySize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFont_GetLegacySize(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) Sources() vectors.Vector[FontConfig] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFont_GetSources(internal.ReinterpretCast[*C.ImFont](selfArg)).Size, C.wrap_ImFont_GetSources(internal.ReinterpretCast[*C.ImFont](selfArg)).Capacity, NewFontConfigFromC(C.wrap_ImFont_GetSources(internal.ReinterpretCast[*C.ImFont](selfArg)).Data))
}

func (self *Font) EllipsisChar() Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (Wchar)(C.wrap_ImFont_GetEllipsisChar(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) FallbackChar() Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (Wchar)(C.wrap_ImFont_GetFallbackChar(internal.ReinterpretCast[*C.ImFont](selfArg)))
}

func (self *Font) Used8kPagesMap() [1](byte) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [1](byte) {
		result := [1](byte){}
		resultMirr := C.wrap_ImFont_GetUsed8kPagesMap(internal.ReinterpretCast[*C.ImFont](selfArg))
		for i := range result {
			result[i] = (byte)(C.imgui_ImU8_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Font) EllipsisAutoBake() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFont_GetEllipsisAutoBake(internal.ReinterpretCast[*C.ImFont](selfArg)) == C.bool(true)
}

func (self *Font) RemapPairs() Storage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFont_GetRemapPairs(internal.ReinterpretCast[*C.ImFont](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStorageFromC(func() *C.ImGuiStorage { result := result; return &result }())
}

func (self FontAtlas) SetFlags(v FontAtlasFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetFlags(selfArg, C.ImFontAtlasFlags(v))
}

func (self FontAtlas) SetTexDesiredFormat(v TextureFormat) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexDesiredFormat(selfArg, C.ImTextureFormat(v))
}

func (self FontAtlas) SetTexGlyphPadding(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexGlyphPadding(selfArg, C.int(v))
}

func (self FontAtlas) SetTexMinWidth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexMinWidth(selfArg, C.int(v))
}

func (self FontAtlas) SetTexMinHeight(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexMinHeight(selfArg, C.int(v))
}

func (self FontAtlas) SetTexMaxWidth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexMaxWidth(selfArg, C.int(v))
}

func (self FontAtlas) SetTexMaxHeight(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexMaxHeight(selfArg, C.int(v))
}

func (self FontAtlas) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetUserData(selfArg, C.uintptr_t(v))
}

func (self FontAtlas) SetTexRef(v TextureRef) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexRef(selfArg, internal.ReinterpretCast[C.ImTextureRef](vArg))
}

func (self FontAtlas) SetTexData(v *TextureData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexData(selfArg, internal.ReinterpretCast[*C.ImTextureData](vArg))
}

func (self FontAtlas) SetLocked(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetLocked(selfArg, C.bool(v))
}

func (self FontAtlas) SetRendererHasTextures(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetRendererHasTextures(selfArg, C.bool(v))
}

func (self FontAtlas) SetTexIsBuilt(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexIsBuilt(selfArg, C.bool(v))
}

func (self FontAtlas) SetTexPixelsUseColors(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexPixelsUseColors(selfArg, C.bool(v))
}

func (self FontAtlas) SetTexUvScale(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexUvScale(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self FontAtlas) SetTexUvWhitePixel(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexUvWhitePixel(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self FontAtlas) SetSources(v vectors.Vector[FontConfig]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImFontConfig)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImFontConfig](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetSources(selfArg, *vVecArg)
}

func (self FontAtlas) SetTexUvLines(v *[33]Vec4) {
	vArg := make([]C.ImVec4, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec4](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexUvLines(selfArg, (*C.ImVec4)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() Vec4 { out := vV; return *(&Vec4{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self FontAtlas) SetTexNextUniqueID(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetTexNextUniqueID(selfArg, C.int(v))
}

func (self FontAtlas) SetFontNextUniqueID(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetFontNextUniqueID(selfArg, C.int(v))
}

func (self FontAtlas) SetBuilder(v *FontAtlasBuilder) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetBuilder(selfArg, internal.ReinterpretCast[*C.ImFontAtlasBuilder](vArg))
}

func (self FontAtlas) SetFontLoaderName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetFontLoaderName(selfArg, vArg)
}

func (self FontAtlas) SetFontLoaderData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetFontLoaderData(selfArg, C.uintptr_t(v))
}

func (self FontAtlas) SetFontLoaderFlags(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetFontLoaderFlags(selfArg, C.uint(v))
}

func (self FontAtlas) SetRefCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetRefCount(selfArg, C.int(v))
}

func (self FontAtlas) SetOwnerContext(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlas_SetOwnerContext(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self *FontAtlas) Flags() FontAtlasFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return FontAtlasFlags(C.wrap_ImFontAtlas_GetFlags(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexDesiredFormat() TextureFormat {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TextureFormat(C.wrap_ImFontAtlas_GetTexDesiredFormat(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexGlyphPadding() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetTexGlyphPadding(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexMinWidth() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetTexMinWidth(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexMinHeight() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetTexMinHeight(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexMaxWidth() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetTexMaxWidth(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexMaxHeight() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetTexMaxHeight(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImFontAtlas_GetUserData(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexRef() TextureRef {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlas_GetTexRef(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextureRefFromC(func() *C.ImTextureRef { result := result; return &result }())
}

func (self *FontAtlas) TexData() *TextureData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTextureDataFromC(C.wrap_ImFontAtlas_GetTexData(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) TexList() vectors.Vector[TextureData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontAtlas_GetTexList(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Size, C.wrap_ImFontAtlas_GetTexList(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Capacity, NewTextureDataFromC(C.wrap_ImFontAtlas_GetTexList(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Data))
}

func (self *FontAtlas) Locked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontAtlas_GetLocked(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)) == C.bool(true)
}

func (self *FontAtlas) RendererHasTextures() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontAtlas_GetRendererHasTextures(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)) == C.bool(true)
}

func (self *FontAtlas) TexIsBuilt() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontAtlas_GetTexIsBuilt(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)) == C.bool(true)
}

func (self *FontAtlas) TexPixelsUseColors() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontAtlas_GetTexPixelsUseColors(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)) == C.bool(true)
}

func (self *FontAtlas) TexUvScale() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImFontAtlas_GetTexUvScale(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *FontAtlas) TexUvWhitePixel() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImFontAtlas_GetTexUvWhitePixel(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *FontAtlas) Fonts() vectors.Vector[Font] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontAtlas_GetFonts(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Size, C.wrap_ImFontAtlas_GetFonts(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Capacity, NewFontFromC(C.wrap_ImFontAtlas_GetFonts(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Data))
}

func (self *FontAtlas) Sources() vectors.Vector[FontConfig] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontAtlas_GetSources(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Size, C.wrap_ImFontAtlas_GetSources(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Capacity, NewFontConfigFromC(C.wrap_ImFontAtlas_GetSources(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Data))
}

func (self *FontAtlas) TexUvLines() [33]Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [33]Vec4 {
		result := [33]Vec4{}
		resultMirr := C.wrap_ImFontAtlas_GetTexUvLines(internal.ReinterpretCast[*C.ImFontAtlas](selfArg))
		for i := range result {
			result[i] = func() Vec4 {
				out := C.imgui_ImVec4_GetAtIdx(resultMirr, C.int(i))
				return *(&Vec4{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *FontAtlas) TexNextUniqueID() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetTexNextUniqueID(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) FontNextUniqueID() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetFontNextUniqueID(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) DrawListSharedDatas() vectors.Vector[DrawListSharedData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontAtlas_GetDrawListSharedDatas(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Size, C.wrap_ImFontAtlas_GetDrawListSharedDatas(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Capacity, NewDrawListSharedDataFromC(C.wrap_ImFontAtlas_GetDrawListSharedDatas(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)).Data))
}

func (self *FontAtlas) Builder() *FontAtlasBuilder {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontAtlasBuilderFromC(C.wrap_ImFontAtlas_GetBuilder(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) FontLoader() *FontLoader {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontLoaderFromC(C.wrap_ImFontAtlas_GetFontLoader(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) FontLoaderName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImFontAtlas_GetFontLoaderName(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) FontLoaderData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImFontAtlas_GetFontLoaderData(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) FontLoaderFlags() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontAtlas_GetFontLoaderFlags(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) RefCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlas_GetRefCount(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self *FontAtlas) OwnerContext() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImFontAtlas_GetOwnerContext(internal.ReinterpretCast[*C.ImFontAtlas](selfArg)))
}

func (self FontAtlasBuilder) SetPackContext(v stbrpcontextopaque) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetPackContext(selfArg, internal.ReinterpretCast[C.stbrp_context_opaque](vArg))
}

func (self FontAtlasBuilder) SetRects(v vectors.Vector[TextureRect]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImTextureRect)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImTextureRect](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRects(selfArg, *vVecArg)
}

func (self FontAtlasBuilder) SetRectsIndex(v vectors.Vector[FontAtlasRectEntry]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImFontAtlasRectEntry)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImFontAtlasRectEntry](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRectsIndex(selfArg, *vVecArg)
}

func (self FontAtlasBuilder) SetRectsIndexFreeListStart(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRectsIndexFreeListStart(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetRectsPackedCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRectsPackedCount(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetRectsPackedSurface(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRectsPackedSurface(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetRectsDiscardedCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRectsDiscardedCount(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetRectsDiscardedSurface(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetRectsDiscardedSurface(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetFrameCount(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetMaxRectSize(v Vec2i) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetMaxRectSize(selfArg, internal.ReinterpretCast[C.ImVec2i](vArg))
}

func (self FontAtlasBuilder) SetMaxRectBounds(v Vec2i) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetMaxRectBounds(selfArg, internal.ReinterpretCast[C.ImVec2i](vArg))
}

func (self FontAtlasBuilder) SetLockDisableResize(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetLockDisableResize(selfArg, C.bool(v))
}

func (self FontAtlasBuilder) SetPreloadedAllGlyphsRanges(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetPreloadedAllGlyphsRanges(selfArg, C.bool(v))
}

func (self FontAtlasBuilder) SetBakedMap(v Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetBakedMap(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self FontAtlasBuilder) SetBakedDiscardedCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetBakedDiscardedCount(selfArg, C.int(v))
}

func (self FontAtlasBuilder) SetPackIdMouseCursors(v FontAtlasRectId) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetPackIdMouseCursors(selfArg, internal.ReinterpretCast[C.ImFontAtlasRectId](vArg))
}

func (self FontAtlasBuilder) SetPackIdLinesTexData(v FontAtlasRectId) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasBuilder_SetPackIdLinesTexData(selfArg, internal.ReinterpretCast[C.ImFontAtlasRectId](vArg))
}

func (self *FontAtlasBuilder) PackContext() stbrpcontextopaque {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlasBuilder_GetPackContext(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewstbrpcontextopaqueFromC(func() *C.stbrp_context_opaque { result := result; return &result }())
}

func (self *FontAtlasBuilder) Rects() vectors.Vector[TextureRect] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontAtlasBuilder_GetRects(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)).Size, C.wrap_ImFontAtlasBuilder_GetRects(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)).Capacity, NewTextureRectFromC(C.wrap_ImFontAtlasBuilder_GetRects(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)).Data))
}

func (self *FontAtlasBuilder) RectsIndex() vectors.Vector[FontAtlasRectEntry] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontAtlasBuilder_GetRectsIndex(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)).Size, C.wrap_ImFontAtlasBuilder_GetRectsIndex(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)).Capacity, NewFontAtlasRectEntryFromC(C.wrap_ImFontAtlasBuilder_GetRectsIndex(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)).Data))
}

func (self *FontAtlasBuilder) RectsIndexFreeListStart() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetRectsIndexFreeListStart(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) RectsPackedCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetRectsPackedCount(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) RectsPackedSurface() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetRectsPackedSurface(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) RectsDiscardedCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetRectsDiscardedCount(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) RectsDiscardedSurface() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetRectsDiscardedSurface(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) FrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetFrameCount(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) MaxRectSize() Vec2i {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlasBuilder_GetMaxRectSize(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec2iFromC(func() *C.ImVec2i { result := result; return &result }())
}

func (self *FontAtlasBuilder) MaxRectBounds() Vec2i {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlasBuilder_GetMaxRectBounds(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec2iFromC(func() *C.ImVec2i { result := result; return &result }())
}

func (self *FontAtlasBuilder) LockDisableResize() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontAtlasBuilder_GetLockDisableResize(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)) == C.bool(true)
}

func (self *FontAtlasBuilder) PreloadedAllGlyphsRanges() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontAtlasBuilder_GetPreloadedAllGlyphsRanges(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)) == C.bool(true)
}

func (self *FontAtlasBuilder) BakedMap() Storage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlasBuilder_GetBakedMap(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStorageFromC(func() *C.ImGuiStorage { result := result; return &result }())
}

func (self *FontAtlasBuilder) BakedDiscardedCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasBuilder_GetBakedDiscardedCount(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg)))
}

func (self *FontAtlasBuilder) PackIdMouseCursors() FontAtlasRectId {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlasBuilder_GetPackIdMouseCursors(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId { result := result; return &result }())
}

func (self *FontAtlasBuilder) PackIdLinesTexData() FontAtlasRectId {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontAtlasBuilder_GetPackIdLinesTexData(internal.ReinterpretCast[*C.ImFontAtlasBuilder](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewFontAtlasRectIdFromC(func() *C.ImFontAtlasRectId { result := result; return &result }())
}

func (self FontAtlasPostProcessData) SetFontAtlas(v *FontAtlas) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetFontAtlas(selfArg, internal.ReinterpretCast[*C.ImFontAtlas](vArg))
}

func (self FontAtlasPostProcessData) SetFont(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetFont(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self FontAtlasPostProcessData) SetFontSrc(v *FontConfig) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetFontSrc(selfArg, internal.ReinterpretCast[*C.ImFontConfig](vArg))
}

func (self FontAtlasPostProcessData) SetFontBaked(v *FontBaked) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetFontBaked(selfArg, internal.ReinterpretCast[*C.ImFontBaked](vArg))
}

func (self FontAtlasPostProcessData) SetGlyph(v *FontGlyph) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetGlyph(selfArg, internal.ReinterpretCast[*C.ImFontGlyph](vArg))
}

func (self FontAtlasPostProcessData) SetPixels(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetPixels(selfArg, C.uintptr_t(v))
}

func (self FontAtlasPostProcessData) SetFormat(v TextureFormat) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetFormat(selfArg, C.ImTextureFormat(v))
}

func (self FontAtlasPostProcessData) SetPitch(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetPitch(selfArg, C.int(v))
}

func (self FontAtlasPostProcessData) SetWidth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetWidth(selfArg, C.int(v))
}

func (self FontAtlasPostProcessData) SetHeight(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasPostProcessData_SetHeight(selfArg, C.int(v))
}

func (self *FontAtlasPostProcessData) FontAtlas() *FontAtlas {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontAtlasFromC(C.wrap_ImFontAtlasPostProcessData_GetFontAtlas(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Font() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontAtlasPostProcessData_GetFont(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) FontSrc() *FontConfig {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontConfigFromC(C.wrap_ImFontAtlasPostProcessData_GetFontSrc(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) FontBaked() *FontBaked {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontBakedFromC(C.wrap_ImFontAtlasPostProcessData_GetFontBaked(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Glyph() *FontGlyph {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontGlyphFromC(C.wrap_ImFontAtlasPostProcessData_GetGlyph(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Pixels() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImFontAtlasPostProcessData_GetPixels(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Format() TextureFormat {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TextureFormat(C.wrap_ImFontAtlasPostProcessData_GetFormat(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Pitch() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasPostProcessData_GetPitch(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Width() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasPostProcessData_GetWidth(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self *FontAtlasPostProcessData) Height() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasPostProcessData_GetHeight(internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](selfArg)))
}

func (self FontAtlasRect) SetX(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRect_SetX(selfArg, C.ushort(v))
}

func (self FontAtlasRect) SetY(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRect_SetY(selfArg, C.ushort(v))
}

func (self FontAtlasRect) SetW(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRect_SetW(selfArg, C.ushort(v))
}

func (self FontAtlasRect) SetH(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRect_SetH(selfArg, C.ushort(v))
}

func (self FontAtlasRect) SetUv0(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRect_SetUv0(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self FontAtlasRect) SetUv1(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRect_SetUv1(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self *FontAtlasRect) X() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImFontAtlasRect_GetX(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg)))
}

func (self *FontAtlasRect) Y() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImFontAtlasRect_GetY(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg)))
}

func (self *FontAtlasRect) W() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImFontAtlasRect_GetW(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg)))
}

func (self *FontAtlasRect) H() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImFontAtlasRect_GetH(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg)))
}

func (self *FontAtlasRect) Uv0() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImFontAtlasRect_GetUv0(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *FontAtlasRect) Uv1() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImFontAtlasRect_GetUv1(internal.ReinterpretCast[*C.ImFontAtlasRect](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self FontAtlasRectEntry) SetTargetIndex(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRectEntry_SetTargetIndex(selfArg, C.int(v))
}

func (self FontAtlasRectEntry) SetGeneration(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRectEntry_SetGeneration(selfArg, C.uint(v))
}

func (self FontAtlasRectEntry) SetIsUsed(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontAtlasRectEntry_SetIsUsed(selfArg, C.uint(v))
}

func (self *FontAtlasRectEntry) TargetIndex() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontAtlasRectEntry_GetTargetIndex(internal.ReinterpretCast[*C.ImFontAtlasRectEntry](selfArg)))
}

func (self *FontAtlasRectEntry) Generation() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontAtlasRectEntry_GetGeneration(internal.ReinterpretCast[*C.ImFontAtlasRectEntry](selfArg)))
}

func (self *FontAtlasRectEntry) IsUsed() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontAtlasRectEntry_GetIsUsed(internal.ReinterpretCast[*C.ImFontAtlasRectEntry](selfArg)))
}

func (self FontBaked) SetIndexAdvanceX(v vectors.Vector[float32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.float, float32](vData)
	vVecArg := new(C.ImVector_float)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetIndexAdvanceX(selfArg, *vVecArg)
}

func (self FontBaked) SetFallbackAdvanceX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetFallbackAdvanceX(selfArg, C.float(v))
}

func (self FontBaked) SetSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetSize(selfArg, C.float(v))
}

func (self FontBaked) SetRasterizerDensity(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetRasterizerDensity(selfArg, C.float(v))
}

func (self FontBaked) SetIndexLookup(v vectors.Vector[uint16]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.ImU16, uint16](vData)
	vVecArg := new(C.ImVector_ImU16)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetIndexLookup(selfArg, *vVecArg)
}

func (self FontBaked) SetGlyphs(v vectors.Vector[FontGlyph]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImFontGlyph)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImFontGlyph](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetGlyphs(selfArg, *vVecArg)
}

func (self FontBaked) SetFallbackGlyphIndex(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetFallbackGlyphIndex(selfArg, C.int(v))
}

func (self FontBaked) SetAscent(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetAscent(selfArg, C.float(v))
}

func (self FontBaked) SetDescent(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetDescent(selfArg, C.float(v))
}

func (self FontBaked) SetMetricsTotalSurface(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetMetricsTotalSurface(selfArg, C.uint(v))
}

func (self FontBaked) SetWantDestroy(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetWantDestroy(selfArg, C.uint(v))
}

func (self FontBaked) SetLoadNoFallback(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetLoadNoFallback(selfArg, C.uint(v))
}

func (self FontBaked) SetLoadNoRenderOnLayout(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetLoadNoRenderOnLayout(selfArg, C.uint(v))
}

func (self FontBaked) SetLastUsedFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetLastUsedFrame(selfArg, C.int(v))
}

func (self FontBaked) SetBakedId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetBakedId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self FontBaked) SetContainerFont(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetContainerFont(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self FontBaked) SetFontLoaderDatas(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontBaked_SetFontLoaderDatas(selfArg, C.uintptr_t(v))
}

func (self *FontBaked) IndexAdvanceX() vectors.Vector[float32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontBaked_GetIndexAdvanceX(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Size, C.wrap_ImFontBaked_GetIndexAdvanceX(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Capacity, (*float32)(C.wrap_ImFontBaked_GetIndexAdvanceX(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Data))
}

func (self *FontBaked) FallbackAdvanceX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontBaked_GetFallbackAdvanceX(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) Size() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontBaked_GetSize(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) RasterizerDensity() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontBaked_GetRasterizerDensity(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) IndexLookup() vectors.Vector[uint16] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontBaked_GetIndexLookup(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Size, C.wrap_ImFontBaked_GetIndexLookup(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Capacity, (*uint16)(C.wrap_ImFontBaked_GetIndexLookup(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Data))
}

func (self *FontBaked) Glyphs() vectors.Vector[FontGlyph] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontBaked_GetGlyphs(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Size, C.wrap_ImFontBaked_GetGlyphs(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Capacity, NewFontGlyphFromC(C.wrap_ImFontBaked_GetGlyphs(internal.ReinterpretCast[*C.ImFontBaked](selfArg)).Data))
}

func (self *FontBaked) FallbackGlyphIndex() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontBaked_GetFallbackGlyphIndex(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) Ascent() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontBaked_GetAscent(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) Descent() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontBaked_GetDescent(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) MetricsTotalSurface() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontBaked_GetMetricsTotalSurface(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) WantDestroy() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontBaked_GetWantDestroy(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) LoadNoFallback() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontBaked_GetLoadNoFallback(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) LoadNoRenderOnLayout() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontBaked_GetLoadNoRenderOnLayout(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) LastUsedFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontBaked_GetLastUsedFrame(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) BakedId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImFontBaked_GetBakedId(internal.ReinterpretCast[*C.ImFontBaked](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *FontBaked) ContainerFont() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontBaked_GetContainerFont(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self *FontBaked) FontLoaderDatas() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImFontBaked_GetFontLoaderDatas(internal.ReinterpretCast[*C.ImFontBaked](selfArg)))
}

func (self FontConfig) SetName(v *[40]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetName(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self FontConfig) SetFontData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontData(selfArg, C.uintptr_t(v))
}

func (self FontConfig) SetFontDataSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontDataSize(selfArg, C.int(v))
}

func (self FontConfig) SetFontDataOwnedByAtlas(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontDataOwnedByAtlas(selfArg, C.bool(v))
}

func (self FontConfig) SetMergeMode(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetMergeMode(selfArg, C.bool(v))
}

func (self FontConfig) SetPixelSnapH(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetPixelSnapH(selfArg, C.bool(v))
}

func (self FontConfig) SetPixelSnapV(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetPixelSnapV(selfArg, C.bool(v))
}

func (self FontConfig) SetOversampleH(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetOversampleH(selfArg, C.ImS8(v))
}

func (self FontConfig) SetOversampleV(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetOversampleV(selfArg, C.ImS8(v))
}

func (self FontConfig) SetEllipsisChar(v Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetEllipsisChar(selfArg, C.ImWchar(v))
}

func (self FontConfig) SetSizePixels(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetSizePixels(selfArg, C.float(v))
}

func (self FontConfig) SetGlyphRanges(v *Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetGlyphRanges(selfArg, (*C.ImWchar)(v))
}

func (self FontConfig) SetGlyphExcludeRanges(v *Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetGlyphExcludeRanges(selfArg, (*C.ImWchar)(v))
}

func (self FontConfig) SetGlyphOffset(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetGlyphOffset(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self FontConfig) SetGlyphMinAdvanceX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetGlyphMinAdvanceX(selfArg, C.float(v))
}

func (self FontConfig) SetGlyphMaxAdvanceX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetGlyphMaxAdvanceX(selfArg, C.float(v))
}

func (self FontConfig) SetGlyphExtraAdvanceX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetGlyphExtraAdvanceX(selfArg, C.float(v))
}

func (self FontConfig) SetFontNo(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontNo(selfArg, C.ImU32(v))
}

func (self FontConfig) SetFontLoaderFlags(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontLoaderFlags(selfArg, C.uint(v))
}

func (self FontConfig) SetRasterizerMultiply(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetRasterizerMultiply(selfArg, C.float(v))
}

func (self FontConfig) SetRasterizerDensity(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetRasterizerDensity(selfArg, C.float(v))
}

func (self FontConfig) SetFlags(v FontFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFlags(selfArg, C.ImFontFlags(v))
}

func (self FontConfig) SetDstFont(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetDstFont(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self FontConfig) SetFontLoader(v *FontLoader) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontLoader(selfArg, internal.ReinterpretCast[*C.ImFontLoader](vArg))
}

func (self FontConfig) SetFontLoaderData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontConfig_SetFontLoaderData(selfArg, C.uintptr_t(v))
}

func (self *FontConfig) Name() [40]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [40]rune {
		result := [40]rune{}
		resultMirr := C.wrap_ImFontConfig_GetName(internal.ReinterpretCast[*C.ImFontConfig](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *FontConfig) FontData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImFontConfig_GetFontData(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) FontDataSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontConfig_GetFontDataSize(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) FontDataOwnedByAtlas() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontConfig_GetFontDataOwnedByAtlas(internal.ReinterpretCast[*C.ImFontConfig](selfArg)) == C.bool(true)
}

func (self *FontConfig) MergeMode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontConfig_GetMergeMode(internal.ReinterpretCast[*C.ImFontConfig](selfArg)) == C.bool(true)
}

func (self *FontConfig) PixelSnapH() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontConfig_GetPixelSnapH(internal.ReinterpretCast[*C.ImFontConfig](selfArg)) == C.bool(true)
}

func (self *FontConfig) PixelSnapV() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImFontConfig_GetPixelSnapV(internal.ReinterpretCast[*C.ImFontConfig](selfArg)) == C.bool(true)
}

func (self *FontConfig) OversampleH() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImFontConfig_GetOversampleH(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) OversampleV() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImFontConfig_GetOversampleV(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) EllipsisChar() Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (Wchar)(C.wrap_ImFontConfig_GetEllipsisChar(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) SizePixels() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontConfig_GetSizePixels(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) GlyphRanges() *Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*Wchar)(C.wrap_ImFontConfig_GetGlyphRanges(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) GlyphExcludeRanges() *Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*Wchar)(C.wrap_ImFontConfig_GetGlyphExcludeRanges(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) GlyphOffset() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImFontConfig_GetGlyphOffset(internal.ReinterpretCast[*C.ImFontConfig](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *FontConfig) GlyphMinAdvanceX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontConfig_GetGlyphMinAdvanceX(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) GlyphMaxAdvanceX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontConfig_GetGlyphMaxAdvanceX(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) GlyphExtraAdvanceX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontConfig_GetGlyphExtraAdvanceX(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) FontNo() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImFontConfig_GetFontNo(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) FontLoaderFlags() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontConfig_GetFontLoaderFlags(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) RasterizerMultiply() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontConfig_GetRasterizerMultiply(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) RasterizerDensity() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontConfig_GetRasterizerDensity(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) Flags() FontFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return FontFlags(C.wrap_ImFontConfig_GetFlags(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) DstFont() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontConfig_GetDstFont(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) FontLoader() *FontLoader {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontLoaderFromC(C.wrap_ImFontConfig_GetFontLoader(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self *FontConfig) FontLoaderData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImFontConfig_GetFontLoaderData(internal.ReinterpretCast[*C.ImFontConfig](selfArg)))
}

func (self FontGlyph) SetColored(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetColored(selfArg, C.uint(v))
}

func (self FontGlyph) SetVisible(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetVisible(selfArg, C.uint(v))
}

func (self FontGlyph) SetSourceIdx(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetSourceIdx(selfArg, C.uint(v))
}

func (self FontGlyph) SetCodepoint(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetCodepoint(selfArg, C.uint(v))
}

func (self FontGlyph) SetAdvanceX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetAdvanceX(selfArg, C.float(v))
}

func (self FontGlyph) SetX0(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetX0(selfArg, C.float(v))
}

func (self FontGlyph) SetY0(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetY0(selfArg, C.float(v))
}

func (self FontGlyph) SetX1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetX1(selfArg, C.float(v))
}

func (self FontGlyph) SetY1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetY1(selfArg, C.float(v))
}

func (self FontGlyph) SetU0(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetU0(selfArg, C.float(v))
}

func (self FontGlyph) SetV0(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetV0(selfArg, C.float(v))
}

func (self FontGlyph) SetU1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetU1(selfArg, C.float(v))
}

func (self FontGlyph) SetV1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetV1(selfArg, C.float(v))
}

func (self FontGlyph) SetPackId(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyph_SetPackId(selfArg, C.int(v))
}

func (self *FontGlyph) Colored() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontGlyph_GetColored(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) Visible() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontGlyph_GetVisible(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) SourceIdx() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontGlyph_GetSourceIdx(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) Codepoint() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImFontGlyph_GetCodepoint(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) AdvanceX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetAdvanceX(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) X0() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetX0(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) Y0() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetY0(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) X1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetX1(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) Y1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetY1(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) U0() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetU0(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) V0() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetV0(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) U1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetU1(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) V1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontGlyph_GetV1(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self *FontGlyph) PackId() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImFontGlyph_GetPackId(internal.ReinterpretCast[*C.ImFontGlyph](selfArg)))
}

func (self FontGlyphRangesBuilder) SetUsedChars(v vectors.Vector[uint32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.ImU32, uint32](vData)
	vVecArg := new(C.ImVector_ImU32)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontGlyphRangesBuilder_SetUsedChars(selfArg, *vVecArg)
}

func (self *FontGlyphRangesBuilder) UsedChars() vectors.Vector[uint32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImFontGlyphRangesBuilder_GetUsedChars(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg)).Size, C.wrap_ImFontGlyphRangesBuilder_GetUsedChars(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg)).Capacity, (*uint32)(C.wrap_ImFontGlyphRangesBuilder_GetUsedChars(internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](selfArg)).Data))
}

func (self FontLoader) SetName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontLoader_SetName(selfArg, vArg)
}

func (self FontLoader) SetFontBakedSrcLoaderDataSize(v uint64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontLoader_SetFontBakedSrcLoaderDataSize(selfArg, C.xulong(v))
}

func (self *FontLoader) Name() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImFontLoader_GetName(internal.ReinterpretCast[*C.ImFontLoader](selfArg)))
}

func (self *FontLoader) FontBakedSrcLoaderDataSize() uint64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint64(C.wrap_ImFontLoader_GetFontBakedSrcLoaderDataSize(internal.ReinterpretCast[*C.ImFontLoader](selfArg)))
}

func (self FontStackData) SetFont(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontStackData_SetFont(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self FontStackData) SetFontSizeBeforeScaling(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontStackData_SetFontSizeBeforeScaling(selfArg, C.float(v))
}

func (self FontStackData) SetFontSizeAfterScaling(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImFontStackData_SetFontSizeAfterScaling(selfArg, C.float(v))
}

func (self *FontStackData) Font() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImFontStackData_GetFont(internal.ReinterpretCast[*C.ImFontStackData](selfArg)))
}

func (self *FontStackData) FontSizeBeforeScaling() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontStackData_GetFontSizeBeforeScaling(internal.ReinterpretCast[*C.ImFontStackData](selfArg)))
}

func (self *FontStackData) FontSizeAfterScaling() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImFontStackData_GetFontSizeAfterScaling(internal.ReinterpretCast[*C.ImFontStackData](selfArg)))
}

func (self BoxSelectState) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self BoxSelectState) SetIsActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetIsActive(selfArg, C.bool(v))
}

func (self BoxSelectState) SetIsStarting(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetIsStarting(selfArg, C.bool(v))
}

func (self BoxSelectState) SetIsStartedFromVoid(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetIsStartedFromVoid(selfArg, C.bool(v))
}

func (self BoxSelectState) SetIsStartedSetNavIdOnce(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetIsStartedSetNavIdOnce(selfArg, C.bool(v))
}

func (self BoxSelectState) SetRequestClear(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetRequestClear(selfArg, C.bool(v))
}

func (self BoxSelectState) SetKeyMods(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetKeyMods(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self BoxSelectState) SetStartPosRel(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetStartPosRel(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self BoxSelectState) SetEndPosRel(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetEndPosRel(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self BoxSelectState) SetScrollAccum(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetScrollAccum(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self BoxSelectState) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self BoxSelectState) SetUnclipMode(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetUnclipMode(selfArg, C.bool(v))
}

func (self BoxSelectState) SetUnclipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetUnclipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self BoxSelectState) SetBoxSelectRectPrev(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetBoxSelectRectPrev(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self BoxSelectState) SetBoxSelectRectCurr(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiBoxSelectState_SetBoxSelectRectCurr(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self *BoxSelectState) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiBoxSelectState_GetID(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *BoxSelectState) IsActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiBoxSelectState_GetIsActive(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)) == C.bool(true)
}

func (self *BoxSelectState) IsStarting() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiBoxSelectState_GetIsStarting(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)) == C.bool(true)
}

func (self *BoxSelectState) IsStartedFromVoid() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiBoxSelectState_GetIsStartedFromVoid(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)) == C.bool(true)
}

func (self *BoxSelectState) IsStartedSetNavIdOnce() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiBoxSelectState_GetIsStartedSetNavIdOnce(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)) == C.bool(true)
}

func (self *BoxSelectState) RequestClear() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiBoxSelectState_GetRequestClear(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)) == C.bool(true)
}

func (self *BoxSelectState) KeyMods() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiBoxSelectState_GetKeyMods(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *BoxSelectState) StartPosRel() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiBoxSelectState_GetStartPosRel(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *BoxSelectState) EndPosRel() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiBoxSelectState_GetEndPosRel(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *BoxSelectState) ScrollAccum() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiBoxSelectState_GetScrollAccum(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *BoxSelectState) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiBoxSelectState_GetWindow(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)))
}

func (self *BoxSelectState) UnclipMode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiBoxSelectState_GetUnclipMode(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg)) == C.bool(true)
}

func (self *BoxSelectState) UnclipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiBoxSelectState_GetUnclipRect(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *BoxSelectState) BoxSelectRectPrev() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiBoxSelectState_GetBoxSelectRectPrev(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *BoxSelectState) BoxSelectRectCurr() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiBoxSelectState_GetBoxSelectRectCurr(internal.ReinterpretCast[*C.ImGuiBoxSelectState](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self ColorMod) SetCol(v Col) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiColorMod_SetCol(selfArg, C.ImGuiCol(v))
}

func (self ColorMod) SetBackupValue(v Vec4) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiColorMod_SetBackupValue(selfArg, internal.ReinterpretCast[C.ImVec4](v.ToC()))
}

func (self *ColorMod) Col() Col {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Col(C.wrap_ImGuiColorMod_GetCol(internal.ReinterpretCast[*C.ImGuiColorMod](selfArg)))
}

func (self *ColorMod) BackupValue() Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImGuiColorMod_GetBackupValue(internal.ReinterpretCast[*C.ImGuiColorMod](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self ComboPreviewData) SetPreviewRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiComboPreviewData_SetPreviewRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self ComboPreviewData) SetBackupCursorPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiComboPreviewData_SetBackupCursorPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ComboPreviewData) SetBackupCursorMaxPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiComboPreviewData_SetBackupCursorMaxPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ComboPreviewData) SetBackupCursorPosPrevLine(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiComboPreviewData_SetBackupCursorPosPrevLine(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ComboPreviewData) SetBackupPrevLineTextBaseOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiComboPreviewData_SetBackupPrevLineTextBaseOffset(selfArg, C.float(v))
}

func (self ComboPreviewData) SetBackupLayout(v LayoutType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiComboPreviewData_SetBackupLayout(selfArg, C.ImGuiLayoutType(v))
}

func (self *ComboPreviewData) PreviewRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiComboPreviewData_GetPreviewRect(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ComboPreviewData) BackupCursorPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiComboPreviewData_GetBackupCursorPos(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ComboPreviewData) BackupCursorMaxPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiComboPreviewData_GetBackupCursorMaxPos(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ComboPreviewData) BackupCursorPosPrevLine() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiComboPreviewData_GetBackupCursorPosPrevLine(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ComboPreviewData) BackupPrevLineTextBaseOffset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiComboPreviewData_GetBackupPrevLineTextBaseOffset(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg)))
}

func (self *ComboPreviewData) BackupLayout() LayoutType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LayoutType(C.wrap_ImGuiComboPreviewData_GetBackupLayout(internal.ReinterpretCast[*C.ImGuiComboPreviewData](selfArg)))
}

func (self Context) SetInitialized(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInitialized(selfArg, C.bool(v))
}

func (self Context) SetIO(v IO) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetIO(selfArg, internal.ReinterpretCast[C.ImGuiIO](vArg))
}

func (self Context) SetPlatformIO(v PlatformIO) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetPlatformIO(selfArg, internal.ReinterpretCast[C.ImGuiPlatformIO](vArg))
}

func (self Context) SetStyle(v Style) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetStyle(selfArg, internal.ReinterpretCast[C.ImGuiStyle](vArg))
}

func (self Context) SetConfigFlagsCurrFrame(v ConfigFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetConfigFlagsCurrFrame(selfArg, C.ImGuiConfigFlags(v))
}

func (self Context) SetConfigFlagsLastFrame(v ConfigFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetConfigFlagsLastFrame(selfArg, C.ImGuiConfigFlags(v))
}

func (self Context) SetFont(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFont(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self Context) SetFontBaked(v *FontBaked) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFontBaked(selfArg, internal.ReinterpretCast[*C.ImFontBaked](vArg))
}

func (self Context) SetFontSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFontSize(selfArg, C.float(v))
}

func (self Context) SetFontSizeBase(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFontSizeBase(selfArg, C.float(v))
}

func (self Context) SetFontBakedScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFontBakedScale(selfArg, C.float(v))
}

func (self Context) SetFontRasterizerDensity(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFontRasterizerDensity(selfArg, C.float(v))
}

func (self Context) SetCurrentDpiScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentDpiScale(selfArg, C.float(v))
}

func (self Context) SetDrawListSharedData(v DrawListSharedData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDrawListSharedData(selfArg, internal.ReinterpretCast[C.ImDrawListSharedData](vArg))
}

func (self Context) SetTime(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTime(selfArg, C.double(v))
}

func (self Context) SetFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFrameCount(selfArg, C.int(v))
}

func (self Context) SetFrameCountEnded(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFrameCountEnded(selfArg, C.int(v))
}

func (self Context) SetFrameCountPlatformEnded(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFrameCountPlatformEnded(selfArg, C.int(v))
}

func (self Context) SetFrameCountRendered(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFrameCountRendered(selfArg, C.int(v))
}

func (self Context) SetWithinEndChildID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWithinEndChildID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetWithinFrameScope(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWithinFrameScope(selfArg, C.bool(v))
}

func (self Context) SetWithinFrameScopeWithImplicitWindow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWithinFrameScopeWithImplicitWindow(selfArg, C.bool(v))
}

func (self Context) SetGcCompactAll(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetGcCompactAll(selfArg, C.bool(v))
}

func (self Context) SetTestEngineHookItems(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTestEngineHookItems(selfArg, C.bool(v))
}

func (self Context) SetTestEngine(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTestEngine(selfArg, C.uintptr_t(v))
}

func (self Context) SetContextName(v *[16]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetContextName(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self Context) SetInputEventsQueue(v vectors.Vector[InputEvent]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiInputEvent)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiInputEvent](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputEventsQueue(selfArg, *vVecArg)
}

func (self Context) SetInputEventsTrail(v vectors.Vector[InputEvent]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiInputEvent)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiInputEvent](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputEventsTrail(selfArg, *vVecArg)
}

func (self Context) SetInputEventsNextMouseSource(v MouseSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputEventsNextMouseSource(selfArg, C.ImGuiMouseSource(v))
}

func (self Context) SetInputEventsNextEventId(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputEventsNextEventId(selfArg, C.ImU32(v))
}

func (self Context) SetCurrentWindowStack(v vectors.Vector[WindowStackData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiWindowStackData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiWindowStackData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentWindowStack(selfArg, *vVecArg)
}

func (self Context) SetWindowsById(v Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWindowsById(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self Context) SetWindowsActiveCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWindowsActiveCount(selfArg, C.int(v))
}

func (self Context) SetWindowsBorderHoverPadding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWindowsBorderHoverPadding(selfArg, C.float(v))
}

func (self Context) SetDebugBreakInWindow(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugBreakInWindow(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetCurrentWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetHoveredWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetHoveredWindowUnderMovingWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredWindowUnderMovingWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetHoveredWindowBeforeClear(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredWindowBeforeClear(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetMovingWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMovingWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetWheelingWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetWheelingWindowRefMousePos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingWindowRefMousePos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetWheelingWindowStartFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingWindowStartFrame(selfArg, C.int(v))
}

func (self Context) SetWheelingWindowScrolledFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingWindowScrolledFrame(selfArg, C.int(v))
}

func (self Context) SetWheelingWindowReleaseTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingWindowReleaseTimer(selfArg, C.float(v))
}

func (self Context) SetWheelingWindowWheelRemainder(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingWindowWheelRemainder(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetWheelingAxisAvg(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWheelingAxisAvg(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetDebugDrawIdConflictsId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugDrawIdConflictsId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDebugHookIdInfoId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugHookIdInfoId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetHoveredId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetHoveredIdPreviousFrame(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredIdPreviousFrame(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetHoveredIdPreviousFrameItemCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredIdPreviousFrameItemCount(selfArg, C.int(v))
}

func (self Context) SetHoveredIdTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredIdTimer(selfArg, C.float(v))
}

func (self Context) SetHoveredIdNotActiveTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredIdNotActiveTimer(selfArg, C.float(v))
}

func (self Context) SetHoveredIdAllowOverlap(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredIdAllowOverlap(selfArg, C.bool(v))
}

func (self Context) SetHoveredIdIsDisabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoveredIdIsDisabled(selfArg, C.bool(v))
}

func (self Context) SetItemUnclipByLog(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetItemUnclipByLog(selfArg, C.bool(v))
}

func (self Context) SetActiveId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetActiveIdIsAlive(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdIsAlive(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetActiveIdTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdTimer(selfArg, C.float(v))
}

func (self Context) SetActiveIdIsJustActivated(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdIsJustActivated(selfArg, C.bool(v))
}

func (self Context) SetActiveIdAllowOverlap(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdAllowOverlap(selfArg, C.bool(v))
}

func (self Context) SetActiveIdNoClearOnFocusLoss(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdNoClearOnFocusLoss(selfArg, C.bool(v))
}

func (self Context) SetActiveIdHasBeenPressedBefore(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdHasBeenPressedBefore(selfArg, C.bool(v))
}

func (self Context) SetActiveIdHasBeenEditedBefore(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdHasBeenEditedBefore(selfArg, C.bool(v))
}

func (self Context) SetActiveIdHasBeenEditedThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdHasBeenEditedThisFrame(selfArg, C.bool(v))
}

func (self Context) SetActiveIdFromShortcut(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdFromShortcut(selfArg, C.bool(v))
}

func (self Context) SetActiveIdDisabledId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdDisabledId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetActiveIdMouseButton(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdMouseButton(selfArg, C.int(v))
}

func (self Context) SetActiveIdClickOffset(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdClickOffset(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetActiveIdWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetActiveIdSource(v InputSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdSource(selfArg, C.ImGuiInputSource(v))
}

func (self Context) SetActiveIdPreviousFrame(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdPreviousFrame(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDeactivatedItemData(v DeactivatedItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDeactivatedItemData(selfArg, internal.ReinterpretCast[C.ImGuiDeactivatedItemData](vArg))
}

func (self Context) SetActiveIdValueOnActivation(v DataTypeStorage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdValueOnActivation(selfArg, internal.ReinterpretCast[C.ImGuiDataTypeStorage](vArg))
}

func (self Context) SetLastActiveId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLastActiveId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetLastActiveIdTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLastActiveIdTimer(selfArg, C.float(v))
}

func (self Context) SetLastKeyModsChangeTime(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLastKeyModsChangeTime(selfArg, C.double(v))
}

func (self Context) SetLastKeyModsChangeFromNoneTime(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLastKeyModsChangeFromNoneTime(selfArg, C.double(v))
}

func (self Context) SetLastKeyboardKeyPressTime(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLastKeyboardKeyPressTime(selfArg, C.double(v))
}

func (self Context) SetKeysOwnerData(v *[155]KeyOwnerData) {
	vArg := make([]C.ImGuiKeyOwnerData, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImGuiKeyOwnerData](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetKeysOwnerData(selfArg, (*C.ImGuiKeyOwnerData)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewKeyOwnerDataFromC(func() *C.ImGuiKeyOwnerData { result := vV; return &result }())
	}
}

func (self Context) SetKeysRoutingTable(v KeyRoutingTable) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetKeysRoutingTable(selfArg, internal.ReinterpretCast[C.ImGuiKeyRoutingTable](vArg))
}

func (self Context) SetActiveIdUsingNavDirMask(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdUsingNavDirMask(selfArg, C.ImU32(v))
}

func (self Context) SetActiveIdUsingAllKeyboardKeys(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetActiveIdUsingAllKeyboardKeys(selfArg, C.bool(v))
}

func (self Context) SetDebugBreakInShortcutRouting(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugBreakInShortcutRouting(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self Context) SetCurrentFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetCurrentItemFlags(v ItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentItemFlags(selfArg, C.ImGuiItemFlags(v))
}

func (self Context) SetDebugLocateId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLocateId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNextItemData(v NextItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNextItemData(selfArg, internal.ReinterpretCast[C.ImGuiNextItemData](vArg))
}

func (self Context) SetLastItemData(v LastItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLastItemData(selfArg, internal.ReinterpretCast[C.ImGuiLastItemData](vArg))
}

func (self Context) SetNextWindowData(v NextWindowData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNextWindowData(selfArg, internal.ReinterpretCast[C.ImGuiNextWindowData](vArg))
}

func (self Context) SetDebugShowGroupRects(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugShowGroupRects(selfArg, C.bool(v))
}

func (self Context) SetDebugFlashStyleColorIdx(v Col) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugFlashStyleColorIdx(selfArg, C.ImGuiCol(v))
}

func (self Context) SetColorStack(v vectors.Vector[ColorMod]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiColorMod)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiColorMod](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorStack(selfArg, *vVecArg)
}

func (self Context) SetStyleVarStack(v vectors.Vector[StyleMod]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiStyleMod)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiStyleMod](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetStyleVarStack(selfArg, *vVecArg)
}

func (self Context) SetFontStack(v vectors.Vector[FontStackData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImFontStackData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImFontStackData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFontStack(selfArg, *vVecArg)
}

func (self Context) SetFocusScopeStack(v vectors.Vector[FocusScopeData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiFocusScopeData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiFocusScopeData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFocusScopeStack(selfArg, *vVecArg)
}

func (self Context) SetItemFlagsStack(v vectors.Vector[ItemFlags]) {
	vData := v.Data

	vVecArg := new(C.ImVector_ImGuiItemFlags)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = (*C.ImGuiItemFlags)(vData)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetItemFlagsStack(selfArg, *vVecArg)
}

func (self Context) SetGroupStack(v vectors.Vector[GroupData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiGroupData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiGroupData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetGroupStack(selfArg, *vVecArg)
}

func (self Context) SetOpenPopupStack(v vectors.Vector[PopupData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiPopupData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiPopupData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetOpenPopupStack(selfArg, *vVecArg)
}

func (self Context) SetBeginPopupStack(v vectors.Vector[PopupData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiPopupData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiPopupData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetBeginPopupStack(selfArg, *vVecArg)
}

func (self Context) SetTreeNodeStack(v vectors.Vector[TreeNodeStackData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTreeNodeStackData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTreeNodeStack(selfArg, *vVecArg)
}

func (self Context) SetCurrentViewport(v *ViewportP) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentViewport(selfArg, internal.ReinterpretCast[*C.ImGuiViewportP](vArg))
}

func (self Context) SetMouseViewport(v *ViewportP) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMouseViewport(selfArg, internal.ReinterpretCast[*C.ImGuiViewportP](vArg))
}

func (self Context) SetMouseLastHoveredViewport(v *ViewportP) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMouseLastHoveredViewport(selfArg, internal.ReinterpretCast[*C.ImGuiViewportP](vArg))
}

func (self Context) SetPlatformLastFocusedViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetPlatformLastFocusedViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetFallbackMonitor(v PlatformMonitor) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFallbackMonitor(selfArg, internal.ReinterpretCast[C.ImGuiPlatformMonitor](vArg))
}

func (self Context) SetPlatformMonitorsFullWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetPlatformMonitorsFullWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Context) SetViewportCreatedCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetViewportCreatedCount(selfArg, C.int(v))
}

func (self Context) SetPlatformWindowsCreatedCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetPlatformWindowsCreatedCount(selfArg, C.int(v))
}

func (self Context) SetViewportFocusedStampCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetViewportFocusedStampCount(selfArg, C.int(v))
}

func (self Context) SetNavCursorVisible(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavCursorVisible(selfArg, C.bool(v))
}

func (self Context) SetNavHighlightItemUnderNav(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavHighlightItemUnderNav(selfArg, C.bool(v))
}

func (self Context) SetNavMousePosDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMousePosDirty(selfArg, C.bool(v))
}

func (self Context) SetNavIdIsAlive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavIdIsAlive(selfArg, C.bool(v))
}

func (self Context) SetNavId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetNavFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavLayer(v NavLayer) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavLayer(selfArg, C.ImGuiNavLayer(v))
}

func (self Context) SetNavActivateId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavActivateId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavActivateDownId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavActivateDownId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavActivatePressedId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavActivatePressedId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavActivateFlags(v ActivateFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavActivateFlags(selfArg, C.ImGuiActivateFlags(v))
}

func (self Context) SetNavFocusRoute(v vectors.Vector[FocusScopeData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiFocusScopeData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiFocusScopeData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavFocusRoute(selfArg, *vVecArg)
}

func (self Context) SetNavHighlightActivatedId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavHighlightActivatedId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavHighlightActivatedTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavHighlightActivatedTimer(selfArg, C.float(v))
}

func (self Context) SetNavNextActivateId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavNextActivateId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavNextActivateFlags(v ActivateFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavNextActivateFlags(selfArg, C.ImGuiActivateFlags(v))
}

func (self Context) SetNavInputSource(v InputSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavInputSource(selfArg, C.ImGuiInputSource(v))
}

func (self Context) SetNavLastValidSelectionUserData(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavLastValidSelectionUserData(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self Context) SetNavCursorHideFrames(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavCursorHideFrames(selfArg, C.ImS8(v))
}

func (self Context) SetNavAnyRequest(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavAnyRequest(selfArg, C.bool(v))
}

func (self Context) SetNavInitRequest(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavInitRequest(selfArg, C.bool(v))
}

func (self Context) SetNavInitRequestFromMove(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavInitRequestFromMove(selfArg, C.bool(v))
}

func (self Context) SetNavInitResult(v NavItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavInitResult(selfArg, internal.ReinterpretCast[C.ImGuiNavItemData](vArg))
}

func (self Context) SetNavMoveSubmitted(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveSubmitted(selfArg, C.bool(v))
}

func (self Context) SetNavMoveScoringItems(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveScoringItems(selfArg, C.bool(v))
}

func (self Context) SetNavMoveForwardToNextFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveForwardToNextFrame(selfArg, C.bool(v))
}

func (self Context) SetNavMoveFlags(v NavMoveFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveFlags(selfArg, C.ImGuiNavMoveFlags(v))
}

func (self Context) SetNavMoveScrollFlags(v ScrollFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveScrollFlags(selfArg, C.ImGuiScrollFlags(v))
}

func (self Context) SetNavMoveKeyMods(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveKeyMods(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self Context) SetNavMoveDir(v Dir) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveDir(selfArg, C.ImGuiDir(v))
}

func (self Context) SetNavMoveDirForDebug(v Dir) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveDirForDebug(selfArg, C.ImGuiDir(v))
}

func (self Context) SetNavMoveClipDir(v Dir) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveClipDir(selfArg, C.ImGuiDir(v))
}

func (self Context) SetNavScoringRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavScoringRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Context) SetNavScoringNoClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavScoringNoClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Context) SetNavScoringDebugCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavScoringDebugCount(selfArg, C.int(v))
}

func (self Context) SetNavTabbingDir(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavTabbingDir(selfArg, C.int(v))
}

func (self Context) SetNavTabbingCounter(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavTabbingCounter(selfArg, C.int(v))
}

func (self Context) SetNavMoveResultLocal(v NavItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveResultLocal(selfArg, internal.ReinterpretCast[C.ImGuiNavItemData](vArg))
}

func (self Context) SetNavMoveResultLocalVisible(v NavItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveResultLocalVisible(selfArg, internal.ReinterpretCast[C.ImGuiNavItemData](vArg))
}

func (self Context) SetNavMoveResultOther(v NavItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavMoveResultOther(selfArg, internal.ReinterpretCast[C.ImGuiNavItemData](vArg))
}

func (self Context) SetNavTabbingResultFirst(v NavItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavTabbingResultFirst(selfArg, internal.ReinterpretCast[C.ImGuiNavItemData](vArg))
}

func (self Context) SetNavJustMovedFromFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavJustMovedFromFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavJustMovedToId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavJustMovedToId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavJustMovedToFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavJustMovedToFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetNavJustMovedToKeyMods(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavJustMovedToKeyMods(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self Context) SetNavJustMovedToIsTabbing(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavJustMovedToIsTabbing(selfArg, C.bool(v))
}

func (self Context) SetNavJustMovedToHasSelectionData(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavJustMovedToHasSelectionData(selfArg, C.bool(v))
}

func (self Context) SetConfigNavWindowingWithGamepad(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetConfigNavWindowingWithGamepad(selfArg, C.bool(v))
}

func (self Context) SetConfigNavWindowingKeyNext(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetConfigNavWindowingKeyNext(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self Context) SetConfigNavWindowingKeyPrev(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetConfigNavWindowingKeyPrev(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self Context) SetNavWindowingTarget(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingTarget(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetNavWindowingTargetAnim(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingTargetAnim(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetNavWindowingListWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingListWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetNavWindowingTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingTimer(selfArg, C.float(v))
}

func (self Context) SetNavWindowingHighlightAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingHighlightAlpha(selfArg, C.float(v))
}

func (self Context) SetNavWindowingInputSource(v InputSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingInputSource(selfArg, C.ImGuiInputSource(v))
}

func (self Context) SetNavWindowingToggleLayer(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingToggleLayer(selfArg, C.bool(v))
}

func (self Context) SetNavWindowingToggleKey(v Key) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingToggleKey(selfArg, C.ImGuiKey(v))
}

func (self Context) SetNavWindowingAccumDeltaPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingAccumDeltaPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetNavWindowingAccumDeltaSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetNavWindowingAccumDeltaSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetDimBgRatio(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDimBgRatio(selfArg, C.float(v))
}

func (self Context) SetDragDropActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropActive(selfArg, C.bool(v))
}

func (self Context) SetDragDropWithinSource(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropWithinSource(selfArg, C.bool(v))
}

func (self Context) SetDragDropWithinTarget(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropWithinTarget(selfArg, C.bool(v))
}

func (self Context) SetDragDropSourceFlags(v DragDropFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropSourceFlags(selfArg, C.ImGuiDragDropFlags(v))
}

func (self Context) SetDragDropSourceFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropSourceFrameCount(selfArg, C.int(v))
}

func (self Context) SetDragDropMouseButton(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropMouseButton(selfArg, C.int(v))
}

func (self Context) SetDragDropPayload(v Payload) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropPayload(selfArg, internal.ReinterpretCast[C.ImGuiPayload](vArg))
}

func (self Context) SetDragDropTargetRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropTargetRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Context) SetDragDropTargetClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropTargetClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Context) SetDragDropTargetId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropTargetId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDragDropAcceptFlags(v DragDropFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropAcceptFlags(selfArg, C.ImGuiDragDropFlags(v))
}

func (self Context) SetDragDropAcceptIdCurrRectSurface(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropAcceptIdCurrRectSurface(selfArg, C.float(v))
}

func (self Context) SetDragDropAcceptIdCurr(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropAcceptIdCurr(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDragDropAcceptIdPrev(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropAcceptIdPrev(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDragDropAcceptFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropAcceptFrameCount(selfArg, C.int(v))
}

func (self Context) SetDragDropHoldJustPressedId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropHoldJustPressedId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDragDropPayloadBufLocal(v *[16]uint) {
	vArg := make([]C.uchar, len(v))
	for i, vV := range v {
		vArg[i] = C.uchar(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragDropPayloadBufLocal(selfArg, (*C.uchar)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = uint(vV)
	}
}

func (self Context) SetClipperTempDataStacked(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetClipperTempDataStacked(selfArg, C.int(v))
}

func (self Context) SetClipperTempData(v vectors.Vector[ListClipperData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiListClipperData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiListClipperData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetClipperTempData(selfArg, *vVecArg)
}

func (self Context) SetCurrentTable(v *Table) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentTable(selfArg, internal.ReinterpretCast[*C.ImGuiTable](vArg))
}

func (self Context) SetDebugBreakInTable(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugBreakInTable(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetTablesTempDataStacked(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTablesTempDataStacked(selfArg, C.int(v))
}

func (self Context) SetTablesTempData(v vectors.Vector[TableTempData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTableTempData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTableTempData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTablesTempData(selfArg, *vVecArg)
}

func (self Context) SetTablesLastTimeActive(v vectors.Vector[float32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.float, float32](vData)
	vVecArg := new(C.ImVector_float)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTablesLastTimeActive(selfArg, *vVecArg)
}

func (self Context) SetDrawChannelsTempMergeBuffer(v vectors.Vector[DrawChannel]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImDrawChannel)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImDrawChannel](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDrawChannelsTempMergeBuffer(selfArg, *vVecArg)
}

func (self Context) SetCurrentTabBar(v *TabBar) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentTabBar(selfArg, internal.ReinterpretCast[*C.ImGuiTabBar](vArg))
}

func (self Context) SetCurrentTabBarStack(v vectors.Vector[PtrOrIndex]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiPtrOrIndex)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiPtrOrIndex](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentTabBarStack(selfArg, *vVecArg)
}

func (self Context) SetShrinkWidthBuffer(v vectors.Vector[ShrinkWidthItem]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiShrinkWidthItem)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiShrinkWidthItem](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetShrinkWidthBuffer(selfArg, *vVecArg)
}

func (self Context) SetBoxSelectState(v BoxSelectState) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetBoxSelectState(selfArg, internal.ReinterpretCast[C.ImGuiBoxSelectState](vArg))
}

func (self Context) SetCurrentMultiSelect(v *MultiSelectTempData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetCurrentMultiSelect(selfArg, internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](vArg))
}

func (self Context) SetMultiSelectTempDataStacked(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMultiSelectTempDataStacked(selfArg, C.int(v))
}

func (self Context) SetMultiSelectTempData(v vectors.Vector[MultiSelectTempData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiMultiSelectTempData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMultiSelectTempData(selfArg, *vVecArg)
}

func (self Context) SetHoverItemDelayId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoverItemDelayId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetHoverItemDelayIdPreviousFrame(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoverItemDelayIdPreviousFrame(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetHoverItemDelayTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoverItemDelayTimer(selfArg, C.float(v))
}

func (self Context) SetHoverItemDelayClearTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoverItemDelayClearTimer(selfArg, C.float(v))
}

func (self Context) SetHoverItemUnlockedStationaryId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoverItemUnlockedStationaryId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetHoverWindowUnlockedStationaryId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHoverWindowUnlockedStationaryId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetMouseCursor(v MouseCursor) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMouseCursor(selfArg, C.ImGuiMouseCursor(v))
}

func (self Context) SetMouseStationaryTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMouseStationaryTimer(selfArg, C.float(v))
}

func (self Context) SetMouseLastValidPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMouseLastValidPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetInputTextState(v InputTextState) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputTextState(selfArg, internal.ReinterpretCast[C.ImGuiInputTextState](vArg))
}

func (self Context) SetInputTextLineIndex(v TextIndex) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputTextLineIndex(selfArg, internal.ReinterpretCast[C.ImGuiTextIndex](vArg))
}

func (self Context) SetInputTextDeactivatedState(v InputTextDeactivatedState) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputTextDeactivatedState(selfArg, internal.ReinterpretCast[C.ImGuiInputTextDeactivatedState](vArg))
}

func (self Context) SetInputTextPasswordFontBackupBaked(v FontBaked) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputTextPasswordFontBackupBaked(selfArg, internal.ReinterpretCast[C.ImFontBaked](vArg))
}

func (self Context) SetInputTextPasswordFontBackupFlags(v FontFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetInputTextPasswordFontBackupFlags(selfArg, C.ImFontFlags(v))
}

func (self Context) SetTempInputId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTempInputId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDataTypeZeroValue(v DataTypeStorage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDataTypeZeroValue(selfArg, internal.ReinterpretCast[C.ImGuiDataTypeStorage](vArg))
}

func (self Context) SetBeginMenuDepth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetBeginMenuDepth(selfArg, C.int(v))
}

func (self Context) SetBeginComboDepth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetBeginComboDepth(selfArg, C.int(v))
}

func (self Context) SetColorEditOptions(v ColorEditFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorEditOptions(selfArg, C.ImGuiColorEditFlags(v))
}

func (self Context) SetColorEditCurrentID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorEditCurrentID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetColorEditSavedID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorEditSavedID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetColorEditSavedHue(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorEditSavedHue(selfArg, C.float(v))
}

func (self Context) SetColorEditSavedSat(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorEditSavedSat(selfArg, C.float(v))
}

func (self Context) SetColorEditSavedColor(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorEditSavedColor(selfArg, C.ImU32(v))
}

func (self Context) SetColorPickerRef(v Vec4) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetColorPickerRef(selfArg, internal.ReinterpretCast[C.ImVec4](v.ToC()))
}

func (self Context) SetComboPreviewData(v ComboPreviewData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetComboPreviewData(selfArg, internal.ReinterpretCast[C.ImGuiComboPreviewData](vArg))
}

func (self Context) SetWindowResizeBorderExpectedRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWindowResizeBorderExpectedRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Context) SetWindowResizeRelativeMode(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWindowResizeRelativeMode(selfArg, C.bool(v))
}

func (self Context) SetScrollbarSeekMode(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetScrollbarSeekMode(selfArg, C.short(v))
}

func (self Context) SetScrollbarClickDeltaToGrabCenter(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetScrollbarClickDeltaToGrabCenter(selfArg, C.float(v))
}

func (self Context) SetSliderGrabClickOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSliderGrabClickOffset(selfArg, C.float(v))
}

func (self Context) SetSliderCurrentAccum(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSliderCurrentAccum(selfArg, C.float(v))
}

func (self Context) SetSliderCurrentAccumDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSliderCurrentAccumDirty(selfArg, C.bool(v))
}

func (self Context) SetDragCurrentAccumDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragCurrentAccumDirty(selfArg, C.bool(v))
}

func (self Context) SetDragCurrentAccum(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragCurrentAccum(selfArg, C.float(v))
}

func (self Context) SetDragSpeedDefaultRatio(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDragSpeedDefaultRatio(selfArg, C.float(v))
}

func (self Context) SetDisabledAlphaBackup(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDisabledAlphaBackup(selfArg, C.float(v))
}

func (self Context) SetDisabledStackSize(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDisabledStackSize(selfArg, C.short(v))
}

func (self Context) SetTooltipOverrideCount(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTooltipOverrideCount(selfArg, C.short(v))
}

func (self Context) SetTooltipPreviousWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTooltipPreviousWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetClipboardHandlerData(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetClipboardHandlerData(selfArg, *vVecArg)
}

func (self Context) SetMenusIdSubmittedThisFrame(v vectors.Vector[ID]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiID)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiID](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetMenusIdSubmittedThisFrame(selfArg, *vVecArg)
}

func (self Context) SetTypingSelectState(v TypingSelectState) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTypingSelectState(selfArg, internal.ReinterpretCast[C.ImGuiTypingSelectState](vArg))
}

func (self Context) SetPlatformImeData(v PlatformImeData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetPlatformImeData(selfArg, internal.ReinterpretCast[C.ImGuiPlatformImeData](vArg))
}

func (self Context) SetPlatformImeDataPrev(v PlatformImeData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetPlatformImeDataPrev(selfArg, internal.ReinterpretCast[C.ImGuiPlatformImeData](vArg))
}

func (self Context) SetDockContext(v DockContext) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDockContext(selfArg, internal.ReinterpretCast[C.ImGuiDockContext](vArg))
}

func (self Context) SetSettingsLoaded(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSettingsLoaded(selfArg, C.bool(v))
}

func (self Context) SetSettingsDirtyTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSettingsDirtyTimer(selfArg, C.float(v))
}

func (self Context) SetSettingsIniData(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSettingsIniData(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Context) SetSettingsHandlers(v vectors.Vector[SettingsHandler]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiSettingsHandler)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiSettingsHandler](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetSettingsHandlers(selfArg, *vVecArg)
}

func (self Context) SetHooks(v vectors.Vector[ContextHook]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiContextHook)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiContextHook](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHooks(selfArg, *vVecArg)
}

func (self Context) SetHookIdNext(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetHookIdNext(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetLocalizationTable(v *[13]string) {
	vArg := make([]*C.char, len(v))
	for i, vV := range v {
		vVArg, _ := internal.WrapString[C.char](vV)
		vArg[i] = vVArg
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLocalizationTable(selfArg, (**C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = C.GoString(vV)
	}
}

func (self Context) SetLogEnabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogEnabled(selfArg, C.bool(v))
}

func (self Context) SetLogFlags(v LogFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogFlags(selfArg, C.ImGuiLogFlags(v))
}

func (self Context) SetLogWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Context) SetLogBuffer(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogBuffer(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Context) SetLogNextPrefix(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogNextPrefix(selfArg, vArg)
}

func (self Context) SetLogNextSuffix(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogNextSuffix(selfArg, vArg)
}

func (self Context) SetLogLinePosY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogLinePosY(selfArg, C.float(v))
}

func (self Context) SetLogLineFirstItem(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogLineFirstItem(selfArg, C.bool(v))
}

func (self Context) SetLogDepthRef(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogDepthRef(selfArg, C.int(v))
}

func (self Context) SetLogDepthToExpand(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogDepthToExpand(selfArg, C.int(v))
}

func (self Context) SetLogDepthToExpandDefault(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetLogDepthToExpandDefault(selfArg, C.int(v))
}

func (self Context) SetErrorCallback(v ErrorCallback) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetErrorCallback(selfArg, internal.ReinterpretCast[C.ImGuiErrorCallback](vArg))
}

func (self Context) SetErrorCallbackUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetErrorCallbackUserData(selfArg, C.uintptr_t(v))
}

func (self Context) SetErrorTooltipLockedPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetErrorTooltipLockedPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Context) SetErrorFirst(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetErrorFirst(selfArg, C.bool(v))
}

func (self Context) SetErrorCountCurrentFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetErrorCountCurrentFrame(selfArg, C.int(v))
}

func (self Context) SetStackSizesInNewFrame(v ErrorRecoveryState) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetStackSizesInNewFrame(selfArg, internal.ReinterpretCast[C.ImGuiErrorRecoveryState](vArg))
}

func (self Context) SetStackSizesInBeginForCurrentWindow(v *ErrorRecoveryState) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetStackSizesInBeginForCurrentWindow(selfArg, internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](vArg))
}

func (self Context) SetDebugDrawIdConflictsCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugDrawIdConflictsCount(selfArg, C.int(v))
}

func (self Context) SetDebugLogFlags(v DebugLogFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLogFlags(selfArg, C.ImGuiDebugLogFlags(v))
}

func (self Context) SetDebugLogBuf(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLogBuf(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Context) SetDebugLogIndex(v TextIndex) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLogIndex(selfArg, internal.ReinterpretCast[C.ImGuiTextIndex](vArg))
}

func (self Context) SetDebugLogSkippedErrors(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLogSkippedErrors(selfArg, C.int(v))
}

func (self Context) SetDebugLogAutoDisableFlags(v DebugLogFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLogAutoDisableFlags(selfArg, C.ImGuiDebugLogFlags(v))
}

func (self Context) SetDebugLogAutoDisableFrames(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLogAutoDisableFrames(selfArg, C.ImU8(v))
}

func (self Context) SetDebugLocateFrames(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugLocateFrames(selfArg, C.ImU8(v))
}

func (self Context) SetDebugBreakInLocateId(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugBreakInLocateId(selfArg, C.bool(v))
}

func (self Context) SetDebugBreakKeyChord(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugBreakKeyChord(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self Context) SetDebugBeginReturnValueCullDepth(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugBeginReturnValueCullDepth(selfArg, C.ImS8(v))
}

func (self Context) SetDebugItemPickerActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugItemPickerActive(selfArg, C.bool(v))
}

func (self Context) SetDebugItemPickerMouseButton(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugItemPickerMouseButton(selfArg, C.ImU8(v))
}

func (self Context) SetDebugItemPickerBreakId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugItemPickerBreakId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Context) SetDebugFlashStyleColorTime(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugFlashStyleColorTime(selfArg, C.float(v))
}

func (self Context) SetDebugFlashStyleColorBackup(v Vec4) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugFlashStyleColorBackup(selfArg, internal.ReinterpretCast[C.ImVec4](v.ToC()))
}

func (self Context) SetDebugMetricsConfig(v MetricsConfig) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugMetricsConfig(selfArg, internal.ReinterpretCast[C.ImGuiMetricsConfig](vArg))
}

func (self Context) SetDebugIDStackTool(v IDStackTool) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugIDStackTool(selfArg, internal.ReinterpretCast[C.ImGuiIDStackTool](vArg))
}

func (self Context) SetDebugAllocInfo(v DebugAllocInfo) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugAllocInfo(selfArg, internal.ReinterpretCast[C.ImGuiDebugAllocInfo](vArg))
}

func (self Context) SetDebugHoveredDockNode(v *DockNode) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetDebugHoveredDockNode(selfArg, internal.ReinterpretCast[*C.ImGuiDockNode](vArg))
}

func (self Context) SetFramerateSecPerFrame(v *[60]float32) {
	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFramerateSecPerFrame(selfArg, (*C.float)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float32(vV)
	}
}

func (self Context) SetFramerateSecPerFrameIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFramerateSecPerFrameIdx(selfArg, C.int(v))
}

func (self Context) SetFramerateSecPerFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFramerateSecPerFrameCount(selfArg, C.int(v))
}

func (self Context) SetFramerateSecPerFrameAccum(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetFramerateSecPerFrameAccum(selfArg, C.float(v))
}

func (self Context) SetWantCaptureMouseNextFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWantCaptureMouseNextFrame(selfArg, C.int(v))
}

func (self Context) SetWantCaptureKeyboardNextFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWantCaptureKeyboardNextFrame(selfArg, C.int(v))
}

func (self Context) SetWantTextInputNextFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetWantTextInputNextFrame(selfArg, C.int(v))
}

func (self Context) SetTempBuffer(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTempBuffer(selfArg, *vVecArg)
}

func (self Context) SetTempKeychordName(v *[64]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContext_SetTempKeychordName(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self *Context) Initialized() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetInitialized(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) IO() IO {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetIO(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIOFromC(func() *C.ImGuiIO { result := result; return &result }())
}

func (self *Context) PlatformIO() PlatformIO {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetPlatformIO(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewPlatformIOFromC(func() *C.ImGuiPlatformIO { result := result; return &result }())
}

func (self *Context) Style() Style {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetStyle(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStyleFromC(func() *C.ImGuiStyle { result := result; return &result }())
}

func (self *Context) ConfigFlagsCurrFrame() ConfigFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ConfigFlags(C.wrap_ImGuiContext_GetConfigFlagsCurrFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ConfigFlagsLastFrame() ConfigFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ConfigFlags(C.wrap_ImGuiContext_GetConfigFlagsLastFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FontAtlases() vectors.Vector[FontAtlas] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetFontAtlases(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetFontAtlases(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewFontAtlasFromC(C.wrap_ImGuiContext_GetFontAtlases(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) Font() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImGuiContext_GetFont(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FontBaked() *FontBaked {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontBakedFromC(C.wrap_ImGuiContext_GetFontBaked(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FontSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetFontSize(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FontSizeBase() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetFontSizeBase(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FontBakedScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetFontBakedScale(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FontRasterizerDensity() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetFontRasterizerDensity(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) CurrentDpiScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetCurrentDpiScale(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DrawListSharedData() DrawListSharedData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDrawListSharedData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawListSharedDataFromC(func() *C.ImDrawListSharedData { result := result; return &result }())
}

func (self *Context) Time() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImGuiContext_GetTime(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetFrameCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FrameCountEnded() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetFrameCountEnded(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FrameCountPlatformEnded() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetFrameCountPlatformEnded(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FrameCountRendered() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetFrameCountRendered(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WithinEndChildID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetWithinEndChildID(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) WithinFrameScope() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetWithinFrameScope(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) WithinFrameScopeWithImplicitWindow() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetWithinFrameScopeWithImplicitWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) GcCompactAll() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetGcCompactAll(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) TestEngineHookItems() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetTestEngineHookItems(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) TestEngine() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiContext_GetTestEngine(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ContextName() [16]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [16]rune {
		result := [16]rune{}
		resultMirr := C.wrap_ImGuiContext_GetContextName(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Context) InputEventsQueue() vectors.Vector[InputEvent] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetInputEventsQueue(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetInputEventsQueue(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewInputEventFromC(C.wrap_ImGuiContext_GetInputEventsQueue(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) InputEventsTrail() vectors.Vector[InputEvent] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetInputEventsTrail(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetInputEventsTrail(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewInputEventFromC(C.wrap_ImGuiContext_GetInputEventsTrail(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) InputEventsNextMouseSource() MouseSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseSource(C.wrap_ImGuiContext_GetInputEventsNextMouseSource(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) InputEventsNextEventId() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiContext_GetInputEventsNextEventId(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) Windows() vectors.Vector[Window] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetWindows(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetWindows(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewWindowFromC(C.wrap_ImGuiContext_GetWindows(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) WindowsFocusOrder() vectors.Vector[Window] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetWindowsFocusOrder(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetWindowsFocusOrder(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewWindowFromC(C.wrap_ImGuiContext_GetWindowsFocusOrder(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) WindowsTempSortBuffer() vectors.Vector[Window] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetWindowsTempSortBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetWindowsTempSortBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewWindowFromC(C.wrap_ImGuiContext_GetWindowsTempSortBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) CurrentWindowStack() vectors.Vector[WindowStackData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetCurrentWindowStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetCurrentWindowStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewWindowStackDataFromC(C.wrap_ImGuiContext_GetCurrentWindowStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) WindowsById() Storage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetWindowsById(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStorageFromC(func() *C.ImGuiStorage { result := result; return &result }())
}

func (self *Context) WindowsActiveCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetWindowsActiveCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WindowsBorderHoverPadding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetWindowsBorderHoverPadding(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugBreakInWindow() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugBreakInWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) CurrentWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetCurrentWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoveredWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetHoveredWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoveredWindowUnderMovingWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetHoveredWindowUnderMovingWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoveredWindowBeforeClear() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetHoveredWindowBeforeClear(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MovingWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetMovingWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WheelingWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetWheelingWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WheelingWindowRefMousePos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetWheelingWindowRefMousePos(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) WheelingWindowStartFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetWheelingWindowStartFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WheelingWindowScrolledFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetWheelingWindowScrolledFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WheelingWindowReleaseTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetWheelingWindowReleaseTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WheelingWindowWheelRemainder() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetWheelingWindowWheelRemainder(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) WheelingAxisAvg() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetWheelingAxisAvg(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) DebugDrawIdConflictsId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugDrawIdConflictsId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DebugHookIdInfoId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugHookIdInfoId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) HoveredId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHoveredId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) HoveredIdPreviousFrame() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHoveredIdPreviousFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) HoveredIdPreviousFrameItemCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetHoveredIdPreviousFrameItemCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoveredIdTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetHoveredIdTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoveredIdNotActiveTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetHoveredIdNotActiveTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoveredIdAllowOverlap() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetHoveredIdAllowOverlap(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) HoveredIdIsDisabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetHoveredIdIsDisabled(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ItemUnclipByLog() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetItemUnclipByLog(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetActiveId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) ActiveIdIsAlive() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetActiveIdIsAlive(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) ActiveIdTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetActiveIdTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ActiveIdIsJustActivated() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdIsJustActivated(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdAllowOverlap() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdAllowOverlap(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdNoClearOnFocusLoss() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdNoClearOnFocusLoss(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdHasBeenPressedBefore() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdHasBeenPressedBefore(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdHasBeenEditedBefore() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdHasBeenEditedBefore(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdHasBeenEditedThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdHasBeenEditedThisFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdFromShortcut() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdFromShortcut(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ActiveIdDisabledId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetActiveIdDisabledId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) ActiveIdMouseButton() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetActiveIdMouseButton(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ActiveIdClickOffset() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetActiveIdClickOffset(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) ActiveIdWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetActiveIdWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ActiveIdSource() InputSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputSource(C.wrap_ImGuiContext_GetActiveIdSource(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ActiveIdPreviousFrame() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetActiveIdPreviousFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DeactivatedItemData() DeactivatedItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDeactivatedItemData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDeactivatedItemDataFromC(func() *C.ImGuiDeactivatedItemData { result := result; return &result }())
}

func (self *Context) ActiveIdValueOnActivation() DataTypeStorage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetActiveIdValueOnActivation(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDataTypeStorageFromC(func() *C.ImGuiDataTypeStorage { result := result; return &result }())
}

func (self *Context) LastActiveId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetLastActiveId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) LastActiveIdTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetLastActiveIdTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LastKeyModsChangeTime() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImGuiContext_GetLastKeyModsChangeTime(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LastKeyModsChangeFromNoneTime() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImGuiContext_GetLastKeyModsChangeFromNoneTime(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LastKeyboardKeyPressTime() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImGuiContext_GetLastKeyboardKeyPressTime(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) KeysOwnerData() [155]KeyOwnerData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [155]KeyOwnerData {
		result := [155]KeyOwnerData{}
		resultMirr := C.wrap_ImGuiContext_GetKeysOwnerData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		for i := range result {
			result[i] = *NewKeyOwnerDataFromC(func() *C.ImGuiKeyOwnerData {
				result := C.imgui_ImGuiKeyOwnerData_GetAtIdx(resultMirr, C.int(i))
				return &result
			}())
		}

		return result
	}()
}

func (self *Context) KeysRoutingTable() KeyRoutingTable {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetKeysRoutingTable(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyRoutingTableFromC(func() *C.ImGuiKeyRoutingTable { result := result; return &result }())
}

func (self *Context) ActiveIdUsingNavDirMask() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiContext_GetActiveIdUsingNavDirMask(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ActiveIdUsingAllKeyboardKeys() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetActiveIdUsingAllKeyboardKeys(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DebugBreakInShortcutRouting() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugBreakInShortcutRouting(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *Context) CurrentFocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetCurrentFocusScopeId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) CurrentItemFlags() ItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemFlags(C.wrap_ImGuiContext_GetCurrentItemFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugLocateId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugLocateId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NextItemData() NextItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNextItemData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNextItemDataFromC(func() *C.ImGuiNextItemData { result := result; return &result }())
}

func (self *Context) LastItemData() LastItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetLastItemData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewLastItemDataFromC(func() *C.ImGuiLastItemData { result := result; return &result }())
}

func (self *Context) NextWindowData() NextWindowData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNextWindowData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNextWindowDataFromC(func() *C.ImGuiNextWindowData { result := result; return &result }())
}

func (self *Context) DebugShowGroupRects() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDebugShowGroupRects(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DebugFlashStyleColorIdx() Col {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Col(C.wrap_ImGuiContext_GetDebugFlashStyleColorIdx(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ColorStack() vectors.Vector[ColorMod] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetColorStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetColorStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewColorModFromC(C.wrap_ImGuiContext_GetColorStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) StyleVarStack() vectors.Vector[StyleMod] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetStyleVarStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetStyleVarStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewStyleModFromC(C.wrap_ImGuiContext_GetStyleVarStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) FontStack() vectors.Vector[FontStackData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetFontStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetFontStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewFontStackDataFromC(C.wrap_ImGuiContext_GetFontStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) FocusScopeStack() vectors.Vector[FocusScopeData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetFocusScopeStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetFocusScopeStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewFocusScopeDataFromC(C.wrap_ImGuiContext_GetFocusScopeStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) ItemFlagsStack() vectors.Vector[ItemFlags] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetItemFlagsStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetItemFlagsStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, (*ItemFlags)(C.wrap_ImGuiContext_GetItemFlagsStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) GroupStack() vectors.Vector[GroupData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetGroupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetGroupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewGroupDataFromC(C.wrap_ImGuiContext_GetGroupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) OpenPopupStack() vectors.Vector[PopupData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetOpenPopupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetOpenPopupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewPopupDataFromC(C.wrap_ImGuiContext_GetOpenPopupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) BeginPopupStack() vectors.Vector[PopupData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetBeginPopupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetBeginPopupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewPopupDataFromC(C.wrap_ImGuiContext_GetBeginPopupStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) TreeNodeStack() vectors.Vector[TreeNodeStackData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetTreeNodeStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetTreeNodeStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewTreeNodeStackDataFromC(C.wrap_ImGuiContext_GetTreeNodeStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) Viewports() vectors.Vector[ViewportP] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetViewports(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetViewports(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewViewportPFromC(C.wrap_ImGuiContext_GetViewports(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) CurrentViewport() *ViewportP {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewViewportPFromC(C.wrap_ImGuiContext_GetCurrentViewport(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MouseViewport() *ViewportP {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewViewportPFromC(C.wrap_ImGuiContext_GetMouseViewport(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MouseLastHoveredViewport() *ViewportP {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewViewportPFromC(C.wrap_ImGuiContext_GetMouseLastHoveredViewport(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) PlatformLastFocusedViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetPlatformLastFocusedViewportId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) FallbackMonitor() PlatformMonitor {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetFallbackMonitor(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewPlatformMonitorFromC(func() *C.ImGuiPlatformMonitor { result := result; return &result }())
}

func (self *Context) PlatformMonitorsFullWorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiContext_GetPlatformMonitorsFullWorkRect(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) ViewportCreatedCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetViewportCreatedCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) PlatformWindowsCreatedCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetPlatformWindowsCreatedCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ViewportFocusedStampCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetViewportFocusedStampCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavCursorVisible() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavCursorVisible(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavHighlightItemUnderNav() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavHighlightItemUnderNav(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavMousePosDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavMousePosDirty(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavIdIsAlive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavIdIsAlive(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetNavWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavFocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavFocusScopeId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavLayer() NavLayer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NavLayer(C.wrap_ImGuiContext_GetNavLayer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavActivateId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavActivateId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavActivateDownId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavActivateDownId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavActivatePressedId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavActivatePressedId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavActivateFlags() ActivateFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ActivateFlags(C.wrap_ImGuiContext_GetNavActivateFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavFocusRoute() vectors.Vector[FocusScopeData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetNavFocusRoute(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetNavFocusRoute(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewFocusScopeDataFromC(C.wrap_ImGuiContext_GetNavFocusRoute(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) NavHighlightActivatedId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavHighlightActivatedId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavHighlightActivatedTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetNavHighlightActivatedTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavNextActivateId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavNextActivateId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavNextActivateFlags() ActivateFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ActivateFlags(C.wrap_ImGuiContext_GetNavNextActivateFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavInputSource() InputSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputSource(C.wrap_ImGuiContext_GetNavInputSource(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavLastValidSelectionUserData() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavLastValidSelectionUserData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *Context) NavCursorHideFrames() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiContext_GetNavCursorHideFrames(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavAnyRequest() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavAnyRequest(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavInitRequest() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavInitRequest(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavInitRequestFromMove() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavInitRequestFromMove(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavInitResult() NavItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavInitResult(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNavItemDataFromC(func() *C.ImGuiNavItemData { result := result; return &result }())
}

func (self *Context) NavMoveSubmitted() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavMoveSubmitted(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavMoveScoringItems() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavMoveScoringItems(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavMoveForwardToNextFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavMoveForwardToNextFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavMoveFlags() NavMoveFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NavMoveFlags(C.wrap_ImGuiContext_GetNavMoveFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavMoveScrollFlags() ScrollFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ScrollFlags(C.wrap_ImGuiContext_GetNavMoveScrollFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavMoveKeyMods() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavMoveKeyMods(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *Context) NavMoveDir() Dir {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Dir(C.wrap_ImGuiContext_GetNavMoveDir(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavMoveDirForDebug() Dir {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Dir(C.wrap_ImGuiContext_GetNavMoveDirForDebug(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavMoveClipDir() Dir {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Dir(C.wrap_ImGuiContext_GetNavMoveClipDir(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavScoringRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiContext_GetNavScoringRect(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) NavScoringNoClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiContext_GetNavScoringNoClipRect(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) NavScoringDebugCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetNavScoringDebugCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavTabbingDir() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetNavTabbingDir(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavTabbingCounter() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetNavTabbingCounter(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavMoveResultLocal() NavItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavMoveResultLocal(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNavItemDataFromC(func() *C.ImGuiNavItemData { result := result; return &result }())
}

func (self *Context) NavMoveResultLocalVisible() NavItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavMoveResultLocalVisible(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNavItemDataFromC(func() *C.ImGuiNavItemData { result := result; return &result }())
}

func (self *Context) NavMoveResultOther() NavItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavMoveResultOther(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNavItemDataFromC(func() *C.ImGuiNavItemData { result := result; return &result }())
}

func (self *Context) NavTabbingResultFirst() NavItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavTabbingResultFirst(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNavItemDataFromC(func() *C.ImGuiNavItemData { result := result; return &result }())
}

func (self *Context) NavJustMovedFromFocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavJustMovedFromFocusScopeId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavJustMovedToId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavJustMovedToId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavJustMovedToFocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavJustMovedToFocusScopeId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) NavJustMovedToKeyMods() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetNavJustMovedToKeyMods(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *Context) NavJustMovedToIsTabbing() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavJustMovedToIsTabbing(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavJustMovedToHasSelectionData() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavJustMovedToHasSelectionData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ConfigNavWindowingWithGamepad() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetConfigNavWindowingWithGamepad(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ConfigNavWindowingKeyNext() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetConfigNavWindowingKeyNext(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *Context) ConfigNavWindowingKeyPrev() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetConfigNavWindowingKeyPrev(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *Context) NavWindowingTarget() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetNavWindowingTarget(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingTargetAnim() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetNavWindowingTargetAnim(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingListWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetNavWindowingListWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetNavWindowingTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingHighlightAlpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetNavWindowingHighlightAlpha(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingInputSource() InputSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputSource(C.wrap_ImGuiContext_GetNavWindowingInputSource(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingToggleLayer() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetNavWindowingToggleLayer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) NavWindowingToggleKey() Key {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Key(C.wrap_ImGuiContext_GetNavWindowingToggleKey(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) NavWindowingAccumDeltaPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetNavWindowingAccumDeltaPos(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) NavWindowingAccumDeltaSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetNavWindowingAccumDeltaSize(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) DimBgRatio() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetDimBgRatio(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDragDropActive(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DragDropWithinSource() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDragDropWithinSource(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DragDropWithinTarget() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDragDropWithinTarget(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DragDropSourceFlags() DragDropFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DragDropFlags(C.wrap_ImGuiContext_GetDragDropSourceFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropSourceFrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetDragDropSourceFrameCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropMouseButton() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetDragDropMouseButton(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropPayload() Payload {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDragDropPayload(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewPayloadFromC(func() *C.ImGuiPayload { result := result; return &result }())
}

func (self *Context) DragDropTargetRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiContext_GetDragDropTargetRect(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) DragDropTargetClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiContext_GetDragDropTargetClipRect(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) DragDropTargetId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDragDropTargetId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DragDropAcceptFlags() DragDropFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DragDropFlags(C.wrap_ImGuiContext_GetDragDropAcceptFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropAcceptIdCurrRectSurface() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetDragDropAcceptIdCurrRectSurface(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropAcceptIdCurr() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDragDropAcceptIdCurr(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DragDropAcceptIdPrev() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDragDropAcceptIdPrev(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DragDropAcceptFrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetDragDropAcceptFrameCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragDropHoldJustPressedId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDragDropHoldJustPressedId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DragDropPayloadBufLocal() [16]uint {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [16]uint {
		result := [16]uint{}
		resultMirr := C.wrap_ImGuiContext_GetDragDropPayloadBufLocal(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		for i := range result {
			result[i] = uint(C.imgui_unsigned_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Context) ClipperTempDataStacked() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetClipperTempDataStacked(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ClipperTempData() vectors.Vector[ListClipperData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetClipperTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetClipperTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewListClipperDataFromC(C.wrap_ImGuiContext_GetClipperTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) CurrentTable() *Table {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTableFromC(C.wrap_ImGuiContext_GetCurrentTable(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugBreakInTable() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugBreakInTable(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) TablesTempDataStacked() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetTablesTempDataStacked(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) TablesTempData() vectors.Vector[TableTempData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetTablesTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetTablesTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewTableTempDataFromC(C.wrap_ImGuiContext_GetTablesTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) TablesLastTimeActive() vectors.Vector[float32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetTablesLastTimeActive(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetTablesLastTimeActive(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, (*float32)(C.wrap_ImGuiContext_GetTablesLastTimeActive(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) DrawChannelsTempMergeBuffer() vectors.Vector[DrawChannel] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetDrawChannelsTempMergeBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetDrawChannelsTempMergeBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewDrawChannelFromC(C.wrap_ImGuiContext_GetDrawChannelsTempMergeBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) CurrentTabBar() *TabBar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTabBarFromC(C.wrap_ImGuiContext_GetCurrentTabBar(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) CurrentTabBarStack() vectors.Vector[PtrOrIndex] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetCurrentTabBarStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetCurrentTabBarStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewPtrOrIndexFromC(C.wrap_ImGuiContext_GetCurrentTabBarStack(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) ShrinkWidthBuffer() vectors.Vector[ShrinkWidthItem] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetShrinkWidthBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetShrinkWidthBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewShrinkWidthItemFromC(C.wrap_ImGuiContext_GetShrinkWidthBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) BoxSelectState() BoxSelectState {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetBoxSelectState(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewBoxSelectStateFromC(func() *C.ImGuiBoxSelectState { result := result; return &result }())
}

func (self *Context) CurrentMultiSelect() *MultiSelectTempData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewMultiSelectTempDataFromC(C.wrap_ImGuiContext_GetCurrentMultiSelect(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MultiSelectTempDataStacked() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetMultiSelectTempDataStacked(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MultiSelectTempData() vectors.Vector[MultiSelectTempData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetMultiSelectTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetMultiSelectTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewMultiSelectTempDataFromC(C.wrap_ImGuiContext_GetMultiSelectTempData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) HoverItemDelayId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHoverItemDelayId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) HoverItemDelayIdPreviousFrame() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHoverItemDelayIdPreviousFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) HoverItemDelayTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetHoverItemDelayTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoverItemDelayClearTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetHoverItemDelayClearTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) HoverItemUnlockedStationaryId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHoverItemUnlockedStationaryId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) HoverWindowUnlockedStationaryId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHoverWindowUnlockedStationaryId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) MouseCursor() MouseCursor {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseCursor(C.wrap_ImGuiContext_GetMouseCursor(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MouseStationaryTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetMouseStationaryTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) MouseLastValidPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetMouseLastValidPos(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) InputTextState() InputTextState {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetInputTextState(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewInputTextStateFromC(func() *C.ImGuiInputTextState { result := result; return &result }())
}

func (self *Context) InputTextLineIndex() TextIndex {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetInputTextLineIndex(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextIndexFromC(func() *C.ImGuiTextIndex { result := result; return &result }())
}

func (self *Context) InputTextDeactivatedState() InputTextDeactivatedState {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetInputTextDeactivatedState(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewInputTextDeactivatedStateFromC(func() *C.ImGuiInputTextDeactivatedState { result := result; return &result }())
}

func (self *Context) InputTextPasswordFontBackupBaked() FontBaked {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetInputTextPasswordFontBackupBaked(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewFontBakedFromC(func() *C.ImFontBaked { result := result; return &result }())
}

func (self *Context) InputTextPasswordFontBackupFlags() FontFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return FontFlags(C.wrap_ImGuiContext_GetInputTextPasswordFontBackupFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) TempInputId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetTempInputId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DataTypeZeroValue() DataTypeStorage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDataTypeZeroValue(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDataTypeStorageFromC(func() *C.ImGuiDataTypeStorage { result := result; return &result }())
}

func (self *Context) BeginMenuDepth() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetBeginMenuDepth(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) BeginComboDepth() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetBeginComboDepth(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ColorEditOptions() ColorEditFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ColorEditFlags(C.wrap_ImGuiContext_GetColorEditOptions(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ColorEditCurrentID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetColorEditCurrentID(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) ColorEditSavedID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetColorEditSavedID(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) ColorEditSavedHue() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetColorEditSavedHue(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ColorEditSavedSat() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetColorEditSavedSat(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ColorEditSavedColor() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiContext_GetColorEditSavedColor(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ColorPickerRef() Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImGuiContext_GetColorPickerRef(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) ComboPreviewData() ComboPreviewData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetComboPreviewData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewComboPreviewDataFromC(func() *C.ImGuiComboPreviewData { result := result; return &result }())
}

func (self *Context) WindowResizeBorderExpectedRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiContext_GetWindowResizeBorderExpectedRect(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) WindowResizeRelativeMode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetWindowResizeRelativeMode(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ScrollbarSeekMode() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiContext_GetScrollbarSeekMode(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ScrollbarClickDeltaToGrabCenter() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetScrollbarClickDeltaToGrabCenter(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) SliderGrabClickOffset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetSliderGrabClickOffset(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) SliderCurrentAccum() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetSliderCurrentAccum(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) SliderCurrentAccumDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetSliderCurrentAccumDirty(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DragCurrentAccumDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDragCurrentAccumDirty(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DragCurrentAccum() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetDragCurrentAccum(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DragSpeedDefaultRatio() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetDragSpeedDefaultRatio(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DisabledAlphaBackup() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetDisabledAlphaBackup(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DisabledStackSize() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiContext_GetDisabledStackSize(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) TooltipOverrideCount() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiContext_GetTooltipOverrideCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) TooltipPreviousWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetTooltipPreviousWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ClipboardHandlerData() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetClipboardHandlerData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetClipboardHandlerData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, (*int8)(C.wrap_ImGuiContext_GetClipboardHandlerData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) MenusIdSubmittedThisFrame() vectors.Vector[ID] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetMenusIdSubmittedThisFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetMenusIdSubmittedThisFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewIDFromC(C.wrap_ImGuiContext_GetMenusIdSubmittedThisFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) TypingSelectState() TypingSelectState {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetTypingSelectState(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTypingSelectStateFromC(func() *C.ImGuiTypingSelectState { result := result; return &result }())
}

func (self *Context) PlatformImeData() PlatformImeData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetPlatformImeData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewPlatformImeDataFromC(func() *C.ImGuiPlatformImeData { result := result; return &result }())
}

func (self *Context) PlatformImeDataPrev() PlatformImeData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetPlatformImeDataPrev(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewPlatformImeDataFromC(func() *C.ImGuiPlatformImeData { result := result; return &result }())
}

func (self *Context) UserTextures() vectors.Vector[TextureData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetUserTextures(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetUserTextures(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewTextureDataFromC(C.wrap_ImGuiContext_GetUserTextures(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) DockContext() DockContext {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDockContext(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDockContextFromC(func() *C.ImGuiDockContext { result := result; return &result }())
}

func (self *Context) SettingsLoaded() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetSettingsLoaded(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) SettingsDirtyTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetSettingsDirtyTimer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) SettingsIniData() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetSettingsIniData(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self *Context) SettingsHandlers() vectors.Vector[SettingsHandler] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetSettingsHandlers(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetSettingsHandlers(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewSettingsHandlerFromC(C.wrap_ImGuiContext_GetSettingsHandlers(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) Hooks() vectors.Vector[ContextHook] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetHooks(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetHooks(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, NewContextHookFromC(C.wrap_ImGuiContext_GetHooks(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) HookIdNext() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetHookIdNext(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) LocalizationTable() [13]string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [13]string {
		result := [13]string{}
		resultMirr := C.wrap_ImGuiContext_GetLocalizationTable(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		for i := range result {
			result[i] = C.GoString(C.imgui_const_charPtr_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Context) LogEnabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetLogEnabled(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) LogFlags() LogFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LogFlags(C.wrap_ImGuiContext_GetLogFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiContext_GetLogWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogBuffer() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetLogBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self *Context) LogNextPrefix() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiContext_GetLogNextPrefix(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogNextSuffix() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiContext_GetLogNextSuffix(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogLinePosY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetLogLinePosY(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogLineFirstItem() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetLogLineFirstItem(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) LogDepthRef() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetLogDepthRef(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogDepthToExpand() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetLogDepthToExpand(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) LogDepthToExpandDefault() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetLogDepthToExpandDefault(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ErrorCallback() ErrorCallback {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetErrorCallback(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewErrorCallbackFromC(func() *C.ImGuiErrorCallback { result := result; return &result }())
}

func (self *Context) ErrorCallbackUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiContext_GetErrorCallbackUserData(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) ErrorTooltipLockedPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiContext_GetErrorTooltipLockedPos(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) ErrorFirst() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetErrorFirst(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) ErrorCountCurrentFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetErrorCountCurrentFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) StackSizesInNewFrame() ErrorRecoveryState {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetStackSizesInNewFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewErrorRecoveryStateFromC(func() *C.ImGuiErrorRecoveryState { result := result; return &result }())
}

func (self *Context) StackSizesInBeginForCurrentWindow() *ErrorRecoveryState {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewErrorRecoveryStateFromC(C.wrap_ImGuiContext_GetStackSizesInBeginForCurrentWindow(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugDrawIdConflictsCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetDebugDrawIdConflictsCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugLogFlags() DebugLogFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DebugLogFlags(C.wrap_ImGuiContext_GetDebugLogFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugLogBuf() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugLogBuf(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self *Context) DebugLogIndex() TextIndex {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugLogIndex(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextIndexFromC(func() *C.ImGuiTextIndex { result := result; return &result }())
}

func (self *Context) DebugLogSkippedErrors() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetDebugLogSkippedErrors(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugLogAutoDisableFlags() DebugLogFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DebugLogFlags(C.wrap_ImGuiContext_GetDebugLogAutoDisableFlags(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugLogAutoDisableFrames() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiContext_GetDebugLogAutoDisableFrames(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugLocateFrames() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiContext_GetDebugLocateFrames(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugBreakInLocateId() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDebugBreakInLocateId(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DebugBreakKeyChord() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugBreakKeyChord(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *Context) DebugBeginReturnValueCullDepth() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiContext_GetDebugBeginReturnValueCullDepth(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugItemPickerActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiContext_GetDebugItemPickerActive(internal.ReinterpretCast[*C.ImGuiContext](selfArg)) == C.bool(true)
}

func (self *Context) DebugItemPickerMouseButton() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiContext_GetDebugItemPickerMouseButton(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugItemPickerBreakId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugItemPickerBreakId(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Context) DebugFlashStyleColorTime() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetDebugFlashStyleColorTime(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) DebugFlashStyleColorBackup() Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec4 {
		out := C.wrap_ImGuiContext_GetDebugFlashStyleColorBackup(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		return *(&Vec4{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) DebugMetricsConfig() MetricsConfig {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugMetricsConfig(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewMetricsConfigFromC(func() *C.ImGuiMetricsConfig { result := result; return &result }())
}

func (self *Context) DebugIDStackTool() IDStackTool {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugIDStackTool(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDStackToolFromC(func() *C.ImGuiIDStackTool { result := result; return &result }())
}

func (self *Context) DebugAllocInfo() DebugAllocInfo {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContext_GetDebugAllocInfo(internal.ReinterpretCast[*C.ImGuiContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDebugAllocInfoFromC(func() *C.ImGuiDebugAllocInfo { result := result; return &result }())
}

func (self *Context) DebugHoveredDockNode() *DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDockNodeFromC(C.wrap_ImGuiContext_GetDebugHoveredDockNode(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FramerateSecPerFrame() [60]float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [60]float32 {
		result := [60]float32{}
		resultMirr := C.wrap_ImGuiContext_GetFramerateSecPerFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		for i := range result {
			result[i] = float32(C.imgui_float_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Context) FramerateSecPerFrameIdx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetFramerateSecPerFrameIdx(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FramerateSecPerFrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetFramerateSecPerFrameCount(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) FramerateSecPerFrameAccum() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiContext_GetFramerateSecPerFrameAccum(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WantCaptureMouseNextFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetWantCaptureMouseNextFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WantCaptureKeyboardNextFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetWantCaptureKeyboardNextFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) WantTextInputNextFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiContext_GetWantTextInputNextFrame(internal.ReinterpretCast[*C.ImGuiContext](selfArg)))
}

func (self *Context) TempBuffer() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiContext_GetTempBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Size, C.wrap_ImGuiContext_GetTempBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Capacity, (*int8)(C.wrap_ImGuiContext_GetTempBuffer(internal.ReinterpretCast[*C.ImGuiContext](selfArg)).Data))
}

func (self *Context) TempKeychordName() [64]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [64]rune {
		result := [64]rune{}
		resultMirr := C.wrap_ImGuiContext_GetTempKeychordName(internal.ReinterpretCast[*C.ImGuiContext](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self ContextHook) SetHookId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContextHook_SetHookId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self ContextHook) SetType(v ContextHookType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContextHook_SetType(selfArg, C.ImGuiContextHookType(v))
}

func (self ContextHook) SetOwner(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContextHook_SetOwner(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self ContextHook) SetCallback(v ContextHookCallback) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContextHook_SetCallback(selfArg, internal.ReinterpretCast[C.ImGuiContextHookCallback](vArg))
}

func (self ContextHook) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiContextHook_SetUserData(selfArg, C.uintptr_t(v))
}

func (self *ContextHook) HookId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContextHook_GetHookId(internal.ReinterpretCast[*C.ImGuiContextHook](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *ContextHook) Type() ContextHookType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ContextHookType(C.wrap_ImGuiContextHook_GetType(internal.ReinterpretCast[*C.ImGuiContextHook](selfArg)))
}

func (self *ContextHook) Owner() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContextHook_GetOwner(internal.ReinterpretCast[*C.ImGuiContextHook](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *ContextHook) Callback() ContextHookCallback {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiContextHook_GetCallback(internal.ReinterpretCast[*C.ImGuiContextHook](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewContextHookCallbackFromC(func() *C.ImGuiContextHookCallback { result := result; return &result }())
}

func (self *ContextHook) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiContextHook_GetUserData(internal.ReinterpretCast[*C.ImGuiContextHook](selfArg)))
}

func (self DataTypeInfo) SetSize(v uint64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDataTypeInfo_SetSize(selfArg, C.xulong(v))
}

func (self DataTypeInfo) SetName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDataTypeInfo_SetName(selfArg, vArg)
}

func (self DataTypeInfo) SetPrintFmt(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDataTypeInfo_SetPrintFmt(selfArg, vArg)
}

func (self DataTypeInfo) SetScanFmt(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDataTypeInfo_SetScanFmt(selfArg, vArg)
}

func (self *DataTypeInfo) Size() uint64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint64(C.wrap_ImGuiDataTypeInfo_GetSize(internal.ReinterpretCast[*C.ImGuiDataTypeInfo](selfArg)))
}

func (self *DataTypeInfo) Name() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiDataTypeInfo_GetName(internal.ReinterpretCast[*C.ImGuiDataTypeInfo](selfArg)))
}

func (self *DataTypeInfo) PrintFmt() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiDataTypeInfo_GetPrintFmt(internal.ReinterpretCast[*C.ImGuiDataTypeInfo](selfArg)))
}

func (self *DataTypeInfo) ScanFmt() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiDataTypeInfo_GetScanFmt(internal.ReinterpretCast[*C.ImGuiDataTypeInfo](selfArg)))
}

func (self DataTypeStorage) SetData(v *[8]byte) {
	vArg := make([]C.ImU8, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU8(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDataTypeStorage_SetData(selfArg, (*C.ImU8)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (byte)(vV)
	}
}

func (self *DataTypeStorage) Data() [8](byte) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [8](byte) {
		result := [8](byte){}
		resultMirr := C.wrap_ImGuiDataTypeStorage_GetData(internal.ReinterpretCast[*C.ImGuiDataTypeStorage](selfArg))
		for i := range result {
			result[i] = (byte)(C.imgui_ImU8_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self DeactivatedItemData) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDeactivatedItemData_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self DeactivatedItemData) SetElapseFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDeactivatedItemData_SetElapseFrame(selfArg, C.int(v))
}

func (self DeactivatedItemData) SetHasBeenEditedBefore(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDeactivatedItemData_SetHasBeenEditedBefore(selfArg, C.bool(v))
}

func (self DeactivatedItemData) SetIsAlive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDeactivatedItemData_SetIsAlive(selfArg, C.bool(v))
}

func (self *DeactivatedItemData) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDeactivatedItemData_GetID(internal.ReinterpretCast[*C.ImGuiDeactivatedItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *DeactivatedItemData) ElapseFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDeactivatedItemData_GetElapseFrame(internal.ReinterpretCast[*C.ImGuiDeactivatedItemData](selfArg)))
}

func (self *DeactivatedItemData) HasBeenEditedBefore() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDeactivatedItemData_GetHasBeenEditedBefore(internal.ReinterpretCast[*C.ImGuiDeactivatedItemData](selfArg)) == C.bool(true)
}

func (self *DeactivatedItemData) IsAlive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDeactivatedItemData_GetIsAlive(internal.ReinterpretCast[*C.ImGuiDeactivatedItemData](selfArg)) == C.bool(true)
}

func (self DebugAllocEntry) SetFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocEntry_SetFrameCount(selfArg, C.int(v))
}

func (self DebugAllocEntry) SetAllocCount(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocEntry_SetAllocCount(selfArg, C.ImS16(v))
}

func (self DebugAllocEntry) SetFreeCount(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocEntry_SetFreeCount(selfArg, C.ImS16(v))
}

func (self *DebugAllocEntry) FrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDebugAllocEntry_GetFrameCount(internal.ReinterpretCast[*C.ImGuiDebugAllocEntry](selfArg)))
}

func (self *DebugAllocEntry) AllocCount() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiDebugAllocEntry_GetAllocCount(internal.ReinterpretCast[*C.ImGuiDebugAllocEntry](selfArg)))
}

func (self *DebugAllocEntry) FreeCount() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiDebugAllocEntry_GetFreeCount(internal.ReinterpretCast[*C.ImGuiDebugAllocEntry](selfArg)))
}

func (self DebugAllocInfo) SetTotalAllocCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocInfo_SetTotalAllocCount(selfArg, C.int(v))
}

func (self DebugAllocInfo) SetTotalFreeCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocInfo_SetTotalFreeCount(selfArg, C.int(v))
}

func (self DebugAllocInfo) SetLastEntriesIdx(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocInfo_SetLastEntriesIdx(selfArg, C.ImS16(v))
}

func (self DebugAllocInfo) SetLastEntriesBuf(v *[6]DebugAllocEntry) {
	vArg := make([]C.ImGuiDebugAllocEntry, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImGuiDebugAllocEntry](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDebugAllocInfo_SetLastEntriesBuf(selfArg, (*C.ImGuiDebugAllocEntry)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewDebugAllocEntryFromC(func() *C.ImGuiDebugAllocEntry { result := vV; return &result }())
	}
}

func (self *DebugAllocInfo) TotalAllocCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDebugAllocInfo_GetTotalAllocCount(internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](selfArg)))
}

func (self *DebugAllocInfo) TotalFreeCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDebugAllocInfo_GetTotalFreeCount(internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](selfArg)))
}

func (self *DebugAllocInfo) LastEntriesIdx() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiDebugAllocInfo_GetLastEntriesIdx(internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](selfArg)))
}

func (self *DebugAllocInfo) LastEntriesBuf() [6]DebugAllocEntry {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]DebugAllocEntry {
		result := [6]DebugAllocEntry{}
		resultMirr := C.wrap_ImGuiDebugAllocInfo_GetLastEntriesBuf(internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](selfArg))
		for i := range result {
			result[i] = *NewDebugAllocEntryFromC(func() *C.ImGuiDebugAllocEntry {
				result := C.imgui_ImGuiDebugAllocEntry_GetAtIdx(resultMirr, C.int(i))
				return &result
			}())
		}

		return result
	}()
}

func (self DockContext) SetNodes(v Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockContext_SetNodes(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self DockContext) SetRequests(v vectors.Vector[DockRequest]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiDockRequest)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiDockRequest](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockContext_SetRequests(selfArg, *vVecArg)
}

func (self DockContext) SetNodesSettings(v vectors.Vector[DockNodeSettings]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiDockNodeSettings)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiDockNodeSettings](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockContext_SetNodesSettings(selfArg, *vVecArg)
}

func (self DockContext) SetWantFullRebuild(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockContext_SetWantFullRebuild(selfArg, C.bool(v))
}

func (self *DockContext) Nodes() Storage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockContext_GetNodes(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStorageFromC(func() *C.ImGuiStorage { result := result; return &result }())
}

func (self *DockContext) Requests() vectors.Vector[DockRequest] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiDockContext_GetRequests(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)).Size, C.wrap_ImGuiDockContext_GetRequests(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)).Capacity, NewDockRequestFromC(C.wrap_ImGuiDockContext_GetRequests(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)).Data))
}

func (self *DockContext) NodesSettings() vectors.Vector[DockNodeSettings] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiDockContext_GetNodesSettings(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)).Size, C.wrap_ImGuiDockContext_GetNodesSettings(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)).Capacity, NewDockNodeSettingsFromC(C.wrap_ImGuiDockContext_GetNodesSettings(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)).Data))
}

func (self *DockContext) WantFullRebuild() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockContext_GetWantFullRebuild(internal.ReinterpretCast[*C.ImGuiDockContext](selfArg)) == C.bool(true)
}

func (self DockNode) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self DockNode) SetSharedFlags(v DockNodeFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetSharedFlags(selfArg, C.ImGuiDockNodeFlags(v))
}

func (self DockNode) SetLocalFlagsInWindows(v DockNodeFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetLocalFlagsInWindows(selfArg, C.ImGuiDockNodeFlags(v))
}

func (self DockNode) SetMergedFlags(v DockNodeFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetMergedFlags(selfArg, C.ImGuiDockNodeFlags(v))
}

func (self DockNode) SetState(v DockNodeState) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetState(selfArg, C.ImGuiDockNodeState(v))
}

func (self DockNode) SetParentNode(v *DockNode) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetParentNode(selfArg, internal.ReinterpretCast[*C.ImGuiDockNode](vArg))
}

func (self DockNode) SetChildNodes(v *[2]*DockNode) {
	vArg := make([]*C.ImGuiDockNode, len(v))
	for i, vV := range v {
		vVArg, _ := vV.Handle()
		vArg[i] = internal.ReinterpretCast[*C.ImGuiDockNode](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetChildNodes(selfArg, (**C.ImGuiDockNode)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = NewDockNodeFromC(vV)
	}
}

func (self DockNode) SetTabBar(v *TabBar) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetTabBar(selfArg, internal.ReinterpretCast[*C.ImGuiTabBar](vArg))
}

func (self DockNode) SetPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DockNode) SetSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DockNode) SetSizeRef(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetSizeRef(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self DockNode) SetSplitAxis(v Axis) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetSplitAxis(selfArg, C.ImGuiAxis(v))
}

func (self DockNode) SetWindowClass(v WindowClass) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWindowClass(selfArg, internal.ReinterpretCast[C.ImGuiWindowClass](vArg))
}

func (self DockNode) SetLastBgColor(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetLastBgColor(selfArg, C.ImU32(v))
}

func (self DockNode) SetHostWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetHostWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self DockNode) SetVisibleWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetVisibleWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self DockNode) SetCentralNode(v *DockNode) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetCentralNode(selfArg, internal.ReinterpretCast[*C.ImGuiDockNode](vArg))
}

func (self DockNode) SetOnlyNodeWithWindows(v *DockNode) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetOnlyNodeWithWindows(selfArg, internal.ReinterpretCast[*C.ImGuiDockNode](vArg))
}

func (self DockNode) SetCountNodeWithWindows(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetCountNodeWithWindows(selfArg, C.int(v))
}

func (self DockNode) SetLastFrameAlive(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetLastFrameAlive(selfArg, C.int(v))
}

func (self DockNode) SetLastFrameActive(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetLastFrameActive(selfArg, C.int(v))
}

func (self DockNode) SetLastFrameFocused(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetLastFrameFocused(selfArg, C.int(v))
}

func (self DockNode) SetLastFocusedNodeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetLastFocusedNodeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self DockNode) SetSelectedTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetSelectedTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self DockNode) SetWantCloseTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWantCloseTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self DockNode) SetRefViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetRefViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self DockNode) SetAuthorityForPos(v DataAuthority) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetAuthorityForPos(selfArg, C.ImGuiDataAuthority(v))
}

func (self DockNode) SetAuthorityForSize(v DataAuthority) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetAuthorityForSize(selfArg, C.ImGuiDataAuthority(v))
}

func (self DockNode) SetAuthorityForViewport(v DataAuthority) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetAuthorityForViewport(selfArg, C.ImGuiDataAuthority(v))
}

func (self DockNode) SetIsVisible(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetIsVisible(selfArg, C.bool(v))
}

func (self DockNode) SetIsFocused(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetIsFocused(selfArg, C.bool(v))
}

func (self DockNode) SetIsBgDrawnThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetIsBgDrawnThisFrame(selfArg, C.bool(v))
}

func (self DockNode) SetHasCloseButton(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetHasCloseButton(selfArg, C.bool(v))
}

func (self DockNode) SetHasWindowMenuButton(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetHasWindowMenuButton(selfArg, C.bool(v))
}

func (self DockNode) SetHasCentralNodeChild(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetHasCentralNodeChild(selfArg, C.bool(v))
}

func (self DockNode) SetWantCloseAll(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWantCloseAll(selfArg, C.bool(v))
}

func (self DockNode) SetWantLockSizeOnce(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWantLockSizeOnce(selfArg, C.bool(v))
}

func (self DockNode) SetWantMouseMove(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWantMouseMove(selfArg, C.bool(v))
}

func (self DockNode) SetWantHiddenTabBarUpdate(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWantHiddenTabBarUpdate(selfArg, C.bool(v))
}

func (self DockNode) SetWantHiddenTabBarToggle(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiDockNode_SetWantHiddenTabBarToggle(selfArg, C.bool(v))
}

func (self *DockNode) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockNode_GetID(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *DockNode) SharedFlags() DockNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DockNodeFlags(C.wrap_ImGuiDockNode_GetSharedFlags(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) LocalFlags() DockNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DockNodeFlags(C.wrap_ImGuiDockNode_GetLocalFlags(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) LocalFlagsInWindows() DockNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DockNodeFlags(C.wrap_ImGuiDockNode_GetLocalFlagsInWindows(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) MergedFlags() DockNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DockNodeFlags(C.wrap_ImGuiDockNode_GetMergedFlags(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) State() DockNodeState {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DockNodeState(C.wrap_ImGuiDockNode_GetState(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) ParentNode() *DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDockNodeFromC(C.wrap_ImGuiDockNode_GetParentNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) ChildNodes() [2]*DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]*DockNode {
		result := [2]*DockNode{}
		resultMirr := C.wrap_ImGuiDockNode_GetChildNodes(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))
		for i := range result {
			result[i] = NewDockNodeFromC(C.imgui_ImGuiDockNodePtr_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *DockNode) Windows() vectors.Vector[Window] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiDockNode_GetWindows(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)).Size, C.wrap_ImGuiDockNode_GetWindows(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)).Capacity, NewWindowFromC(C.wrap_ImGuiDockNode_GetWindows(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)).Data))
}

func (self *DockNode) TabBar() *TabBar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTabBarFromC(C.wrap_ImGuiDockNode_GetTabBar(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) Pos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiDockNode_GetPos(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DockNode) Size() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiDockNode_GetSize(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DockNode) SizeRef() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiDockNode_GetSizeRef(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *DockNode) SplitAxis() Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Axis(C.wrap_ImGuiDockNode_GetSplitAxis(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) WindowClass() WindowClass {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockNode_GetWindowClass(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewWindowClassFromC(func() *C.ImGuiWindowClass { result := result; return &result }())
}

func (self *DockNode) LastBgColor() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiDockNode_GetLastBgColor(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) HostWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiDockNode_GetHostWindow(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) VisibleWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiDockNode_GetVisibleWindow(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) CentralNode() *DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDockNodeFromC(C.wrap_ImGuiDockNode_GetCentralNode(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) OnlyNodeWithWindows() *DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDockNodeFromC(C.wrap_ImGuiDockNode_GetOnlyNodeWithWindows(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) CountNodeWithWindows() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDockNode_GetCountNodeWithWindows(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) LastFrameAlive() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDockNode_GetLastFrameAlive(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) LastFrameActive() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDockNode_GetLastFrameActive(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) LastFrameFocused() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiDockNode_GetLastFrameFocused(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) LastFocusedNodeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockNode_GetLastFocusedNodeId(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *DockNode) SelectedTabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockNode_GetSelectedTabId(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *DockNode) WantCloseTabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockNode_GetWantCloseTabId(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *DockNode) RefViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiDockNode_GetRefViewportId(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *DockNode) AuthorityForPos() DataAuthority {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DataAuthority(C.wrap_ImGuiDockNode_GetAuthorityForPos(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) AuthorityForSize() DataAuthority {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DataAuthority(C.wrap_ImGuiDockNode_GetAuthorityForSize(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) AuthorityForViewport() DataAuthority {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DataAuthority(C.wrap_ImGuiDockNode_GetAuthorityForViewport(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)))
}

func (self *DockNode) IsVisible() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetIsVisible(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) IsFocused() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetIsFocused(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) IsBgDrawnThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetIsBgDrawnThisFrame(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) HasCloseButton() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetHasCloseButton(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) HasWindowMenuButton() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetHasWindowMenuButton(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) HasCentralNodeChild() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetHasCentralNodeChild(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) WantCloseAll() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetWantCloseAll(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) WantLockSizeOnce() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetWantLockSizeOnce(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) WantMouseMove() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetWantMouseMove(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) WantHiddenTabBarUpdate() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetWantHiddenTabBarUpdate(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self *DockNode) WantHiddenTabBarToggle() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiDockNode_GetWantHiddenTabBarToggle(internal.ReinterpretCast[*C.ImGuiDockNode](selfArg)) == C.bool(true)
}

func (self ErrorRecoveryState) SetSizeOfWindowStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfWindowStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfIDStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfIDStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfTreeStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfTreeStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfColorStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfColorStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfStyleVarStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfStyleVarStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfFontStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfFontStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfFocusScopeStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfFocusScopeStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfGroupStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfGroupStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfItemFlagsStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfItemFlagsStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfBeginPopupStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfBeginPopupStack(selfArg, C.short(v))
}

func (self ErrorRecoveryState) SetSizeOfDisabledStack(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiErrorRecoveryState_SetSizeOfDisabledStack(selfArg, C.short(v))
}

func (self *ErrorRecoveryState) SizeOfWindowStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfWindowStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfIDStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfIDStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfTreeStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfTreeStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfColorStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfColorStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfStyleVarStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfStyleVarStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfFontStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfFontStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfFocusScopeStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfFocusScopeStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfGroupStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfGroupStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfItemFlagsStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfItemFlagsStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfBeginPopupStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfBeginPopupStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self *ErrorRecoveryState) SizeOfDisabledStack() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiErrorRecoveryState_GetSizeOfDisabledStack(internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](selfArg)))
}

func (self FocusScopeData) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiFocusScopeData_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self FocusScopeData) SetWindowID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiFocusScopeData_SetWindowID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *FocusScopeData) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiFocusScopeData_GetID(internal.ReinterpretCast[*C.ImGuiFocusScopeData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *FocusScopeData) WindowID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiFocusScopeData_GetWindowID(internal.ReinterpretCast[*C.ImGuiFocusScopeData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self GroupData) SetWindowID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetWindowID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self GroupData) SetBackupCursorPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupCursorPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self GroupData) SetBackupCursorMaxPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupCursorMaxPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self GroupData) SetBackupCursorPosPrevLine(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupCursorPosPrevLine(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self GroupData) SetBackupIndent(v Vec1) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupIndent(selfArg, internal.ReinterpretCast[C.ImVec1](vArg))
}

func (self GroupData) SetBackupGroupOffset(v Vec1) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupGroupOffset(selfArg, internal.ReinterpretCast[C.ImVec1](vArg))
}

func (self GroupData) SetBackupCurrLineSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupCurrLineSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self GroupData) SetBackupCurrLineTextBaseOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupCurrLineTextBaseOffset(selfArg, C.float(v))
}

func (self GroupData) SetBackupActiveIdIsAlive(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupActiveIdIsAlive(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self GroupData) SetBackupDeactivatedIdIsAlive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupDeactivatedIdIsAlive(selfArg, C.bool(v))
}

func (self GroupData) SetBackupHoveredIdIsAlive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupHoveredIdIsAlive(selfArg, C.bool(v))
}

func (self GroupData) SetBackupIsSameLine(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetBackupIsSameLine(selfArg, C.bool(v))
}

func (self GroupData) SetEmitItem(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiGroupData_SetEmitItem(selfArg, C.bool(v))
}

func (self *GroupData) WindowID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiGroupData_GetWindowID(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *GroupData) BackupCursorPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiGroupData_GetBackupCursorPos(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *GroupData) BackupCursorMaxPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiGroupData_GetBackupCursorMaxPos(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *GroupData) BackupCursorPosPrevLine() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiGroupData_GetBackupCursorPosPrevLine(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *GroupData) BackupIndent() Vec1 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiGroupData_GetBackupIndent(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec1FromC(func() *C.ImVec1 { result := result; return &result }())
}

func (self *GroupData) BackupGroupOffset() Vec1 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiGroupData_GetBackupGroupOffset(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec1FromC(func() *C.ImVec1 { result := result; return &result }())
}

func (self *GroupData) BackupCurrLineSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiGroupData_GetBackupCurrLineSize(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *GroupData) BackupCurrLineTextBaseOffset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiGroupData_GetBackupCurrLineTextBaseOffset(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg)))
}

func (self *GroupData) BackupActiveIdIsAlive() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiGroupData_GetBackupActiveIdIsAlive(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *GroupData) BackupDeactivatedIdIsAlive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiGroupData_GetBackupDeactivatedIdIsAlive(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg)) == C.bool(true)
}

func (self *GroupData) BackupHoveredIdIsAlive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiGroupData_GetBackupHoveredIdIsAlive(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg)) == C.bool(true)
}

func (self *GroupData) BackupIsSameLine() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiGroupData_GetBackupIsSameLine(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg)) == C.bool(true)
}

func (self *GroupData) EmitItem() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiGroupData_GetEmitItem(internal.ReinterpretCast[*C.ImGuiGroupData](selfArg)) == C.bool(true)
}

func (self IDStackTool) SetLastActiveFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetLastActiveFrame(selfArg, C.int(v))
}

func (self IDStackTool) SetStackLevel(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetStackLevel(selfArg, C.int(v))
}

func (self IDStackTool) SetQueryMainId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetQueryMainId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self IDStackTool) SetResults(v vectors.Vector[StackLevelInfo]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiStackLevelInfo)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiStackLevelInfo](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetResults(selfArg, *vVecArg)
}

func (self IDStackTool) SetQueryHookActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetQueryHookActive(selfArg, C.bool(v))
}

func (self IDStackTool) SetOptHexEncodeNonAsciiChars(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetOptHexEncodeNonAsciiChars(selfArg, C.bool(v))
}

func (self IDStackTool) SetOptCopyToClipboardOnCtrlC(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetOptCopyToClipboardOnCtrlC(selfArg, C.bool(v))
}

func (self IDStackTool) SetCopyToClipboardLastTime(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetCopyToClipboardLastTime(selfArg, C.float(v))
}

func (self IDStackTool) SetResultPathsBuf(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetResultPathsBuf(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self IDStackTool) SetResultTempBuf(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIDStackTool_SetResultTempBuf(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self *IDStackTool) LastActiveFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiIDStackTool_GetLastActiveFrame(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)))
}

func (self *IDStackTool) StackLevel() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiIDStackTool_GetStackLevel(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)))
}

func (self *IDStackTool) QueryMainId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiIDStackTool_GetQueryMainId(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *IDStackTool) Results() vectors.Vector[StackLevelInfo] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiIDStackTool_GetResults(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)).Size, C.wrap_ImGuiIDStackTool_GetResults(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)).Capacity, NewStackLevelInfoFromC(C.wrap_ImGuiIDStackTool_GetResults(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)).Data))
}

func (self *IDStackTool) QueryHookActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIDStackTool_GetQueryHookActive(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)) == C.bool(true)
}

func (self *IDStackTool) OptHexEncodeNonAsciiChars() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIDStackTool_GetOptHexEncodeNonAsciiChars(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)) == C.bool(true)
}

func (self *IDStackTool) OptCopyToClipboardOnCtrlC() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIDStackTool_GetOptCopyToClipboardOnCtrlC(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)) == C.bool(true)
}

func (self *IDStackTool) CopyToClipboardLastTime() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIDStackTool_GetCopyToClipboardLastTime(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg)))
}

func (self *IDStackTool) ResultPathsBuf() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiIDStackTool_GetResultPathsBuf(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self *IDStackTool) ResultTempBuf() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiIDStackTool_GetResultTempBuf(internal.ReinterpretCast[*C.ImGuiIDStackTool](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self IO) SetConfigFlags(v ConfigFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigFlags(selfArg, C.ImGuiConfigFlags(v))
}

func (self IO) SetBackendFlags(v BackendFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetBackendFlags(selfArg, C.ImGuiBackendFlags(v))
}

func (self IO) SetDisplaySize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetDisplaySize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self IO) SetDisplayFramebufferScale(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetDisplayFramebufferScale(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self IO) SetDeltaTime(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetDeltaTime(selfArg, C.float(v))
}

func (self IO) SetIniSavingRate(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetIniSavingRate(selfArg, C.float(v))
}

func (self IO) SetIniFilename(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetIniFilename(selfArg, vArg)
}

func (self IO) SetLogFilename(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetLogFilename(selfArg, vArg)
}

func (self IO) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetUserData(selfArg, C.uintptr_t(v))
}

func (self IO) SetFonts(v *FontAtlas) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetFonts(selfArg, internal.ReinterpretCast[*C.ImFontAtlas](vArg))
}

func (self IO) SetFontDefault(v *Font) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetFontDefault(selfArg, internal.ReinterpretCast[*C.ImFont](vArg))
}

func (self IO) SetFontAllowUserScaling(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetFontAllowUserScaling(selfArg, C.bool(v))
}

func (self IO) SetConfigNavSwapGamepadButtons(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavSwapGamepadButtons(selfArg, C.bool(v))
}

func (self IO) SetConfigNavMoveSetMousePos(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavMoveSetMousePos(selfArg, C.bool(v))
}

func (self IO) SetConfigNavCaptureKeyboard(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavCaptureKeyboard(selfArg, C.bool(v))
}

func (self IO) SetConfigNavEscapeClearFocusItem(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavEscapeClearFocusItem(selfArg, C.bool(v))
}

func (self IO) SetConfigNavEscapeClearFocusWindow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavEscapeClearFocusWindow(selfArg, C.bool(v))
}

func (self IO) SetConfigNavCursorVisibleAuto(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavCursorVisibleAuto(selfArg, C.bool(v))
}

func (self IO) SetConfigNavCursorVisibleAlways(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigNavCursorVisibleAlways(selfArg, C.bool(v))
}

func (self IO) SetConfigDockingNoSplit(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDockingNoSplit(selfArg, C.bool(v))
}

func (self IO) SetConfigDockingWithShift(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDockingWithShift(selfArg, C.bool(v))
}

func (self IO) SetConfigDockingAlwaysTabBar(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDockingAlwaysTabBar(selfArg, C.bool(v))
}

func (self IO) SetConfigDockingTransparentPayload(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDockingTransparentPayload(selfArg, C.bool(v))
}

func (self IO) SetConfigViewportsNoAutoMerge(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigViewportsNoAutoMerge(selfArg, C.bool(v))
}

func (self IO) SetConfigViewportsNoTaskBarIcon(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigViewportsNoTaskBarIcon(selfArg, C.bool(v))
}

func (self IO) SetConfigViewportsNoDecoration(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigViewportsNoDecoration(selfArg, C.bool(v))
}

func (self IO) SetConfigViewportsNoDefaultParent(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigViewportsNoDefaultParent(selfArg, C.bool(v))
}

func (self IO) SetConfigViewportsPlatformFocusSetsImGuiFocus(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigViewportsPlatformFocusSetsImGuiFocus(selfArg, C.bool(v))
}

func (self IO) SetConfigDpiScaleFonts(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDpiScaleFonts(selfArg, C.bool(v))
}

func (self IO) SetConfigDpiScaleViewports(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDpiScaleViewports(selfArg, C.bool(v))
}

func (self IO) SetMouseDrawCursor(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDrawCursor(selfArg, C.bool(v))
}

func (self IO) SetConfigMacOSXBehaviors(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigMacOSXBehaviors(selfArg, C.bool(v))
}

func (self IO) SetConfigInputTrickleEventQueue(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigInputTrickleEventQueue(selfArg, C.bool(v))
}

func (self IO) SetConfigInputTextCursorBlink(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigInputTextCursorBlink(selfArg, C.bool(v))
}

func (self IO) SetConfigInputTextEnterKeepActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigInputTextEnterKeepActive(selfArg, C.bool(v))
}

func (self IO) SetConfigDragClickToInputText(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDragClickToInputText(selfArg, C.bool(v))
}

func (self IO) SetConfigWindowsResizeFromEdges(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigWindowsResizeFromEdges(selfArg, C.bool(v))
}

func (self IO) SetConfigWindowsMoveFromTitleBarOnly(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigWindowsMoveFromTitleBarOnly(selfArg, C.bool(v))
}

func (self IO) SetConfigWindowsCopyContentsWithCtrlC(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigWindowsCopyContentsWithCtrlC(selfArg, C.bool(v))
}

func (self IO) SetConfigScrollbarScrollByPage(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigScrollbarScrollByPage(selfArg, C.bool(v))
}

func (self IO) SetConfigMemoryCompactTimer(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigMemoryCompactTimer(selfArg, C.float(v))
}

func (self IO) SetMouseDoubleClickTime(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDoubleClickTime(selfArg, C.float(v))
}

func (self IO) SetMouseDoubleClickMaxDist(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDoubleClickMaxDist(selfArg, C.float(v))
}

func (self IO) SetMouseDragThreshold(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDragThreshold(selfArg, C.float(v))
}

func (self IO) SetKeyRepeatDelay(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeyRepeatDelay(selfArg, C.float(v))
}

func (self IO) SetKeyRepeatRate(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeyRepeatRate(selfArg, C.float(v))
}

func (self IO) SetConfigErrorRecovery(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigErrorRecovery(selfArg, C.bool(v))
}

func (self IO) SetConfigErrorRecoveryEnableAssert(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigErrorRecoveryEnableAssert(selfArg, C.bool(v))
}

func (self IO) SetConfigErrorRecoveryEnableDebugLog(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigErrorRecoveryEnableDebugLog(selfArg, C.bool(v))
}

func (self IO) SetConfigErrorRecoveryEnableTooltip(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigErrorRecoveryEnableTooltip(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugIsDebuggerPresent(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugIsDebuggerPresent(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugHighlightIdConflicts(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugHighlightIdConflicts(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugHighlightIdConflictsShowItemPicker(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugHighlightIdConflictsShowItemPicker(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugBeginReturnValueOnce(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugBeginReturnValueOnce(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugBeginReturnValueLoop(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugBeginReturnValueLoop(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugIgnoreFocusLoss(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugIgnoreFocusLoss(selfArg, C.bool(v))
}

func (self IO) SetConfigDebugIniSettings(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetConfigDebugIniSettings(selfArg, C.bool(v))
}

func (self IO) SetBackendPlatformName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetBackendPlatformName(selfArg, vArg)
}

func (self IO) SetBackendRendererName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetBackendRendererName(selfArg, vArg)
}

func (self IO) SetBackendPlatformUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetBackendPlatformUserData(selfArg, C.uintptr_t(v))
}

func (self IO) SetBackendRendererUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetBackendRendererUserData(selfArg, C.uintptr_t(v))
}

func (self IO) SetBackendLanguageUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetBackendLanguageUserData(selfArg, C.uintptr_t(v))
}

func (self IO) SetWantCaptureMouse(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetWantCaptureMouse(selfArg, C.bool(v))
}

func (self IO) SetWantCaptureKeyboard(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetWantCaptureKeyboard(selfArg, C.bool(v))
}

func (self IO) SetWantTextInput(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetWantTextInput(selfArg, C.bool(v))
}

func (self IO) SetWantSetMousePos(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetWantSetMousePos(selfArg, C.bool(v))
}

func (self IO) SetWantSaveIniSettings(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetWantSaveIniSettings(selfArg, C.bool(v))
}

func (self IO) SetNavActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetNavActive(selfArg, C.bool(v))
}

func (self IO) SetNavVisible(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetNavVisible(selfArg, C.bool(v))
}

func (self IO) SetFramerate(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetFramerate(selfArg, C.float(v))
}

func (self IO) SetMetricsRenderVertices(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMetricsRenderVertices(selfArg, C.int(v))
}

func (self IO) SetMetricsRenderIndices(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMetricsRenderIndices(selfArg, C.int(v))
}

func (self IO) SetMetricsRenderWindows(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMetricsRenderWindows(selfArg, C.int(v))
}

func (self IO) SetMetricsActiveWindows(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMetricsActiveWindows(selfArg, C.int(v))
}

func (self IO) SetMouseDelta(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDelta(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self IO) SetCtx(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetCtx(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self IO) SetMousePos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMousePos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self IO) SetMouseDown(v *[5]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDown(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self IO) SetMouseWheel(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseWheel(selfArg, C.float(v))
}

func (self IO) SetMouseWheelH(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseWheelH(selfArg, C.float(v))
}

func (self IO) SetMouseSource(v MouseSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseSource(selfArg, C.ImGuiMouseSource(v))
}

func (self IO) SetMouseHoveredViewport(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseHoveredViewport(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self IO) SetKeyCtrl(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeyCtrl(selfArg, C.bool(v))
}

func (self IO) SetKeyShift(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeyShift(selfArg, C.bool(v))
}

func (self IO) SetKeyAlt(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeyAlt(selfArg, C.bool(v))
}

func (self IO) SetKeySuper(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeySuper(selfArg, C.bool(v))
}

func (self IO) SetKeyMods(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeyMods(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self IO) SetKeysData(v *[155]KeyData) {
	vArg := make([]C.ImGuiKeyData, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImGuiKeyData](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetKeysData(selfArg, (*C.ImGuiKeyData)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewKeyDataFromC(func() *C.ImGuiKeyData { result := vV; return &result }())
	}
}

func (self IO) SetWantCaptureMouseUnlessPopupClose(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetWantCaptureMouseUnlessPopupClose(selfArg, C.bool(v))
}

func (self IO) SetMousePosPrev(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMousePosPrev(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self IO) SetMouseClickedPos(v *[5]Vec2) {
	vArg := make([]C.ImVec2, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec2](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseClickedPos(selfArg, (*C.ImVec2)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() Vec2 { out := vV; return *(&Vec2{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self IO) SetMouseClickedTime(v *[5]float64) {
	vArg := make([]C.double, len(v))
	for i, vV := range v {
		vArg[i] = C.double(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseClickedTime(selfArg, (*C.double)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float64(vV)
	}
}

func (self IO) SetMouseClicked(v *[5]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseClicked(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self IO) SetMouseDoubleClicked(v *[5]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDoubleClicked(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self IO) SetMouseClickedCount(v *[5]uint16) {
	vArg := make([]C.ImU16, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU16(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseClickedCount(selfArg, (*C.ImU16)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (uint16)(vV)
	}
}

func (self IO) SetMouseClickedLastCount(v *[5]uint16) {
	vArg := make([]C.ImU16, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU16(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseClickedLastCount(selfArg, (*C.ImU16)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (uint16)(vV)
	}
}

func (self IO) SetMouseReleased(v *[5]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseReleased(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self IO) SetMouseReleasedTime(v *[5]float64) {
	vArg := make([]C.double, len(v))
	for i, vV := range v {
		vArg[i] = C.double(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseReleasedTime(selfArg, (*C.double)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float64(vV)
	}
}

func (self IO) SetMouseDownOwned(v *[5]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDownOwned(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self IO) SetMouseDownOwnedUnlessPopupClose(v *[5]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDownOwnedUnlessPopupClose(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self IO) SetMouseWheelRequestAxisSwap(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseWheelRequestAxisSwap(selfArg, C.bool(v))
}

func (self IO) SetMouseCtrlLeftAsRightClick(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseCtrlLeftAsRightClick(selfArg, C.bool(v))
}

func (self IO) SetMouseDownDuration(v *[5]float32) {
	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDownDuration(selfArg, (*C.float)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float32(vV)
	}
}

func (self IO) SetMouseDownDurationPrev(v *[5]float32) {
	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDownDurationPrev(selfArg, (*C.float)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float32(vV)
	}
}

func (self IO) SetMouseDragMaxDistanceAbs(v *[5]Vec2) {
	vArg := make([]C.ImVec2, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec2](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDragMaxDistanceAbs(selfArg, (*C.ImVec2)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() Vec2 { out := vV; return *(&Vec2{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self IO) SetMouseDragMaxDistanceSqr(v *[5]float32) {
	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetMouseDragMaxDistanceSqr(selfArg, (*C.float)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float32(vV)
	}
}

func (self IO) SetPenPressure(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetPenPressure(selfArg, C.float(v))
}

func (self IO) SetAppFocusLost(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetAppFocusLost(selfArg, C.bool(v))
}

func (self IO) SetInputQueueSurrogate(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetInputQueueSurrogate(selfArg, C.ImWchar16(v))
}

func (self IO) SetInputQueueCharacters(v vectors.Vector[Wchar]) {
	vData := v.Data

	vVecArg := new(C.ImVector_ImWchar)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = (*C.ImWchar)(vData)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiIO_SetInputQueueCharacters(selfArg, *vVecArg)
}

func (self *IO) ConfigFlags() ConfigFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ConfigFlags(C.wrap_ImGuiIO_GetConfigFlags(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) BackendFlags() BackendFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return BackendFlags(C.wrap_ImGuiIO_GetBackendFlags(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) DisplaySize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiIO_GetDisplaySize(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *IO) DisplayFramebufferScale() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiIO_GetDisplayFramebufferScale(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *IO) DeltaTime() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetDeltaTime(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) IniSavingRate() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetIniSavingRate(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) IniFilename() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiIO_GetIniFilename(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) LogFilename() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiIO_GetLogFilename(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiIO_GetUserData(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) Fonts() *FontAtlas {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontAtlasFromC(C.wrap_ImGuiIO_GetFonts(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) FontDefault() *Font {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewFontFromC(C.wrap_ImGuiIO_GetFontDefault(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) FontAllowUserScaling() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetFontAllowUserScaling(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavSwapGamepadButtons() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavSwapGamepadButtons(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavMoveSetMousePos() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavMoveSetMousePos(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavCaptureKeyboard() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavCaptureKeyboard(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavEscapeClearFocusItem() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavEscapeClearFocusItem(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavEscapeClearFocusWindow() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavEscapeClearFocusWindow(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavCursorVisibleAuto() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavCursorVisibleAuto(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigNavCursorVisibleAlways() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigNavCursorVisibleAlways(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDockingNoSplit() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDockingNoSplit(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDockingWithShift() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDockingWithShift(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDockingAlwaysTabBar() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDockingAlwaysTabBar(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDockingTransparentPayload() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDockingTransparentPayload(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigViewportsNoAutoMerge() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigViewportsNoAutoMerge(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigViewportsNoTaskBarIcon() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigViewportsNoTaskBarIcon(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigViewportsNoDecoration() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigViewportsNoDecoration(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigViewportsNoDefaultParent() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigViewportsNoDefaultParent(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigViewportsPlatformFocusSetsImGuiFocus() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigViewportsPlatformFocusSetsImGuiFocus(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDpiScaleFonts() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDpiScaleFonts(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDpiScaleViewports() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDpiScaleViewports(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) MouseDrawCursor() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetMouseDrawCursor(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigMacOSXBehaviors() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigMacOSXBehaviors(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigInputTrickleEventQueue() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigInputTrickleEventQueue(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigInputTextCursorBlink() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigInputTextCursorBlink(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigInputTextEnterKeepActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigInputTextEnterKeepActive(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDragClickToInputText() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDragClickToInputText(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigWindowsResizeFromEdges() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigWindowsResizeFromEdges(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigWindowsMoveFromTitleBarOnly() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigWindowsMoveFromTitleBarOnly(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigWindowsCopyContentsWithCtrlC() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigWindowsCopyContentsWithCtrlC(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigScrollbarScrollByPage() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigScrollbarScrollByPage(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigMemoryCompactTimer() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetConfigMemoryCompactTimer(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseDoubleClickTime() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetMouseDoubleClickTime(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseDoubleClickMaxDist() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetMouseDoubleClickMaxDist(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseDragThreshold() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetMouseDragThreshold(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) KeyRepeatDelay() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetKeyRepeatDelay(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) KeyRepeatRate() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetKeyRepeatRate(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) ConfigErrorRecovery() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigErrorRecovery(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigErrorRecoveryEnableAssert() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigErrorRecoveryEnableAssert(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigErrorRecoveryEnableDebugLog() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigErrorRecoveryEnableDebugLog(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigErrorRecoveryEnableTooltip() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigErrorRecoveryEnableTooltip(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugIsDebuggerPresent() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugIsDebuggerPresent(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugHighlightIdConflicts() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugHighlightIdConflicts(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugHighlightIdConflictsShowItemPicker() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugHighlightIdConflictsShowItemPicker(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugBeginReturnValueOnce() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugBeginReturnValueOnce(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugBeginReturnValueLoop() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugBeginReturnValueLoop(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugIgnoreFocusLoss() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugIgnoreFocusLoss(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) ConfigDebugIniSettings() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetConfigDebugIniSettings(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) BackendPlatformName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiIO_GetBackendPlatformName(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) BackendRendererName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiIO_GetBackendRendererName(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) BackendPlatformUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiIO_GetBackendPlatformUserData(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) BackendRendererUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiIO_GetBackendRendererUserData(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) BackendLanguageUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiIO_GetBackendLanguageUserData(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) WantCaptureMouse() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetWantCaptureMouse(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) WantCaptureKeyboard() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetWantCaptureKeyboard(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) WantTextInput() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetWantTextInput(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) WantSetMousePos() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetWantSetMousePos(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) WantSaveIniSettings() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetWantSaveIniSettings(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) NavActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetNavActive(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) NavVisible() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetNavVisible(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) Framerate() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetFramerate(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MetricsRenderVertices() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiIO_GetMetricsRenderVertices(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MetricsRenderIndices() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiIO_GetMetricsRenderIndices(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MetricsRenderWindows() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiIO_GetMetricsRenderWindows(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MetricsActiveWindows() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiIO_GetMetricsActiveWindows(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseDelta() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiIO_GetMouseDelta(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *IO) Ctx() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImGuiIO_GetCtx(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MousePos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiIO_GetMousePos(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *IO) MouseDown() [5]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]bool {
		result := [5]bool{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDown(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = C.imgui_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *IO) MouseWheel() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetMouseWheel(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseWheelH() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetMouseWheelH(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseSource() MouseSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseSource(C.wrap_ImGuiIO_GetMouseSource(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) MouseHoveredViewport() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiIO_GetMouseHoveredViewport(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *IO) KeyCtrl() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetKeyCtrl(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) KeyShift() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetKeyShift(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) KeyAlt() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetKeyAlt(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) KeySuper() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetKeySuper(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) KeyMods() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiIO_GetKeyMods(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *IO) KeysData() [155]KeyData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [155]KeyData {
		result := [155]KeyData{}
		resultMirr := C.wrap_ImGuiIO_GetKeysData(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = *NewKeyDataFromC(func() *C.ImGuiKeyData { result := C.imgui_ImGuiKeyData_GetAtIdx(resultMirr, C.int(i)); return &result }())
		}

		return result
	}()
}

func (self *IO) WantCaptureMouseUnlessPopupClose() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetWantCaptureMouseUnlessPopupClose(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) MousePosPrev() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiIO_GetMousePosPrev(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *IO) MouseClickedPos() [5]Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]Vec2 {
		result := [5]Vec2{}
		resultMirr := C.wrap_ImGuiIO_GetMouseClickedPos(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = func() Vec2 {
				out := C.imgui_ImVec2_GetAtIdx(resultMirr, C.int(i))
				return *(&Vec2{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *IO) MouseClickedTime() [5]float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]float64 {
		result := [5]float64{}
		resultMirr := C.wrap_ImGuiIO_GetMouseClickedTime(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = float64(C.imgui_double_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) MouseClicked() [5]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]bool {
		result := [5]bool{}
		resultMirr := C.wrap_ImGuiIO_GetMouseClicked(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = C.imgui_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *IO) MouseDoubleClicked() [5]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]bool {
		result := [5]bool{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDoubleClicked(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = C.imgui_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *IO) MouseClickedCount() [5](uint16) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5](uint16) {
		result := [5](uint16){}
		resultMirr := C.wrap_ImGuiIO_GetMouseClickedCount(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = (uint16)(C.imgui_ImU16_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) MouseClickedLastCount() [5](uint16) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5](uint16) {
		result := [5](uint16){}
		resultMirr := C.wrap_ImGuiIO_GetMouseClickedLastCount(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = (uint16)(C.imgui_ImU16_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) MouseReleased() [5]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]bool {
		result := [5]bool{}
		resultMirr := C.wrap_ImGuiIO_GetMouseReleased(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = C.imgui_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *IO) MouseReleasedTime() [5]float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]float64 {
		result := [5]float64{}
		resultMirr := C.wrap_ImGuiIO_GetMouseReleasedTime(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = float64(C.imgui_double_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) MouseDownOwned() [5]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]bool {
		result := [5]bool{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDownOwned(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = C.imgui_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *IO) MouseDownOwnedUnlessPopupClose() [5]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]bool {
		result := [5]bool{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDownOwnedUnlessPopupClose(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = C.imgui_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *IO) MouseWheelRequestAxisSwap() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetMouseWheelRequestAxisSwap(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) MouseCtrlLeftAsRightClick() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetMouseCtrlLeftAsRightClick(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) MouseDownDuration() [5]float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]float32 {
		result := [5]float32{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDownDuration(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = float32(C.imgui_float_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) MouseDownDurationPrev() [5]float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]float32 {
		result := [5]float32{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDownDurationPrev(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = float32(C.imgui_float_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) MouseDragMaxDistanceAbs() [5]Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]Vec2 {
		result := [5]Vec2{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDragMaxDistanceAbs(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = func() Vec2 {
				out := C.imgui_ImVec2_GetAtIdx(resultMirr, C.int(i))
				return *(&Vec2{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *IO) MouseDragMaxDistanceSqr() [5]float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]float32 {
		result := [5]float32{}
		resultMirr := C.wrap_ImGuiIO_GetMouseDragMaxDistanceSqr(internal.ReinterpretCast[*C.ImGuiIO](selfArg))
		for i := range result {
			result[i] = float32(C.imgui_float_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *IO) PenPressure() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiIO_GetPenPressure(internal.ReinterpretCast[*C.ImGuiIO](selfArg)))
}

func (self *IO) AppFocusLost() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetAppFocusLost(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) AppAcceptingEvents() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiIO_GetAppAcceptingEvents(internal.ReinterpretCast[*C.ImGuiIO](selfArg)) == C.bool(true)
}

func (self *IO) InputQueueSurrogate() uint16 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiIO_GetInputQueueSurrogate(internal.ReinterpretCast[*C.ImGuiIO](selfArg))

	defer func() {
		selfFin()
	}()
	return (uint16)(result)
}

func (self *IO) InputQueueCharacters() vectors.Vector[(Wchar)] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiIO_GetInputQueueCharacters(internal.ReinterpretCast[*C.ImGuiIO](selfArg)).Size, C.wrap_ImGuiIO_GetInputQueueCharacters(internal.ReinterpretCast[*C.ImGuiIO](selfArg)).Capacity, (*Wchar)(C.wrap_ImGuiIO_GetInputQueueCharacters(internal.ReinterpretCast[*C.ImGuiIO](selfArg)).Data))
}

func (self InputEvent) SetType(v InputEventType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEvent_SetType(selfArg, C.ImGuiInputEventType(v))
}

func (self InputEvent) SetSource(v InputSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEvent_SetSource(selfArg, C.ImGuiInputSource(v))
}

func (self InputEvent) SetEventId(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEvent_SetEventId(selfArg, C.ImU32(v))
}

func (self InputEvent) SetAddedByTestEngine(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEvent_SetAddedByTestEngine(selfArg, C.bool(v))
}

func (self *InputEvent) Type() InputEventType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputEventType(C.wrap_ImGuiInputEvent_GetType(internal.ReinterpretCast[*C.ImGuiInputEvent](selfArg)))
}

func (self *InputEvent) Source() InputSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputSource(C.wrap_ImGuiInputEvent_GetSource(internal.ReinterpretCast[*C.ImGuiInputEvent](selfArg)))
}

func (self *InputEvent) EventId() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiInputEvent_GetEventId(internal.ReinterpretCast[*C.ImGuiInputEvent](selfArg)))
}

func (self *InputEvent) AddedByTestEngine() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputEvent_GetAddedByTestEngine(internal.ReinterpretCast[*C.ImGuiInputEvent](selfArg)) == C.bool(true)
}

func (self InputEventAppFocused) SetFocused(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventAppFocused_SetFocused(selfArg, C.bool(v))
}

func (self *InputEventAppFocused) Focused() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputEventAppFocused_GetFocused(internal.ReinterpretCast[*C.ImGuiInputEventAppFocused](selfArg)) == C.bool(true)
}

func (self InputEventKey) SetKey(v Key) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventKey_SetKey(selfArg, C.ImGuiKey(v))
}

func (self InputEventKey) SetDown(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventKey_SetDown(selfArg, C.bool(v))
}

func (self InputEventKey) SetAnalogValue(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventKey_SetAnalogValue(selfArg, C.float(v))
}

func (self *InputEventKey) Key() Key {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Key(C.wrap_ImGuiInputEventKey_GetKey(internal.ReinterpretCast[*C.ImGuiInputEventKey](selfArg)))
}

func (self *InputEventKey) Down() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputEventKey_GetDown(internal.ReinterpretCast[*C.ImGuiInputEventKey](selfArg)) == C.bool(true)
}

func (self *InputEventKey) AnalogValue() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputEventKey_GetAnalogValue(internal.ReinterpretCast[*C.ImGuiInputEventKey](selfArg)))
}

func (self InputEventMouseButton) SetButton(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseButton_SetButton(selfArg, C.int(v))
}

func (self InputEventMouseButton) SetDown(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseButton_SetDown(selfArg, C.bool(v))
}

func (self InputEventMouseButton) SetMouseSource(v MouseSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseButton_SetMouseSource(selfArg, C.ImGuiMouseSource(v))
}

func (self *InputEventMouseButton) Button() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputEventMouseButton_GetButton(internal.ReinterpretCast[*C.ImGuiInputEventMouseButton](selfArg)))
}

func (self *InputEventMouseButton) Down() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputEventMouseButton_GetDown(internal.ReinterpretCast[*C.ImGuiInputEventMouseButton](selfArg)) == C.bool(true)
}

func (self *InputEventMouseButton) MouseSource() MouseSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseSource(C.wrap_ImGuiInputEventMouseButton_GetMouseSource(internal.ReinterpretCast[*C.ImGuiInputEventMouseButton](selfArg)))
}

func (self InputEventMousePos) SetPosX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMousePos_SetPosX(selfArg, C.float(v))
}

func (self InputEventMousePos) SetPosY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMousePos_SetPosY(selfArg, C.float(v))
}

func (self InputEventMousePos) SetMouseSource(v MouseSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMousePos_SetMouseSource(selfArg, C.ImGuiMouseSource(v))
}

func (self *InputEventMousePos) PosX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputEventMousePos_GetPosX(internal.ReinterpretCast[*C.ImGuiInputEventMousePos](selfArg)))
}

func (self *InputEventMousePos) PosY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputEventMousePos_GetPosY(internal.ReinterpretCast[*C.ImGuiInputEventMousePos](selfArg)))
}

func (self *InputEventMousePos) MouseSource() MouseSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseSource(C.wrap_ImGuiInputEventMousePos_GetMouseSource(internal.ReinterpretCast[*C.ImGuiInputEventMousePos](selfArg)))
}

func (self InputEventMouseViewport) SetHoveredViewportID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseViewport_SetHoveredViewportID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *InputEventMouseViewport) HoveredViewportID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiInputEventMouseViewport_GetHoveredViewportID(internal.ReinterpretCast[*C.ImGuiInputEventMouseViewport](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self InputEventMouseWheel) SetWheelX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseWheel_SetWheelX(selfArg, C.float(v))
}

func (self InputEventMouseWheel) SetWheelY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseWheel_SetWheelY(selfArg, C.float(v))
}

func (self InputEventMouseWheel) SetMouseSource(v MouseSource) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventMouseWheel_SetMouseSource(selfArg, C.ImGuiMouseSource(v))
}

func (self *InputEventMouseWheel) WheelX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputEventMouseWheel_GetWheelX(internal.ReinterpretCast[*C.ImGuiInputEventMouseWheel](selfArg)))
}

func (self *InputEventMouseWheel) WheelY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputEventMouseWheel_GetWheelY(internal.ReinterpretCast[*C.ImGuiInputEventMouseWheel](selfArg)))
}

func (self *InputEventMouseWheel) MouseSource() MouseSource {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseSource(C.wrap_ImGuiInputEventMouseWheel_GetMouseSource(internal.ReinterpretCast[*C.ImGuiInputEventMouseWheel](selfArg)))
}

func (self InputEventText) SetChar(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputEventText_SetChar(selfArg, C.uint(v))
}

func (self *InputEventText) Char() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint32(C.wrap_ImGuiInputEventText_GetChar(internal.ReinterpretCast[*C.ImGuiInputEventText](selfArg)))
}

func (self InputTextCallbackData) SetCtx(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetCtx(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self InputTextCallbackData) SetEventFlag(v InputTextFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetEventFlag(selfArg, C.ImGuiInputTextFlags(v))
}

func (self InputTextCallbackData) SetFlags(v InputTextFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetFlags(selfArg, C.ImGuiInputTextFlags(v))
}

func (self InputTextCallbackData) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetUserData(selfArg, C.uintptr_t(v))
}

func (self InputTextCallbackData) SetEventChar(v Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetEventChar(selfArg, C.ImWchar(v))
}

func (self InputTextCallbackData) SetEventKey(v Key) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetEventKey(selfArg, C.ImGuiKey(v))
}

func (self InputTextCallbackData) SetBuf(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetBuf(selfArg, vArg)
}

func (self InputTextCallbackData) SetBufTextLen(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetBufTextLen(selfArg, C.int(v))
}

func (self InputTextCallbackData) SetBufSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetBufSize(selfArg, C.int(v))
}

func (self InputTextCallbackData) SetBufDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetBufDirty(selfArg, C.bool(v))
}

func (self InputTextCallbackData) SetCursorPos(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetCursorPos(selfArg, C.int(v))
}

func (self InputTextCallbackData) SetSelectionStart(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetSelectionStart(selfArg, C.int(v))
}

func (self InputTextCallbackData) SetSelectionEnd(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextCallbackData_SetSelectionEnd(selfArg, C.int(v))
}

func (self *InputTextCallbackData) Ctx() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImGuiInputTextCallbackData_GetCtx(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) EventFlag() InputTextFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputTextFlags(C.wrap_ImGuiInputTextCallbackData_GetEventFlag(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) Flags() InputTextFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputTextFlags(C.wrap_ImGuiInputTextCallbackData_GetFlags(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiInputTextCallbackData_GetUserData(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) EventChar() Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (Wchar)(C.wrap_ImGuiInputTextCallbackData_GetEventChar(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) EventKey() Key {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Key(C.wrap_ImGuiInputTextCallbackData_GetEventKey(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) Buf() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiInputTextCallbackData_GetBuf(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) BufTextLen() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextCallbackData_GetBufTextLen(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) BufSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextCallbackData_GetBufSize(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) BufDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputTextCallbackData_GetBufDirty(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)) == C.bool(true)
}

func (self *InputTextCallbackData) CursorPos() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextCallbackData_GetCursorPos(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) SelectionStart() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextCallbackData_GetSelectionStart(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self *InputTextCallbackData) SelectionEnd() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextCallbackData_GetSelectionEnd(internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](selfArg)))
}

func (self InputTextDeactivatedState) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextDeactivatedState_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self InputTextDeactivatedState) SetTextA(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextDeactivatedState_SetTextA(selfArg, *vVecArg)
}

func (self *InputTextDeactivatedState) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiInputTextDeactivatedState_GetID(internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *InputTextDeactivatedState) TextA() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiInputTextDeactivatedState_GetTextA(internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](selfArg)).Size, C.wrap_ImGuiInputTextDeactivatedState_GetTextA(internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](selfArg)).Capacity, (*int8)(C.wrap_ImGuiInputTextDeactivatedState_GetTextA(internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](selfArg)).Data))
}

func (self InputTextState) SetCtx(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetCtx(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self InputTextState) SetFlags(v InputTextFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetFlags(selfArg, C.ImGuiInputTextFlags(v))
}

func (self InputTextState) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self InputTextState) SetTextLen(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetTextLen(selfArg, C.int(v))
}

func (self InputTextState) SetTextSrc(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetTextSrc(selfArg, vArg)
}

func (self InputTextState) SetTextA(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetTextA(selfArg, *vVecArg)
}

func (self InputTextState) SetTextToRevertTo(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetTextToRevertTo(selfArg, *vVecArg)
}

func (self InputTextState) SetCallbackTextBackup(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetCallbackTextBackup(selfArg, *vVecArg)
}

func (self InputTextState) SetBufCapacity(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetBufCapacity(selfArg, C.int(v))
}

func (self InputTextState) SetScroll(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetScroll(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self InputTextState) SetLineCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetLineCount(selfArg, C.int(v))
}

func (self InputTextState) SetWrapWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetWrapWidth(selfArg, C.float(v))
}

func (self InputTextState) SetCursorAnim(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetCursorAnim(selfArg, C.float(v))
}

func (self InputTextState) SetCursorFollow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetCursorFollow(selfArg, C.bool(v))
}

func (self InputTextState) SetCursorCenterY(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetCursorCenterY(selfArg, C.bool(v))
}

func (self InputTextState) SetSelectedAllMouseLock(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetSelectedAllMouseLock(selfArg, C.bool(v))
}

func (self InputTextState) SetEdited(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetEdited(selfArg, C.bool(v))
}

func (self InputTextState) SetWantReloadUserBuf(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetWantReloadUserBuf(selfArg, C.bool(v))
}

func (self InputTextState) SetLastMoveDirectionLR(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetLastMoveDirectionLR(selfArg, C.ImS8(v))
}

func (self InputTextState) SetReloadSelectionStart(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetReloadSelectionStart(selfArg, C.int(v))
}

func (self InputTextState) SetReloadSelectionEnd(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiInputTextState_SetReloadSelectionEnd(selfArg, C.int(v))
}

func (self *InputTextState) Ctx() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImGuiInputTextState_GetCtx(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) Flags() InputTextFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputTextFlags(C.wrap_ImGuiInputTextState_GetFlags(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiInputTextState_GetID(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *InputTextState) TextLen() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextState_GetTextLen(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) TextSrc() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiInputTextState_GetTextSrc(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) TextA() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiInputTextState_GetTextA(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Size, C.wrap_ImGuiInputTextState_GetTextA(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Capacity, (*int8)(C.wrap_ImGuiInputTextState_GetTextA(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Data))
}

func (self *InputTextState) TextToRevertTo() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiInputTextState_GetTextToRevertTo(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Size, C.wrap_ImGuiInputTextState_GetTextToRevertTo(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Capacity, (*int8)(C.wrap_ImGuiInputTextState_GetTextToRevertTo(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Data))
}

func (self *InputTextState) CallbackTextBackup() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiInputTextState_GetCallbackTextBackup(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Size, C.wrap_ImGuiInputTextState_GetCallbackTextBackup(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Capacity, (*int8)(C.wrap_ImGuiInputTextState_GetCallbackTextBackup(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)).Data))
}

func (self *InputTextState) BufCapacity() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextState_GetBufCapacity(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) Scroll() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiInputTextState_GetScroll(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *InputTextState) LineCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextState_GetLineCount(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) WrapWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputTextState_GetWrapWidth(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) CursorAnim() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiInputTextState_GetCursorAnim(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) CursorFollow() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputTextState_GetCursorFollow(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)) == C.bool(true)
}

func (self *InputTextState) CursorCenterY() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputTextState_GetCursorCenterY(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)) == C.bool(true)
}

func (self *InputTextState) SelectedAllMouseLock() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputTextState_GetSelectedAllMouseLock(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)) == C.bool(true)
}

func (self *InputTextState) Edited() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputTextState_GetEdited(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)) == C.bool(true)
}

func (self *InputTextState) WantReloadUserBuf() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiInputTextState_GetWantReloadUserBuf(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)) == C.bool(true)
}

func (self *InputTextState) LastMoveDirectionLR() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiInputTextState_GetLastMoveDirectionLR(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) ReloadSelectionStart() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextState_GetReloadSelectionStart(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self *InputTextState) ReloadSelectionEnd() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiInputTextState_GetReloadSelectionEnd(internal.ReinterpretCast[*C.ImGuiInputTextState](selfArg)))
}

func (self KeyData) SetDown(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyData_SetDown(selfArg, C.bool(v))
}

func (self KeyData) SetDownDuration(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyData_SetDownDuration(selfArg, C.float(v))
}

func (self KeyData) SetDownDurationPrev(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyData_SetDownDurationPrev(selfArg, C.float(v))
}

func (self KeyData) SetAnalogValue(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyData_SetAnalogValue(selfArg, C.float(v))
}

func (self *KeyData) Down() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiKeyData_GetDown(internal.ReinterpretCast[*C.ImGuiKeyData](selfArg)) == C.bool(true)
}

func (self *KeyData) DownDuration() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiKeyData_GetDownDuration(internal.ReinterpretCast[*C.ImGuiKeyData](selfArg)))
}

func (self *KeyData) DownDurationPrev() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiKeyData_GetDownDurationPrev(internal.ReinterpretCast[*C.ImGuiKeyData](selfArg)))
}

func (self *KeyData) AnalogValue() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiKeyData_GetAnalogValue(internal.ReinterpretCast[*C.ImGuiKeyData](selfArg)))
}

func (self KeyOwnerData) SetOwnerCurr(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyOwnerData_SetOwnerCurr(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self KeyOwnerData) SetOwnerNext(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyOwnerData_SetOwnerNext(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self KeyOwnerData) SetLockThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyOwnerData_SetLockThisFrame(selfArg, C.bool(v))
}

func (self KeyOwnerData) SetLockUntilRelease(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyOwnerData_SetLockUntilRelease(selfArg, C.bool(v))
}

func (self *KeyOwnerData) OwnerCurr() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiKeyOwnerData_GetOwnerCurr(internal.ReinterpretCast[*C.ImGuiKeyOwnerData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *KeyOwnerData) OwnerNext() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiKeyOwnerData_GetOwnerNext(internal.ReinterpretCast[*C.ImGuiKeyOwnerData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *KeyOwnerData) LockThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiKeyOwnerData_GetLockThisFrame(internal.ReinterpretCast[*C.ImGuiKeyOwnerData](selfArg)) == C.bool(true)
}

func (self *KeyOwnerData) LockUntilRelease() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiKeyOwnerData_GetLockUntilRelease(internal.ReinterpretCast[*C.ImGuiKeyOwnerData](selfArg)) == C.bool(true)
}

func (self KeyRoutingData) SetNextEntryIndex(v KeyRoutingIndex) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingData_SetNextEntryIndex(selfArg, internal.ReinterpretCast[C.ImGuiKeyRoutingIndex](vArg))
}

func (self KeyRoutingData) SetMods(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingData_SetMods(selfArg, C.ImU16(v))
}

func (self KeyRoutingData) SetRoutingCurrScore(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingData_SetRoutingCurrScore(selfArg, C.ImU8(v))
}

func (self KeyRoutingData) SetRoutingNextScore(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingData_SetRoutingNextScore(selfArg, C.ImU8(v))
}

func (self KeyRoutingData) SetRoutingCurr(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingData_SetRoutingCurr(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self KeyRoutingData) SetRoutingNext(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingData_SetRoutingNext(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *KeyRoutingData) NextEntryIndex() KeyRoutingIndex {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiKeyRoutingData_GetNextEntryIndex(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyRoutingIndexFromC(func() *C.ImGuiKeyRoutingIndex { result := result; return &result }())
}

func (self *KeyRoutingData) Mods() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint16)(C.wrap_ImGuiKeyRoutingData_GetMods(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg)))
}

func (self *KeyRoutingData) RoutingCurrScore() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiKeyRoutingData_GetRoutingCurrScore(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg)))
}

func (self *KeyRoutingData) RoutingNextScore() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiKeyRoutingData_GetRoutingNextScore(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg)))
}

func (self *KeyRoutingData) RoutingCurr() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiKeyRoutingData_GetRoutingCurr(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *KeyRoutingData) RoutingNext() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiKeyRoutingData_GetRoutingNext(internal.ReinterpretCast[*C.ImGuiKeyRoutingData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self KeyRoutingTable) SetIndex(v *[155]KeyRoutingIndex) {
	vArg := make([]C.ImGuiKeyRoutingIndex, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImGuiKeyRoutingIndex](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingTable_SetIndex(selfArg, (*C.ImGuiKeyRoutingIndex)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewKeyRoutingIndexFromC(func() *C.ImGuiKeyRoutingIndex { result := vV; return &result }())
	}
}

func (self KeyRoutingTable) SetEntries(v vectors.Vector[KeyRoutingData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiKeyRoutingData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiKeyRoutingData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingTable_SetEntries(selfArg, *vVecArg)
}

func (self KeyRoutingTable) SetEntriesNext(v vectors.Vector[KeyRoutingData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiKeyRoutingData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiKeyRoutingData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiKeyRoutingTable_SetEntriesNext(selfArg, *vVecArg)
}

func (self *KeyRoutingTable) Index() [155]KeyRoutingIndex {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [155]KeyRoutingIndex {
		result := [155]KeyRoutingIndex{}
		resultMirr := C.wrap_ImGuiKeyRoutingTable_GetIndex(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg))
		for i := range result {
			result[i] = *NewKeyRoutingIndexFromC(func() *C.ImGuiKeyRoutingIndex {
				result := C.imgui_ImGuiKeyRoutingIndex_GetAtIdx(resultMirr, C.int(i))
				return &result
			}())
		}

		return result
	}()
}

func (self *KeyRoutingTable) Entries() vectors.Vector[KeyRoutingData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiKeyRoutingTable_GetEntries(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg)).Size, C.wrap_ImGuiKeyRoutingTable_GetEntries(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg)).Capacity, NewKeyRoutingDataFromC(C.wrap_ImGuiKeyRoutingTable_GetEntries(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg)).Data))
}

func (self *KeyRoutingTable) EntriesNext() vectors.Vector[KeyRoutingData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiKeyRoutingTable_GetEntriesNext(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg)).Size, C.wrap_ImGuiKeyRoutingTable_GetEntriesNext(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg)).Capacity, NewKeyRoutingDataFromC(C.wrap_ImGuiKeyRoutingTable_GetEntriesNext(internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](selfArg)).Data))
}

func (self LastItemData) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self LastItemData) SetItemFlags(v ItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetItemFlags(selfArg, C.ImGuiItemFlags(v))
}

func (self LastItemData) SetStatusFlags(v ItemStatusFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetStatusFlags(selfArg, C.ImGuiItemStatusFlags(v))
}

func (self LastItemData) SetRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self LastItemData) SetNavRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetNavRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self LastItemData) SetDisplayRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetDisplayRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self LastItemData) SetClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self LastItemData) SetShortcut(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLastItemData_SetShortcut(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self *LastItemData) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiLastItemData_GetID(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *LastItemData) ItemFlags() ItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemFlags(C.wrap_ImGuiLastItemData_GetItemFlags(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg)))
}

func (self *LastItemData) StatusFlags() ItemStatusFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemStatusFlags(C.wrap_ImGuiLastItemData_GetStatusFlags(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg)))
}

func (self *LastItemData) Rect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiLastItemData_GetRect(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *LastItemData) NavRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiLastItemData_GetNavRect(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *LastItemData) DisplayRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiLastItemData_GetDisplayRect(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *LastItemData) ClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiLastItemData_GetClipRect(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *LastItemData) Shortcut() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiLastItemData_GetShortcut(internal.ReinterpretCast[*C.ImGuiLastItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self ListClipper) SetCtx(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetCtx(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self ListClipper) SetDisplayStart(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetDisplayStart(selfArg, C.int(v))
}

func (self ListClipper) SetDisplayEnd(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetDisplayEnd(selfArg, C.int(v))
}

func (self ListClipper) SetItemsCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetItemsCount(selfArg, C.int(v))
}

func (self ListClipper) SetItemsHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetItemsHeight(selfArg, C.float(v))
}

func (self ListClipper) SetStartPosY(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetStartPosY(selfArg, C.double(v))
}

func (self ListClipper) SetStartSeekOffsetY(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetStartSeekOffsetY(selfArg, C.double(v))
}

func (self ListClipper) SetTempData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetTempData(selfArg, C.uintptr_t(v))
}

func (self ListClipper) SetFlags(v ListClipperFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipper_SetFlags(selfArg, C.ImGuiListClipperFlags(v))
}

func (self *ListClipper) Ctx() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImGuiListClipper_GetCtx(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) DisplayStart() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipper_GetDisplayStart(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) DisplayEnd() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipper_GetDisplayEnd(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) ItemsCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipper_GetItemsCount(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) ItemsHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiListClipper_GetItemsHeight(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) StartPosY() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImGuiListClipper_GetStartPosY(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) StartSeekOffsetY() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImGuiListClipper_GetStartSeekOffsetY(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) TempData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiListClipper_GetTempData(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self *ListClipper) Flags() ListClipperFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ListClipperFlags(C.wrap_ImGuiListClipper_GetFlags(internal.ReinterpretCast[*C.ImGuiListClipper](selfArg)))
}

func (self ListClipperData) SetListClipper(v *ListClipper) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperData_SetListClipper(selfArg, internal.ReinterpretCast[*C.ImGuiListClipper](vArg))
}

func (self ListClipperData) SetLossynessOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperData_SetLossynessOffset(selfArg, C.float(v))
}

func (self ListClipperData) SetStepNo(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperData_SetStepNo(selfArg, C.int(v))
}

func (self ListClipperData) SetItemsFrozen(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperData_SetItemsFrozen(selfArg, C.int(v))
}

func (self ListClipperData) SetRanges(v vectors.Vector[ListClipperRange]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiListClipperRange)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiListClipperRange](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperData_SetRanges(selfArg, *vVecArg)
}

func (self *ListClipperData) ListClipper() *ListClipper {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewListClipperFromC(C.wrap_ImGuiListClipperData_GetListClipper(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)))
}

func (self *ListClipperData) LossynessOffset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiListClipperData_GetLossynessOffset(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)))
}

func (self *ListClipperData) StepNo() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipperData_GetStepNo(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)))
}

func (self *ListClipperData) ItemsFrozen() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipperData_GetItemsFrozen(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)))
}

func (self *ListClipperData) Ranges() vectors.Vector[ListClipperRange] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiListClipperData_GetRanges(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)).Size, C.wrap_ImGuiListClipperData_GetRanges(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)).Capacity, NewListClipperRangeFromC(C.wrap_ImGuiListClipperData_GetRanges(internal.ReinterpretCast[*C.ImGuiListClipperData](selfArg)).Data))
}

func (self ListClipperRange) SetMin(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperRange_SetMin(selfArg, C.int(v))
}

func (self ListClipperRange) SetMax(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperRange_SetMax(selfArg, C.int(v))
}

func (self ListClipperRange) SetPosToIndexConvert(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperRange_SetPosToIndexConvert(selfArg, C.bool(v))
}

func (self ListClipperRange) SetPosToIndexOffsetMin(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperRange_SetPosToIndexOffsetMin(selfArg, C.ImS8(v))
}

func (self ListClipperRange) SetPosToIndexOffsetMax(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiListClipperRange_SetPosToIndexOffsetMax(selfArg, C.ImS8(v))
}

func (self *ListClipperRange) Min() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipperRange_GetMin(internal.ReinterpretCast[*C.ImGuiListClipperRange](selfArg)))
}

func (self *ListClipperRange) Max() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiListClipperRange_GetMax(internal.ReinterpretCast[*C.ImGuiListClipperRange](selfArg)))
}

func (self *ListClipperRange) PosToIndexConvert() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiListClipperRange_GetPosToIndexConvert(internal.ReinterpretCast[*C.ImGuiListClipperRange](selfArg)) == C.bool(true)
}

func (self *ListClipperRange) PosToIndexOffsetMin() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiListClipperRange_GetPosToIndexOffsetMin(internal.ReinterpretCast[*C.ImGuiListClipperRange](selfArg)))
}

func (self *ListClipperRange) PosToIndexOffsetMax() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiListClipperRange_GetPosToIndexOffsetMax(internal.ReinterpretCast[*C.ImGuiListClipperRange](selfArg)))
}

func (self LocEntry) SetKey(v LocKey) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLocEntry_SetKey(selfArg, C.ImGuiLocKey(v))
}

func (self LocEntry) SetText(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiLocEntry_SetText(selfArg, vArg)
}

func (self *LocEntry) Key() LocKey {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LocKey(C.wrap_ImGuiLocEntry_GetKey(internal.ReinterpretCast[*C.ImGuiLocEntry](selfArg)))
}

func (self *LocEntry) Text() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiLocEntry_GetText(internal.ReinterpretCast[*C.ImGuiLocEntry](selfArg)))
}

func (self MenuColumns) SetTotalWidth(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetTotalWidth(selfArg, C.ImU32(v))
}

func (self MenuColumns) SetNextTotalWidth(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetNextTotalWidth(selfArg, C.ImU32(v))
}

func (self MenuColumns) SetSpacing(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetSpacing(selfArg, C.ImU16(v))
}

func (self MenuColumns) SetOffsetIcon(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetOffsetIcon(selfArg, C.ImU16(v))
}

func (self MenuColumns) SetOffsetLabel(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetOffsetLabel(selfArg, C.ImU16(v))
}

func (self MenuColumns) SetOffsetShortcut(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetOffsetShortcut(selfArg, C.ImU16(v))
}

func (self MenuColumns) SetOffsetMark(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetOffsetMark(selfArg, C.ImU16(v))
}

func (self MenuColumns) SetWidths(v *[4]uint16) {
	vArg := make([]C.ImU16, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU16(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMenuColumns_SetWidths(selfArg, (*C.ImU16)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (uint16)(vV)
	}
}

func (self *MenuColumns) TotalWidth() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiMenuColumns_GetTotalWidth(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) NextTotalWidth() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiMenuColumns_GetNextTotalWidth(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) Spacing() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint16)(C.wrap_ImGuiMenuColumns_GetSpacing(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) OffsetIcon() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint16)(C.wrap_ImGuiMenuColumns_GetOffsetIcon(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) OffsetLabel() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint16)(C.wrap_ImGuiMenuColumns_GetOffsetLabel(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) OffsetShortcut() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint16)(C.wrap_ImGuiMenuColumns_GetOffsetShortcut(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) OffsetMark() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint16)(C.wrap_ImGuiMenuColumns_GetOffsetMark(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg)))
}

func (self *MenuColumns) Widths() [4](uint16) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [4](uint16) {
		result := [4](uint16){}
		resultMirr := C.wrap_ImGuiMenuColumns_GetWidths(internal.ReinterpretCast[*C.ImGuiMenuColumns](selfArg))
		for i := range result {
			result[i] = (uint16)(C.imgui_ImU16_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self MetricsConfig) SetShowDebugLog(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowDebugLog(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowIDStackTool(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowIDStackTool(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowWindowsRects(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowWindowsRects(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowWindowsBeginOrder(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowWindowsBeginOrder(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowTablesRects(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowTablesRects(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowDrawCmdMesh(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowDrawCmdMesh(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowDrawCmdBoundingBoxes(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowDrawCmdBoundingBoxes(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowTextEncodingViewer(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowTextEncodingViewer(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowTextureUsedRect(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowTextureUsedRect(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowDockingNodes(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowDockingNodes(selfArg, C.bool(v))
}

func (self MetricsConfig) SetShowWindowsRectsType(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowWindowsRectsType(selfArg, C.int(v))
}

func (self MetricsConfig) SetShowTablesRectsType(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowTablesRectsType(selfArg, C.int(v))
}

func (self MetricsConfig) SetHighlightMonitorIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetHighlightMonitorIdx(selfArg, C.int(v))
}

func (self MetricsConfig) SetHighlightViewportID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetHighlightViewportID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self MetricsConfig) SetShowFontPreview(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMetricsConfig_SetShowFontPreview(selfArg, C.bool(v))
}

func (self *MetricsConfig) ShowDebugLog() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowDebugLog(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowIDStackTool() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowIDStackTool(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowWindowsRects() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowWindowsRects(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowWindowsBeginOrder() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowWindowsBeginOrder(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowTablesRects() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowTablesRects(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowDrawCmdMesh() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowDrawCmdMesh(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowDrawCmdBoundingBoxes() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowDrawCmdBoundingBoxes(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowTextEncodingViewer() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowTextEncodingViewer(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowTextureUsedRect() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowTextureUsedRect(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowDockingNodes() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowDockingNodes(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self *MetricsConfig) ShowWindowsRectsType() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiMetricsConfig_GetShowWindowsRectsType(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)))
}

func (self *MetricsConfig) ShowTablesRectsType() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiMetricsConfig_GetShowTablesRectsType(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)))
}

func (self *MetricsConfig) HighlightMonitorIdx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiMetricsConfig_GetHighlightMonitorIdx(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)))
}

func (self *MetricsConfig) HighlightViewportID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMetricsConfig_GetHighlightViewportID(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *MetricsConfig) ShowFontPreview() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMetricsConfig_GetShowFontPreview(internal.ReinterpretCast[*C.ImGuiMetricsConfig](selfArg)) == C.bool(true)
}

func (self MultiSelectIO) SetRequests(v vectors.Vector[SelectionRequest]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiSelectionRequest)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiSelectionRequest](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectIO_SetRequests(selfArg, *vVecArg)
}

func (self MultiSelectIO) SetRangeSrcItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectIO_SetRangeSrcItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self MultiSelectIO) SetNavIdItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectIO_SetNavIdItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self MultiSelectIO) SetNavIdSelected(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectIO_SetNavIdSelected(selfArg, C.bool(v))
}

func (self MultiSelectIO) SetRangeSrcReset(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectIO_SetRangeSrcReset(selfArg, C.bool(v))
}

func (self MultiSelectIO) SetItemsCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectIO_SetItemsCount(selfArg, C.int(v))
}

func (self *MultiSelectIO) Requests() vectors.Vector[SelectionRequest] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiMultiSelectIO_GetRequests(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg)).Size, C.wrap_ImGuiMultiSelectIO_GetRequests(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg)).Capacity, NewSelectionRequestFromC(C.wrap_ImGuiMultiSelectIO_GetRequests(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg)).Data))
}

func (self *MultiSelectIO) RangeSrcItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectIO_GetRangeSrcItem(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *MultiSelectIO) NavIdItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectIO_GetNavIdItem(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *MultiSelectIO) NavIdSelected() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectIO_GetNavIdSelected(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg)) == C.bool(true)
}

func (self *MultiSelectIO) RangeSrcReset() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectIO_GetRangeSrcReset(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg)) == C.bool(true)
}

func (self *MultiSelectIO) ItemsCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiMultiSelectIO_GetItemsCount(internal.ReinterpretCast[*C.ImGuiMultiSelectIO](selfArg)))
}

func (self MultiSelectState) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self MultiSelectState) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self MultiSelectState) SetLastFrameActive(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetLastFrameActive(selfArg, C.int(v))
}

func (self MultiSelectState) SetLastSelectionSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetLastSelectionSize(selfArg, C.int(v))
}

func (self MultiSelectState) SetRangeSelected(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetRangeSelected(selfArg, C.ImS8(v))
}

func (self MultiSelectState) SetNavIdSelected(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetNavIdSelected(selfArg, C.ImS8(v))
}

func (self MultiSelectState) SetRangeSrcItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetRangeSrcItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self MultiSelectState) SetNavIdItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectState_SetNavIdItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self *MultiSelectState) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiMultiSelectState_GetWindow(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg)))
}

func (self *MultiSelectState) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectState_GetID(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *MultiSelectState) LastFrameActive() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiMultiSelectState_GetLastFrameActive(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg)))
}

func (self *MultiSelectState) LastSelectionSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiMultiSelectState_GetLastSelectionSize(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg)))
}

func (self *MultiSelectState) RangeSelected() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiMultiSelectState_GetRangeSelected(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg)))
}

func (self *MultiSelectState) NavIdSelected() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiMultiSelectState_GetNavIdSelected(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg)))
}

func (self *MultiSelectState) RangeSrcItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectState_GetRangeSrcItem(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *MultiSelectState) NavIdItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectState_GetNavIdItem(internal.ReinterpretCast[*C.ImGuiMultiSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self MultiSelectTempData) SetIO(v MultiSelectIO) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetIO(selfArg, internal.ReinterpretCast[C.ImGuiMultiSelectIO](vArg))
}

func (self MultiSelectTempData) SetStorage(v *MultiSelectState) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetStorage(selfArg, internal.ReinterpretCast[*C.ImGuiMultiSelectState](vArg))
}

func (self MultiSelectTempData) SetFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self MultiSelectTempData) SetFlags(v MultiSelectFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetFlags(selfArg, C.ImGuiMultiSelectFlags(v))
}

func (self MultiSelectTempData) SetScopeRectMin(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetScopeRectMin(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self MultiSelectTempData) SetBackupCursorMaxPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetBackupCursorMaxPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self MultiSelectTempData) SetLastSubmittedItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetLastSubmittedItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self MultiSelectTempData) SetBoxSelectId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetBoxSelectId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self MultiSelectTempData) SetKeyMods(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetKeyMods(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self MultiSelectTempData) SetLoopRequestSetAll(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetLoopRequestSetAll(selfArg, C.ImS8(v))
}

func (self MultiSelectTempData) SetIsEndIO(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetIsEndIO(selfArg, C.bool(v))
}

func (self MultiSelectTempData) SetIsFocused(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetIsFocused(selfArg, C.bool(v))
}

func (self MultiSelectTempData) SetIsKeyboardSetRange(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetIsKeyboardSetRange(selfArg, C.bool(v))
}

func (self MultiSelectTempData) SetNavIdPassedBy(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetNavIdPassedBy(selfArg, C.bool(v))
}

func (self MultiSelectTempData) SetRangeSrcPassedBy(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetRangeSrcPassedBy(selfArg, C.bool(v))
}

func (self MultiSelectTempData) SetRangeDstPassedBy(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiMultiSelectTempData_SetRangeDstPassedBy(selfArg, C.bool(v))
}

func (self *MultiSelectTempData) IO() MultiSelectIO {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectTempData_GetIO(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewMultiSelectIOFromC(func() *C.ImGuiMultiSelectIO { result := result; return &result }())
}

func (self *MultiSelectTempData) Storage() *MultiSelectState {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewMultiSelectStateFromC(C.wrap_ImGuiMultiSelectTempData_GetStorage(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)))
}

func (self *MultiSelectTempData) FocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectTempData_GetFocusScopeId(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *MultiSelectTempData) Flags() MultiSelectFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MultiSelectFlags(C.wrap_ImGuiMultiSelectTempData_GetFlags(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)))
}

func (self *MultiSelectTempData) ScopeRectMin() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiMultiSelectTempData_GetScopeRectMin(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *MultiSelectTempData) BackupCursorMaxPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiMultiSelectTempData_GetBackupCursorMaxPos(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *MultiSelectTempData) LastSubmittedItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectTempData_GetLastSubmittedItem(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *MultiSelectTempData) BoxSelectId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectTempData_GetBoxSelectId(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *MultiSelectTempData) KeyMods() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiMultiSelectTempData_GetKeyMods(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *MultiSelectTempData) LoopRequestSetAll() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiMultiSelectTempData_GetLoopRequestSetAll(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)))
}

func (self *MultiSelectTempData) IsEndIO() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectTempData_GetIsEndIO(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)) == C.bool(true)
}

func (self *MultiSelectTempData) IsFocused() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectTempData_GetIsFocused(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)) == C.bool(true)
}

func (self *MultiSelectTempData) IsKeyboardSetRange() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectTempData_GetIsKeyboardSetRange(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)) == C.bool(true)
}

func (self *MultiSelectTempData) NavIdPassedBy() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectTempData_GetNavIdPassedBy(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)) == C.bool(true)
}

func (self *MultiSelectTempData) RangeSrcPassedBy() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectTempData_GetRangeSrcPassedBy(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)) == C.bool(true)
}

func (self *MultiSelectTempData) RangeDstPassedBy() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiMultiSelectTempData_GetRangeDstPassedBy(internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](selfArg)) == C.bool(true)
}

func (self NavItemData) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self NavItemData) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self NavItemData) SetFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self NavItemData) SetRectRel(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetRectRel(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self NavItemData) SetItemFlags(v ItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetItemFlags(selfArg, C.ImGuiItemFlags(v))
}

func (self NavItemData) SetDistBox(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetDistBox(selfArg, C.float(v))
}

func (self NavItemData) SetDistCenter(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetDistCenter(selfArg, C.float(v))
}

func (self NavItemData) SetDistAxial(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetDistAxial(selfArg, C.float(v))
}

func (self NavItemData) SetSelectionUserData(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNavItemData_SetSelectionUserData(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self *NavItemData) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiNavItemData_GetWindow(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg)))
}

func (self *NavItemData) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNavItemData_GetID(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *NavItemData) FocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNavItemData_GetFocusScopeId(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *NavItemData) RectRel() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiNavItemData_GetRectRel(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NavItemData) ItemFlags() ItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemFlags(C.wrap_ImGuiNavItemData_GetItemFlags(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg)))
}

func (self *NavItemData) DistBox() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiNavItemData_GetDistBox(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg)))
}

func (self *NavItemData) DistCenter() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiNavItemData_GetDistCenter(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg)))
}

func (self *NavItemData) DistAxial() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiNavItemData_GetDistAxial(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg)))
}

func (self *NavItemData) SelectionUserData() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNavItemData_GetSelectionUserData(internal.ReinterpretCast[*C.ImGuiNavItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self NextItemData) SetHasFlags(v NextItemDataFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetHasFlags(selfArg, C.ImGuiNextItemDataFlags(v))
}

func (self NextItemData) SetItemFlags(v ItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetItemFlags(selfArg, C.ImGuiItemFlags(v))
}

func (self NextItemData) SetFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self NextItemData) SetSelectionUserData(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetSelectionUserData(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self NextItemData) SetWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetWidth(selfArg, C.float(v))
}

func (self NextItemData) SetShortcut(v KeyChord) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetShortcut(selfArg, internal.ReinterpretCast[C.ImGuiKeyChord](vArg))
}

func (self NextItemData) SetShortcutFlags(v InputFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetShortcutFlags(selfArg, C.ImGuiInputFlags(v))
}

func (self NextItemData) SetOpenVal(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetOpenVal(selfArg, C.bool(v))
}

func (self NextItemData) SetOpenCond(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetOpenCond(selfArg, C.ImU8(v))
}

func (self NextItemData) SetRefVal(v DataTypeStorage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetRefVal(selfArg, internal.ReinterpretCast[C.ImGuiDataTypeStorage](vArg))
}

func (self NextItemData) SetStorageId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextItemData_SetStorageId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *NextItemData) HasFlags() NextItemDataFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NextItemDataFlags(C.wrap_ImGuiNextItemData_GetHasFlags(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg)))
}

func (self *NextItemData) ItemFlags() ItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemFlags(C.wrap_ImGuiNextItemData_GetItemFlags(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg)))
}

func (self *NextItemData) FocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextItemData_GetFocusScopeId(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *NextItemData) SelectionUserData() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextItemData_GetSelectionUserData(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *NextItemData) Width() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiNextItemData_GetWidth(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg)))
}

func (self *NextItemData) Shortcut() KeyChord {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextItemData_GetShortcut(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewKeyChordFromC(func() *C.ImGuiKeyChord { result := result; return &result }())
}

func (self *NextItemData) ShortcutFlags() InputFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return InputFlags(C.wrap_ImGuiNextItemData_GetShortcutFlags(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg)))
}

func (self *NextItemData) OpenVal() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiNextItemData_GetOpenVal(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) OpenCond() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiNextItemData_GetOpenCond(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg)))
}

func (self *NextItemData) RefVal() DataTypeStorage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextItemData_GetRefVal(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDataTypeStorageFromC(func() *C.ImGuiDataTypeStorage { result := result; return &result }())
}

func (self *NextItemData) StorageId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextItemData_GetStorageId(internal.ReinterpretCast[*C.ImGuiNextItemData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self NextWindowData) SetHasFlags(v NextWindowDataFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetHasFlags(selfArg, C.ImGuiNextWindowDataFlags(v))
}

func (self NextWindowData) SetPosCond(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetPosCond(selfArg, C.ImGuiCond(v))
}

func (self NextWindowData) SetSizeCond(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetSizeCond(selfArg, C.ImGuiCond(v))
}

func (self NextWindowData) SetCollapsedCond(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetCollapsedCond(selfArg, C.ImGuiCond(v))
}

func (self NextWindowData) SetDockCond(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetDockCond(selfArg, C.ImGuiCond(v))
}

func (self NextWindowData) SetPosVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetPosVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self NextWindowData) SetPosPivotVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetPosPivotVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self NextWindowData) SetSizeVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetSizeVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self NextWindowData) SetContentSizeVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetContentSizeVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self NextWindowData) SetScrollVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetScrollVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self NextWindowData) SetWindowFlags(v WindowFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetWindowFlags(selfArg, C.ImGuiWindowFlags(v))
}

func (self NextWindowData) SetChildFlags(v ChildFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetChildFlags(selfArg, C.ImGuiChildFlags(v))
}

func (self NextWindowData) SetPosUndock(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetPosUndock(selfArg, C.bool(v))
}

func (self NextWindowData) SetCollapsedVal(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetCollapsedVal(selfArg, C.bool(v))
}

func (self NextWindowData) SetSizeConstraintRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetSizeConstraintRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self NextWindowData) SetSizeCallback(v SizeCallback) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetSizeCallback(selfArg, internal.ReinterpretCast[C.ImGuiSizeCallback](vArg))
}

func (self NextWindowData) SetSizeCallbackUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetSizeCallbackUserData(selfArg, C.uintptr_t(v))
}

func (self NextWindowData) SetBgAlphaVal(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetBgAlphaVal(selfArg, C.float(v))
}

func (self NextWindowData) SetViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self NextWindowData) SetDockId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetDockId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self NextWindowData) SetWindowClass(v WindowClass) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetWindowClass(selfArg, internal.ReinterpretCast[C.ImGuiWindowClass](vArg))
}

func (self NextWindowData) SetMenuBarOffsetMinVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetMenuBarOffsetMinVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self NextWindowData) SetRefreshFlagsVal(v WindowRefreshFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiNextWindowData_SetRefreshFlagsVal(selfArg, C.ImGuiWindowRefreshFlags(v))
}

func (self *NextWindowData) HasFlags() NextWindowDataFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NextWindowDataFlags(C.wrap_ImGuiNextWindowData_GetHasFlags(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) PosCond() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiNextWindowData_GetPosCond(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) SizeCond() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiNextWindowData_GetSizeCond(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) CollapsedCond() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiNextWindowData_GetCollapsedCond(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) DockCond() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiNextWindowData_GetDockCond(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) PosVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiNextWindowData_GetPosVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) PosPivotVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiNextWindowData_GetPosPivotVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) SizeVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiNextWindowData_GetSizeVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) ContentSizeVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiNextWindowData_GetContentSizeVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) ScrollVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiNextWindowData_GetScrollVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) WindowFlags() WindowFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return WindowFlags(C.wrap_ImGuiNextWindowData_GetWindowFlags(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) ChildFlags() ChildFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ChildFlags(C.wrap_ImGuiNextWindowData_GetChildFlags(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) PosUndock() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiNextWindowData_GetPosUndock(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)) == C.bool(true)
}

func (self *NextWindowData) CollapsedVal() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiNextWindowData_GetCollapsedVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)) == C.bool(true)
}

func (self *NextWindowData) SizeConstraintRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiNextWindowData_GetSizeConstraintRect(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) SizeCallback() SizeCallback {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextWindowData_GetSizeCallback(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSizeCallbackFromC(func() *C.ImGuiSizeCallback { result := result; return &result }())
}

func (self *NextWindowData) SizeCallbackUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiNextWindowData_GetSizeCallbackUserData(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) BgAlphaVal() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiNextWindowData_GetBgAlphaVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self *NextWindowData) ViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextWindowData_GetViewportId(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *NextWindowData) DockId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextWindowData_GetDockId(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *NextWindowData) WindowClass() WindowClass {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiNextWindowData_GetWindowClass(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewWindowClassFromC(func() *C.ImGuiWindowClass { result := result; return &result }())
}

func (self *NextWindowData) MenuBarOffsetMinVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiNextWindowData_GetMenuBarOffsetMinVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *NextWindowData) RefreshFlagsVal() WindowRefreshFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return WindowRefreshFlags(C.wrap_ImGuiNextWindowData_GetRefreshFlagsVal(internal.ReinterpretCast[*C.ImGuiNextWindowData](selfArg)))
}

func (self OldColumnData) SetOffsetNorm(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumnData_SetOffsetNorm(selfArg, C.float(v))
}

func (self OldColumnData) SetOffsetNormBeforeResize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumnData_SetOffsetNormBeforeResize(selfArg, C.float(v))
}

func (self OldColumnData) SetFlags(v OldColumnFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumnData_SetFlags(selfArg, C.ImGuiOldColumnFlags(v))
}

func (self OldColumnData) SetClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumnData_SetClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self *OldColumnData) OffsetNorm() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumnData_GetOffsetNorm(internal.ReinterpretCast[*C.ImGuiOldColumnData](selfArg)))
}

func (self *OldColumnData) OffsetNormBeforeResize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumnData_GetOffsetNormBeforeResize(internal.ReinterpretCast[*C.ImGuiOldColumnData](selfArg)))
}

func (self *OldColumnData) Flags() OldColumnFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return OldColumnFlags(C.wrap_ImGuiOldColumnData_GetFlags(internal.ReinterpretCast[*C.ImGuiOldColumnData](selfArg)))
}

func (self *OldColumnData) ClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiOldColumnData_GetClipRect(internal.ReinterpretCast[*C.ImGuiOldColumnData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self OldColumns) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self OldColumns) SetFlags(v OldColumnFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetFlags(selfArg, C.ImGuiOldColumnFlags(v))
}

func (self OldColumns) SetIsFirstFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetIsFirstFrame(selfArg, C.bool(v))
}

func (self OldColumns) SetIsBeingResized(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetIsBeingResized(selfArg, C.bool(v))
}

func (self OldColumns) SetCurrent(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetCurrent(selfArg, C.int(v))
}

func (self OldColumns) SetCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetCount(selfArg, C.int(v))
}

func (self OldColumns) SetOffMinX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetOffMinX(selfArg, C.float(v))
}

func (self OldColumns) SetOffMaxX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetOffMaxX(selfArg, C.float(v))
}

func (self OldColumns) SetLineMinY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetLineMinY(selfArg, C.float(v))
}

func (self OldColumns) SetLineMaxY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetLineMaxY(selfArg, C.float(v))
}

func (self OldColumns) SetHostCursorPosY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetHostCursorPosY(selfArg, C.float(v))
}

func (self OldColumns) SetHostCursorMaxPosX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetHostCursorMaxPosX(selfArg, C.float(v))
}

func (self OldColumns) SetHostInitialClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetHostInitialClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self OldColumns) SetHostBackupClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetHostBackupClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self OldColumns) SetHostBackupParentWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetHostBackupParentWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self OldColumns) SetColumns(v vectors.Vector[OldColumnData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiOldColumnData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiOldColumnData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetColumns(selfArg, *vVecArg)
}

func (self OldColumns) SetSplitter(v DrawListSplitter) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOldColumns_SetSplitter(selfArg, internal.ReinterpretCast[C.ImDrawListSplitter](vArg))
}

func (self *OldColumns) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiOldColumns_GetID(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *OldColumns) Flags() OldColumnFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return OldColumnFlags(C.wrap_ImGuiOldColumns_GetFlags(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) IsFirstFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiOldColumns_GetIsFirstFrame(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)) == C.bool(true)
}

func (self *OldColumns) IsBeingResized() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiOldColumns_GetIsBeingResized(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)) == C.bool(true)
}

func (self *OldColumns) Current() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiOldColumns_GetCurrent(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) Count() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiOldColumns_GetCount(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) OffMinX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumns_GetOffMinX(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) OffMaxX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumns_GetOffMaxX(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) LineMinY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumns_GetLineMinY(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) LineMaxY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumns_GetLineMaxY(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) HostCursorPosY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumns_GetHostCursorPosY(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) HostCursorMaxPosX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiOldColumns_GetHostCursorMaxPosX(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)))
}

func (self *OldColumns) HostInitialClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiOldColumns_GetHostInitialClipRect(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *OldColumns) HostBackupClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiOldColumns_GetHostBackupClipRect(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *OldColumns) HostBackupParentWorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiOldColumns_GetHostBackupParentWorkRect(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *OldColumns) Columns() vectors.Vector[OldColumnData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiOldColumns_GetColumns(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)).Size, C.wrap_ImGuiOldColumns_GetColumns(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)).Capacity, NewOldColumnDataFromC(C.wrap_ImGuiOldColumns_GetColumns(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg)).Data))
}

func (self *OldColumns) Splitter() DrawListSplitter {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiOldColumns_GetSplitter(internal.ReinterpretCast[*C.ImGuiOldColumns](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawListSplitterFromC(func() *C.ImDrawListSplitter { result := result; return &result }())
}

func (self OnceUponAFrame) SetRefFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiOnceUponAFrame_SetRefFrame(selfArg, C.int(v))
}

func (self *OnceUponAFrame) RefFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiOnceUponAFrame_GetRefFrame(internal.ReinterpretCast[*C.ImGuiOnceUponAFrame](selfArg)))
}

func (self Payload) SetData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetData(selfArg, C.uintptr_t(v))
}

func (self Payload) SetDataSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetDataSize(selfArg, C.int(v))
}

func (self Payload) SetSourceId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetSourceId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Payload) SetSourceParentId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetSourceParentId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Payload) SetDataFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetDataFrameCount(selfArg, C.int(v))
}

func (self Payload) SetDataType(v *[33]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetDataType(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self Payload) SetPreview(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetPreview(selfArg, C.bool(v))
}

func (self Payload) SetDelivery(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPayload_SetDelivery(selfArg, C.bool(v))
}

func (self *Payload) Data() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPayload_GetData(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)))
}

func (self *Payload) DataSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPayload_GetDataSize(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)))
}

func (self *Payload) SourceId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiPayload_GetSourceId(internal.ReinterpretCast[*C.ImGuiPayload](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Payload) SourceParentId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiPayload_GetSourceParentId(internal.ReinterpretCast[*C.ImGuiPayload](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Payload) DataFrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPayload_GetDataFrameCount(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)))
}

func (self *Payload) DataType() [33]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [33]rune {
		result := [33]rune{}
		resultMirr := C.wrap_ImGuiPayload_GetDataType(internal.ReinterpretCast[*C.ImGuiPayload](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Payload) Preview() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiPayload_GetPreview(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)) == C.bool(true)
}

func (self *Payload) Delivery() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiPayload_GetDelivery(internal.ReinterpretCast[*C.ImGuiPayload](selfArg)) == C.bool(true)
}

func (self PlatformIO) SetPlatformClipboardUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetPlatform_ClipboardUserData(selfArg, C.uintptr_t(v))
}

func (self PlatformIO) SetPlatformOpenInShellUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetPlatform_OpenInShellUserData(selfArg, C.uintptr_t(v))
}

func (self PlatformIO) SetPlatformImeUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetPlatform_ImeUserData(selfArg, C.uintptr_t(v))
}

func (self PlatformIO) SetPlatformLocaleDecimalPoint(v Wchar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetPlatform_LocaleDecimalPoint(selfArg, C.ImWchar(v))
}

func (self PlatformIO) SetRendererTextureMaxWidth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetRenderer_TextureMaxWidth(selfArg, C.int(v))
}

func (self PlatformIO) SetRendererTextureMaxHeight(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetRenderer_TextureMaxHeight(selfArg, C.int(v))
}

func (self PlatformIO) SetRendererRenderState(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetRenderer_RenderState(selfArg, C.uintptr_t(v))
}

func (self PlatformIO) SetMonitors(v vectors.Vector[PlatformMonitor]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiPlatformMonitor)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiPlatformMonitor](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformIO_SetMonitors(selfArg, *vVecArg)
}

func (self *PlatformIO) PlatformClipboardUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPlatformIO_GetPlatform_ClipboardUserData(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) PlatformOpenInShellUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPlatformIO_GetPlatform_OpenInShellUserData(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) PlatformImeUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPlatformIO_GetPlatform_ImeUserData(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) PlatformLocaleDecimalPoint() Wchar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (Wchar)(C.wrap_ImGuiPlatformIO_GetPlatform_LocaleDecimalPoint(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) RendererTextureMaxWidth() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPlatformIO_GetRenderer_TextureMaxWidth(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) RendererTextureMaxHeight() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPlatformIO_GetRenderer_TextureMaxHeight(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) RendererRenderState() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPlatformIO_GetRenderer_RenderState(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)))
}

func (self *PlatformIO) Monitors() vectors.Vector[PlatformMonitor] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiPlatformIO_GetMonitors(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Size, C.wrap_ImGuiPlatformIO_GetMonitors(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Capacity, NewPlatformMonitorFromC(C.wrap_ImGuiPlatformIO_GetMonitors(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Data))
}

func (self *PlatformIO) Textures() vectors.Vector[TextureData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiPlatformIO_GetTextures(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Size, C.wrap_ImGuiPlatformIO_GetTextures(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Capacity, NewTextureDataFromC(C.wrap_ImGuiPlatformIO_GetTextures(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Data))
}

func (self *PlatformIO) Viewports() vectors.Vector[Viewport] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiPlatformIO_GetViewports(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Size, C.wrap_ImGuiPlatformIO_GetViewports(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Capacity, NewViewportFromC(C.wrap_ImGuiPlatformIO_GetViewports(internal.ReinterpretCast[*C.ImGuiPlatformIO](selfArg)).Data))
}

func (self PlatformImeData) SetWantVisible(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformImeData_SetWantVisible(selfArg, C.bool(v))
}

func (self PlatformImeData) SetWantTextInput(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformImeData_SetWantTextInput(selfArg, C.bool(v))
}

func (self PlatformImeData) SetInputPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformImeData_SetInputPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self PlatformImeData) SetInputLineHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformImeData_SetInputLineHeight(selfArg, C.float(v))
}

func (self PlatformImeData) SetViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformImeData_SetViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *PlatformImeData) WantVisible() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiPlatformImeData_GetWantVisible(internal.ReinterpretCast[*C.ImGuiPlatformImeData](selfArg)) == C.bool(true)
}

func (self *PlatformImeData) WantTextInput() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiPlatformImeData_GetWantTextInput(internal.ReinterpretCast[*C.ImGuiPlatformImeData](selfArg)) == C.bool(true)
}

func (self *PlatformImeData) InputPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPlatformImeData_GetInputPos(internal.ReinterpretCast[*C.ImGuiPlatformImeData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *PlatformImeData) InputLineHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiPlatformImeData_GetInputLineHeight(internal.ReinterpretCast[*C.ImGuiPlatformImeData](selfArg)))
}

func (self *PlatformImeData) ViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiPlatformImeData_GetViewportId(internal.ReinterpretCast[*C.ImGuiPlatformImeData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self PlatformMonitor) SetMainPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformMonitor_SetMainPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self PlatformMonitor) SetMainSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformMonitor_SetMainSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self PlatformMonitor) SetWorkPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformMonitor_SetWorkPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self PlatformMonitor) SetWorkSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformMonitor_SetWorkSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self PlatformMonitor) SetDpiScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformMonitor_SetDpiScale(selfArg, C.float(v))
}

func (self PlatformMonitor) SetPlatformHandle(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPlatformMonitor_SetPlatformHandle(selfArg, C.uintptr_t(v))
}

func (self *PlatformMonitor) MainPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPlatformMonitor_GetMainPos(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *PlatformMonitor) MainSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPlatformMonitor_GetMainSize(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *PlatformMonitor) WorkPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPlatformMonitor_GetWorkPos(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *PlatformMonitor) WorkSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPlatformMonitor_GetWorkSize(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *PlatformMonitor) DpiScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiPlatformMonitor_GetDpiScale(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg)))
}

func (self *PlatformMonitor) PlatformHandle() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPlatformMonitor_GetPlatformHandle(internal.ReinterpretCast[*C.ImGuiPlatformMonitor](selfArg)))
}

func (self PopupData) SetPopupId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetPopupId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self PopupData) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self PopupData) SetRestoreNavWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetRestoreNavWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self PopupData) SetParentNavLayer(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetParentNavLayer(selfArg, C.int(v))
}

func (self PopupData) SetOpenFrameCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetOpenFrameCount(selfArg, C.int(v))
}

func (self PopupData) SetOpenParentId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetOpenParentId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self PopupData) SetOpenPopupPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetOpenPopupPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self PopupData) SetOpenMousePos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPopupData_SetOpenMousePos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self *PopupData) PopupId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiPopupData_GetPopupId(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *PopupData) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiPopupData_GetWindow(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg)))
}

func (self *PopupData) RestoreNavWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiPopupData_GetRestoreNavWindow(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg)))
}

func (self *PopupData) ParentNavLayer() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPopupData_GetParentNavLayer(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg)))
}

func (self *PopupData) OpenFrameCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPopupData_GetOpenFrameCount(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg)))
}

func (self *PopupData) OpenParentId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiPopupData_GetOpenParentId(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *PopupData) OpenPopupPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPopupData_GetOpenPopupPos(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *PopupData) OpenMousePos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiPopupData_GetOpenMousePos(internal.ReinterpretCast[*C.ImGuiPopupData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self PtrOrIndex) SetPtr(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPtrOrIndex_SetPtr(selfArg, C.uintptr_t(v))
}

func (self PtrOrIndex) SetIndex(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiPtrOrIndex_SetIndex(selfArg, C.int(v))
}

func (self *PtrOrIndex) Ptr() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiPtrOrIndex_GetPtr(internal.ReinterpretCast[*C.ImGuiPtrOrIndex](selfArg)))
}

func (self *PtrOrIndex) Index() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiPtrOrIndex_GetIndex(internal.ReinterpretCast[*C.ImGuiPtrOrIndex](selfArg)))
}

func (self SelectionBasicStorage) SetSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionBasicStorage_SetSize(selfArg, C.int(v))
}

func (self SelectionBasicStorage) SetPreserveOrder(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionBasicStorage_SetPreserveOrder(selfArg, C.bool(v))
}

func (self SelectionBasicStorage) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionBasicStorage_SetUserData(selfArg, C.uintptr_t(v))
}

func (self SelectionBasicStorage) SetSelectionOrder(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionBasicStorage_Set_SelectionOrder(selfArg, C.int(v))
}

func (self SelectionBasicStorage) SetStorage(v Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionBasicStorage_Set_Storage(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self *SelectionBasicStorage) Size() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiSelectionBasicStorage_GetSize(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg)))
}

func (self *SelectionBasicStorage) PreserveOrder() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiSelectionBasicStorage_GetPreserveOrder(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg)) == C.bool(true)
}

func (self *SelectionBasicStorage) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiSelectionBasicStorage_GetUserData(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg)))
}

func (self *SelectionBasicStorage) SelectionOrder() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiSelectionBasicStorage_Get_SelectionOrder(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg)))
}

func (self *SelectionBasicStorage) Storage() Storage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiSelectionBasicStorage_Get_Storage(internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStorageFromC(func() *C.ImGuiStorage { result := result; return &result }())
}

func (self SelectionExternalStorage) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionExternalStorage_SetUserData(selfArg, C.uintptr_t(v))
}

func (self *SelectionExternalStorage) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiSelectionExternalStorage_GetUserData(internal.ReinterpretCast[*C.ImGuiSelectionExternalStorage](selfArg)))
}

func (self SelectionRequest) SetType(v SelectionRequestType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionRequest_SetType(selfArg, C.ImGuiSelectionRequestType(v))
}

func (self SelectionRequest) SetSelected(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionRequest_SetSelected(selfArg, C.bool(v))
}

func (self SelectionRequest) SetRangeDirection(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionRequest_SetRangeDirection(selfArg, C.ImS8(v))
}

func (self SelectionRequest) SetRangeFirstItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionRequest_SetRangeFirstItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self SelectionRequest) SetRangeLastItem(v SelectionUserData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSelectionRequest_SetRangeLastItem(selfArg, internal.ReinterpretCast[C.ImGuiSelectionUserData](vArg))
}

func (self *SelectionRequest) Type() SelectionRequestType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return SelectionRequestType(C.wrap_ImGuiSelectionRequest_GetType(internal.ReinterpretCast[*C.ImGuiSelectionRequest](selfArg)))
}

func (self *SelectionRequest) Selected() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiSelectionRequest_GetSelected(internal.ReinterpretCast[*C.ImGuiSelectionRequest](selfArg)) == C.bool(true)
}

func (self *SelectionRequest) RangeDirection() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiSelectionRequest_GetRangeDirection(internal.ReinterpretCast[*C.ImGuiSelectionRequest](selfArg)))
}

func (self *SelectionRequest) RangeFirstItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiSelectionRequest_GetRangeFirstItem(internal.ReinterpretCast[*C.ImGuiSelectionRequest](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self *SelectionRequest) RangeLastItem() SelectionUserData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiSelectionRequest_GetRangeLastItem(internal.ReinterpretCast[*C.ImGuiSelectionRequest](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewSelectionUserDataFromC(func() *C.ImGuiSelectionUserData { result := result; return &result }())
}

func (self SettingsHandler) SetTypeName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSettingsHandler_SetTypeName(selfArg, vArg)
}

func (self SettingsHandler) SetTypeHash(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSettingsHandler_SetTypeHash(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self SettingsHandler) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSettingsHandler_SetUserData(selfArg, C.uintptr_t(v))
}

func (self *SettingsHandler) TypeName() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiSettingsHandler_GetTypeName(internal.ReinterpretCast[*C.ImGuiSettingsHandler](selfArg)))
}

func (self *SettingsHandler) TypeHash() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiSettingsHandler_GetTypeHash(internal.ReinterpretCast[*C.ImGuiSettingsHandler](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *SettingsHandler) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiSettingsHandler_GetUserData(internal.ReinterpretCast[*C.ImGuiSettingsHandler](selfArg)))
}

func (self ShrinkWidthItem) SetIndex(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiShrinkWidthItem_SetIndex(selfArg, C.int(v))
}

func (self ShrinkWidthItem) SetWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiShrinkWidthItem_SetWidth(selfArg, C.float(v))
}

func (self ShrinkWidthItem) SetInitialWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiShrinkWidthItem_SetInitialWidth(selfArg, C.float(v))
}

func (self *ShrinkWidthItem) Index() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiShrinkWidthItem_GetIndex(internal.ReinterpretCast[*C.ImGuiShrinkWidthItem](selfArg)))
}

func (self *ShrinkWidthItem) Width() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiShrinkWidthItem_GetWidth(internal.ReinterpretCast[*C.ImGuiShrinkWidthItem](selfArg)))
}

func (self *ShrinkWidthItem) InitialWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiShrinkWidthItem_GetInitialWidth(internal.ReinterpretCast[*C.ImGuiShrinkWidthItem](selfArg)))
}

func (self SizeCallbackData) SetUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSizeCallbackData_SetUserData(selfArg, C.uintptr_t(v))
}

func (self SizeCallbackData) SetPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSizeCallbackData_SetPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self SizeCallbackData) SetCurrentSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSizeCallbackData_SetCurrentSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self SizeCallbackData) SetDesiredSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiSizeCallbackData_SetDesiredSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self *SizeCallbackData) UserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiSizeCallbackData_GetUserData(internal.ReinterpretCast[*C.ImGuiSizeCallbackData](selfArg)))
}

func (self *SizeCallbackData) Pos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiSizeCallbackData_GetPos(internal.ReinterpretCast[*C.ImGuiSizeCallbackData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *SizeCallbackData) CurrentSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiSizeCallbackData_GetCurrentSize(internal.ReinterpretCast[*C.ImGuiSizeCallbackData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *SizeCallbackData) DesiredSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiSizeCallbackData_GetDesiredSize(internal.ReinterpretCast[*C.ImGuiSizeCallbackData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self StackLevelInfo) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStackLevelInfo_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self StackLevelInfo) SetQueryFrameCount(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStackLevelInfo_SetQueryFrameCount(selfArg, C.ImS8(v))
}

func (self StackLevelInfo) SetQuerySuccess(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStackLevelInfo_SetQuerySuccess(selfArg, C.bool(v))
}

func (self StackLevelInfo) SetDataType(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStackLevelInfo_SetDataType(selfArg, C.ImS8(v))
}

func (self StackLevelInfo) SetDescOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStackLevelInfo_SetDescOffset(selfArg, C.int(v))
}

func (self *StackLevelInfo) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiStackLevelInfo_GetID(internal.ReinterpretCast[*C.ImGuiStackLevelInfo](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *StackLevelInfo) QueryFrameCount() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiStackLevelInfo_GetQueryFrameCount(internal.ReinterpretCast[*C.ImGuiStackLevelInfo](selfArg)))
}

func (self *StackLevelInfo) QuerySuccess() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiStackLevelInfo_GetQuerySuccess(internal.ReinterpretCast[*C.ImGuiStackLevelInfo](selfArg)) == C.bool(true)
}

func (self *StackLevelInfo) DataType() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiStackLevelInfo_GetDataType(internal.ReinterpretCast[*C.ImGuiStackLevelInfo](selfArg)))
}

func (self *StackLevelInfo) DescOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiStackLevelInfo_GetDescOffset(internal.ReinterpretCast[*C.ImGuiStackLevelInfo](selfArg)))
}

func (self Storage) SetData(v vectors.Vector[StoragePair]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiStoragePair)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiStoragePair](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStorage_SetData(selfArg, *vVecArg)
}

func (self *Storage) Data() vectors.Vector[StoragePair] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiStorage_GetData(internal.ReinterpretCast[*C.ImGuiStorage](selfArg)).Size, C.wrap_ImGuiStorage_GetData(internal.ReinterpretCast[*C.ImGuiStorage](selfArg)).Capacity, NewStoragePairFromC(C.wrap_ImGuiStorage_GetData(internal.ReinterpretCast[*C.ImGuiStorage](selfArg)).Data))
}

func (self StoragePair) SetKey(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStoragePair_SetKey(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *StoragePair) Key() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiStoragePair_GetKey(internal.ReinterpretCast[*C.ImGuiStoragePair](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self Style) SetFontSizeBase(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetFontSizeBase(selfArg, C.float(v))
}

func (self Style) SetFontScaleMain(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetFontScaleMain(selfArg, C.float(v))
}

func (self Style) SetFontScaleDpi(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetFontScaleDpi(selfArg, C.float(v))
}

func (self Style) SetAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetAlpha(selfArg, C.float(v))
}

func (self Style) SetDisabledAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetDisabledAlpha(selfArg, C.float(v))
}

func (self Style) SetWindowPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetWindowRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowRounding(selfArg, C.float(v))
}

func (self Style) SetWindowBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowBorderSize(selfArg, C.float(v))
}

func (self Style) SetWindowBorderHoverPadding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowBorderHoverPadding(selfArg, C.float(v))
}

func (self Style) SetWindowMinSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowMinSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetWindowTitleAlign(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowTitleAlign(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetWindowMenuButtonPosition(v Dir) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetWindowMenuButtonPosition(selfArg, C.ImGuiDir(v))
}

func (self Style) SetChildRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetChildRounding(selfArg, C.float(v))
}

func (self Style) SetChildBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetChildBorderSize(selfArg, C.float(v))
}

func (self Style) SetPopupRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetPopupRounding(selfArg, C.float(v))
}

func (self Style) SetPopupBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetPopupBorderSize(selfArg, C.float(v))
}

func (self Style) SetFramePadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetFramePadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetFrameRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetFrameRounding(selfArg, C.float(v))
}

func (self Style) SetFrameBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetFrameBorderSize(selfArg, C.float(v))
}

func (self Style) SetItemSpacing(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetItemSpacing(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetItemInnerSpacing(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetItemInnerSpacing(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetCellPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetCellPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetTouchExtraPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTouchExtraPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetIndentSpacing(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetIndentSpacing(selfArg, C.float(v))
}

func (self Style) SetColumnsMinSpacing(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetColumnsMinSpacing(selfArg, C.float(v))
}

func (self Style) SetScrollbarSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetScrollbarSize(selfArg, C.float(v))
}

func (self Style) SetScrollbarRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetScrollbarRounding(selfArg, C.float(v))
}

func (self Style) SetScrollbarPadding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetScrollbarPadding(selfArg, C.float(v))
}

func (self Style) SetGrabMinSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetGrabMinSize(selfArg, C.float(v))
}

func (self Style) SetGrabRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetGrabRounding(selfArg, C.float(v))
}

func (self Style) SetLogSliderDeadzone(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetLogSliderDeadzone(selfArg, C.float(v))
}

func (self Style) SetImageBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetImageBorderSize(selfArg, C.float(v))
}

func (self Style) SetTabRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabRounding(selfArg, C.float(v))
}

func (self Style) SetTabBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabBorderSize(selfArg, C.float(v))
}

func (self Style) SetTabMinWidthBase(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabMinWidthBase(selfArg, C.float(v))
}

func (self Style) SetTabMinWidthShrink(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabMinWidthShrink(selfArg, C.float(v))
}

func (self Style) SetTabCloseButtonMinWidthSelected(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabCloseButtonMinWidthSelected(selfArg, C.float(v))
}

func (self Style) SetTabCloseButtonMinWidthUnselected(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabCloseButtonMinWidthUnselected(selfArg, C.float(v))
}

func (self Style) SetTabBarBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabBarBorderSize(selfArg, C.float(v))
}

func (self Style) SetTabBarOverlineSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTabBarOverlineSize(selfArg, C.float(v))
}

func (self Style) SetTableAngledHeadersAngle(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTableAngledHeadersAngle(selfArg, C.float(v))
}

func (self Style) SetTableAngledHeadersTextAlign(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTableAngledHeadersTextAlign(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetTreeLinesFlags(v TreeNodeFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTreeLinesFlags(selfArg, C.ImGuiTreeNodeFlags(v))
}

func (self Style) SetTreeLinesSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTreeLinesSize(selfArg, C.float(v))
}

func (self Style) SetTreeLinesRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetTreeLinesRounding(selfArg, C.float(v))
}

func (self Style) SetColorButtonPosition(v Dir) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetColorButtonPosition(selfArg, C.ImGuiDir(v))
}

func (self Style) SetButtonTextAlign(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetButtonTextAlign(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetSelectableTextAlign(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetSelectableTextAlign(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetSeparatorTextBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetSeparatorTextBorderSize(selfArg, C.float(v))
}

func (self Style) SetSeparatorTextAlign(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetSeparatorTextAlign(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetSeparatorTextPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetSeparatorTextPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetDisplayWindowPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetDisplayWindowPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetDisplaySafeAreaPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetDisplaySafeAreaPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetDockingNodeHasCloseButton(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetDockingNodeHasCloseButton(selfArg, C.bool(v))
}

func (self Style) SetDockingSeparatorSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetDockingSeparatorSize(selfArg, C.float(v))
}

func (self Style) SetMouseCursorScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetMouseCursorScale(selfArg, C.float(v))
}

func (self Style) SetAntiAliasedLines(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetAntiAliasedLines(selfArg, C.bool(v))
}

func (self Style) SetAntiAliasedLinesUseTex(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetAntiAliasedLinesUseTex(selfArg, C.bool(v))
}

func (self Style) SetAntiAliasedFill(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetAntiAliasedFill(selfArg, C.bool(v))
}

func (self Style) SetCurveTessellationTol(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetCurveTessellationTol(selfArg, C.float(v))
}

func (self Style) SetCircleTessellationMaxError(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetCircleTessellationMaxError(selfArg, C.float(v))
}

func (self Style) SetColors(v *[60]Vec4) {
	vArg := make([]C.ImVec4, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec4](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetColors(selfArg, (*C.ImVec4)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() Vec4 { out := vV; return *(&Vec4{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self Style) SetHoverStationaryDelay(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetHoverStationaryDelay(selfArg, C.float(v))
}

func (self Style) SetHoverDelayShort(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetHoverDelayShort(selfArg, C.float(v))
}

func (self Style) SetHoverDelayNormal(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetHoverDelayNormal(selfArg, C.float(v))
}

func (self Style) SetHoverFlagsForTooltipMouse(v HoveredFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetHoverFlagsForTooltipMouse(selfArg, C.ImGuiHoveredFlags(v))
}

func (self Style) SetHoverFlagsForTooltipNav(v HoveredFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_SetHoverFlagsForTooltipNav(selfArg, C.ImGuiHoveredFlags(v))
}

func (self Style) SetMainScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_Set_MainScale(selfArg, C.float(v))
}

func (self Style) SetNextFrameFontSizeBase(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyle_Set_NextFrameFontSizeBase(selfArg, C.float(v))
}

func (self *Style) FontSizeBase() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetFontSizeBase(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) FontScaleMain() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetFontScaleMain(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) FontScaleDpi() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetFontScaleDpi(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) Alpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetAlpha(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) DisabledAlpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetDisabledAlpha(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) WindowPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetWindowPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) WindowRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetWindowRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) WindowBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetWindowBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) WindowBorderHoverPadding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetWindowBorderHoverPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) WindowMinSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetWindowMinSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) WindowTitleAlign() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetWindowTitleAlign(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) WindowMenuButtonPosition() Dir {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Dir(C.wrap_ImGuiStyle_GetWindowMenuButtonPosition(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ChildRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetChildRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ChildBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetChildBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) PopupRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetPopupRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) PopupBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetPopupBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) FramePadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetFramePadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) FrameRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetFrameRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) FrameBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetFrameBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ItemSpacing() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetItemSpacing(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) ItemInnerSpacing() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetItemInnerSpacing(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) CellPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetCellPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) TouchExtraPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetTouchExtraPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) IndentSpacing() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetIndentSpacing(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ColumnsMinSpacing() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetColumnsMinSpacing(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ScrollbarSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetScrollbarSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ScrollbarRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetScrollbarRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ScrollbarPadding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetScrollbarPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) GrabMinSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetGrabMinSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) GrabRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetGrabRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) LogSliderDeadzone() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetLogSliderDeadzone(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ImageBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetImageBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabMinWidthBase() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabMinWidthBase(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabMinWidthShrink() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabMinWidthShrink(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabCloseButtonMinWidthSelected() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabCloseButtonMinWidthSelected(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabCloseButtonMinWidthUnselected() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabCloseButtonMinWidthUnselected(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabBarBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabBarBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TabBarOverlineSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTabBarOverlineSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TableAngledHeadersAngle() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTableAngledHeadersAngle(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TableAngledHeadersTextAlign() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetTableAngledHeadersTextAlign(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) TreeLinesFlags() TreeNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TreeNodeFlags(C.wrap_ImGuiStyle_GetTreeLinesFlags(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TreeLinesSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTreeLinesSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) TreeLinesRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetTreeLinesRounding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ColorButtonPosition() Dir {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Dir(C.wrap_ImGuiStyle_GetColorButtonPosition(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) ButtonTextAlign() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetButtonTextAlign(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) SelectableTextAlign() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetSelectableTextAlign(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) SeparatorTextBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetSeparatorTextBorderSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) SeparatorTextAlign() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetSeparatorTextAlign(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) SeparatorTextPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetSeparatorTextPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) DisplayWindowPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetDisplayWindowPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) DisplaySafeAreaPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiStyle_GetDisplaySafeAreaPadding(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) DockingNodeHasCloseButton() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiStyle_GetDockingNodeHasCloseButton(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)) == C.bool(true)
}

func (self *Style) DockingSeparatorSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetDockingSeparatorSize(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) MouseCursorScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetMouseCursorScale(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) AntiAliasedLines() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiStyle_GetAntiAliasedLines(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)) == C.bool(true)
}

func (self *Style) AntiAliasedLinesUseTex() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiStyle_GetAntiAliasedLinesUseTex(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)) == C.bool(true)
}

func (self *Style) AntiAliasedFill() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiStyle_GetAntiAliasedFill(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)) == C.bool(true)
}

func (self *Style) CurveTessellationTol() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetCurveTessellationTol(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) CircleTessellationMaxError() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetCircleTessellationMaxError(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) Colors() [60]Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [60]Vec4 {
		result := [60]Vec4{}
		resultMirr := C.wrap_ImGuiStyle_GetColors(internal.ReinterpretCast[*C.ImGuiStyle](selfArg))
		for i := range result {
			result[i] = func() Vec4 {
				out := C.imgui_ImVec4_GetAtIdx(resultMirr, C.int(i))
				return *(&Vec4{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *Style) HoverStationaryDelay() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetHoverStationaryDelay(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) HoverDelayShort() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetHoverDelayShort(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) HoverDelayNormal() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_GetHoverDelayNormal(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) HoverFlagsForTooltipMouse() HoveredFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return HoveredFlags(C.wrap_ImGuiStyle_GetHoverFlagsForTooltipMouse(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) HoverFlagsForTooltipNav() HoveredFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return HoveredFlags(C.wrap_ImGuiStyle_GetHoverFlagsForTooltipNav(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) MainScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_Get_MainScale(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self *Style) NextFrameFontSizeBase() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiStyle_Get_NextFrameFontSizeBase(internal.ReinterpretCast[*C.ImGuiStyle](selfArg)))
}

func (self StyleMod) SetVarIdx(v StyleVar) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyleMod_SetVarIdx(selfArg, C.ImGuiStyleVar(v))
}

func (self *StyleMod) VarIdx() StyleVar {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return StyleVar(C.wrap_ImGuiStyleMod_GetVarIdx(internal.ReinterpretCast[*C.ImGuiStyleMod](selfArg)))
}

func (self StyleVarInfo) SetCount(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyleVarInfo_SetCount(selfArg, C.ImU32(v))
}

func (self StyleVarInfo) SetDataType(v DataType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyleVarInfo_SetDataType(selfArg, C.ImGuiDataType(v))
}

func (self StyleVarInfo) SetOffset(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiStyleVarInfo_SetOffset(selfArg, C.ImU32(v))
}

func (self *StyleVarInfo) Count() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiStyleVarInfo_GetCount(internal.ReinterpretCast[*C.ImGuiStyleVarInfo](selfArg)))
}

func (self *StyleVarInfo) DataType() DataType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DataType(C.wrap_ImGuiStyleVarInfo_GetDataType(internal.ReinterpretCast[*C.ImGuiStyleVarInfo](selfArg)))
}

func (self *StyleVarInfo) Offset() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiStyleVarInfo_GetOffset(internal.ReinterpretCast[*C.ImGuiStyleVarInfo](selfArg)))
}

func (self TabBar) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self TabBar) SetTabs(v vectors.Vector[TabItem]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTabItem)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTabItem](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetTabs(selfArg, *vVecArg)
}

func (self TabBar) SetFlags(v TabBarFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetFlags(selfArg, C.ImGuiTabBarFlags(v))
}

func (self TabBar) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TabBar) SetSelectedTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetSelectedTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TabBar) SetNextSelectedTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetNextSelectedTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TabBar) SetVisibleTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetVisibleTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TabBar) SetCurrFrameVisible(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetCurrFrameVisible(selfArg, C.int(v))
}

func (self TabBar) SetPrevFrameVisible(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetPrevFrameVisible(selfArg, C.int(v))
}

func (self TabBar) SetBarRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetBarRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self TabBar) SetBarRectPrevWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetBarRectPrevWidth(selfArg, C.float(v))
}

func (self TabBar) SetCurrTabsContentsHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetCurrTabsContentsHeight(selfArg, C.float(v))
}

func (self TabBar) SetPrevTabsContentsHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetPrevTabsContentsHeight(selfArg, C.float(v))
}

func (self TabBar) SetWidthAllTabs(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetWidthAllTabs(selfArg, C.float(v))
}

func (self TabBar) SetWidthAllTabsIdeal(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetWidthAllTabsIdeal(selfArg, C.float(v))
}

func (self TabBar) SetScrollingAnim(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollingAnim(selfArg, C.float(v))
}

func (self TabBar) SetScrollingTarget(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollingTarget(selfArg, C.float(v))
}

func (self TabBar) SetScrollingTargetDistToVisibility(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollingTargetDistToVisibility(selfArg, C.float(v))
}

func (self TabBar) SetScrollingSpeed(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollingSpeed(selfArg, C.float(v))
}

func (self TabBar) SetScrollingRectMinX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollingRectMinX(selfArg, C.float(v))
}

func (self TabBar) SetScrollingRectMaxX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollingRectMaxX(selfArg, C.float(v))
}

func (self TabBar) SetSeparatorMinX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetSeparatorMinX(selfArg, C.float(v))
}

func (self TabBar) SetSeparatorMaxX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetSeparatorMaxX(selfArg, C.float(v))
}

func (self TabBar) SetReorderRequestTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetReorderRequestTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TabBar) SetReorderRequestOffset(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetReorderRequestOffset(selfArg, C.ImS16(v))
}

func (self TabBar) SetBeginCount(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetBeginCount(selfArg, C.ImS8(v))
}

func (self TabBar) SetWantLayout(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetWantLayout(selfArg, C.bool(v))
}

func (self TabBar) SetVisibleTabWasSubmitted(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetVisibleTabWasSubmitted(selfArg, C.bool(v))
}

func (self TabBar) SetTabsAddedNew(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetTabsAddedNew(selfArg, C.bool(v))
}

func (self TabBar) SetScrollButtonEnabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetScrollButtonEnabled(selfArg, C.bool(v))
}

func (self TabBar) SetTabsActiveCount(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetTabsActiveCount(selfArg, C.ImS16(v))
}

func (self TabBar) SetLastTabItemIdx(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetLastTabItemIdx(selfArg, C.ImS16(v))
}

func (self TabBar) SetItemSpacingY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetItemSpacingY(selfArg, C.float(v))
}

func (self TabBar) SetFramePadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetFramePadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self TabBar) SetBackupCursorPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetBackupCursorPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self TabBar) SetTabsNames(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabBar_SetTabsNames(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self *TabBar) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiTabBar_GetWindow(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) Tabs() vectors.Vector[TabItem] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTabBar_GetTabs(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)).Size, C.wrap_ImGuiTabBar_GetTabs(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)).Capacity, NewTabItemFromC(C.wrap_ImGuiTabBar_GetTabs(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)).Data))
}

func (self *TabBar) Flags() TabBarFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TabBarFlags(C.wrap_ImGuiTabBar_GetFlags(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabBar_GetID(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TabBar) SelectedTabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabBar_GetSelectedTabId(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TabBar) NextSelectedTabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabBar_GetNextSelectedTabId(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TabBar) VisibleTabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabBar_GetVisibleTabId(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TabBar) CurrFrameVisible() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTabBar_GetCurrFrameVisible(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) PrevFrameVisible() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTabBar_GetPrevFrameVisible(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) BarRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTabBar_GetBarRect(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TabBar) BarRectPrevWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetBarRectPrevWidth(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) CurrTabsContentsHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetCurrTabsContentsHeight(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) PrevTabsContentsHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetPrevTabsContentsHeight(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) WidthAllTabs() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetWidthAllTabs(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) WidthAllTabsIdeal() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetWidthAllTabsIdeal(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ScrollingAnim() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetScrollingAnim(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ScrollingTarget() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetScrollingTarget(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ScrollingTargetDistToVisibility() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetScrollingTargetDistToVisibility(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ScrollingSpeed() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetScrollingSpeed(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ScrollingRectMinX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetScrollingRectMinX(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ScrollingRectMaxX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetScrollingRectMaxX(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) SeparatorMinX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetSeparatorMinX(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) SeparatorMaxX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetSeparatorMaxX(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ReorderRequestTabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabBar_GetReorderRequestTabId(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TabBar) ReorderRequestOffset() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTabBar_GetReorderRequestOffset(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) BeginCount() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiTabBar_GetBeginCount(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) WantLayout() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTabBar_GetWantLayout(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)) == C.bool(true)
}

func (self *TabBar) VisibleTabWasSubmitted() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTabBar_GetVisibleTabWasSubmitted(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)) == C.bool(true)
}

func (self *TabBar) TabsAddedNew() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTabBar_GetTabsAddedNew(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)) == C.bool(true)
}

func (self *TabBar) ScrollButtonEnabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTabBar_GetScrollButtonEnabled(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)) == C.bool(true)
}

func (self *TabBar) TabsActiveCount() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTabBar_GetTabsActiveCount(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) LastTabItemIdx() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTabBar_GetLastTabItemIdx(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) ItemSpacingY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabBar_GetItemSpacingY(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg)))
}

func (self *TabBar) FramePadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiTabBar_GetFramePadding(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TabBar) BackupCursorPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiTabBar_GetBackupCursorPos(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TabBar) TabsNames() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabBar_GetTabsNames(internal.ReinterpretCast[*C.ImGuiTabBar](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self TabItem) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TabItem) SetFlags(v TabItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetFlags(selfArg, C.ImGuiTabItemFlags(v))
}

func (self TabItem) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self TabItem) SetLastFrameVisible(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetLastFrameVisible(selfArg, C.int(v))
}

func (self TabItem) SetLastFrameSelected(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetLastFrameSelected(selfArg, C.int(v))
}

func (self TabItem) SetOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetOffset(selfArg, C.float(v))
}

func (self TabItem) SetWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetWidth(selfArg, C.float(v))
}

func (self TabItem) SetContentWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetContentWidth(selfArg, C.float(v))
}

func (self TabItem) SetRequestedWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetRequestedWidth(selfArg, C.float(v))
}

func (self TabItem) SetNameOffset(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetNameOffset(selfArg, C.ImS32(v))
}

func (self TabItem) SetBeginOrder(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetBeginOrder(selfArg, C.ImS16(v))
}

func (self TabItem) SetIndexDuringLayout(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetIndexDuringLayout(selfArg, C.ImS16(v))
}

func (self TabItem) SetWantClose(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTabItem_SetWantClose(selfArg, C.bool(v))
}

func (self *TabItem) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTabItem_GetID(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TabItem) Flags() TabItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TabItemFlags(C.wrap_ImGuiTabItem_GetFlags(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiTabItem_GetWindow(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) LastFrameVisible() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTabItem_GetLastFrameVisible(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) LastFrameSelected() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTabItem_GetLastFrameSelected(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) Offset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabItem_GetOffset(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) Width() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabItem_GetWidth(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) ContentWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabItem_GetContentWidth(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) RequestedWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTabItem_GetRequestedWidth(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) NameOffset() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiTabItem_GetNameOffset(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) BeginOrder() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTabItem_GetBeginOrder(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) IndexDuringLayout() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTabItem_GetIndexDuringLayout(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)))
}

func (self *TabItem) WantClose() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTabItem_GetWantClose(internal.ReinterpretCast[*C.ImGuiTabItem](selfArg)) == C.bool(true)
}

func (self Table) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Table) SetFlags(v TableFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetFlags(selfArg, C.ImGuiTableFlags(v))
}

func (self Table) SetRawData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRawData(selfArg, C.uintptr_t(v))
}

func (self Table) SetTempData(v *TableTempData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetTempData(selfArg, internal.ReinterpretCast[*C.ImGuiTableTempData](vArg))
}

func (self Table) SetEnabledMaskByDisplayOrder(v BitArrayPtr) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetEnabledMaskByDisplayOrder(selfArg, internal.ReinterpretCast[C.ImBitArrayPtr](vArg))
}

func (self Table) SetEnabledMaskByIndex(v BitArrayPtr) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetEnabledMaskByIndex(selfArg, internal.ReinterpretCast[C.ImBitArrayPtr](vArg))
}

func (self Table) SetVisibleMaskByIndex(v BitArrayPtr) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetVisibleMaskByIndex(selfArg, internal.ReinterpretCast[C.ImBitArrayPtr](vArg))
}

func (self Table) SetSettingsLoadedFlags(v TableFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetSettingsLoadedFlags(selfArg, C.ImGuiTableFlags(v))
}

func (self Table) SetSettingsOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetSettingsOffset(selfArg, C.int(v))
}

func (self Table) SetLastFrameActive(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetLastFrameActive(selfArg, C.int(v))
}

func (self Table) SetColumnsCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsCount(selfArg, C.int(v))
}

func (self Table) SetCurrentRow(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetCurrentRow(selfArg, C.int(v))
}

func (self Table) SetCurrentColumn(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetCurrentColumn(selfArg, C.int(v))
}

func (self Table) SetInstanceCurrent(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInstanceCurrent(selfArg, C.ImS16(v))
}

func (self Table) SetInstanceInteracted(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInstanceInteracted(selfArg, C.ImS16(v))
}

func (self Table) SetRowPosY1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowPosY1(selfArg, C.float(v))
}

func (self Table) SetRowPosY2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowPosY2(selfArg, C.float(v))
}

func (self Table) SetRowMinHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowMinHeight(selfArg, C.float(v))
}

func (self Table) SetRowCellPaddingY(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowCellPaddingY(selfArg, C.float(v))
}

func (self Table) SetRowTextBaseline(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowTextBaseline(selfArg, C.float(v))
}

func (self Table) SetRowIndentOffsetX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowIndentOffsetX(selfArg, C.float(v))
}

func (self Table) SetRowFlags(v TableRowFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowFlags(selfArg, C.ImGuiTableRowFlags(v))
}

func (self Table) SetLastRowFlags(v TableRowFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetLastRowFlags(selfArg, C.ImGuiTableRowFlags(v))
}

func (self Table) SetRowBgColorCounter(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowBgColorCounter(selfArg, C.int(v))
}

func (self Table) SetRowBgColor(v *[2]uint32) {
	vArg := make([]C.ImU32, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU32(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowBgColor(selfArg, (*C.ImU32)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (uint32)(vV)
	}
}

func (self Table) SetBorderColorStrong(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBorderColorStrong(selfArg, C.ImU32(v))
}

func (self Table) SetBorderColorLight(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBorderColorLight(selfArg, C.ImU32(v))
}

func (self Table) SetBorderX1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBorderX1(selfArg, C.float(v))
}

func (self Table) SetBorderX2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBorderX2(selfArg, C.float(v))
}

func (self Table) SetHostIndentX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHostIndentX(selfArg, C.float(v))
}

func (self Table) SetMinColumnWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetMinColumnWidth(selfArg, C.float(v))
}

func (self Table) SetOuterPaddingX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetOuterPaddingX(selfArg, C.float(v))
}

func (self Table) SetCellPaddingX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetCellPaddingX(selfArg, C.float(v))
}

func (self Table) SetCellSpacingX1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetCellSpacingX1(selfArg, C.float(v))
}

func (self Table) SetCellSpacingX2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetCellSpacingX2(selfArg, C.float(v))
}

func (self Table) SetInnerWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInnerWidth(selfArg, C.float(v))
}

func (self Table) SetColumnsGivenWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsGivenWidth(selfArg, C.float(v))
}

func (self Table) SetColumnsAutoFitWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsAutoFitWidth(selfArg, C.float(v))
}

func (self Table) SetColumnsStretchSumWeights(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsStretchSumWeights(selfArg, C.float(v))
}

func (self Table) SetResizedColumnNextWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetResizedColumnNextWidth(selfArg, C.float(v))
}

func (self Table) SetResizeLockMinContentsX2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetResizeLockMinContentsX2(selfArg, C.float(v))
}

func (self Table) SetRefScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRefScale(selfArg, C.float(v))
}

func (self Table) SetAngledHeadersHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetAngledHeadersHeight(selfArg, C.float(v))
}

func (self Table) SetAngledHeadersSlope(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetAngledHeadersSlope(selfArg, C.float(v))
}

func (self Table) SetOuterRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetOuterRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetInnerRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInnerRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetInnerClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInnerClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetBgClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBgClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetBg0ClipRectForDrawCmd(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBg0ClipRectForDrawCmd(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetBg2ClipRectForDrawCmd(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBg2ClipRectForDrawCmd(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetHostClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHostClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetHostBackupInnerClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHostBackupInnerClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Table) SetOuterWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetOuterWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Table) SetInnerWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInnerWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Table) SetColumnsNames(v TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsNames(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Table) SetDrawSplitter(v *DrawListSplitter) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetDrawSplitter(selfArg, internal.ReinterpretCast[*C.ImDrawListSplitter](vArg))
}

func (self Table) SetInstanceDataFirst(v TableInstanceData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInstanceDataFirst(selfArg, internal.ReinterpretCast[C.ImGuiTableInstanceData](vArg))
}

func (self Table) SetInstanceDataExtra(v vectors.Vector[TableInstanceData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTableInstanceData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTableInstanceData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetInstanceDataExtra(selfArg, *vVecArg)
}

func (self Table) SetSortSpecsSingle(v TableColumnSortSpecs) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetSortSpecsSingle(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnSortSpecs](vArg))
}

func (self Table) SetSortSpecsMulti(v vectors.Vector[TableColumnSortSpecs]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTableColumnSortSpecs)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetSortSpecsMulti(selfArg, *vVecArg)
}

func (self Table) SetSortSpecs(v TableSortSpecs) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetSortSpecs(selfArg, internal.ReinterpretCast[C.ImGuiTableSortSpecs](vArg))
}

func (self Table) SetSortSpecsCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetSortSpecsCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetColumnsEnabledCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsEnabledCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetColumnsEnabledFixedCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetColumnsEnabledFixedCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetDeclColumnsCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetDeclColumnsCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetAngledHeadersCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetAngledHeadersCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetHoveredColumnBody(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHoveredColumnBody(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetHoveredColumnBorder(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHoveredColumnBorder(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetHighlightColumnHeader(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHighlightColumnHeader(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetAutoFitSingleColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetAutoFitSingleColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetResizedColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetResizedColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetLastResizedColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetLastResizedColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetHeldHeaderColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHeldHeaderColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetReorderColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetReorderColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetReorderColumnDir(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetReorderColumnDir(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetLeftMostEnabledColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetLeftMostEnabledColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetRightMostEnabledColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRightMostEnabledColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetLeftMostStretchedColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetLeftMostStretchedColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetRightMostStretchedColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRightMostStretchedColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetContextPopupColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetContextPopupColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetFreezeRowsRequest(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetFreezeRowsRequest(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetFreezeRowsCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetFreezeRowsCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetFreezeColumnsRequest(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetFreezeColumnsRequest(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetFreezeColumnsCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetFreezeColumnsCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetRowCellDataCurrent(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetRowCellDataCurrent(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self Table) SetDummyDrawChannel(v TableDrawChannelIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetDummyDrawChannel(selfArg, internal.ReinterpretCast[C.ImGuiTableDrawChannelIdx](vArg))
}

func (self Table) SetBg2DrawChannelCurrent(v TableDrawChannelIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBg2DrawChannelCurrent(selfArg, internal.ReinterpretCast[C.ImGuiTableDrawChannelIdx](vArg))
}

func (self Table) SetBg2DrawChannelUnfrozen(v TableDrawChannelIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetBg2DrawChannelUnfrozen(selfArg, internal.ReinterpretCast[C.ImGuiTableDrawChannelIdx](vArg))
}

func (self Table) SetNavLayer(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetNavLayer(selfArg, C.ImS8(v))
}

func (self Table) SetIsLayoutLocked(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsLayoutLocked(selfArg, C.bool(v))
}

func (self Table) SetIsInsideRow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsInsideRow(selfArg, C.bool(v))
}

func (self Table) SetIsInitializing(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsInitializing(selfArg, C.bool(v))
}

func (self Table) SetIsSortSpecsDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsSortSpecsDirty(selfArg, C.bool(v))
}

func (self Table) SetIsUsingHeaders(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsUsingHeaders(selfArg, C.bool(v))
}

func (self Table) SetIsContextPopupOpen(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsContextPopupOpen(selfArg, C.bool(v))
}

func (self Table) SetDisableDefaultContextMenu(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetDisableDefaultContextMenu(selfArg, C.bool(v))
}

func (self Table) SetIsSettingsRequestLoad(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsSettingsRequestLoad(selfArg, C.bool(v))
}

func (self Table) SetIsSettingsDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsSettingsDirty(selfArg, C.bool(v))
}

func (self Table) SetIsDefaultDisplayOrder(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsDefaultDisplayOrder(selfArg, C.bool(v))
}

func (self Table) SetIsResetAllRequest(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsResetAllRequest(selfArg, C.bool(v))
}

func (self Table) SetIsResetDisplayOrderRequest(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsResetDisplayOrderRequest(selfArg, C.bool(v))
}

func (self Table) SetIsUnfrozenRows(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsUnfrozenRows(selfArg, C.bool(v))
}

func (self Table) SetIsDefaultSizingPolicy(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsDefaultSizingPolicy(selfArg, C.bool(v))
}

func (self Table) SetIsActiveIdAliveBeforeTable(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsActiveIdAliveBeforeTable(selfArg, C.bool(v))
}

func (self Table) SetIsActiveIdInTable(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetIsActiveIdInTable(selfArg, C.bool(v))
}

func (self Table) SetHasScrollbarYCurr(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHasScrollbarYCurr(selfArg, C.bool(v))
}

func (self Table) SetHasScrollbarYPrev(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHasScrollbarYPrev(selfArg, C.bool(v))
}

func (self Table) SetMemoryCompacted(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetMemoryCompacted(selfArg, C.bool(v))
}

func (self Table) SetHostSkipItems(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTable_SetHostSkipItems(selfArg, C.bool(v))
}

func (self *Table) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetID(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Table) Flags() TableFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TableFlags(C.wrap_ImGuiTable_GetFlags(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RawData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiTable_GetRawData(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) TempData() *TableTempData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTableTempDataFromC(C.wrap_ImGuiTable_GetTempData(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) EnabledMaskByDisplayOrder() BitArrayPtr {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetEnabledMaskByDisplayOrder(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewBitArrayPtrFromC(func() *C.ImBitArrayPtr { result := result; return &result }())
}

func (self *Table) EnabledMaskByIndex() BitArrayPtr {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetEnabledMaskByIndex(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewBitArrayPtrFromC(func() *C.ImBitArrayPtr { result := result; return &result }())
}

func (self *Table) VisibleMaskByIndex() BitArrayPtr {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetVisibleMaskByIndex(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewBitArrayPtrFromC(func() *C.ImBitArrayPtr { result := result; return &result }())
}

func (self *Table) SettingsLoadedFlags() TableFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TableFlags(C.wrap_ImGuiTable_GetSettingsLoadedFlags(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) SettingsOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTable_GetSettingsOffset(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) LastFrameActive() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTable_GetLastFrameActive(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ColumnsCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTable_GetColumnsCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) CurrentRow() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTable_GetCurrentRow(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) CurrentColumn() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTable_GetCurrentColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) InstanceCurrent() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTable_GetInstanceCurrent(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) InstanceInteracted() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTable_GetInstanceInteracted(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowPosY1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRowPosY1(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowPosY2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRowPosY2(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowMinHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRowMinHeight(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowCellPaddingY() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRowCellPaddingY(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowTextBaseline() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRowTextBaseline(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowIndentOffsetX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRowIndentOffsetX(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowFlags() TableRowFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TableRowFlags(C.wrap_ImGuiTable_GetRowFlags(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) LastRowFlags() TableRowFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TableRowFlags(C.wrap_ImGuiTable_GetLastRowFlags(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowBgColorCounter() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTable_GetRowBgColorCounter(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RowBgColor() [2](uint32) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2](uint32) {
		result := [2](uint32){}
		resultMirr := C.wrap_ImGuiTable_GetRowBgColor(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		for i := range result {
			result[i] = (uint32)(C.imgui_ImU32_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Table) BorderColorStrong() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiTable_GetBorderColorStrong(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) BorderColorLight() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiTable_GetBorderColorLight(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) BorderX1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetBorderX1(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) BorderX2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetBorderX2(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) HostIndentX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetHostIndentX(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) MinColumnWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetMinColumnWidth(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) OuterPaddingX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetOuterPaddingX(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) CellPaddingX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetCellPaddingX(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) CellSpacingX1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetCellSpacingX1(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) CellSpacingX2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetCellSpacingX2(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) InnerWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetInnerWidth(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ColumnsGivenWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetColumnsGivenWidth(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ColumnsAutoFitWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetColumnsAutoFitWidth(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ColumnsStretchSumWeights() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetColumnsStretchSumWeights(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ResizedColumnNextWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetResizedColumnNextWidth(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ResizeLockMinContentsX2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetResizeLockMinContentsX2(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) RefScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetRefScale(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) AngledHeadersHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetAngledHeadersHeight(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) AngledHeadersSlope() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTable_GetAngledHeadersSlope(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) OuterRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetOuterRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) InnerRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetInnerRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) WorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetWorkRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) InnerClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetInnerClipRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) BgClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetBgClipRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) Bg0ClipRectForDrawCmd() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetBg0ClipRectForDrawCmd(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) Bg2ClipRectForDrawCmd() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetBg2ClipRectForDrawCmd(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) HostClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetHostClipRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) HostBackupInnerClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTable_GetHostBackupInnerClipRect(internal.ReinterpretCast[*C.ImGuiTable](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Table) OuterWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiTable_GetOuterWindow(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) InnerWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiTable_GetInnerWindow(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) ColumnsNames() TextBuffer {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetColumnsNames(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextBufferFromC(func() *C.ImGuiTextBuffer { result := result; return &result }())
}

func (self *Table) DrawSplitter() *DrawListSplitter {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawListSplitterFromC(C.wrap_ImGuiTable_GetDrawSplitter(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) InstanceDataFirst() TableInstanceData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetInstanceDataFirst(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableInstanceDataFromC(func() *C.ImGuiTableInstanceData { result := result; return &result }())
}

func (self *Table) InstanceDataExtra() vectors.Vector[TableInstanceData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTable_GetInstanceDataExtra(internal.ReinterpretCast[*C.ImGuiTable](selfArg)).Size, C.wrap_ImGuiTable_GetInstanceDataExtra(internal.ReinterpretCast[*C.ImGuiTable](selfArg)).Capacity, NewTableInstanceDataFromC(C.wrap_ImGuiTable_GetInstanceDataExtra(internal.ReinterpretCast[*C.ImGuiTable](selfArg)).Data))
}

func (self *Table) SortSpecsSingle() TableColumnSortSpecs {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetSortSpecsSingle(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnSortSpecsFromC(func() *C.ImGuiTableColumnSortSpecs { result := result; return &result }())
}

func (self *Table) SortSpecsMulti() vectors.Vector[TableColumnSortSpecs] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTable_GetSortSpecsMulti(internal.ReinterpretCast[*C.ImGuiTable](selfArg)).Size, C.wrap_ImGuiTable_GetSortSpecsMulti(internal.ReinterpretCast[*C.ImGuiTable](selfArg)).Capacity, NewTableColumnSortSpecsFromC(C.wrap_ImGuiTable_GetSortSpecsMulti(internal.ReinterpretCast[*C.ImGuiTable](selfArg)).Data))
}

func (self *Table) SortSpecs() TableSortSpecs {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetSortSpecs(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableSortSpecsFromC(func() *C.ImGuiTableSortSpecs { result := result; return &result }())
}

func (self *Table) SortSpecsCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetSortSpecsCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) ColumnsEnabledCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetColumnsEnabledCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) ColumnsEnabledFixedCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetColumnsEnabledFixedCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) DeclColumnsCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetDeclColumnsCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) AngledHeadersCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetAngledHeadersCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) HoveredColumnBody() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetHoveredColumnBody(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) HoveredColumnBorder() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetHoveredColumnBorder(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) HighlightColumnHeader() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetHighlightColumnHeader(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) AutoFitSingleColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetAutoFitSingleColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) ResizedColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetResizedColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) LastResizedColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetLastResizedColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) HeldHeaderColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetHeldHeaderColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) ReorderColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetReorderColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) ReorderColumnDir() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetReorderColumnDir(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) LeftMostEnabledColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetLeftMostEnabledColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) RightMostEnabledColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetRightMostEnabledColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) LeftMostStretchedColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetLeftMostStretchedColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) RightMostStretchedColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetRightMostStretchedColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) ContextPopupColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetContextPopupColumn(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) FreezeRowsRequest() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetFreezeRowsRequest(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) FreezeRowsCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetFreezeRowsCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) FreezeColumnsRequest() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetFreezeColumnsRequest(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) FreezeColumnsCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetFreezeColumnsCount(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) RowCellDataCurrent() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetRowCellDataCurrent(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *Table) DummyDrawChannel() TableDrawChannelIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetDummyDrawChannel(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableDrawChannelIdxFromC(func() *C.ImGuiTableDrawChannelIdx { result := result; return &result }())
}

func (self *Table) Bg2DrawChannelCurrent() TableDrawChannelIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetBg2DrawChannelCurrent(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableDrawChannelIdxFromC(func() *C.ImGuiTableDrawChannelIdx { result := result; return &result }())
}

func (self *Table) Bg2DrawChannelUnfrozen() TableDrawChannelIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTable_GetBg2DrawChannelUnfrozen(internal.ReinterpretCast[*C.ImGuiTable](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableDrawChannelIdxFromC(func() *C.ImGuiTableDrawChannelIdx { result := result; return &result }())
}

func (self *Table) NavLayer() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiTable_GetNavLayer(internal.ReinterpretCast[*C.ImGuiTable](selfArg)))
}

func (self *Table) IsLayoutLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsLayoutLocked(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsInsideRow() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsInsideRow(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsInitializing() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsInitializing(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsSortSpecsDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsSortSpecsDirty(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsUsingHeaders() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsUsingHeaders(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsContextPopupOpen() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsContextPopupOpen(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) DisableDefaultContextMenu() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetDisableDefaultContextMenu(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsSettingsRequestLoad() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsSettingsRequestLoad(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsSettingsDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsSettingsDirty(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsDefaultDisplayOrder() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsDefaultDisplayOrder(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsResetAllRequest() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsResetAllRequest(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsResetDisplayOrderRequest() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsResetDisplayOrderRequest(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsUnfrozenRows() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsUnfrozenRows(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsDefaultSizingPolicy() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsDefaultSizingPolicy(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsActiveIdAliveBeforeTable() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsActiveIdAliveBeforeTable(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) IsActiveIdInTable() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetIsActiveIdInTable(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) HasScrollbarYCurr() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetHasScrollbarYCurr(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) HasScrollbarYPrev() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetHasScrollbarYPrev(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) MemoryCompacted() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetMemoryCompacted(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self *Table) HostSkipItems() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTable_GetHostSkipItems(internal.ReinterpretCast[*C.ImGuiTable](selfArg)) == C.bool(true)
}

func (self TableCellData) SetBgColor(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableCellData_SetBgColor(selfArg, C.ImU32(v))
}

func (self TableCellData) SetColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableCellData_SetColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self *TableCellData) BgColor() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiTableCellData_GetBgColor(internal.ReinterpretCast[*C.ImGuiTableCellData](selfArg)))
}

func (self *TableCellData) Column() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableCellData_GetColumn(internal.ReinterpretCast[*C.ImGuiTableCellData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self TableColumn) SetFlags(v TableColumnFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetFlags(selfArg, C.ImGuiTableColumnFlags(v))
}

func (self TableColumn) SetWidthGiven(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetWidthGiven(selfArg, C.float(v))
}

func (self TableColumn) SetMinX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetMinX(selfArg, C.float(v))
}

func (self TableColumn) SetMaxX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetMaxX(selfArg, C.float(v))
}

func (self TableColumn) SetWidthRequest(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetWidthRequest(selfArg, C.float(v))
}

func (self TableColumn) SetWidthAuto(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetWidthAuto(selfArg, C.float(v))
}

func (self TableColumn) SetWidthMax(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetWidthMax(selfArg, C.float(v))
}

func (self TableColumn) SetStretchWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetStretchWeight(selfArg, C.float(v))
}

func (self TableColumn) SetInitStretchWeightOrWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetInitStretchWeightOrWidth(selfArg, C.float(v))
}

func (self TableColumn) SetClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self TableColumn) SetUserID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetUserID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TableColumn) SetWorkMinX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetWorkMinX(selfArg, C.float(v))
}

func (self TableColumn) SetWorkMaxX(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetWorkMaxX(selfArg, C.float(v))
}

func (self TableColumn) SetItemWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetItemWidth(selfArg, C.float(v))
}

func (self TableColumn) SetContentMaxXFrozen(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetContentMaxXFrozen(selfArg, C.float(v))
}

func (self TableColumn) SetContentMaxXUnfrozen(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetContentMaxXUnfrozen(selfArg, C.float(v))
}

func (self TableColumn) SetContentMaxXHeadersUsed(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetContentMaxXHeadersUsed(selfArg, C.float(v))
}

func (self TableColumn) SetContentMaxXHeadersIdeal(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetContentMaxXHeadersIdeal(selfArg, C.float(v))
}

func (self TableColumn) SetNameOffset(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetNameOffset(selfArg, C.ImS16(v))
}

func (self TableColumn) SetDisplayOrder(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetDisplayOrder(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumn) SetIndexWithinEnabledSet(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIndexWithinEnabledSet(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumn) SetPrevEnabledColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetPrevEnabledColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumn) SetNextEnabledColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetNextEnabledColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumn) SetSortOrder(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetSortOrder(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumn) SetDrawChannelCurrent(v TableDrawChannelIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetDrawChannelCurrent(selfArg, internal.ReinterpretCast[C.ImGuiTableDrawChannelIdx](vArg))
}

func (self TableColumn) SetDrawChannelFrozen(v TableDrawChannelIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetDrawChannelFrozen(selfArg, internal.ReinterpretCast[C.ImGuiTableDrawChannelIdx](vArg))
}

func (self TableColumn) SetDrawChannelUnfrozen(v TableDrawChannelIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetDrawChannelUnfrozen(selfArg, internal.ReinterpretCast[C.ImGuiTableDrawChannelIdx](vArg))
}

func (self TableColumn) SetIsEnabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsEnabled(selfArg, C.bool(v))
}

func (self TableColumn) SetIsUserEnabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsUserEnabled(selfArg, C.bool(v))
}

func (self TableColumn) SetIsUserEnabledNextFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsUserEnabledNextFrame(selfArg, C.bool(v))
}

func (self TableColumn) SetIsVisibleX(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsVisibleX(selfArg, C.bool(v))
}

func (self TableColumn) SetIsVisibleY(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsVisibleY(selfArg, C.bool(v))
}

func (self TableColumn) SetIsRequestOutput(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsRequestOutput(selfArg, C.bool(v))
}

func (self TableColumn) SetIsSkipItems(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsSkipItems(selfArg, C.bool(v))
}

func (self TableColumn) SetIsPreserveWidthAuto(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetIsPreserveWidthAuto(selfArg, C.bool(v))
}

func (self TableColumn) SetNavLayerCurrent(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetNavLayerCurrent(selfArg, C.ImS8(v))
}

func (self TableColumn) SetAutoFitQueue(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetAutoFitQueue(selfArg, C.ImU8(v))
}

func (self TableColumn) SetCannotSkipItemsQueue(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetCannotSkipItemsQueue(selfArg, C.ImU8(v))
}

func (self TableColumn) SetSortDirection(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetSortDirection(selfArg, C.ImU8(v))
}

func (self TableColumn) SetSortDirectionsAvailCount(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetSortDirectionsAvailCount(selfArg, C.ImU8(v))
}

func (self TableColumn) SetSortDirectionsAvailMask(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetSortDirectionsAvailMask(selfArg, C.ImU8(v))
}

func (self TableColumn) SetSortDirectionsAvailList(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumn_SetSortDirectionsAvailList(selfArg, C.ImU8(v))
}

func (self *TableColumn) Flags() TableColumnFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TableColumnFlags(C.wrap_ImGuiTableColumn_GetFlags(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) WidthGiven() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetWidthGiven(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) MinX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetMinX(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) MaxX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetMaxX(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) WidthRequest() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetWidthRequest(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) WidthAuto() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetWidthAuto(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) WidthMax() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetWidthMax(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) StretchWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetStretchWeight(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) InitStretchWeightOrWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetInitStretchWeightOrWidth(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) ClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTableColumn_GetClipRect(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableColumn) UserID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetUserID(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TableColumn) WorkMinX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetWorkMinX(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) WorkMaxX() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetWorkMaxX(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) ItemWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetItemWidth(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) ContentMaxXFrozen() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetContentMaxXFrozen(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) ContentMaxXUnfrozen() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetContentMaxXUnfrozen(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) ContentMaxXHeadersUsed() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetContentMaxXHeadersUsed(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) ContentMaxXHeadersIdeal() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumn_GetContentMaxXHeadersIdeal(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) NameOffset() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTableColumn_GetNameOffset(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) DisplayOrder() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetDisplayOrder(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumn) IndexWithinEnabledSet() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetIndexWithinEnabledSet(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumn) PrevEnabledColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetPrevEnabledColumn(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumn) NextEnabledColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetNextEnabledColumn(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumn) SortOrder() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetSortOrder(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumn) DrawChannelCurrent() TableDrawChannelIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetDrawChannelCurrent(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableDrawChannelIdxFromC(func() *C.ImGuiTableDrawChannelIdx { result := result; return &result }())
}

func (self *TableColumn) DrawChannelFrozen() TableDrawChannelIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetDrawChannelFrozen(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableDrawChannelIdxFromC(func() *C.ImGuiTableDrawChannelIdx { result := result; return &result }())
}

func (self *TableColumn) DrawChannelUnfrozen() TableDrawChannelIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumn_GetDrawChannelUnfrozen(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableDrawChannelIdxFromC(func() *C.ImGuiTableDrawChannelIdx { result := result; return &result }())
}

func (self *TableColumn) IsEnabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsEnabled(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsUserEnabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsUserEnabled(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsUserEnabledNextFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsUserEnabledNextFrame(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsVisibleX() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsVisibleX(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsVisibleY() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsVisibleY(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsRequestOutput() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsRequestOutput(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsSkipItems() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsSkipItems(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) IsPreserveWidthAuto() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableColumn_GetIsPreserveWidthAuto(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)) == C.bool(true)
}

func (self *TableColumn) NavLayerCurrent() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiTableColumn_GetNavLayerCurrent(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) AutoFitQueue() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumn_GetAutoFitQueue(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) CannotSkipItemsQueue() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumn_GetCannotSkipItemsQueue(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) SortDirection() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumn_GetSortDirection(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) SortDirectionsAvailCount() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumn_GetSortDirectionsAvailCount(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) SortDirectionsAvailMask() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumn_GetSortDirectionsAvailMask(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self *TableColumn) SortDirectionsAvailList() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumn_GetSortDirectionsAvailList(internal.ReinterpretCast[*C.ImGuiTableColumn](selfArg)))
}

func (self TableColumnSettings) SetWidthOrWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetWidthOrWeight(selfArg, C.float(v))
}

func (self TableColumnSettings) SetUserID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetUserID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TableColumnSettings) SetIndex(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetIndex(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumnSettings) SetDisplayOrder(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetDisplayOrder(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumnSettings) SetSortOrder(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetSortOrder(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableColumnSettings) SetSortDirection(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetSortDirection(selfArg, C.ImU8(v))
}

func (self TableColumnSettings) SetIsEnabled(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetIsEnabled(selfArg, C.ImS8(v))
}

func (self TableColumnSettings) SetIsStretch(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSettings_SetIsStretch(selfArg, C.ImU8(v))
}

func (self *TableColumnSettings) WidthOrWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableColumnSettings_GetWidthOrWeight(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg)))
}

func (self *TableColumnSettings) UserID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumnSettings_GetUserID(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TableColumnSettings) Index() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumnSettings_GetIndex(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumnSettings) DisplayOrder() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumnSettings_GetDisplayOrder(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumnSettings) SortOrder() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumnSettings_GetSortOrder(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableColumnSettings) SortDirection() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumnSettings_GetSortDirection(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg)))
}

func (self *TableColumnSettings) IsEnabled() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiTableColumnSettings_GetIsEnabled(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg)))
}

func (self *TableColumnSettings) IsStretch() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiTableColumnSettings_GetIsStretch(internal.ReinterpretCast[*C.ImGuiTableColumnSettings](selfArg)))
}

func (self TableColumnSortSpecs) SetColumnUserID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSortSpecs_SetColumnUserID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TableColumnSortSpecs) SetColumnIndex(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSortSpecs_SetColumnIndex(selfArg, C.ImS16(v))
}

func (self TableColumnSortSpecs) SetSortOrder(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSortSpecs_SetSortOrder(selfArg, C.ImS16(v))
}

func (self TableColumnSortSpecs) SetSortDirection(v SortDirection) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableColumnSortSpecs_SetSortDirection(selfArg, C.ImGuiSortDirection(v))
}

func (self *TableColumnSortSpecs) ColumnUserID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableColumnSortSpecs_GetColumnUserID(internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TableColumnSortSpecs) ColumnIndex() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTableColumnSortSpecs_GetColumnIndex(internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](selfArg)))
}

func (self *TableColumnSortSpecs) SortOrder() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int16)(C.wrap_ImGuiTableColumnSortSpecs_GetSortOrder(internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](selfArg)))
}

func (self *TableColumnSortSpecs) SortDirection() SortDirection {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return SortDirection(C.wrap_ImGuiTableColumnSortSpecs_GetSortDirection(internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](selfArg)))
}

func (self TableHeaderData) SetIndex(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableHeaderData_SetIndex(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableHeaderData) SetTextColor(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableHeaderData_SetTextColor(selfArg, C.ImU32(v))
}

func (self TableHeaderData) SetBgColor0(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableHeaderData_SetBgColor0(selfArg, C.ImU32(v))
}

func (self TableHeaderData) SetBgColor1(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableHeaderData_SetBgColor1(selfArg, C.ImU32(v))
}

func (self *TableHeaderData) Index() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableHeaderData_GetIndex(internal.ReinterpretCast[*C.ImGuiTableHeaderData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableHeaderData) TextColor() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiTableHeaderData_GetTextColor(internal.ReinterpretCast[*C.ImGuiTableHeaderData](selfArg)))
}

func (self *TableHeaderData) BgColor0() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiTableHeaderData_GetBgColor0(internal.ReinterpretCast[*C.ImGuiTableHeaderData](selfArg)))
}

func (self *TableHeaderData) BgColor1() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiTableHeaderData_GetBgColor1(internal.ReinterpretCast[*C.ImGuiTableHeaderData](selfArg)))
}

func (self TableInstanceData) SetTableInstanceID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableInstanceData_SetTableInstanceID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TableInstanceData) SetLastOuterHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableInstanceData_SetLastOuterHeight(selfArg, C.float(v))
}

func (self TableInstanceData) SetLastTopHeadersRowHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableInstanceData_SetLastTopHeadersRowHeight(selfArg, C.float(v))
}

func (self TableInstanceData) SetLastFrozenHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableInstanceData_SetLastFrozenHeight(selfArg, C.float(v))
}

func (self TableInstanceData) SetHoveredRowLast(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableInstanceData_SetHoveredRowLast(selfArg, C.int(v))
}

func (self TableInstanceData) SetHoveredRowNext(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableInstanceData_SetHoveredRowNext(selfArg, C.int(v))
}

func (self *TableInstanceData) TableInstanceID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableInstanceData_GetTableInstanceID(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TableInstanceData) LastOuterHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableInstanceData_GetLastOuterHeight(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg)))
}

func (self *TableInstanceData) LastTopHeadersRowHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableInstanceData_GetLastTopHeadersRowHeight(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg)))
}

func (self *TableInstanceData) LastFrozenHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableInstanceData_GetLastFrozenHeight(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg)))
}

func (self *TableInstanceData) HoveredRowLast() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTableInstanceData_GetHoveredRowLast(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg)))
}

func (self *TableInstanceData) HoveredRowNext() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTableInstanceData_GetHoveredRowNext(internal.ReinterpretCast[*C.ImGuiTableInstanceData](selfArg)))
}

func (self TableSettings) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSettings_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TableSettings) SetSaveFlags(v TableFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSettings_SetSaveFlags(selfArg, C.ImGuiTableFlags(v))
}

func (self TableSettings) SetRefScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSettings_SetRefScale(selfArg, C.float(v))
}

func (self TableSettings) SetColumnsCount(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSettings_SetColumnsCount(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableSettings) SetColumnsCountMax(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSettings_SetColumnsCountMax(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self TableSettings) SetWantApply(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSettings_SetWantApply(selfArg, C.bool(v))
}

func (self *TableSettings) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableSettings_GetID(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TableSettings) SaveFlags() TableFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TableFlags(C.wrap_ImGuiTableSettings_GetSaveFlags(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg)))
}

func (self *TableSettings) RefScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableSettings_GetRefScale(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg)))
}

func (self *TableSettings) ColumnsCount() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableSettings_GetColumnsCount(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableSettings) ColumnsCountMax() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableSettings_GetColumnsCountMax(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self *TableSettings) WantApply() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableSettings_GetWantApply(internal.ReinterpretCast[*C.ImGuiTableSettings](selfArg)) == C.bool(true)
}

func (self TableSortSpecs) SetSpecs(v *TableColumnSortSpecs) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSortSpecs_SetSpecs(selfArg, internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](vArg))
}

func (self TableSortSpecs) SetSpecsCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSortSpecs_SetSpecsCount(selfArg, C.int(v))
}

func (self TableSortSpecs) SetSpecsDirty(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableSortSpecs_SetSpecsDirty(selfArg, C.bool(v))
}

func (self *TableSortSpecs) Specs() *TableColumnSortSpecs {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTableColumnSortSpecsFromC(C.wrap_ImGuiTableSortSpecs_GetSpecs(internal.ReinterpretCast[*C.ImGuiTableSortSpecs](selfArg)))
}

func (self *TableSortSpecs) SpecsCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTableSortSpecs_GetSpecsCount(internal.ReinterpretCast[*C.ImGuiTableSortSpecs](selfArg)))
}

func (self *TableSortSpecs) SpecsDirty() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTableSortSpecs_GetSpecsDirty(internal.ReinterpretCast[*C.ImGuiTableSortSpecs](selfArg)) == C.bool(true)
}

func (self TableTempData) SetTableIndex(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetTableIndex(selfArg, C.int(v))
}

func (self TableTempData) SetLastTimeActive(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetLastTimeActive(selfArg, C.float(v))
}

func (self TableTempData) SetAngledHeadersExtraWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetAngledHeadersExtraWidth(selfArg, C.float(v))
}

func (self TableTempData) SetAngledHeadersRequests(v vectors.Vector[TableHeaderData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTableHeaderData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTableHeaderData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetAngledHeadersRequests(selfArg, *vVecArg)
}

func (self TableTempData) SetUserOuterSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetUserOuterSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self TableTempData) SetDrawSplitter(v DrawListSplitter) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetDrawSplitter(selfArg, internal.ReinterpretCast[C.ImDrawListSplitter](vArg))
}

func (self TableTempData) SetHostBackupWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self TableTempData) SetHostBackupParentWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupParentWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self TableTempData) SetHostBackupPrevLineSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupPrevLineSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self TableTempData) SetHostBackupCurrLineSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupCurrLineSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self TableTempData) SetHostBackupCursorMaxPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupCursorMaxPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self TableTempData) SetHostBackupColumnsOffset(v Vec1) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupColumnsOffset(selfArg, internal.ReinterpretCast[C.ImVec1](vArg))
}

func (self TableTempData) SetHostBackupItemWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupItemWidth(selfArg, C.float(v))
}

func (self TableTempData) SetHostBackupItemWidthStackSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTableTempData_SetHostBackupItemWidthStackSize(selfArg, C.int(v))
}

func (self *TableTempData) TableIndex() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTableTempData_GetTableIndex(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)))
}

func (self *TableTempData) LastTimeActive() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableTempData_GetLastTimeActive(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)))
}

func (self *TableTempData) AngledHeadersExtraWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableTempData_GetAngledHeadersExtraWidth(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)))
}

func (self *TableTempData) AngledHeadersRequests() vectors.Vector[TableHeaderData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTableTempData_GetAngledHeadersRequests(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)).Size, C.wrap_ImGuiTableTempData_GetAngledHeadersRequests(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)).Capacity, NewTableHeaderDataFromC(C.wrap_ImGuiTableTempData_GetAngledHeadersRequests(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)).Data))
}

func (self *TableTempData) UserOuterSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiTableTempData_GetUserOuterSize(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableTempData) DrawSplitter() DrawListSplitter {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableTempData_GetDrawSplitter(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawListSplitterFromC(func() *C.ImDrawListSplitter { result := result; return &result }())
}

func (self *TableTempData) HostBackupWorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTableTempData_GetHostBackupWorkRect(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableTempData) HostBackupParentWorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTableTempData_GetHostBackupParentWorkRect(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableTempData) HostBackupPrevLineSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiTableTempData_GetHostBackupPrevLineSize(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableTempData) HostBackupCurrLineSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiTableTempData_GetHostBackupCurrLineSize(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableTempData) HostBackupCursorMaxPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiTableTempData_GetHostBackupCursorMaxPos(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TableTempData) HostBackupColumnsOffset() Vec1 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTableTempData_GetHostBackupColumnsOffset(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec1FromC(func() *C.ImVec1 { result := result; return &result }())
}

func (self *TableTempData) HostBackupItemWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTableTempData_GetHostBackupItemWidth(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)))
}

func (self *TableTempData) HostBackupItemWidthStackSize() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTableTempData_GetHostBackupItemWidthStackSize(internal.ReinterpretCast[*C.ImGuiTableTempData](selfArg)))
}

func (self TextBuffer) SetBuf(v vectors.Vector[int8]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.char, int8](vData)
	vVecArg := new(C.ImVector_char)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextBuffer_SetBuf(selfArg, *vVecArg)
}

func (self *TextBuffer) Buf() vectors.Vector[int8] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTextBuffer_GetBuf(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)).Size, C.wrap_ImGuiTextBuffer_GetBuf(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)).Capacity, (*int8)(C.wrap_ImGuiTextBuffer_GetBuf(internal.ReinterpretCast[*C.ImGuiTextBuffer](selfArg)).Data))
}

func (self TextFilter) SetInputBuf(v *[256]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextFilter_SetInputBuf(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self TextFilter) SetFilters(v vectors.Vector[TextRange]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiTextRange)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiTextRange](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextFilter_SetFilters(selfArg, *vVecArg)
}

func (self TextFilter) SetCountGrep(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextFilter_SetCountGrep(selfArg, C.int(v))
}

func (self *TextFilter) InputBuf() [256]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [256]rune {
		result := [256]rune{}
		resultMirr := C.wrap_ImGuiTextFilter_GetInputBuf(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *TextFilter) Filters() vectors.Vector[TextRange] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTextFilter_GetFilters(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg)).Size, C.wrap_ImGuiTextFilter_GetFilters(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg)).Capacity, NewTextRangeFromC(C.wrap_ImGuiTextFilter_GetFilters(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg)).Data))
}

func (self *TextFilter) CountGrep() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTextFilter_GetCountGrep(internal.ReinterpretCast[*C.ImGuiTextFilter](selfArg)))
}

func (self TextIndex) SetOffsets(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextIndex_SetOffsets(selfArg, *vVecArg)
}

func (self TextIndex) SetEndOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextIndex_SetEndOffset(selfArg, C.int(v))
}

func (self *TextIndex) Offsets() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiTextIndex_GetOffsets(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg)).Size, C.wrap_ImGuiTextIndex_GetOffsets(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg)).Capacity, (*int32)(C.wrap_ImGuiTextIndex_GetOffsets(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg)).Data))
}

func (self *TextIndex) EndOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTextIndex_GetEndOffset(internal.ReinterpretCast[*C.ImGuiTextIndex](selfArg)))
}

func (self TextRange) SetB(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextRange_SetB(selfArg, vArg)
}

func (self TextRange) SetE(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTextRange_SetE(selfArg, vArg)
}

func (self *TextRange) B() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiTextRange_GetB(internal.ReinterpretCast[*C.ImGuiTextRange](selfArg)))
}

func (self *TextRange) E() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiTextRange_GetE(internal.ReinterpretCast[*C.ImGuiTextRange](selfArg)))
}

func (self TreeNodeStackData) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TreeNodeStackData) SetTreeFlags(v TreeNodeFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetTreeFlags(selfArg, C.ImGuiTreeNodeFlags(v))
}

func (self TreeNodeStackData) SetItemFlags(v ItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetItemFlags(selfArg, C.ImGuiItemFlags(v))
}

func (self TreeNodeStackData) SetNavRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetNavRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self TreeNodeStackData) SetDrawLinesX1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetDrawLinesX1(selfArg, C.float(v))
}

func (self TreeNodeStackData) SetDrawLinesToNodesY2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetDrawLinesToNodesY2(selfArg, C.float(v))
}

func (self TreeNodeStackData) SetDrawLinesTableColumn(v TableColumnIdx) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTreeNodeStackData_SetDrawLinesTableColumn(selfArg, internal.ReinterpretCast[C.ImGuiTableColumnIdx](vArg))
}

func (self *TreeNodeStackData) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTreeNodeStackData_GetID(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TreeNodeStackData) TreeFlags() TreeNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TreeNodeFlags(C.wrap_ImGuiTreeNodeStackData_GetTreeFlags(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg)))
}

func (self *TreeNodeStackData) ItemFlags() ItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemFlags(C.wrap_ImGuiTreeNodeStackData_GetItemFlags(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg)))
}

func (self *TreeNodeStackData) NavRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiTreeNodeStackData_GetNavRect(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *TreeNodeStackData) DrawLinesX1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTreeNodeStackData_GetDrawLinesX1(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg)))
}

func (self *TreeNodeStackData) DrawLinesToNodesY2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTreeNodeStackData_GetDrawLinesToNodesY2(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg)))
}

func (self *TreeNodeStackData) DrawLinesTableColumn() TableColumnIdx {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTreeNodeStackData_GetDrawLinesTableColumn(internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTableColumnIdxFromC(func() *C.ImGuiTableColumnIdx { result := result; return &result }())
}

func (self TypingSelectRequest) SetFlags(v TypingSelectFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectRequest_SetFlags(selfArg, C.ImGuiTypingSelectFlags(v))
}

func (self TypingSelectRequest) SetSearchBufferLen(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectRequest_SetSearchBufferLen(selfArg, C.int(v))
}

func (self TypingSelectRequest) SetSearchBuffer(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectRequest_SetSearchBuffer(selfArg, vArg)
}

func (self TypingSelectRequest) SetSelectRequest(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectRequest_SetSelectRequest(selfArg, C.bool(v))
}

func (self TypingSelectRequest) SetSingleCharMode(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectRequest_SetSingleCharMode(selfArg, C.bool(v))
}

func (self TypingSelectRequest) SetSingleCharSize(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectRequest_SetSingleCharSize(selfArg, C.ImS8(v))
}

func (self *TypingSelectRequest) Flags() TypingSelectFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TypingSelectFlags(C.wrap_ImGuiTypingSelectRequest_GetFlags(internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](selfArg)))
}

func (self *TypingSelectRequest) SearchBufferLen() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTypingSelectRequest_GetSearchBufferLen(internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](selfArg)))
}

func (self *TypingSelectRequest) SearchBuffer() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiTypingSelectRequest_GetSearchBuffer(internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](selfArg)))
}

func (self *TypingSelectRequest) SelectRequest() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTypingSelectRequest_GetSelectRequest(internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](selfArg)) == C.bool(true)
}

func (self *TypingSelectRequest) SingleCharMode() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTypingSelectRequest_GetSingleCharMode(internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](selfArg)) == C.bool(true)
}

func (self *TypingSelectRequest) SingleCharSize() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiTypingSelectRequest_GetSingleCharSize(internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](selfArg)))
}

func (self TypingSelectState) SetRequest(v TypingSelectRequest) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectState_SetRequest(selfArg, internal.ReinterpretCast[C.ImGuiTypingSelectRequest](vArg))
}

func (self TypingSelectState) SetSearchBuffer(v *[64]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectState_SetSearchBuffer(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self TypingSelectState) SetFocusScope(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectState_SetFocusScope(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self TypingSelectState) SetLastRequestFrame(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectState_SetLastRequestFrame(selfArg, C.int(v))
}

func (self TypingSelectState) SetLastRequestTime(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectState_SetLastRequestTime(selfArg, C.float(v))
}

func (self TypingSelectState) SetSingleCharModeLock(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiTypingSelectState_SetSingleCharModeLock(selfArg, C.bool(v))
}

func (self *TypingSelectState) Request() TypingSelectRequest {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTypingSelectState_GetRequest(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTypingSelectRequestFromC(func() *C.ImGuiTypingSelectRequest { result := result; return &result }())
}

func (self *TypingSelectState) SearchBuffer() [64]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [64]rune {
		result := [64]rune{}
		resultMirr := C.wrap_ImGuiTypingSelectState_GetSearchBuffer(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *TypingSelectState) FocusScope() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiTypingSelectState_GetFocusScope(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *TypingSelectState) LastRequestFrame() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiTypingSelectState_GetLastRequestFrame(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg)))
}

func (self *TypingSelectState) LastRequestTime() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiTypingSelectState_GetLastRequestTime(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg)))
}

func (self *TypingSelectState) SingleCharModeLock() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiTypingSelectState_GetSingleCharModeLock(internal.ReinterpretCast[*C.ImGuiTypingSelectState](selfArg)) == C.bool(true)
}

func (self Viewport) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Viewport) SetFlags(v ViewportFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetFlags(selfArg, C.ImGuiViewportFlags(v))
}

func (self Viewport) SetPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Viewport) SetSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Viewport) SetFramebufferScale(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetFramebufferScale(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Viewport) SetWorkPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetWorkPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Viewport) SetWorkSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetWorkSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Viewport) SetDpiScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetDpiScale(selfArg, C.float(v))
}

func (self Viewport) SetParentViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetParentViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Viewport) SetDrawData(v *DrawData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetDrawData(selfArg, internal.ReinterpretCast[*C.ImDrawData](vArg))
}

func (self Viewport) SetRendererUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetRendererUserData(selfArg, C.uintptr_t(v))
}

func (self Viewport) SetPlatformUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformUserData(selfArg, C.uintptr_t(v))
}

func (self Viewport) SetPlatformHandle(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformHandle(selfArg, C.uintptr_t(v))
}

func (self Viewport) SetPlatformHandleRaw(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformHandleRaw(selfArg, C.uintptr_t(v))
}

func (self Viewport) SetPlatformWindowCreated(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformWindowCreated(selfArg, C.bool(v))
}

func (self Viewport) SetPlatformRequestMove(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformRequestMove(selfArg, C.bool(v))
}

func (self Viewport) SetPlatformRequestResize(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformRequestResize(selfArg, C.bool(v))
}

func (self Viewport) SetPlatformRequestClose(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewport_SetPlatformRequestClose(selfArg, C.bool(v))
}

func (self *Viewport) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiViewport_GetID(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Viewport) Flags() ViewportFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ViewportFlags(C.wrap_ImGuiViewport_GetFlags(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) Pos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewport_GetPos(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Viewport) Size() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewport_GetSize(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Viewport) FramebufferScale() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewport_GetFramebufferScale(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Viewport) WorkPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewport_GetWorkPos(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Viewport) WorkSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewport_GetWorkSize(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Viewport) DpiScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiViewport_GetDpiScale(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) ParentViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiViewport_GetParentViewportId(internal.ReinterpretCast[*C.ImGuiViewport](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Viewport) DrawData() *DrawData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawDataFromC(C.wrap_ImGuiViewport_GetDrawData(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) RendererUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiViewport_GetRendererUserData(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) PlatformUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiViewport_GetPlatformUserData(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) PlatformHandle() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiViewport_GetPlatformHandle(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) PlatformHandleRaw() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImGuiViewport_GetPlatformHandleRaw(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)))
}

func (self *Viewport) PlatformWindowCreated() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiViewport_GetPlatformWindowCreated(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)) == C.bool(true)
}

func (self *Viewport) PlatformRequestMove() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiViewport_GetPlatformRequestMove(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)) == C.bool(true)
}

func (self *Viewport) PlatformRequestResize() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiViewport_GetPlatformRequestResize(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)) == C.bool(true)
}

func (self *Viewport) PlatformRequestClose() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiViewport_GetPlatformRequestClose(internal.ReinterpretCast[*C.ImGuiViewport](selfArg)) == C.bool(true)
}

func (self ViewportP) SetImGuiViewport(v Viewport) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_Set_ImGuiViewport(selfArg, internal.ReinterpretCast[C.ImGuiViewport](vArg))
}

func (self ViewportP) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self ViewportP) SetIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetIdx(selfArg, C.int(v))
}

func (self ViewportP) SetLastFrameActive(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastFrameActive(selfArg, C.int(v))
}

func (self ViewportP) SetLastFocusedStampCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastFocusedStampCount(selfArg, C.int(v))
}

func (self ViewportP) SetLastNameHash(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastNameHash(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self ViewportP) SetLastPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetLastSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetAlpha(selfArg, C.float(v))
}

func (self ViewportP) SetLastAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastAlpha(selfArg, C.float(v))
}

func (self ViewportP) SetLastFocusedHadNavWindow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastFocusedHadNavWindow(selfArg, C.bool(v))
}

func (self ViewportP) SetPlatformMonitor(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetPlatformMonitor(selfArg, C.short(v))
}

func (self ViewportP) SetBgFgDrawListsLastFrame(v *[2]int32) {
	vArg := make([]C.int, len(v))
	for i, vV := range v {
		vArg[i] = C.int(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetBgFgDrawListsLastFrame(selfArg, (*C.int)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = int32(vV)
	}
}

func (self ViewportP) SetBgFgDrawLists(v *[2]*DrawList) {
	vArg := make([]*C.ImDrawList, len(v))
	for i, vV := range v {
		vVArg, _ := vV.Handle()
		vArg[i] = internal.ReinterpretCast[*C.ImDrawList](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetBgFgDrawLists(selfArg, (**C.ImDrawList)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = NewDrawListFromC(vV)
	}
}

func (self ViewportP) SetDrawDataP(v DrawData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetDrawDataP(selfArg, internal.ReinterpretCast[C.ImDrawData](vArg))
}

func (self ViewportP) SetDrawDataBuilder(v DrawDataBuilder) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetDrawDataBuilder(selfArg, internal.ReinterpretCast[C.ImDrawDataBuilder](vArg))
}

func (self ViewportP) SetLastPlatformPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastPlatformPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetLastPlatformSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastPlatformSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetLastRendererSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetLastRendererSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetWorkInsetMin(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetWorkInsetMin(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetWorkInsetMax(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetWorkInsetMax(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetBuildWorkInsetMin(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetBuildWorkInsetMin(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self ViewportP) SetBuildWorkInsetMax(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiViewportP_SetBuildWorkInsetMax(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self *ViewportP) ImGuiViewport() Viewport {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiViewportP_Get_ImGuiViewport(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewViewportFromC(func() *C.ImGuiViewport { result := result; return &result }())
}

func (self *ViewportP) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiViewportP_GetWindow(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) Idx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiViewportP_GetIdx(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) LastFrameActive() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiViewportP_GetLastFrameActive(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) LastFocusedStampCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiViewportP_GetLastFocusedStampCount(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) LastNameHash() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiViewportP_GetLastNameHash(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *ViewportP) LastPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetLastPos(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) LastSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetLastSize(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) Alpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiViewportP_GetAlpha(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) LastAlpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiViewportP_GetLastAlpha(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) LastFocusedHadNavWindow() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiViewportP_GetLastFocusedHadNavWindow(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)) == C.bool(true)
}

func (self *ViewportP) PlatformMonitor() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiViewportP_GetPlatformMonitor(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg)))
}

func (self *ViewportP) BgFgDrawListsLastFrame() [2]int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]int32 {
		result := [2]int32{}
		resultMirr := C.wrap_ImGuiViewportP_GetBgFgDrawListsLastFrame(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		for i := range result {
			result[i] = int32(C.imgui_int_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *ViewportP) BgFgDrawLists() [2]*DrawList {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]*DrawList {
		result := [2]*DrawList{}
		resultMirr := C.wrap_ImGuiViewportP_GetBgFgDrawLists(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		for i := range result {
			result[i] = NewDrawListFromC(C.imgui_ImDrawListPtr_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *ViewportP) DrawDataP() DrawData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiViewportP_GetDrawDataP(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawDataFromC(func() *C.ImDrawData { result := result; return &result }())
}

func (self *ViewportP) DrawDataBuilder() DrawDataBuilder {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiViewportP_GetDrawDataBuilder(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawDataBuilderFromC(func() *C.ImDrawDataBuilder { result := result; return &result }())
}

func (self *ViewportP) LastPlatformPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetLastPlatformPos(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) LastPlatformSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetLastPlatformSize(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) LastRendererSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetLastRendererSize(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) WorkInsetMin() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetWorkInsetMin(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) WorkInsetMax() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetWorkInsetMax(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) BuildWorkInsetMin() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetBuildWorkInsetMin(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *ViewportP) BuildWorkInsetMax() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiViewportP_GetBuildWorkInsetMax(internal.ReinterpretCast[*C.ImGuiViewportP](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self Window) SetCtx(v *Context) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetCtx(selfArg, internal.ReinterpretCast[*C.ImGuiContext](vArg))
}

func (self Window) SetName(v string) {
	vArg, _ := internal.WrapString[C.char](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetName(selfArg, vArg)
}

func (self Window) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetFlags(v WindowFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetFlags(selfArg, C.ImGuiWindowFlags(v))
}

func (self Window) SetFlagsPreviousFrame(v WindowFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetFlagsPreviousFrame(selfArg, C.ImGuiWindowFlags(v))
}

func (self Window) SetChildFlags(v ChildFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetChildFlags(selfArg, C.ImGuiChildFlags(v))
}

func (self Window) SetWindowClass(v WindowClass) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWindowClass(selfArg, internal.ReinterpretCast[C.ImGuiWindowClass](vArg))
}

func (self Window) SetViewport(v *ViewportP) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetViewport(selfArg, internal.ReinterpretCast[*C.ImGuiViewportP](vArg))
}

func (self Window) SetViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetViewportPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetViewportPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetViewportAllowPlatformMonitorExtend(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetViewportAllowPlatformMonitorExtend(selfArg, C.int(v))
}

func (self Window) SetPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetSizeFull(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSizeFull(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetContentSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetContentSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetContentSizeIdeal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetContentSizeIdeal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetContentSizeExplicit(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetContentSizeExplicit(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetWindowPadding(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWindowPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetWindowRounding(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWindowRounding(selfArg, C.float(v))
}

func (self Window) SetWindowBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWindowBorderSize(selfArg, C.float(v))
}

func (self Window) SetTitleBarHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetTitleBarHeight(selfArg, C.float(v))
}

func (self Window) SetMenuBarHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetMenuBarHeight(selfArg, C.float(v))
}

func (self Window) SetDecoOuterSizeX1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDecoOuterSizeX1(selfArg, C.float(v))
}

func (self Window) SetDecoOuterSizeY1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDecoOuterSizeY1(selfArg, C.float(v))
}

func (self Window) SetDecoOuterSizeX2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDecoOuterSizeX2(selfArg, C.float(v))
}

func (self Window) SetDecoOuterSizeY2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDecoOuterSizeY2(selfArg, C.float(v))
}

func (self Window) SetDecoInnerSizeX1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDecoInnerSizeX1(selfArg, C.float(v))
}

func (self Window) SetDecoInnerSizeY1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDecoInnerSizeY1(selfArg, C.float(v))
}

func (self Window) SetNameBufLen(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetNameBufLen(selfArg, C.int(v))
}

func (self Window) SetMoveId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetMoveId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetTabId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetTabId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetChildId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetChildId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetPopupId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetPopupId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetScroll(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScroll(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetScrollMax(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollMax(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetScrollTarget(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollTarget(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetScrollTargetCenterRatio(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollTargetCenterRatio(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetScrollTargetEdgeSnapDist(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollTargetEdgeSnapDist(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetScrollbarSizes(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollbarSizes(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetScrollbarX(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollbarX(selfArg, C.bool(v))
}

func (self Window) SetScrollbarY(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollbarY(selfArg, C.bool(v))
}

func (self Window) SetScrollbarXStabilizeEnabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollbarXStabilizeEnabled(selfArg, C.bool(v))
}

func (self Window) SetScrollbarXStabilizeToggledHistory(v byte) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetScrollbarXStabilizeToggledHistory(selfArg, C.ImU8(v))
}

func (self Window) SetViewportOwned(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetViewportOwned(selfArg, C.bool(v))
}

func (self Window) SetActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetActive(selfArg, C.bool(v))
}

func (self Window) SetWasActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWasActive(selfArg, C.bool(v))
}

func (self Window) SetWriteAccessed(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWriteAccessed(selfArg, C.bool(v))
}

func (self Window) SetCollapsed(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetCollapsed(selfArg, C.bool(v))
}

func (self Window) SetWantCollapseToggle(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWantCollapseToggle(selfArg, C.bool(v))
}

func (self Window) SetSkipItems(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSkipItems(selfArg, C.bool(v))
}

func (self Window) SetSkipRefresh(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSkipRefresh(selfArg, C.bool(v))
}

func (self Window) SetAppearing(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetAppearing(selfArg, C.bool(v))
}

func (self Window) SetHidden(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetHidden(selfArg, C.bool(v))
}

func (self Window) SetIsFallbackWindow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetIsFallbackWindow(selfArg, C.bool(v))
}

func (self Window) SetIsExplicitChild(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetIsExplicitChild(selfArg, C.bool(v))
}

func (self Window) SetHasCloseButton(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetHasCloseButton(selfArg, C.bool(v))
}

func (self Window) SetBeginCount(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetBeginCount(selfArg, C.short(v))
}

func (self Window) SetBeginCountPreviousFrame(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetBeginCountPreviousFrame(selfArg, C.short(v))
}

func (self Window) SetBeginOrderWithinParent(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetBeginOrderWithinParent(selfArg, C.short(v))
}

func (self Window) SetBeginOrderWithinContext(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetBeginOrderWithinContext(selfArg, C.short(v))
}

func (self Window) SetFocusOrder(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetFocusOrder(selfArg, C.short(v))
}

func (self Window) SetAutoFitFramesX(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetAutoFitFramesX(selfArg, C.ImS8(v))
}

func (self Window) SetAutoFitFramesY(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetAutoFitFramesY(selfArg, C.ImS8(v))
}

func (self Window) SetAutoFitOnlyGrows(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetAutoFitOnlyGrows(selfArg, C.bool(v))
}

func (self Window) SetAutoPosLastDirection(v Dir) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetAutoPosLastDirection(selfArg, C.ImGuiDir(v))
}

func (self Window) SetHiddenFramesCanSkipItems(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetHiddenFramesCanSkipItems(selfArg, C.ImS8(v))
}

func (self Window) SetHiddenFramesCannotSkipItems(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetHiddenFramesCannotSkipItems(selfArg, C.ImS8(v))
}

func (self Window) SetHiddenFramesForRenderOnly(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetHiddenFramesForRenderOnly(selfArg, C.ImS8(v))
}

func (self Window) SetDisableInputsFrames(v int) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDisableInputsFrames(selfArg, C.ImS8(v))
}

func (self Window) SetSetWindowPosAllowFlags(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSetWindowPosAllowFlags(selfArg, C.ImGuiCond(v))
}

func (self Window) SetSetWindowSizeAllowFlags(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSetWindowSizeAllowFlags(selfArg, C.ImGuiCond(v))
}

func (self Window) SetSetWindowCollapsedAllowFlags(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSetWindowCollapsedAllowFlags(selfArg, C.ImGuiCond(v))
}

func (self Window) SetSetWindowDockAllowFlags(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSetWindowDockAllowFlags(selfArg, C.ImGuiCond(v))
}

func (self Window) SetSetWindowPosVal(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSetWindowPosVal(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetSetWindowPosPivot(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSetWindowPosPivot(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Window) SetIDStack(v vectors.Vector[ID]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiID)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiID](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetIDStack(selfArg, *vVecArg)
}

func (self Window) SetDC(v WindowTempData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDC(selfArg, internal.ReinterpretCast[C.ImGuiWindowTempData](vArg))
}

func (self Window) SetOuterRectClipped(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetOuterRectClipped(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetInnerRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetInnerRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetInnerClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetInnerClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetParentWorkRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetParentWorkRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetClipRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetClipRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetContentRegionRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetContentRegionRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Window) SetLastFrameActive(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetLastFrameActive(selfArg, C.int(v))
}

func (self Window) SetLastFrameJustFocused(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetLastFrameJustFocused(selfArg, C.int(v))
}

func (self Window) SetLastTimeActive(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetLastTimeActive(selfArg, C.float(v))
}

func (self Window) SetItemWidthDefault(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetItemWidthDefault(selfArg, C.float(v))
}

func (self Window) SetStateStorage(v Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetStateStorage(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self Window) SetColumnsStorage(v vectors.Vector[OldColumns]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiOldColumns)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiOldColumns](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetColumnsStorage(selfArg, *vVecArg)
}

func (self Window) SetFontWindowScale(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetFontWindowScale(selfArg, C.float(v))
}

func (self Window) SetFontWindowScaleParents(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetFontWindowScaleParents(selfArg, C.float(v))
}

func (self Window) SetFontRefSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetFontRefSize(selfArg, C.float(v))
}

func (self Window) SetSettingsOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetSettingsOffset(selfArg, C.int(v))
}

func (self Window) SetDrawList(v *DrawList) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDrawList(selfArg, internal.ReinterpretCast[*C.ImDrawList](vArg))
}

func (self Window) SetDrawListInst(v DrawList) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDrawListInst(selfArg, internal.ReinterpretCast[C.ImDrawList](vArg))
}

func (self Window) SetParentWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetParentWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetParentWindowInBeginStack(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetParentWindowInBeginStack(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetRootWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetRootWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetRootWindowPopupTree(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetRootWindowPopupTree(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetRootWindowDockTree(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetRootWindowDockTree(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetRootWindowForTitleBarHighlight(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetRootWindowForTitleBarHighlight(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetRootWindowForNav(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetRootWindowForNav(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetParentWindowForFocusRoute(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetParentWindowForFocusRoute(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetNavLastChildNavWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetNavLastChildNavWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self Window) SetNavLastIds(v *[2]ID) {
	vArg := make([]C.ImGuiID, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImGuiID](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetNavLastIds(selfArg, (*C.ImGuiID)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewIDFromC(func() *C.ImGuiID { result := vV; return &result }())
	}
}

func (self Window) SetNavRectRel(v *[2]Rect) {
	vArg := make([]C.ImRect, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImRect](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetNavRectRel(selfArg, (*C.ImRect)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() Rect { out := vV; return *(&Rect{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self Window) SetNavPreferredScoringPosRel(v [2]*Vec2) {
	vArg := make([]C.ImVec2, len(v))
	vFin := make([]func(), len(v))
	for i, vV := range v {
		var tmp *C.ImVec2
		tmp, vFin[i] = internal.Wrap(vV)
		vArg[i] = *tmp
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetNavPreferredScoringPosRel(selfArg, (*C.ImVec2)(&vArg[0]))
}

func (self Window) SetNavRootFocusScopeId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetNavRootFocusScopeId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Window) SetMemoryDrawListIdxCapacity(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetMemoryDrawListIdxCapacity(selfArg, C.int(v))
}

func (self Window) SetMemoryDrawListVtxCapacity(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetMemoryDrawListVtxCapacity(selfArg, C.int(v))
}

func (self Window) SetMemoryCompacted(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetMemoryCompacted(selfArg, C.bool(v))
}

func (self Window) SetDockIsActive(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockIsActive(selfArg, C.bool(v))
}

func (self Window) SetDockNodeIsVisible(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockNodeIsVisible(selfArg, C.bool(v))
}

func (self Window) SetDockTabIsVisible(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockTabIsVisible(selfArg, C.bool(v))
}

func (self Window) SetDockTabWantClose(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockTabWantClose(selfArg, C.bool(v))
}

func (self Window) SetDockOrder(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockOrder(selfArg, C.short(v))
}

func (self Window) SetDockStyle(v WindowDockStyle) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockStyle(selfArg, internal.ReinterpretCast[C.ImGuiWindowDockStyle](vArg))
}

func (self Window) SetDockNode(v *DockNode) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockNode(selfArg, internal.ReinterpretCast[*C.ImGuiDockNode](vArg))
}

func (self Window) SetDockNodeAsHost(v *DockNode) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockNodeAsHost(selfArg, internal.ReinterpretCast[*C.ImGuiDockNode](vArg))
}

func (self Window) SetDockId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindow_SetDockId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self *Window) Ctx() *Context {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewContextFromC(C.wrap_ImGuiWindow_GetCtx(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) Name() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.wrap_ImGuiWindow_GetName(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetID(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) Flags() WindowFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return WindowFlags(C.wrap_ImGuiWindow_GetFlags(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) FlagsPreviousFrame() WindowFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return WindowFlags(C.wrap_ImGuiWindow_GetFlagsPreviousFrame(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ChildFlags() ChildFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ChildFlags(C.wrap_ImGuiWindow_GetChildFlags(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) WindowClass() WindowClass {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetWindowClass(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewWindowClassFromC(func() *C.ImGuiWindowClass { result := result; return &result }())
}

func (self *Window) Viewport() *ViewportP {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewViewportPFromC(C.wrap_ImGuiWindow_GetViewport(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetViewportId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) ViewportPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetViewportPos(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ViewportAllowPlatformMonitorExtend() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetViewportAllowPlatformMonitorExtend(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) Pos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetPos(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) Size() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetSize(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) SizeFull() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetSizeFull(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ContentSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetContentSize(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ContentSizeIdeal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetContentSizeIdeal(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ContentSizeExplicit() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetContentSizeExplicit(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) WindowPadding() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetWindowPadding(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) WindowRounding() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetWindowRounding(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) WindowBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetWindowBorderSize(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) TitleBarHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetTitleBarHeight(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) MenuBarHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetMenuBarHeight(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DecoOuterSizeX1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetDecoOuterSizeX1(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DecoOuterSizeY1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetDecoOuterSizeY1(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DecoOuterSizeX2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetDecoOuterSizeX2(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DecoOuterSizeY2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetDecoOuterSizeY2(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DecoInnerSizeX1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetDecoInnerSizeX1(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DecoInnerSizeY1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetDecoInnerSizeY1(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) NameBufLen() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetNameBufLen(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) MoveId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetMoveId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) TabId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetTabId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) ChildId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetChildId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) PopupId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetPopupId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) Scroll() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetScroll(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ScrollMax() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetScrollMax(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ScrollTarget() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetScrollTarget(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ScrollTargetCenterRatio() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetScrollTargetCenterRatio(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ScrollTargetEdgeSnapDist() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetScrollTargetEdgeSnapDist(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ScrollbarSizes() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetScrollbarSizes(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ScrollbarX() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetScrollbarX(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) ScrollbarY() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetScrollbarY(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) ScrollbarXStabilizeEnabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetScrollbarXStabilizeEnabled(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) ScrollbarXStabilizeToggledHistory() byte {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (byte)(C.wrap_ImGuiWindow_GetScrollbarXStabilizeToggledHistory(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ViewportOwned() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetViewportOwned(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) Active() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetActive(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) WasActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetWasActive(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) WriteAccessed() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetWriteAccessed(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) Collapsed() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetCollapsed(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) WantCollapseToggle() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetWantCollapseToggle(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) SkipItems() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetSkipItems(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) SkipRefresh() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetSkipRefresh(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) Appearing() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetAppearing(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) Hidden() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetHidden(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) IsFallbackWindow() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetIsFallbackWindow(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) IsExplicitChild() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetIsExplicitChild(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) HasCloseButton() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetHasCloseButton(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) BeginCount() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindow_GetBeginCount(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) BeginCountPreviousFrame() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindow_GetBeginCountPreviousFrame(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) BeginOrderWithinParent() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindow_GetBeginOrderWithinParent(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) BeginOrderWithinContext() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindow_GetBeginOrderWithinContext(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) FocusOrder() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindow_GetFocusOrder(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) AutoFitFramesX() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiWindow_GetAutoFitFramesX(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) AutoFitFramesY() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiWindow_GetAutoFitFramesY(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) AutoFitOnlyGrows() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetAutoFitOnlyGrows(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) AutoPosLastDirection() Dir {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Dir(C.wrap_ImGuiWindow_GetAutoPosLastDirection(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) HiddenFramesCanSkipItems() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiWindow_GetHiddenFramesCanSkipItems(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) HiddenFramesCannotSkipItems() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiWindow_GetHiddenFramesCannotSkipItems(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) HiddenFramesForRenderOnly() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiWindow_GetHiddenFramesForRenderOnly(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DisableInputsFrames() int {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (int)(C.wrap_ImGuiWindow_GetDisableInputsFrames(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) SetWindowPosAllowFlags() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiWindow_GetSetWindowPosAllowFlags(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) SetWindowSizeAllowFlags() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiWindow_GetSetWindowSizeAllowFlags(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) SetWindowCollapsedAllowFlags() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiWindow_GetSetWindowCollapsedAllowFlags(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) SetWindowDockAllowFlags() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImGuiWindow_GetSetWindowDockAllowFlags(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) SetWindowPosVal() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetSetWindowPosVal(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) SetWindowPosPivot() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindow_GetSetWindowPosPivot(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) IDStack() vectors.Vector[ID] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiWindow_GetIDStack(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)).Size, C.wrap_ImGuiWindow_GetIDStack(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)).Capacity, NewIDFromC(C.wrap_ImGuiWindow_GetIDStack(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)).Data))
}

func (self *Window) DC() WindowTempData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetDC(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewWindowTempDataFromC(func() *C.ImGuiWindowTempData { result := result; return &result }())
}

func (self *Window) OuterRectClipped() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetOuterRectClipped(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) InnerRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetInnerRect(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) InnerClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetInnerClipRect(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) WorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetWorkRect(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ParentWorkRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetParentWorkRect(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ClipRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetClipRect(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) ContentRegionRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindow_GetContentRegionRect(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Window) LastFrameActive() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetLastFrameActive(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) LastFrameJustFocused() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetLastFrameJustFocused(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) LastTimeActive() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetLastTimeActive(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ItemWidthDefault() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetItemWidthDefault(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) StateStorage() Storage {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetStateStorage(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStorageFromC(func() *C.ImGuiStorage { result := result; return &result }())
}

func (self *Window) ColumnsStorage() vectors.Vector[OldColumns] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiWindow_GetColumnsStorage(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)).Size, C.wrap_ImGuiWindow_GetColumnsStorage(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)).Capacity, NewOldColumnsFromC(C.wrap_ImGuiWindow_GetColumnsStorage(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)).Data))
}

func (self *Window) FontWindowScale() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetFontWindowScale(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) FontWindowScaleParents() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetFontWindowScaleParents(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) FontRefSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindow_GetFontRefSize(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) SettingsOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetSettingsOffset(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DrawList() *DrawList {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDrawListFromC(C.wrap_ImGuiWindow_GetDrawList(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DrawListInst() DrawList {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetDrawListInst(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDrawListFromC(func() *C.ImDrawList { result := result; return &result }())
}

func (self *Window) ParentWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetParentWindow(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ParentWindowInBeginStack() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetParentWindowInBeginStack(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) RootWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetRootWindow(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) RootWindowPopupTree() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetRootWindowPopupTree(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) RootWindowDockTree() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetRootWindowDockTree(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) RootWindowForTitleBarHighlight() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetRootWindowForTitleBarHighlight(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) RootWindowForNav() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetRootWindowForNav(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) ParentWindowForFocusRoute() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetParentWindowForFocusRoute(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) NavLastChildNavWindow() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindow_GetNavLastChildNavWindow(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) NavLastIds() [2]ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]ID {
		result := [2]ID{}
		resultMirr := C.wrap_ImGuiWindow_GetNavLastIds(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		for i := range result {
			result[i] = *NewIDFromC(func() *C.ImGuiID { result := C.imgui_ImGuiID_GetAtIdx(resultMirr, C.int(i)); return &result }())
		}

		return result
	}()
}

func (self *Window) NavRectRel() [2]Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]Rect {
		result := [2]Rect{}
		resultMirr := C.wrap_ImGuiWindow_GetNavRectRel(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		for i := range result {
			result[i] = func() Rect {
				out := C.imgui_ImRect_GetAtIdx(resultMirr, C.int(i))
				return *(&Rect{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *Window) NavPreferredScoringPosRel() [2]Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]Vec2 {
		result := [2]Vec2{}
		resultMirr := C.wrap_ImGuiWindow_GetNavPreferredScoringPosRel(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))
		for i := range result {
			result[i] = func() Vec2 {
				out := C.imgui_ImVec2_GetAtIdx(resultMirr, C.int(i))
				return *(&Vec2{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *Window) NavRootFocusScopeId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetNavRootFocusScopeId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *Window) MemoryDrawListIdxCapacity() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetMemoryDrawListIdxCapacity(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) MemoryDrawListVtxCapacity() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindow_GetMemoryDrawListVtxCapacity(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) MemoryCompacted() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetMemoryCompacted(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) DockIsActive() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetDockIsActive(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) DockNodeIsVisible() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetDockNodeIsVisible(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) DockTabIsVisible() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetDockTabIsVisible(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) DockTabWantClose() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindow_GetDockTabWantClose(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)) == C.bool(true)
}

func (self *Window) DockOrder() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindow_GetDockOrder(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DockStyle() WindowDockStyle {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetDockStyle(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewWindowDockStyleFromC(func() *C.ImGuiWindowDockStyle { result := result; return &result }())
}

func (self *Window) DockNode() *DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDockNodeFromC(C.wrap_ImGuiWindow_GetDockNode(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DockNodeAsHost() *DockNode {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewDockNodeFromC(C.wrap_ImGuiWindow_GetDockNodeAsHost(internal.ReinterpretCast[*C.ImGuiWindow](selfArg)))
}

func (self *Window) DockId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindow_GetDockId(internal.ReinterpretCast[*C.ImGuiWindow](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self WindowClass) SetClassId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetClassId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowClass) SetParentViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetParentViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowClass) SetFocusRouteParentWindowId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetFocusRouteParentWindowId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowClass) SetViewportFlagsOverrideSet(v ViewportFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetViewportFlagsOverrideSet(selfArg, C.ImGuiViewportFlags(v))
}

func (self WindowClass) SetViewportFlagsOverrideClear(v ViewportFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetViewportFlagsOverrideClear(selfArg, C.ImGuiViewportFlags(v))
}

func (self WindowClass) SetTabItemFlagsOverrideSet(v TabItemFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetTabItemFlagsOverrideSet(selfArg, C.ImGuiTabItemFlags(v))
}

func (self WindowClass) SetDockNodeFlagsOverrideSet(v DockNodeFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetDockNodeFlagsOverrideSet(selfArg, C.ImGuiDockNodeFlags(v))
}

func (self WindowClass) SetDockingAlwaysTabBar(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetDockingAlwaysTabBar(selfArg, C.bool(v))
}

func (self WindowClass) SetDockingAllowUnclassed(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowClass_SetDockingAllowUnclassed(selfArg, C.bool(v))
}

func (self *WindowClass) ClassId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowClass_GetClassId(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowClass) ParentViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowClass_GetParentViewportId(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowClass) FocusRouteParentWindowId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowClass_GetFocusRouteParentWindowId(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowClass) ViewportFlagsOverrideSet() ViewportFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ViewportFlags(C.wrap_ImGuiWindowClass_GetViewportFlagsOverrideSet(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg)))
}

func (self *WindowClass) ViewportFlagsOverrideClear() ViewportFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ViewportFlags(C.wrap_ImGuiWindowClass_GetViewportFlagsOverrideClear(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg)))
}

func (self *WindowClass) TabItemFlagsOverrideSet() TabItemFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TabItemFlags(C.wrap_ImGuiWindowClass_GetTabItemFlagsOverrideSet(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg)))
}

func (self *WindowClass) DockNodeFlagsOverrideSet() DockNodeFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DockNodeFlags(C.wrap_ImGuiWindowClass_GetDockNodeFlagsOverrideSet(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg)))
}

func (self *WindowClass) DockingAlwaysTabBar() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowClass_GetDockingAlwaysTabBar(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg)) == C.bool(true)
}

func (self *WindowClass) DockingAllowUnclassed() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowClass_GetDockingAllowUnclassed(internal.ReinterpretCast[*C.ImGuiWindowClass](selfArg)) == C.bool(true)
}

func (self WindowDockStyle) SetColors(v *[8]uint32) {
	vArg := make([]C.ImU32, len(v))
	for i, vV := range v {
		vArg[i] = C.ImU32(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowDockStyle_SetColors(selfArg, (*C.ImU32)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (uint32)(vV)
	}
}

func (self *WindowDockStyle) Colors() [8](uint32) {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [8](uint32) {
		result := [8](uint32){}
		resultMirr := C.wrap_ImGuiWindowDockStyle_GetColors(internal.ReinterpretCast[*C.ImGuiWindowDockStyle](selfArg))
		for i := range result {
			result[i] = (uint32)(C.imgui_ImU32_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self WindowSettings) SetID(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowSettings) SetViewportId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetViewportId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowSettings) SetDockId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetDockId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowSettings) SetClassId(v ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetClassId(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self WindowSettings) SetDockOrder(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetDockOrder(selfArg, C.short(v))
}

func (self WindowSettings) SetCollapsed(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetCollapsed(selfArg, C.bool(v))
}

func (self WindowSettings) SetIsChild(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetIsChild(selfArg, C.bool(v))
}

func (self WindowSettings) SetWantApply(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetWantApply(selfArg, C.bool(v))
}

func (self WindowSettings) SetWantDelete(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowSettings_SetWantDelete(selfArg, C.bool(v))
}

func (self *WindowSettings) ID() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowSettings_GetID(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowSettings) ViewportId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowSettings_GetViewportId(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowSettings) DockId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowSettings_GetDockId(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowSettings) ClassId() ID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowSettings_GetClassId(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewIDFromC(func() *C.ImGuiID { result := result; return &result }())
}

func (self *WindowSettings) DockOrder() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindowSettings_GetDockOrder(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg)))
}

func (self *WindowSettings) Collapsed() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowSettings_GetCollapsed(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg)) == C.bool(true)
}

func (self *WindowSettings) IsChild() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowSettings_GetIsChild(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg)) == C.bool(true)
}

func (self *WindowSettings) WantApply() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowSettings_GetWantApply(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg)) == C.bool(true)
}

func (self *WindowSettings) WantDelete() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowSettings_GetWantDelete(internal.ReinterpretCast[*C.ImGuiWindowSettings](selfArg)) == C.bool(true)
}

func (self WindowStackData) SetWindow(v *Window) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowStackData_SetWindow(selfArg, internal.ReinterpretCast[*C.ImGuiWindow](vArg))
}

func (self WindowStackData) SetParentLastItemDataBackup(v LastItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowStackData_SetParentLastItemDataBackup(selfArg, internal.ReinterpretCast[C.ImGuiLastItemData](vArg))
}

func (self WindowStackData) SetStackSizesInBegin(v ErrorRecoveryState) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowStackData_SetStackSizesInBegin(selfArg, internal.ReinterpretCast[C.ImGuiErrorRecoveryState](vArg))
}

func (self WindowStackData) SetDisabledOverrideReenable(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowStackData_SetDisabledOverrideReenable(selfArg, C.bool(v))
}

func (self WindowStackData) SetDisabledOverrideReenableAlphaBackup(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowStackData_SetDisabledOverrideReenableAlphaBackup(selfArg, C.float(v))
}

func (self *WindowStackData) Window() *Window {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewWindowFromC(C.wrap_ImGuiWindowStackData_GetWindow(internal.ReinterpretCast[*C.ImGuiWindowStackData](selfArg)))
}

func (self *WindowStackData) ParentLastItemDataBackup() LastItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowStackData_GetParentLastItemDataBackup(internal.ReinterpretCast[*C.ImGuiWindowStackData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewLastItemDataFromC(func() *C.ImGuiLastItemData { result := result; return &result }())
}

func (self *WindowStackData) StackSizesInBegin() ErrorRecoveryState {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowStackData_GetStackSizesInBegin(internal.ReinterpretCast[*C.ImGuiWindowStackData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewErrorRecoveryStateFromC(func() *C.ImGuiErrorRecoveryState { result := result; return &result }())
}

func (self *WindowStackData) DisabledOverrideReenable() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowStackData_GetDisabledOverrideReenable(internal.ReinterpretCast[*C.ImGuiWindowStackData](selfArg)) == C.bool(true)
}

func (self *WindowStackData) DisabledOverrideReenableAlphaBackup() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindowStackData_GetDisabledOverrideReenableAlphaBackup(internal.ReinterpretCast[*C.ImGuiWindowStackData](selfArg)))
}

func (self WindowTempData) SetCursorPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCursorPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetCursorPosPrevLine(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCursorPosPrevLine(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetCursorStartPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCursorStartPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetCursorMaxPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCursorMaxPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetIdealMaxPos(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetIdealMaxPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetCurrLineSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCurrLineSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetPrevLineSize(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetPrevLineSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetCurrLineTextBaseOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCurrLineTextBaseOffset(selfArg, C.float(v))
}

func (self WindowTempData) SetPrevLineTextBaseOffset(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetPrevLineTextBaseOffset(selfArg, C.float(v))
}

func (self WindowTempData) SetIsSameLine(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetIsSameLine(selfArg, C.bool(v))
}

func (self WindowTempData) SetIsSetPos(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetIsSetPos(selfArg, C.bool(v))
}

func (self WindowTempData) SetIndent(v Vec1) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetIndent(selfArg, internal.ReinterpretCast[C.ImVec1](vArg))
}

func (self WindowTempData) SetColumnsOffset(v Vec1) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetColumnsOffset(selfArg, internal.ReinterpretCast[C.ImVec1](vArg))
}

func (self WindowTempData) SetGroupOffset(v Vec1) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetGroupOffset(selfArg, internal.ReinterpretCast[C.ImVec1](vArg))
}

func (self WindowTempData) SetCursorStartPosLossyness(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCursorStartPosLossyness(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetNavLayerCurrent(v NavLayer) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetNavLayerCurrent(selfArg, C.ImGuiNavLayer(v))
}

func (self WindowTempData) SetNavLayersActiveMask(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetNavLayersActiveMask(selfArg, C.short(v))
}

func (self WindowTempData) SetNavLayersActiveMaskNext(v int16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetNavLayersActiveMaskNext(selfArg, C.short(v))
}

func (self WindowTempData) SetNavIsScrollPushableX(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetNavIsScrollPushableX(selfArg, C.bool(v))
}

func (self WindowTempData) SetNavHideHighlightOneFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetNavHideHighlightOneFrame(selfArg, C.bool(v))
}

func (self WindowTempData) SetNavWindowHasScrollY(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetNavWindowHasScrollY(selfArg, C.bool(v))
}

func (self WindowTempData) SetMenuBarAppending(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetMenuBarAppending(selfArg, C.bool(v))
}

func (self WindowTempData) SetMenuBarOffset(v Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetMenuBarOffset(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self WindowTempData) SetMenuColumns(v MenuColumns) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetMenuColumns(selfArg, internal.ReinterpretCast[C.ImGuiMenuColumns](vArg))
}

func (self WindowTempData) SetTreeDepth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetTreeDepth(selfArg, C.int(v))
}

func (self WindowTempData) SetTreeHasStackDataDepthMask(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetTreeHasStackDataDepthMask(selfArg, C.ImU32(v))
}

func (self WindowTempData) SetTreeRecordsClippedNodesY2Mask(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetTreeRecordsClippedNodesY2Mask(selfArg, C.ImU32(v))
}

func (self WindowTempData) SetStateStorage(v *Storage) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetStateStorage(selfArg, internal.ReinterpretCast[*C.ImGuiStorage](vArg))
}

func (self WindowTempData) SetCurrentColumns(v *OldColumns) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCurrentColumns(selfArg, internal.ReinterpretCast[*C.ImGuiOldColumns](vArg))
}

func (self WindowTempData) SetCurrentTableIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetCurrentTableIdx(selfArg, C.int(v))
}

func (self WindowTempData) SetLayoutType(v LayoutType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetLayoutType(selfArg, C.ImGuiLayoutType(v))
}

func (self WindowTempData) SetParentLayoutType(v LayoutType) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetParentLayoutType(selfArg, C.ImGuiLayoutType(v))
}

func (self WindowTempData) SetModalDimBgColor(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetModalDimBgColor(selfArg, C.ImU32(v))
}

func (self WindowTempData) SetWindowItemStatusFlags(v ItemStatusFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetWindowItemStatusFlags(selfArg, C.ImGuiItemStatusFlags(v))
}

func (self WindowTempData) SetChildItemStatusFlags(v ItemStatusFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetChildItemStatusFlags(selfArg, C.ImGuiItemStatusFlags(v))
}

func (self WindowTempData) SetDockTabItemStatusFlags(v ItemStatusFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetDockTabItemStatusFlags(selfArg, C.ImGuiItemStatusFlags(v))
}

func (self WindowTempData) SetDockTabItemRect(v Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetDockTabItemRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self WindowTempData) SetItemWidth(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetItemWidth(selfArg, C.float(v))
}

func (self WindowTempData) SetTextWrapPos(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetTextWrapPos(selfArg, C.float(v))
}

func (self WindowTempData) SetItemWidthStack(v vectors.Vector[float32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.float, float32](vData)
	vVecArg := new(C.ImVector_float)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetItemWidthStack(selfArg, *vVecArg)
}

func (self WindowTempData) SetTextWrapPosStack(v vectors.Vector[float32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.float, float32](vData)
	vVecArg := new(C.ImVector_float)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImGuiWindowTempData_SetTextWrapPosStack(selfArg, *vVecArg)
}

func (self *WindowTempData) CursorPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetCursorPos(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) CursorPosPrevLine() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetCursorPosPrevLine(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) CursorStartPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetCursorStartPos(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) CursorMaxPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetCursorMaxPos(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) IdealMaxPos() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetIdealMaxPos(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) CurrLineSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetCurrLineSize(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) PrevLineSize() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetPrevLineSize(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) CurrLineTextBaseOffset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindowTempData_GetCurrLineTextBaseOffset(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) PrevLineTextBaseOffset() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindowTempData_GetPrevLineTextBaseOffset(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) IsSameLine() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowTempData_GetIsSameLine(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)) == C.bool(true)
}

func (self *WindowTempData) IsSetPos() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowTempData_GetIsSetPos(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)) == C.bool(true)
}

func (self *WindowTempData) Indent() Vec1 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowTempData_GetIndent(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec1FromC(func() *C.ImVec1 { result := result; return &result }())
}

func (self *WindowTempData) ColumnsOffset() Vec1 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowTempData_GetColumnsOffset(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec1FromC(func() *C.ImVec1 { result := result; return &result }())
}

func (self *WindowTempData) GroupOffset() Vec1 {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowTempData_GetGroupOffset(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewVec1FromC(func() *C.ImVec1 { result := result; return &result }())
}

func (self *WindowTempData) CursorStartPosLossyness() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetCursorStartPosLossyness(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) NavLayerCurrent() NavLayer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NavLayer(C.wrap_ImGuiWindowTempData_GetNavLayerCurrent(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) NavLayersActiveMask() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindowTempData_GetNavLayersActiveMask(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) NavLayersActiveMaskNext() int16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int16(C.wrap_ImGuiWindowTempData_GetNavLayersActiveMaskNext(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) NavIsScrollPushableX() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowTempData_GetNavIsScrollPushableX(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)) == C.bool(true)
}

func (self *WindowTempData) NavHideHighlightOneFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowTempData_GetNavHideHighlightOneFrame(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)) == C.bool(true)
}

func (self *WindowTempData) NavWindowHasScrollY() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowTempData_GetNavWindowHasScrollY(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)) == C.bool(true)
}

func (self *WindowTempData) MenuBarAppending() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImGuiWindowTempData_GetMenuBarAppending(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)) == C.bool(true)
}

func (self *WindowTempData) MenuBarOffset() Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Vec2 {
		out := C.wrap_ImGuiWindowTempData_GetMenuBarOffset(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) MenuColumns() MenuColumns {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImGuiWindowTempData_GetMenuColumns(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewMenuColumnsFromC(func() *C.ImGuiMenuColumns { result := result; return &result }())
}

func (self *WindowTempData) TreeDepth() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindowTempData_GetTreeDepth(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) TreeHasStackDataDepthMask() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiWindowTempData_GetTreeHasStackDataDepthMask(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) TreeRecordsClippedNodesY2Mask() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiWindowTempData_GetTreeRecordsClippedNodesY2Mask(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) ChildWindows() vectors.Vector[Window] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiWindowTempData_GetChildWindows(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Size, C.wrap_ImGuiWindowTempData_GetChildWindows(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Capacity, NewWindowFromC(C.wrap_ImGuiWindowTempData_GetChildWindows(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Data))
}

func (self *WindowTempData) StateStorage() *Storage {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewStorageFromC(C.wrap_ImGuiWindowTempData_GetStateStorage(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) CurrentColumns() *OldColumns {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewOldColumnsFromC(C.wrap_ImGuiWindowTempData_GetCurrentColumns(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) CurrentTableIdx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImGuiWindowTempData_GetCurrentTableIdx(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) LayoutType() LayoutType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LayoutType(C.wrap_ImGuiWindowTempData_GetLayoutType(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) ParentLayoutType() LayoutType {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LayoutType(C.wrap_ImGuiWindowTempData_GetParentLayoutType(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) ModalDimBgColor() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImGuiWindowTempData_GetModalDimBgColor(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) WindowItemStatusFlags() ItemStatusFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemStatusFlags(C.wrap_ImGuiWindowTempData_GetWindowItemStatusFlags(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) ChildItemStatusFlags() ItemStatusFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemStatusFlags(C.wrap_ImGuiWindowTempData_GetChildItemStatusFlags(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) DockTabItemStatusFlags() ItemStatusFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return ItemStatusFlags(C.wrap_ImGuiWindowTempData_GetDockTabItemStatusFlags(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) DockTabItemRect() Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Rect {
		out := C.wrap_ImGuiWindowTempData_GetDockTabItemRect(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg))
		return *(&Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *WindowTempData) ItemWidth() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindowTempData_GetItemWidth(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) TextWrapPos() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImGuiWindowTempData_GetTextWrapPos(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)))
}

func (self *WindowTempData) ItemWidthStack() vectors.Vector[float32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiWindowTempData_GetItemWidthStack(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Size, C.wrap_ImGuiWindowTempData_GetItemWidthStack(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Capacity, (*float32)(C.wrap_ImGuiWindowTempData_GetItemWidthStack(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Data))
}

func (self *WindowTempData) TextWrapPosStack() vectors.Vector[float32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImGuiWindowTempData_GetTextWrapPosStack(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Size, C.wrap_ImGuiWindowTempData_GetTextWrapPosStack(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Capacity, (*float32)(C.wrap_ImGuiWindowTempData_GetTextWrapPosStack(internal.ReinterpretCast[*C.ImGuiWindowTempData](selfArg)).Data))
}

func (self TextureData) SetUniqueID(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetUniqueID(selfArg, C.int(v))
}

func (self TextureData) SetBackendUserData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetBackendUserData(selfArg, C.uintptr_t(v))
}

func (self TextureData) SetFormat(v TextureFormat) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetFormat(selfArg, C.ImTextureFormat(v))
}

func (self TextureData) SetWidth(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetWidth(selfArg, C.int(v))
}

func (self TextureData) SetHeight(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetHeight(selfArg, C.int(v))
}

func (self TextureData) SetBytesPerPixel(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetBytesPerPixel(selfArg, C.int(v))
}

func (self TextureData) SetPixels(v *uint) {
	vArg, _ := internal.WrapNumberPtr[C.uchar, uint](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetPixels(selfArg, vArg)
}

func (self TextureData) SetUsedRect(v TextureRect) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetUsedRect(selfArg, internal.ReinterpretCast[C.ImTextureRect](vArg))
}

func (self TextureData) SetUpdateRect(v TextureRect) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetUpdateRect(selfArg, internal.ReinterpretCast[C.ImTextureRect](vArg))
}

func (self TextureData) SetUpdates(v vectors.Vector[TextureRect]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImTextureRect)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImTextureRect](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetUpdates(selfArg, *vVecArg)
}

func (self TextureData) SetUnusedFrames(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetUnusedFrames(selfArg, C.int(v))
}

func (self TextureData) SetRefCount(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetRefCount(selfArg, C.ushort(v))
}

func (self TextureData) SetUseColors(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetUseColors(selfArg, C.bool(v))
}

func (self TextureData) SetWantDestroyNextFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureData_SetWantDestroyNextFrame(selfArg, C.bool(v))
}

func (self *TextureData) UniqueID() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImTextureData_GetUniqueID(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) Status() TextureStatus {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TextureStatus(C.wrap_ImTextureData_GetStatus(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) BackendUserData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImTextureData_GetBackendUserData(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) Format() TextureFormat {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TextureFormat(C.wrap_ImTextureData_GetFormat(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) Width() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImTextureData_GetWidth(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) Height() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImTextureData_GetHeight(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) BytesPerPixel() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImTextureData_GetBytesPerPixel(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) UsedRect() TextureRect {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImTextureData_GetUsedRect(internal.ReinterpretCast[*C.ImTextureData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextureRectFromC(func() *C.ImTextureRect { result := result; return &result }())
}

func (self *TextureData) UpdateRect() TextureRect {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImTextureData_GetUpdateRect(internal.ReinterpretCast[*C.ImTextureData](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextureRectFromC(func() *C.ImTextureRect { result := result; return &result }())
}

func (self *TextureData) Updates() vectors.Vector[TextureRect] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImTextureData_GetUpdates(internal.ReinterpretCast[*C.ImTextureData](selfArg)).Size, C.wrap_ImTextureData_GetUpdates(internal.ReinterpretCast[*C.ImTextureData](selfArg)).Capacity, NewTextureRectFromC(C.wrap_ImTextureData_GetUpdates(internal.ReinterpretCast[*C.ImTextureData](selfArg)).Data))
}

func (self *TextureData) UnusedFrames() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImTextureData_GetUnusedFrames(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) RefCount() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImTextureData_GetRefCount(internal.ReinterpretCast[*C.ImTextureData](selfArg)))
}

func (self *TextureData) UseColors() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImTextureData_GetUseColors(internal.ReinterpretCast[*C.ImTextureData](selfArg)) == C.bool(true)
}

func (self *TextureData) WantDestroyNextFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImTextureData_GetWantDestroyNextFrame(internal.ReinterpretCast[*C.ImTextureData](selfArg)) == C.bool(true)
}

func (self TextureRect) SetX(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureRect_SetX(selfArg, C.ushort(v))
}

func (self TextureRect) SetY(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureRect_SetY(selfArg, C.ushort(v))
}

func (self TextureRect) SetW(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureRect_SetW(selfArg, C.ushort(v))
}

func (self TextureRect) SetH(v uint16) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureRect_SetH(selfArg, C.ushort(v))
}

func (self *TextureRect) X() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImTextureRect_GetX(internal.ReinterpretCast[*C.ImTextureRect](selfArg)))
}

func (self *TextureRect) Y() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImTextureRect_GetY(internal.ReinterpretCast[*C.ImTextureRect](selfArg)))
}

func (self *TextureRect) W() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImTextureRect_GetW(internal.ReinterpretCast[*C.ImTextureRect](selfArg)))
}

func (self *TextureRect) H() uint16 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uint16(C.wrap_ImTextureRect_GetH(internal.ReinterpretCast[*C.ImTextureRect](selfArg)))
}

func (self TextureRef) SetTexData(v *TextureData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureRef_Set_TexData(selfArg, internal.ReinterpretCast[*C.ImTextureData](vArg))
}

func (self TextureRef) SetTexID(v TextureID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImTextureRef_Set_TexID(selfArg, internal.ReinterpretCast[C.ImTextureID](vArg))
}

func (self *TextureRef) TexData() *TextureData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewTextureDataFromC(C.wrap_ImTextureRef_Get_TexData(internal.ReinterpretCast[*C.ImTextureRef](selfArg)))
}

func (self *TextureRef) GetTexID() TextureID {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImTextureRef_Get_TexID(internal.ReinterpretCast[*C.ImTextureRef](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTextureIDFromC(func() *C.ImTextureID { result := result; return &result }())
}

func (self Vec2i) SetX(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImVec2i_SetX(selfArg, C.int(v))
}

func (self Vec2i) SetY(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImVec2i_SetY(selfArg, C.int(v))
}

func (self *Vec2i) X() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImVec2i_GetX(internal.ReinterpretCast[*C.ImVec2i](selfArg)))
}

func (self *Vec2i) Y() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImVec2i_GetY(internal.ReinterpretCast[*C.ImVec2i](selfArg)))
}

func (self *stbrpcontextopaque) ContextopaqueGetData() [80]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [80]rune {
		result := [80]rune{}
		resultMirr := C.wrap_stbrp_context_opaque_GetData(internal.ReinterpretCast[*C.stbrp_context_opaque](selfArg))
		for i := range result {
			result[i] = rune(C.imgui_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}
