cimgui_typedefs.go

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

package imgui

// #include <stdlib.h>
// #include <memory.h>
// #include "extra_types.h"
// #include "cimgui_wrapper.h"
// #include "cimgui_typedefs.h"
import "C"

type BitArrayPtr struct {
	Data *uint32
}

func (self *BitArrayPtr) handle() (*C.ImBitArrayPtr, func()) {
	result, fn := self.c()
	return &result, fn
}

func (selfStruct *BitArrayPtr) c() (result C.ImBitArrayPtr, fin func()) {
	self := selfStruct.Data
	selfArg, selfFin := WrapNumberPtr[C.ImU32, uint32](self)
	return (C.ImBitArrayPtr)(selfArg), func() { selfFin() }
}

func newBitArrayPtrFromC(cvalue *C.ImBitArrayPtr) *BitArrayPtr {
	v := (*C.ImU32)(*cvalue)
	return &BitArrayPtr{Data: (*uint32)(v)}
}

type BitVector struct {
	CData *C.ImBitVector
}

func (self *BitVector) handle() (result *C.ImBitVector, fin func()) {
	return self.CData, func() {}
}

func (self BitVector) c() (C.ImBitVector, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newBitVectorFromC(cvalue *C.ImBitVector) *BitVector {
	return &BitVector{CData: cvalue}
}

type DrawChannel struct {
	CData *C.ImDrawChannel
}

func (self *DrawChannel) handle() (result *C.ImDrawChannel, fin func()) {
	return self.CData, func() {}
}

func (self DrawChannel) c() (C.ImDrawChannel, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawChannelFromC(cvalue *C.ImDrawChannel) *DrawChannel {
	return &DrawChannel{CData: cvalue}
}

type DrawCmd struct {
	CData *C.ImDrawCmd
}

func (self *DrawCmd) handle() (result *C.ImDrawCmd, fin func()) {
	return self.CData, func() {}
}

func (self DrawCmd) c() (C.ImDrawCmd, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawCmdFromC(cvalue *C.ImDrawCmd) *DrawCmd {
	return &DrawCmd{CData: cvalue}
}

type DrawCmdHeader struct {
	CData *C.ImDrawCmdHeader
}

func (self *DrawCmdHeader) handle() (result *C.ImDrawCmdHeader, fin func()) {
	return self.CData, func() {}
}

func (self DrawCmdHeader) c() (C.ImDrawCmdHeader, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawCmdHeaderFromC(cvalue *C.ImDrawCmdHeader) *DrawCmdHeader {
	return &DrawCmdHeader{CData: cvalue}
}

type DrawData struct {
	CData *C.ImDrawData
}

func (self *DrawData) handle() (result *C.ImDrawData, fin func()) {
	return self.CData, func() {}
}

func (self DrawData) c() (C.ImDrawData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawDataFromC(cvalue *C.ImDrawData) *DrawData {
	return &DrawData{CData: cvalue}
}

type DrawDataBuilder struct {
	CData *C.ImDrawDataBuilder
}

func (self *DrawDataBuilder) handle() (result *C.ImDrawDataBuilder, fin func()) {
	return self.CData, func() {}
}

func (self DrawDataBuilder) c() (C.ImDrawDataBuilder, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawDataBuilderFromC(cvalue *C.ImDrawDataBuilder) *DrawDataBuilder {
	return &DrawDataBuilder{CData: cvalue}
}

type DrawList struct {
	CData *C.ImDrawList
}

func (self *DrawList) handle() (result *C.ImDrawList, fin func()) {
	return self.CData, func() {}
}

func (self DrawList) c() (C.ImDrawList, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawListFromC(cvalue *C.ImDrawList) *DrawList {
	return &DrawList{CData: cvalue}
}

type DrawListSharedData struct {
	CData *C.ImDrawListSharedData
}

func (self *DrawListSharedData) handle() (result *C.ImDrawListSharedData, fin func()) {
	return self.CData, func() {}
}

func (self DrawListSharedData) c() (C.ImDrawListSharedData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawListSharedDataFromC(cvalue *C.ImDrawListSharedData) *DrawListSharedData {
	return &DrawListSharedData{CData: cvalue}
}

type DrawListSplitter struct {
	CData *C.ImDrawListSplitter
}

func (self *DrawListSplitter) handle() (result *C.ImDrawListSplitter, fin func()) {
	return self.CData, func() {}
}

func (self DrawListSplitter) c() (C.ImDrawListSplitter, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawListSplitterFromC(cvalue *C.ImDrawListSplitter) *DrawListSplitter {
	return &DrawListSplitter{CData: cvalue}
}

type DrawVert struct {
	CData *C.ImDrawVert
}

func (self *DrawVert) handle() (result *C.ImDrawVert, fin func()) {
	return self.CData, func() {}
}

func (self DrawVert) c() (C.ImDrawVert, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDrawVertFromC(cvalue *C.ImDrawVert) *DrawVert {
	return &DrawVert{CData: cvalue}
}

type Font struct {
	CData *C.ImFont
}

func (self *Font) handle() (result *C.ImFont, fin func()) {
	return self.CData, func() {}
}

func (self Font) c() (C.ImFont, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontFromC(cvalue *C.ImFont) *Font {
	return &Font{CData: cvalue}
}

type FontAtlas struct {
	CData *C.ImFontAtlas
}

func (self *FontAtlas) handle() (result *C.ImFontAtlas, fin func()) {
	return self.CData, func() {}
}

func (self FontAtlas) c() (C.ImFontAtlas, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontAtlasFromC(cvalue *C.ImFontAtlas) *FontAtlas {
	return &FontAtlas{CData: cvalue}
}

type FontAtlasCustomRect struct {
	CData *C.ImFontAtlasCustomRect
}

func (self *FontAtlasCustomRect) handle() (result *C.ImFontAtlasCustomRect, fin func()) {
	return self.CData, func() {}
}

func (self FontAtlasCustomRect) c() (C.ImFontAtlasCustomRect, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontAtlasCustomRectFromC(cvalue *C.ImFontAtlasCustomRect) *FontAtlasCustomRect {
	return &FontAtlasCustomRect{CData: cvalue}
}

type FontBuilderIO struct {
	CData *C.ImFontBuilderIO
}

func (self *FontBuilderIO) handle() (result *C.ImFontBuilderIO, fin func()) {
	return self.CData, func() {}
}

func (self FontBuilderIO) c() (C.ImFontBuilderIO, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontBuilderIOFromC(cvalue *C.ImFontBuilderIO) *FontBuilderIO {
	return &FontBuilderIO{CData: cvalue}
}

type FontConfig struct {
	CData *C.ImFontConfig
}

func (self *FontConfig) handle() (result *C.ImFontConfig, fin func()) {
	return self.CData, func() {}
}

func (self FontConfig) c() (C.ImFontConfig, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontConfigFromC(cvalue *C.ImFontConfig) *FontConfig {
	return &FontConfig{CData: cvalue}
}

type FontGlyph struct {
	CData *C.ImFontGlyph
}

func (self *FontGlyph) handle() (result *C.ImFontGlyph, fin func()) {
	return self.CData, func() {}
}

func (self FontGlyph) c() (C.ImFontGlyph, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontGlyphFromC(cvalue *C.ImFontGlyph) *FontGlyph {
	return &FontGlyph{CData: cvalue}
}

type FontGlyphRangesBuilder struct {
	CData *C.ImFontGlyphRangesBuilder
}

func (self *FontGlyphRangesBuilder) handle() (result *C.ImFontGlyphRangesBuilder, fin func()) {
	return self.CData, func() {}
}

func (self FontGlyphRangesBuilder) c() (C.ImFontGlyphRangesBuilder, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFontGlyphRangesBuilderFromC(cvalue *C.ImFontGlyphRangesBuilder) *FontGlyphRangesBuilder {
	return &FontGlyphRangesBuilder{CData: cvalue}
}

type ColorMod struct {
	CData *C.ImGuiColorMod
}

func (self *ColorMod) handle() (result *C.ImGuiColorMod, fin func()) {
	return self.CData, func() {}
}

func (self ColorMod) c() (C.ImGuiColorMod, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newColorModFromC(cvalue *C.ImGuiColorMod) *ColorMod {
	return &ColorMod{CData: cvalue}
}

type ComboPreviewData struct {
	CData *C.ImGuiComboPreviewData
}

func (self *ComboPreviewData) handle() (result *C.ImGuiComboPreviewData, fin func()) {
	return self.CData, func() {}
}

func (self ComboPreviewData) c() (C.ImGuiComboPreviewData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newComboPreviewDataFromC(cvalue *C.ImGuiComboPreviewData) *ComboPreviewData {
	return &ComboPreviewData{CData: cvalue}
}

type Context struct {
	CData *C.ImGuiContext
}

func (self *Context) handle() (result *C.ImGuiContext, fin func()) {
	return self.CData, func() {}
}

func (self Context) c() (C.ImGuiContext, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newContextFromC(cvalue *C.ImGuiContext) *Context {
	return &Context{CData: cvalue}
}

type ContextHook struct {
	CData *C.ImGuiContextHook
}

func (self *ContextHook) handle() (result *C.ImGuiContextHook, fin func()) {
	return self.CData, func() {}
}

func (self ContextHook) c() (C.ImGuiContextHook, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newContextHookFromC(cvalue *C.ImGuiContextHook) *ContextHook {
	return &ContextHook{CData: cvalue}
}

type DataTypeInfo struct {
	CData *C.ImGuiDataTypeInfo
}

func (self *DataTypeInfo) handle() (result *C.ImGuiDataTypeInfo, fin func()) {
	return self.CData, func() {}
}

func (self DataTypeInfo) c() (C.ImGuiDataTypeInfo, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDataTypeInfoFromC(cvalue *C.ImGuiDataTypeInfo) *DataTypeInfo {
	return &DataTypeInfo{CData: cvalue}
}

type DataTypeStorage struct {
	CData *C.ImGuiDataTypeStorage
}

func (self *DataTypeStorage) handle() (result *C.ImGuiDataTypeStorage, fin func()) {
	return self.CData, func() {}
}

func (self DataTypeStorage) c() (C.ImGuiDataTypeStorage, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDataTypeStorageFromC(cvalue *C.ImGuiDataTypeStorage) *DataTypeStorage {
	return &DataTypeStorage{CData: cvalue}
}

type DataVarInfo struct {
	CData *C.ImGuiDataVarInfo
}

func (self *DataVarInfo) handle() (result *C.ImGuiDataVarInfo, fin func()) {
	return self.CData, func() {}
}

func (self DataVarInfo) c() (C.ImGuiDataVarInfo, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDataVarInfoFromC(cvalue *C.ImGuiDataVarInfo) *DataVarInfo {
	return &DataVarInfo{CData: cvalue}
}

type DebugAllocEntry struct {
	CData *C.ImGuiDebugAllocEntry
}

func (self *DebugAllocEntry) handle() (result *C.ImGuiDebugAllocEntry, fin func()) {
	return self.CData, func() {}
}

func (self DebugAllocEntry) c() (C.ImGuiDebugAllocEntry, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDebugAllocEntryFromC(cvalue *C.ImGuiDebugAllocEntry) *DebugAllocEntry {
	return &DebugAllocEntry{CData: cvalue}
}

type DebugAllocInfo struct {
	CData *C.ImGuiDebugAllocInfo
}

func (self *DebugAllocInfo) handle() (result *C.ImGuiDebugAllocInfo, fin func()) {
	return self.CData, func() {}
}

func (self DebugAllocInfo) c() (C.ImGuiDebugAllocInfo, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDebugAllocInfoFromC(cvalue *C.ImGuiDebugAllocInfo) *DebugAllocInfo {
	return &DebugAllocInfo{CData: cvalue}
}

type DockContext struct {
	CData *C.ImGuiDockContext
}

func (self *DockContext) handle() (result *C.ImGuiDockContext, fin func()) {
	return self.CData, func() {}
}

func (self DockContext) c() (C.ImGuiDockContext, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDockContextFromC(cvalue *C.ImGuiDockContext) *DockContext {
	return &DockContext{CData: cvalue}
}

type DockNode struct {
	CData *C.ImGuiDockNode
}

func (self *DockNode) handle() (result *C.ImGuiDockNode, fin func()) {
	return self.CData, func() {}
}

func (self DockNode) c() (C.ImGuiDockNode, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newDockNodeFromC(cvalue *C.ImGuiDockNode) *DockNode {
	return &DockNode{CData: cvalue}
}

type DockNodeSettings struct {
	CData *C.ImGuiDockNodeSettings
}

func (self *DockNodeSettings) handle() (result *C.ImGuiDockNodeSettings, fin func()) {
	return self.CData, func() {}
}

func newDockNodeSettingsFromC(cvalue *C.ImGuiDockNodeSettings) *DockNodeSettings {
	return &DockNodeSettings{CData: cvalue}
}

type DockRequest struct {
	CData *C.ImGuiDockRequest
}

func (self *DockRequest) handle() (result *C.ImGuiDockRequest, fin func()) {
	return self.CData, func() {}
}

func newDockRequestFromC(cvalue *C.ImGuiDockRequest) *DockRequest {
	return &DockRequest{CData: cvalue}
}

type FocusScopeData struct {
	CData *C.ImGuiFocusScopeData
}

func (self *FocusScopeData) handle() (result *C.ImGuiFocusScopeData, fin func()) {
	return self.CData, func() {}
}

func (self FocusScopeData) c() (C.ImGuiFocusScopeData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newFocusScopeDataFromC(cvalue *C.ImGuiFocusScopeData) *FocusScopeData {
	return &FocusScopeData{CData: cvalue}
}

type GroupData struct {
	CData *C.ImGuiGroupData
}

func (self *GroupData) handle() (result *C.ImGuiGroupData, fin func()) {
	return self.CData, func() {}
}

func (self GroupData) c() (C.ImGuiGroupData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newGroupDataFromC(cvalue *C.ImGuiGroupData) *GroupData {
	return &GroupData{CData: cvalue}
}

type ID uint32

func (selfSrc *ID) handle() (result *C.ImGuiID, fin func()) {
	self := (*uint32)(selfSrc)
	selfArg, selfFin := WrapNumberPtr[C.uint, uint32](self)
	return (*C.ImGuiID)(selfArg), func() { selfFin() }
}

func (self ID) c() (C.ImGuiID, func()) {
	return (C.ImGuiID)(C.uint(self)), func() {}
}

func newIDFromC(cvalue *C.ImGuiID) *ID {
	return (*ID)((*uint32)(cvalue))
}

type IDStackTool struct {
	CData *C.ImGuiIDStackTool
}

func (self *IDStackTool) handle() (result *C.ImGuiIDStackTool, fin func()) {
	return self.CData, func() {}
}

func (self IDStackTool) c() (C.ImGuiIDStackTool, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newIDStackToolFromC(cvalue *C.ImGuiIDStackTool) *IDStackTool {
	return &IDStackTool{CData: cvalue}
}

type IO struct {
	CData *C.ImGuiIO
}

func (self *IO) handle() (result *C.ImGuiIO, fin func()) {
	return self.CData, func() {}
}

func (self IO) c() (C.ImGuiIO, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newIOFromC(cvalue *C.ImGuiIO) *IO {
	return &IO{CData: cvalue}
}

type InputEvent struct {
	CData *C.ImGuiInputEvent
}

func (self *InputEvent) handle() (result *C.ImGuiInputEvent, fin func()) {
	return self.CData, func() {}
}

func (self InputEvent) c() (C.ImGuiInputEvent, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventFromC(cvalue *C.ImGuiInputEvent) *InputEvent {
	return &InputEvent{CData: cvalue}
}

type InputEventAppFocused struct {
	CData *C.ImGuiInputEventAppFocused
}

func (self *InputEventAppFocused) handle() (result *C.ImGuiInputEventAppFocused, fin func()) {
	return self.CData, func() {}
}

func (self InputEventAppFocused) c() (C.ImGuiInputEventAppFocused, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventAppFocusedFromC(cvalue *C.ImGuiInputEventAppFocused) *InputEventAppFocused {
	return &InputEventAppFocused{CData: cvalue}
}

type InputEventKey struct {
	CData *C.ImGuiInputEventKey
}

func (self *InputEventKey) handle() (result *C.ImGuiInputEventKey, fin func()) {
	return self.CData, func() {}
}

func (self InputEventKey) c() (C.ImGuiInputEventKey, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventKeyFromC(cvalue *C.ImGuiInputEventKey) *InputEventKey {
	return &InputEventKey{CData: cvalue}
}

type InputEventMouseButton struct {
	CData *C.ImGuiInputEventMouseButton
}

func (self *InputEventMouseButton) handle() (result *C.ImGuiInputEventMouseButton, fin func()) {
	return self.CData, func() {}
}

func (self InputEventMouseButton) c() (C.ImGuiInputEventMouseButton, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventMouseButtonFromC(cvalue *C.ImGuiInputEventMouseButton) *InputEventMouseButton {
	return &InputEventMouseButton{CData: cvalue}
}

type InputEventMousePos struct {
	CData *C.ImGuiInputEventMousePos
}

func (self *InputEventMousePos) handle() (result *C.ImGuiInputEventMousePos, fin func()) {
	return self.CData, func() {}
}

func (self InputEventMousePos) c() (C.ImGuiInputEventMousePos, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventMousePosFromC(cvalue *C.ImGuiInputEventMousePos) *InputEventMousePos {
	return &InputEventMousePos{CData: cvalue}
}

type InputEventMouseViewport struct {
	CData *C.ImGuiInputEventMouseViewport
}

func (self *InputEventMouseViewport) handle() (result *C.ImGuiInputEventMouseViewport, fin func()) {
	return self.CData, func() {}
}

func (self InputEventMouseViewport) c() (C.ImGuiInputEventMouseViewport, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventMouseViewportFromC(cvalue *C.ImGuiInputEventMouseViewport) *InputEventMouseViewport {
	return &InputEventMouseViewport{CData: cvalue}
}

type InputEventMouseWheel struct {
	CData *C.ImGuiInputEventMouseWheel
}

func (self *InputEventMouseWheel) handle() (result *C.ImGuiInputEventMouseWheel, fin func()) {
	return self.CData, func() {}
}

func (self InputEventMouseWheel) c() (C.ImGuiInputEventMouseWheel, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventMouseWheelFromC(cvalue *C.ImGuiInputEventMouseWheel) *InputEventMouseWheel {
	return &InputEventMouseWheel{CData: cvalue}
}

type InputEventText struct {
	CData *C.ImGuiInputEventText
}

func (self *InputEventText) handle() (result *C.ImGuiInputEventText, fin func()) {
	return self.CData, func() {}
}

func (self InputEventText) c() (C.ImGuiInputEventText, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputEventTextFromC(cvalue *C.ImGuiInputEventText) *InputEventText {
	return &InputEventText{CData: cvalue}
}

type InputTextCallbackData struct {
	CData *C.ImGuiInputTextCallbackData
}

func (self *InputTextCallbackData) handle() (result *C.ImGuiInputTextCallbackData, fin func()) {
	return self.CData, func() {}
}

func (self InputTextCallbackData) c() (C.ImGuiInputTextCallbackData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputTextCallbackDataFromC(cvalue *C.ImGuiInputTextCallbackData) *InputTextCallbackData {
	return &InputTextCallbackData{CData: cvalue}
}

type InputTextDeactivateData struct {
	CData *C.ImGuiInputTextDeactivateData
}

func (self *InputTextDeactivateData) handle() (result *C.ImGuiInputTextDeactivateData, fin func()) {
	return self.CData, func() {}
}

func newInputTextDeactivateDataFromC(cvalue *C.ImGuiInputTextDeactivateData) *InputTextDeactivateData {
	return &InputTextDeactivateData{CData: cvalue}
}

type InputTextDeactivatedState struct {
	CData *C.ImGuiInputTextDeactivatedState
}

func (self *InputTextDeactivatedState) handle() (result *C.ImGuiInputTextDeactivatedState, fin func()) {
	return self.CData, func() {}
}

func (self InputTextDeactivatedState) c() (C.ImGuiInputTextDeactivatedState, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputTextDeactivatedStateFromC(cvalue *C.ImGuiInputTextDeactivatedState) *InputTextDeactivatedState {
	return &InputTextDeactivatedState{CData: cvalue}
}

type InputTextState struct {
	CData *C.ImGuiInputTextState
}

func (self *InputTextState) handle() (result *C.ImGuiInputTextState, fin func()) {
	return self.CData, func() {}
}

func (self InputTextState) c() (C.ImGuiInputTextState, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newInputTextStateFromC(cvalue *C.ImGuiInputTextState) *InputTextState {
	return &InputTextState{CData: cvalue}
}

type KeyChord int32

func (selfSrc *KeyChord) handle() (result *C.ImGuiKeyChord, fin func()) {
	self := (*int32)(selfSrc)
	selfArg, selfFin := WrapNumberPtr[C.int, int32](self)
	return (*C.ImGuiKeyChord)(selfArg), func() { selfFin() }
}

func (self KeyChord) c() (C.ImGuiKeyChord, func()) {
	return (C.ImGuiKeyChord)(C.int(self)), func() {}
}

func newKeyChordFromC(cvalue *C.ImGuiKeyChord) *KeyChord {
	return (*KeyChord)((*int32)(cvalue))
}

type KeyData struct {
	CData *C.ImGuiKeyData
}

func (self *KeyData) handle() (result *C.ImGuiKeyData, fin func()) {
	return self.CData, func() {}
}

func (self KeyData) c() (C.ImGuiKeyData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newKeyDataFromC(cvalue *C.ImGuiKeyData) *KeyData {
	return &KeyData{CData: cvalue}
}

type KeyOwnerData struct {
	CData *C.ImGuiKeyOwnerData
}

func (self *KeyOwnerData) handle() (result *C.ImGuiKeyOwnerData, fin func()) {
	return self.CData, func() {}
}

func (self KeyOwnerData) c() (C.ImGuiKeyOwnerData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newKeyOwnerDataFromC(cvalue *C.ImGuiKeyOwnerData) *KeyOwnerData {
	return &KeyOwnerData{CData: cvalue}
}

type KeyRoutingData struct {
	CData *C.ImGuiKeyRoutingData
}

func (self *KeyRoutingData) handle() (result *C.ImGuiKeyRoutingData, fin func()) {
	return self.CData, func() {}
}

func (self KeyRoutingData) c() (C.ImGuiKeyRoutingData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newKeyRoutingDataFromC(cvalue *C.ImGuiKeyRoutingData) *KeyRoutingData {
	return &KeyRoutingData{CData: cvalue}
}

type KeyRoutingTable struct {
	CData *C.ImGuiKeyRoutingTable
}

func (self *KeyRoutingTable) handle() (result *C.ImGuiKeyRoutingTable, fin func()) {
	return self.CData, func() {}
}

func (self KeyRoutingTable) c() (C.ImGuiKeyRoutingTable, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newKeyRoutingTableFromC(cvalue *C.ImGuiKeyRoutingTable) *KeyRoutingTable {
	return &KeyRoutingTable{CData: cvalue}
}

type LastItemData struct {
	CData *C.ImGuiLastItemData
}

func (self *LastItemData) handle() (result *C.ImGuiLastItemData, fin func()) {
	return self.CData, func() {}
}

func (self LastItemData) c() (C.ImGuiLastItemData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newLastItemDataFromC(cvalue *C.ImGuiLastItemData) *LastItemData {
	return &LastItemData{CData: cvalue}
}

type ListClipper struct {
	CData *C.ImGuiListClipper
}

func (self *ListClipper) handle() (result *C.ImGuiListClipper, fin func()) {
	return self.CData, func() {}
}

func (self ListClipper) c() (C.ImGuiListClipper, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newListClipperFromC(cvalue *C.ImGuiListClipper) *ListClipper {
	return &ListClipper{CData: cvalue}
}

type ListClipperData struct {
	CData *C.ImGuiListClipperData
}

func (self *ListClipperData) handle() (result *C.ImGuiListClipperData, fin func()) {
	return self.CData, func() {}
}

func (self ListClipperData) c() (C.ImGuiListClipperData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newListClipperDataFromC(cvalue *C.ImGuiListClipperData) *ListClipperData {
	return &ListClipperData{CData: cvalue}
}

type ListClipperRange struct {
	CData *C.ImGuiListClipperRange
}

func (self *ListClipperRange) handle() (result *C.ImGuiListClipperRange, fin func()) {
	return self.CData, func() {}
}

func (self ListClipperRange) c() (C.ImGuiListClipperRange, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newListClipperRangeFromC(cvalue *C.ImGuiListClipperRange) *ListClipperRange {
	return &ListClipperRange{CData: cvalue}
}

type LocEntry struct {
	CData *C.ImGuiLocEntry
}

func (self *LocEntry) handle() (result *C.ImGuiLocEntry, fin func()) {
	return self.CData, func() {}
}

func (self LocEntry) c() (C.ImGuiLocEntry, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newLocEntryFromC(cvalue *C.ImGuiLocEntry) *LocEntry {
	return &LocEntry{CData: cvalue}
}

type MenuColumns struct {
	CData *C.ImGuiMenuColumns
}

func (self *MenuColumns) handle() (result *C.ImGuiMenuColumns, fin func()) {
	return self.CData, func() {}
}

func (self MenuColumns) c() (C.ImGuiMenuColumns, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newMenuColumnsFromC(cvalue *C.ImGuiMenuColumns) *MenuColumns {
	return &MenuColumns{CData: cvalue}
}

type MetricsConfig struct {
	CData *C.ImGuiMetricsConfig
}

func (self *MetricsConfig) handle() (result *C.ImGuiMetricsConfig, fin func()) {
	return self.CData, func() {}
}

func (self MetricsConfig) c() (C.ImGuiMetricsConfig, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newMetricsConfigFromC(cvalue *C.ImGuiMetricsConfig) *MetricsConfig {
	return &MetricsConfig{CData: cvalue}
}

type NavItemData struct {
	CData *C.ImGuiNavItemData
}

func (self *NavItemData) handle() (result *C.ImGuiNavItemData, fin func()) {
	return self.CData, func() {}
}

func (self NavItemData) c() (C.ImGuiNavItemData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newNavItemDataFromC(cvalue *C.ImGuiNavItemData) *NavItemData {
	return &NavItemData{CData: cvalue}
}

type NavTreeNodeData struct {
	CData *C.ImGuiNavTreeNodeData
}

func (self *NavTreeNodeData) handle() (result *C.ImGuiNavTreeNodeData, fin func()) {
	return self.CData, func() {}
}

func (self NavTreeNodeData) c() (C.ImGuiNavTreeNodeData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newNavTreeNodeDataFromC(cvalue *C.ImGuiNavTreeNodeData) *NavTreeNodeData {
	return &NavTreeNodeData{CData: cvalue}
}

type NextItemData struct {
	CData *C.ImGuiNextItemData
}

func (self *NextItemData) handle() (result *C.ImGuiNextItemData, fin func()) {
	return self.CData, func() {}
}

func (self NextItemData) c() (C.ImGuiNextItemData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newNextItemDataFromC(cvalue *C.ImGuiNextItemData) *NextItemData {
	return &NextItemData{CData: cvalue}
}

type NextWindowData struct {
	CData *C.ImGuiNextWindowData
}

func (self *NextWindowData) handle() (result *C.ImGuiNextWindowData, fin func()) {
	return self.CData, func() {}
}

func (self NextWindowData) c() (C.ImGuiNextWindowData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newNextWindowDataFromC(cvalue *C.ImGuiNextWindowData) *NextWindowData {
	return &NextWindowData{CData: cvalue}
}

type OldColumnData struct {
	CData *C.ImGuiOldColumnData
}

func (self *OldColumnData) handle() (result *C.ImGuiOldColumnData, fin func()) {
	return self.CData, func() {}
}

func (self OldColumnData) c() (C.ImGuiOldColumnData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newOldColumnDataFromC(cvalue *C.ImGuiOldColumnData) *OldColumnData {
	return &OldColumnData{CData: cvalue}
}

type OldColumns struct {
	CData *C.ImGuiOldColumns
}

func (self *OldColumns) handle() (result *C.ImGuiOldColumns, fin func()) {
	return self.CData, func() {}
}

func (self OldColumns) c() (C.ImGuiOldColumns, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newOldColumnsFromC(cvalue *C.ImGuiOldColumns) *OldColumns {
	return &OldColumns{CData: cvalue}
}

type OnceUponAFrame struct {
	CData *C.ImGuiOnceUponAFrame
}

func (self *OnceUponAFrame) handle() (result *C.ImGuiOnceUponAFrame, fin func()) {
	return self.CData, func() {}
}

func (self OnceUponAFrame) c() (C.ImGuiOnceUponAFrame, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newOnceUponAFrameFromC(cvalue *C.ImGuiOnceUponAFrame) *OnceUponAFrame {
	return &OnceUponAFrame{CData: cvalue}
}

type Payload struct {
	CData *C.ImGuiPayload
}

func (self *Payload) handle() (result *C.ImGuiPayload, fin func()) {
	return self.CData, func() {}
}

func (self Payload) c() (C.ImGuiPayload, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newPayloadFromC(cvalue *C.ImGuiPayload) *Payload {
	return &Payload{CData: cvalue}
}

type PlatformIO struct {
	CData *C.ImGuiPlatformIO
}

func (self *PlatformIO) handle() (result *C.ImGuiPlatformIO, fin func()) {
	return self.CData, func() {}
}

func (self PlatformIO) c() (C.ImGuiPlatformIO, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newPlatformIOFromC(cvalue *C.ImGuiPlatformIO) *PlatformIO {
	return &PlatformIO{CData: cvalue}
}

type PlatformImeData struct {
	CData *C.ImGuiPlatformImeData
}

func (self *PlatformImeData) handle() (result *C.ImGuiPlatformImeData, fin func()) {
	return self.CData, func() {}
}

func (self PlatformImeData) c() (C.ImGuiPlatformImeData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newPlatformImeDataFromC(cvalue *C.ImGuiPlatformImeData) *PlatformImeData {
	return &PlatformImeData{CData: cvalue}
}

type PlatformMonitor struct {
	CData *C.ImGuiPlatformMonitor
}

func (self *PlatformMonitor) handle() (result *C.ImGuiPlatformMonitor, fin func()) {
	return self.CData, func() {}
}

func (self PlatformMonitor) c() (C.ImGuiPlatformMonitor, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newPlatformMonitorFromC(cvalue *C.ImGuiPlatformMonitor) *PlatformMonitor {
	return &PlatformMonitor{CData: cvalue}
}

type PopupData struct {
	CData *C.ImGuiPopupData
}

func (self *PopupData) handle() (result *C.ImGuiPopupData, fin func()) {
	return self.CData, func() {}
}

func (self PopupData) c() (C.ImGuiPopupData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newPopupDataFromC(cvalue *C.ImGuiPopupData) *PopupData {
	return &PopupData{CData: cvalue}
}

type PtrOrIndex struct {
	CData *C.ImGuiPtrOrIndex
}

func (self *PtrOrIndex) handle() (result *C.ImGuiPtrOrIndex, fin func()) {
	return self.CData, func() {}
}

func (self PtrOrIndex) c() (C.ImGuiPtrOrIndex, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newPtrOrIndexFromC(cvalue *C.ImGuiPtrOrIndex) *PtrOrIndex {
	return &PtrOrIndex{CData: cvalue}
}

type SettingsHandler struct {
	CData *C.ImGuiSettingsHandler
}

func (self *SettingsHandler) handle() (result *C.ImGuiSettingsHandler, fin func()) {
	return self.CData, func() {}
}

func (self SettingsHandler) c() (C.ImGuiSettingsHandler, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newSettingsHandlerFromC(cvalue *C.ImGuiSettingsHandler) *SettingsHandler {
	return &SettingsHandler{CData: cvalue}
}

type ShrinkWidthItem struct {
	CData *C.ImGuiShrinkWidthItem
}

func (self *ShrinkWidthItem) handle() (result *C.ImGuiShrinkWidthItem, fin func()) {
	return self.CData, func() {}
}

func (self ShrinkWidthItem) c() (C.ImGuiShrinkWidthItem, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newShrinkWidthItemFromC(cvalue *C.ImGuiShrinkWidthItem) *ShrinkWidthItem {
	return &ShrinkWidthItem{CData: cvalue}
}

type SizeCallbackData struct {
	CData *C.ImGuiSizeCallbackData
}

func (self *SizeCallbackData) handle() (result *C.ImGuiSizeCallbackData, fin func()) {
	return self.CData, func() {}
}

func (self SizeCallbackData) c() (C.ImGuiSizeCallbackData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newSizeCallbackDataFromC(cvalue *C.ImGuiSizeCallbackData) *SizeCallbackData {
	return &SizeCallbackData{CData: cvalue}
}

type StackLevelInfo struct {
	CData *C.ImGuiStackLevelInfo
}

func (self *StackLevelInfo) handle() (result *C.ImGuiStackLevelInfo, fin func()) {
	return self.CData, func() {}
}

func (self StackLevelInfo) c() (C.ImGuiStackLevelInfo, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStackLevelInfoFromC(cvalue *C.ImGuiStackLevelInfo) *StackLevelInfo {
	return &StackLevelInfo{CData: cvalue}
}

type StackSizes struct {
	CData *C.ImGuiStackSizes
}

func (self *StackSizes) handle() (result *C.ImGuiStackSizes, fin func()) {
	return self.CData, func() {}
}

func (self StackSizes) c() (C.ImGuiStackSizes, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStackSizesFromC(cvalue *C.ImGuiStackSizes) *StackSizes {
	return &StackSizes{CData: cvalue}
}

type Storage struct {
	CData *C.ImGuiStorage
}

func (self *Storage) handle() (result *C.ImGuiStorage, fin func()) {
	return self.CData, func() {}
}

func (self Storage) c() (C.ImGuiStorage, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStorageFromC(cvalue *C.ImGuiStorage) *Storage {
	return &Storage{CData: cvalue}
}

type StoragePair struct {
	CData *C.ImGuiStoragePair
}

func (self *StoragePair) handle() (result *C.ImGuiStoragePair, fin func()) {
	return self.CData, func() {}
}

func (self StoragePair) c() (C.ImGuiStoragePair, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStoragePairFromC(cvalue *C.ImGuiStoragePair) *StoragePair {
	return &StoragePair{CData: cvalue}
}

type Style struct {
	CData *C.ImGuiStyle
}

func (self *Style) handle() (result *C.ImGuiStyle, fin func()) {
	return self.CData, func() {}
}

func (self Style) c() (C.ImGuiStyle, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStyleFromC(cvalue *C.ImGuiStyle) *Style {
	return &Style{CData: cvalue}
}

type StyleMod struct {
	CData *C.ImGuiStyleMod
}

func (self *StyleMod) handle() (result *C.ImGuiStyleMod, fin func()) {
	return self.CData, func() {}
}

func (self StyleMod) c() (C.ImGuiStyleMod, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStyleModFromC(cvalue *C.ImGuiStyleMod) *StyleMod {
	return &StyleMod{CData: cvalue}
}

type TabBar struct {
	CData *C.ImGuiTabBar
}

func (self *TabBar) handle() (result *C.ImGuiTabBar, fin func()) {
	return self.CData, func() {}
}

func (self TabBar) c() (C.ImGuiTabBar, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTabBarFromC(cvalue *C.ImGuiTabBar) *TabBar {
	return &TabBar{CData: cvalue}
}

type TabItem struct {
	CData *C.ImGuiTabItem
}

func (self *TabItem) handle() (result *C.ImGuiTabItem, fin func()) {
	return self.CData, func() {}
}

func (self TabItem) c() (C.ImGuiTabItem, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTabItemFromC(cvalue *C.ImGuiTabItem) *TabItem {
	return &TabItem{CData: cvalue}
}

type Table struct {
	CData *C.ImGuiTable
}

func (self *Table) handle() (result *C.ImGuiTable, fin func()) {
	return self.CData, func() {}
}

func (self Table) c() (C.ImGuiTable, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableFromC(cvalue *C.ImGuiTable) *Table {
	return &Table{CData: cvalue}
}

type TableCellData struct {
	CData *C.ImGuiTableCellData
}

func (self *TableCellData) handle() (result *C.ImGuiTableCellData, fin func()) {
	return self.CData, func() {}
}

func (self TableCellData) c() (C.ImGuiTableCellData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableCellDataFromC(cvalue *C.ImGuiTableCellData) *TableCellData {
	return &TableCellData{CData: cvalue}
}

type TableColumn struct {
	CData *C.ImGuiTableColumn
}

func (self *TableColumn) handle() (result *C.ImGuiTableColumn, fin func()) {
	return self.CData, func() {}
}

func (self TableColumn) c() (C.ImGuiTableColumn, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableColumnFromC(cvalue *C.ImGuiTableColumn) *TableColumn {
	return &TableColumn{CData: cvalue}
}

type TableColumnSettings struct {
	CData *C.ImGuiTableColumnSettings
}

func (self *TableColumnSettings) handle() (result *C.ImGuiTableColumnSettings, fin func()) {
	return self.CData, func() {}
}

func (self TableColumnSettings) c() (C.ImGuiTableColumnSettings, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableColumnSettingsFromC(cvalue *C.ImGuiTableColumnSettings) *TableColumnSettings {
	return &TableColumnSettings{CData: cvalue}
}

type TableColumnSortSpecs struct {
	CData *C.ImGuiTableColumnSortSpecs
}

func (self *TableColumnSortSpecs) handle() (result *C.ImGuiTableColumnSortSpecs, fin func()) {
	return self.CData, func() {}
}

func (self TableColumnSortSpecs) c() (C.ImGuiTableColumnSortSpecs, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableColumnSortSpecsFromC(cvalue *C.ImGuiTableColumnSortSpecs) *TableColumnSortSpecs {
	return &TableColumnSortSpecs{CData: cvalue}
}

type TableColumnsSettings struct {
	CData *C.ImGuiTableColumnsSettings
}

func (self *TableColumnsSettings) handle() (result *C.ImGuiTableColumnsSettings, fin func()) {
	return self.CData, func() {}
}

func newTableColumnsSettingsFromC(cvalue *C.ImGuiTableColumnsSettings) *TableColumnsSettings {
	return &TableColumnsSettings{CData: cvalue}
}

type TableDrawChannelIdx uint16

func (selfSrc *TableDrawChannelIdx) handle() (result *C.ImGuiTableDrawChannelIdx, fin func()) {
	self := (*uint16)(selfSrc)
	selfArg, selfFin := WrapNumberPtr[C.ImU16, uint16](self)
	return (*C.ImGuiTableDrawChannelIdx)(selfArg), func() { selfFin() }
}

func (self TableDrawChannelIdx) c() (C.ImGuiTableDrawChannelIdx, func()) {
	return (C.ImGuiTableDrawChannelIdx)(C.ImU16(self)), func() {}
}

func newTableDrawChannelIdxFromC(cvalue *C.ImGuiTableDrawChannelIdx) *TableDrawChannelIdx {
	return (*TableDrawChannelIdx)((*uint16)(cvalue))
}

type TableHeaderData struct {
	CData *C.ImGuiTableHeaderData
}

func (self *TableHeaderData) handle() (result *C.ImGuiTableHeaderData, fin func()) {
	return self.CData, func() {}
}

func (self TableHeaderData) c() (C.ImGuiTableHeaderData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableHeaderDataFromC(cvalue *C.ImGuiTableHeaderData) *TableHeaderData {
	return &TableHeaderData{CData: cvalue}
}

type TableInstanceData struct {
	CData *C.ImGuiTableInstanceData
}

func (self *TableInstanceData) handle() (result *C.ImGuiTableInstanceData, fin func()) {
	return self.CData, func() {}
}

func (self TableInstanceData) c() (C.ImGuiTableInstanceData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableInstanceDataFromC(cvalue *C.ImGuiTableInstanceData) *TableInstanceData {
	return &TableInstanceData{CData: cvalue}
}

type TableSettings struct {
	CData *C.ImGuiTableSettings
}

func (self *TableSettings) handle() (result *C.ImGuiTableSettings, fin func()) {
	return self.CData, func() {}
}

func (self TableSettings) c() (C.ImGuiTableSettings, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableSettingsFromC(cvalue *C.ImGuiTableSettings) *TableSettings {
	return &TableSettings{CData: cvalue}
}

type TableSortSpecs struct {
	CData *C.ImGuiTableSortSpecs
}

func (self *TableSortSpecs) handle() (result *C.ImGuiTableSortSpecs, fin func()) {
	return self.CData, func() {}
}

func (self TableSortSpecs) c() (C.ImGuiTableSortSpecs, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableSortSpecsFromC(cvalue *C.ImGuiTableSortSpecs) *TableSortSpecs {
	return &TableSortSpecs{CData: cvalue}
}

type TableTempData struct {
	CData *C.ImGuiTableTempData
}

func (self *TableTempData) handle() (result *C.ImGuiTableTempData, fin func()) {
	return self.CData, func() {}
}

func (self TableTempData) c() (C.ImGuiTableTempData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTableTempDataFromC(cvalue *C.ImGuiTableTempData) *TableTempData {
	return &TableTempData{CData: cvalue}
}

type TextBuffer struct {
	CData *C.ImGuiTextBuffer
}

func (self *TextBuffer) handle() (result *C.ImGuiTextBuffer, fin func()) {
	return self.CData, func() {}
}

func (self TextBuffer) c() (C.ImGuiTextBuffer, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTextBufferFromC(cvalue *C.ImGuiTextBuffer) *TextBuffer {
	return &TextBuffer{CData: cvalue}
}

type TextFilter struct {
	CData *C.ImGuiTextFilter
}

func (self *TextFilter) handle() (result *C.ImGuiTextFilter, fin func()) {
	return self.CData, func() {}
}

func (self TextFilter) c() (C.ImGuiTextFilter, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTextFilterFromC(cvalue *C.ImGuiTextFilter) *TextFilter {
	return &TextFilter{CData: cvalue}
}

type TextIndex struct {
	CData *C.ImGuiTextIndex
}

func (self *TextIndex) handle() (result *C.ImGuiTextIndex, fin func()) {
	return self.CData, func() {}
}

func (self TextIndex) c() (C.ImGuiTextIndex, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTextIndexFromC(cvalue *C.ImGuiTextIndex) *TextIndex {
	return &TextIndex{CData: cvalue}
}

type TextRange struct {
	CData *C.ImGuiTextRange
}

func (self *TextRange) handle() (result *C.ImGuiTextRange, fin func()) {
	return self.CData, func() {}
}

func (self TextRange) c() (C.ImGuiTextRange, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTextRangeFromC(cvalue *C.ImGuiTextRange) *TextRange {
	return &TextRange{CData: cvalue}
}

type TypingSelectRequest struct {
	CData *C.ImGuiTypingSelectRequest
}

func (self *TypingSelectRequest) handle() (result *C.ImGuiTypingSelectRequest, fin func()) {
	return self.CData, func() {}
}

func (self TypingSelectRequest) c() (C.ImGuiTypingSelectRequest, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTypingSelectRequestFromC(cvalue *C.ImGuiTypingSelectRequest) *TypingSelectRequest {
	return &TypingSelectRequest{CData: cvalue}
}

type TypingSelectState struct {
	CData *C.ImGuiTypingSelectState
}

func (self *TypingSelectState) handle() (result *C.ImGuiTypingSelectState, fin func()) {
	return self.CData, func() {}
}

func (self TypingSelectState) c() (C.ImGuiTypingSelectState, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newTypingSelectStateFromC(cvalue *C.ImGuiTypingSelectState) *TypingSelectState {
	return &TypingSelectState{CData: cvalue}
}

type Viewport struct {
	CData *C.ImGuiViewport
}

func (self *Viewport) handle() (result *C.ImGuiViewport, fin func()) {
	return self.CData, func() {}
}

func (self Viewport) c() (C.ImGuiViewport, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newViewportFromC(cvalue *C.ImGuiViewport) *Viewport {
	return &Viewport{CData: cvalue}
}

type ViewportP struct {
	CData *C.ImGuiViewportP
}

func (self *ViewportP) handle() (result *C.ImGuiViewportP, fin func()) {
	return self.CData, func() {}
}

func (self ViewportP) c() (C.ImGuiViewportP, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newViewportPFromC(cvalue *C.ImGuiViewportP) *ViewportP {
	return &ViewportP{CData: cvalue}
}

type Window struct {
	CData *C.ImGuiWindow
}

func (self *Window) handle() (result *C.ImGuiWindow, fin func()) {
	return self.CData, func() {}
}

func (self Window) c() (C.ImGuiWindow, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newWindowFromC(cvalue *C.ImGuiWindow) *Window {
	return &Window{CData: cvalue}
}

type WindowClass struct {
	CData *C.ImGuiWindowClass
}

func (self *WindowClass) handle() (result *C.ImGuiWindowClass, fin func()) {
	return self.CData, func() {}
}

func (self WindowClass) c() (C.ImGuiWindowClass, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newWindowClassFromC(cvalue *C.ImGuiWindowClass) *WindowClass {
	return &WindowClass{CData: cvalue}
}

type WindowDockStyle struct {
	CData *C.ImGuiWindowDockStyle
}

func (self *WindowDockStyle) handle() (result *C.ImGuiWindowDockStyle, fin func()) {
	return self.CData, func() {}
}

func (self WindowDockStyle) c() (C.ImGuiWindowDockStyle, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newWindowDockStyleFromC(cvalue *C.ImGuiWindowDockStyle) *WindowDockStyle {
	return &WindowDockStyle{CData: cvalue}
}

type WindowSettings struct {
	CData *C.ImGuiWindowSettings
}

func (self *WindowSettings) handle() (result *C.ImGuiWindowSettings, fin func()) {
	return self.CData, func() {}
}

func (self WindowSettings) c() (C.ImGuiWindowSettings, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newWindowSettingsFromC(cvalue *C.ImGuiWindowSettings) *WindowSettings {
	return &WindowSettings{CData: cvalue}
}

type WindowStackData struct {
	CData *C.ImGuiWindowStackData
}

func (self *WindowStackData) handle() (result *C.ImGuiWindowStackData, fin func()) {
	return self.CData, func() {}
}

func (self WindowStackData) c() (C.ImGuiWindowStackData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newWindowStackDataFromC(cvalue *C.ImGuiWindowStackData) *WindowStackData {
	return &WindowStackData{CData: cvalue}
}

type WindowTempData struct {
	CData *C.ImGuiWindowTempData
}

func (self *WindowTempData) handle() (result *C.ImGuiWindowTempData, fin func()) {
	return self.CData, func() {}
}

func (self WindowTempData) c() (C.ImGuiWindowTempData, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newWindowTempDataFromC(cvalue *C.ImGuiWindowTempData) *WindowTempData {
	return &WindowTempData{CData: cvalue}
}

type PoolIdx int32

func (selfSrc *PoolIdx) handle() (result *C.ImPoolIdx, fin func()) {
	self := (*int32)(selfSrc)
	selfArg, selfFin := WrapNumberPtr[C.int, int32](self)
	return (*C.ImPoolIdx)(selfArg), func() { selfFin() }
}

func (self PoolIdx) c() (C.ImPoolIdx, func()) {
	return (C.ImPoolIdx)(C.int(self)), func() {}
}

func newPoolIdxFromC(cvalue *C.ImPoolIdx) *PoolIdx {
	return (*PoolIdx)((*int32)(cvalue))
}

type TextureID struct {
	Data uintptr
}

func (self *TextureID) handle() (result *C.ImTextureID, fin func()) {
	r, f := self.c()
	return &r, f
}

func (self TextureID) c() (C.ImTextureID, func()) {
	return (C.ImTextureID)(C.ImTextureID_fromUintptr(C.uintptr_t(self.Data))), func() {}
}

func newTextureIDFromC(cvalue *C.ImTextureID) *TextureID {
	return &TextureID{Data: (uintptr)(C.ImTextureID_toUintptr(*cvalue))}
}

type Vec1 struct {
	CData *C.ImVec1
}

func (self *Vec1) handle() (result *C.ImVec1, fin func()) {
	return self.CData, func() {}
}

func (self Vec1) c() (C.ImVec1, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newVec1FromC(cvalue *C.ImVec1) *Vec1 {
	return &Vec1{CData: cvalue}
}

type Wchar32 uint32

func (selfSrc *Wchar32) handle() (result *C.ImWchar32, fin func()) {
	self := (*uint32)(selfSrc)
	selfArg, selfFin := WrapNumberPtr[C.uint, uint32](self)
	return (*C.ImWchar32)(selfArg), func() { selfFin() }
}

func (self Wchar32) c() (C.ImWchar32, func()) {
	return (C.ImWchar32)(C.uint(self)), func() {}
}

func newWchar32FromC(cvalue *C.ImWchar32) *Wchar32 {
	return (*Wchar32)((*uint32)(cvalue))
}

type STBTexteditState struct {
	CData *C.STB_TexteditState
}

func (self *STBTexteditState) handle() (result *C.STB_TexteditState, fin func()) {
	return self.CData, func() {}
}

func (self STBTexteditState) c() (C.STB_TexteditState, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newSTBTexteditStateFromC(cvalue *C.STB_TexteditState) *STBTexteditState {
	return &STBTexteditState{CData: cvalue}
}

type StbTexteditRow struct {
	CData *C.StbTexteditRow
}

func (self *StbTexteditRow) handle() (result *C.StbTexteditRow, fin func()) {
	return self.CData, func() {}
}

func (self StbTexteditRow) c() (C.StbTexteditRow, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStbTexteditRowFromC(cvalue *C.StbTexteditRow) *StbTexteditRow {
	return &StbTexteditRow{CData: cvalue}
}

type StbUndoRecord struct {
	CData *C.StbUndoRecord
}

func (self *StbUndoRecord) handle() (result *C.StbUndoRecord, fin func()) {
	return self.CData, func() {}
}

func (self StbUndoRecord) c() (C.StbUndoRecord, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStbUndoRecordFromC(cvalue *C.StbUndoRecord) *StbUndoRecord {
	return &StbUndoRecord{CData: cvalue}
}

type StbUndoState struct {
	CData *C.StbUndoState
}

func (self *StbUndoState) handle() (result *C.StbUndoState, fin func()) {
	return self.CData, func() {}
}

func (self StbUndoState) c() (C.StbUndoState, func()) {
	result, fn := self.handle()
	return *result, fn
}

func newStbUndoStateFromC(cvalue *C.StbUndoState) *StbUndoState {
	return &StbUndoState{CData: cvalue}
}