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

package imgui

// Flags for ImDrawList functions
// (Legacy: bit 0 must always correspond to ImDrawFlags_Closed to be backward compatible with old API using a bool. Bits 1..3 must be unused)
// original name: ImDrawFlags_
type DrawFlags int32

const (
	DrawFlagsNone DrawFlags = 0
	// PathStroke(), AddPolyline(): specify that shape should be closed (Important: this is always == 1 for legacy reason)
	DrawFlagsClosed DrawFlags = 1
	// AddRect(), AddRectFilled(), PathRect(): enable rounding top-left corner only (when rounding > 0.0f, we default to all corners). Was 0x01.
	DrawFlagsRoundCornersTopLeft DrawFlags = 16
	// AddRect(), AddRectFilled(), PathRect(): enable rounding top-right corner only (when rounding > 0.0f, we default to all corners). Was 0x02.
	DrawFlagsRoundCornersTopRight DrawFlags = 32
	// AddRect(), AddRectFilled(), PathRect(): enable rounding bottom-left corner only (when rounding > 0.0f, we default to all corners). Was 0x04.
	DrawFlagsRoundCornersBottomLeft DrawFlags = 64
	// AddRect(), AddRectFilled(), PathRect(): enable rounding bottom-right corner only (when rounding > 0.0f, we default to all corners). Wax 0x08.
	DrawFlagsRoundCornersBottomRight DrawFlags = 128
	// AddRect(), AddRectFilled(), PathRect(): disable rounding on all corners (when rounding > 0.0f). This is NOT zero, NOT an implicit flag!
	DrawFlagsRoundCornersNone   DrawFlags = 256
	DrawFlagsRoundCornersTop    DrawFlags = 48
	DrawFlagsRoundCornersBottom DrawFlags = 192
	DrawFlagsRoundCornersLeft   DrawFlags = 80
	DrawFlagsRoundCornersRight  DrawFlags = 160
	DrawFlagsRoundCornersAll    DrawFlags = 240
	// Default to ALL corners if none of the _RoundCornersXX flags are specified.
	DrawFlagsRoundCornersDefault DrawFlags = 240
	DrawFlagsRoundCornersMask    DrawFlags = 496
)

// Flags for ImDrawList instance. Those are set automatically by ImGui:: functions from ImGuiIO settings, and generally not manipulated directly.
// It is however possible to temporarily alter flags between calls to ImDrawList:: functions.
// original name: ImDrawListFlags_
type DrawListFlags int32

const (
	DrawListFlagsNone DrawListFlags = 0
	// Enable anti-aliased lines/borders (*2 the number of triangles for 1.0f wide line or lines thin enough to be drawn using textures, otherwise *3 the number of triangles)
	DrawListFlagsAntiAliasedLines DrawListFlags = 1
	// Enable anti-aliased lines/borders using textures when possible. Require backend to render with bilinear filtering (NOT point/nearest filtering).
	DrawListFlagsAntiAliasedLinesUseTex DrawListFlags = 2
	// Enable anti-aliased edge around filled shapes (rounded rectangles, circles).
	DrawListFlagsAntiAliasedFill DrawListFlags = 4
	// Can emit 'VtxOffset > 0' to allow large meshes. Set when 'ImGuiBackendFlags_RendererHasVtxOffset' is enabled.
	DrawListFlagsAllowVtxOffset DrawListFlags = 8
)

// Helpers: High-level text functions (DO NOT USE!!! THIS IS A MINIMAL SUBSET OF LARGER UPCOMING CHANGES)
// original name: ImDrawTextFlags_
type DrawTextFlags int32

const (
	DrawTextFlagsNone DrawTextFlags = 0
	// Must be == 1/true for legacy with 'bool cpu_fine_clip' arg to RenderText()
	DrawTextFlagsCpuFineClip    DrawTextFlags = 1
	DrawTextFlagsWrapKeepBlanks DrawTextFlags = 2
	DrawTextFlagsStopOnNewLine  DrawTextFlags = 4
)

// Flags for ImFontAtlas build
// original name: ImFontAtlasFlags_
type FontAtlasFlags int32

const (
	FontAtlasFlagsNone FontAtlasFlags = 0
	// Don't round the height to next power of two
	FontAtlasFlagsNoPowerOfTwoHeight FontAtlasFlags = 1
	// Don't build software mouse cursors into the atlas (save a little texture memory)
	FontAtlasFlagsNoMouseCursors FontAtlasFlags = 2
	// Don't build thick line textures into the atlas (save a little texture memory, allow support for point/nearest filtering). The AntiAliasedLinesUseTex features uses them, otherwise they will be rendered using polygons (more expensive for CPU/GPU).
	FontAtlasFlagsNoBakedLines FontAtlasFlags = 4
)

// Font flags
// (in future versions as we redesign font loading API, this will become more important and better documented. for now please consider this as internal/advanced use)
// original name: ImFontFlags_
type FontFlags int32

const (
	FontFlagsNone FontFlags = 0
	// Disable throwing an error/assert when calling AddFontXXX() with missing file/data. Calling code is expected to check AddFontXXX() return value.
	FontFlagsNoLoadError FontFlags = 2
	// [Internal] Disable loading new glyphs.
	FontFlagsNoLoadGlyphs FontFlags = 4
	// [Internal] Disable loading new baked sizes, disable garbage collecting current ones. e.g. if you want to lock a font to a single size. Important: if you use this to preload given sizes, consider the possibility of multiple font density used on Retina display.
	FontFlagsLockBakedSizes FontFlags = 8
)

// original name: ImGuiActivateFlags_
type ActivateFlags int32

const (
	ActivateFlagsNone ActivateFlags = 0
	// Favor activation that requires keyboard text input (e.g. for Slider/Drag). Default for Enter key.
	ActivateFlagsPreferInput ActivateFlags = 1
	// Favor activation for tweaking with arrows or gamepad (e.g. for Slider/Drag). Default for Space key and if keyboard is not used.
	ActivateFlagsPreferTweak ActivateFlags = 2
	// Request widget to preserve state if it can (e.g. InputText will try to preserve cursor/selection)
	ActivateFlagsTryToPreserveState ActivateFlags = 4
	// Activation requested by a tabbing request (ImGuiNavMoveFlags_IsTabbing)
	ActivateFlagsFromTabbing ActivateFlags = 8
	// Activation requested by an item shortcut via SetNextItemShortcut() function.
	ActivateFlagsFromShortcut ActivateFlags = 16
	// Activation requested by an api request (ImGuiNavMoveFlags_FocusApi)
	ActivateFlagsFromFocusApi ActivateFlags = 32
)

// X/Y enums are fixed to 0/1 so they may be used to index ImVec2
// original name: ImGuiAxis
type Axis int32

const (
	AxisNone Axis = -1
	AxisX    Axis = 0
	AxisY    Axis = 1
)

// Backend capabilities flags stored in io.BackendFlags. Set by imgui_impl_xxx or custom backend.
// original name: ImGuiBackendFlags_
type BackendFlags int32

const (
	BackendFlagsNone BackendFlags = 0
	// Backend Platform supports gamepad and currently has one connected.
	BackendFlagsHasGamepad BackendFlags = 1
	// Backend Platform supports honoring GetMouseCursor() value to change the OS cursor shape.
	BackendFlagsHasMouseCursors BackendFlags = 2
	// Backend Platform supports io.WantSetMousePos requests to reposition the OS mouse position (only used if io.ConfigNavMoveSetMousePos is set).
	BackendFlagsHasSetMousePos BackendFlags = 4
	// Backend Renderer supports ImDrawCmd::VtxOffset. This enables output of large meshes (64K+ vertices) while still using 16-bit indices.
	BackendFlagsRendererHasVtxOffset BackendFlags = 8
	// Backend Renderer supports ImTextureData requests to create/update/destroy textures. This enables incremental texture updates and texture reloads. See https://github.com/ocornut/imgui/blob/master/docs/BACKENDS.md for instructions on how to upgrade your custom backend.
	BackendFlagsRendererHasTextures BackendFlags = 16
	// Backend Renderer supports multiple viewports.
	BackendFlagsRendererHasViewports BackendFlags = 1024
	// Backend Platform supports multiple viewports.
	BackendFlagsPlatformHasViewports BackendFlags = 2048
	// Backend Platform supports calling io.AddMouseViewportEvent() with the viewport under the mouse. IF POSSIBLE, ignore viewports with the ImGuiViewportFlags_NoInputs flag (Win32 backend, GLFW 3.30+ backend can do this, SDL backend cannot). If this cannot be done, Dear ImGui needs to use a flawed heuristic to find the viewport under.
	BackendFlagsHasMouseHoveredViewport BackendFlags = 4096
	// Backend Platform supports honoring viewport->ParentViewportId value, by applying the corresponding parent/child relation at the Platform level.
	BackendFlagsHasParentViewportId BackendFlags = 8192
)

// Extend ImGuiButtonFlags_
// original name: ImGuiButtonFlagsPrivate_
type ButtonFlagsPrivate int32

const (
	// return true on click (mouse down event)
	ButtonFlagsPressedOnClick ButtonFlagsPrivate = 16
	// [Default] return true on click + release on same item <-- this is what the majority of Button are using
	ButtonFlagsPressedOnClickRelease ButtonFlagsPrivate = 32
	// return true on click + release even if the release event is not done while hovering the item
	ButtonFlagsPressedOnClickReleaseAnywhere ButtonFlagsPrivate = 64
	// return true on release (default requires click+release)
	ButtonFlagsPressedOnRelease ButtonFlagsPrivate = 128
	// return true on double-click (default requires click+release)
	ButtonFlagsPressedOnDoubleClick ButtonFlagsPrivate = 256
	// return true when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
	ButtonFlagsPressedOnDragDropHold ButtonFlagsPrivate = 512
	// allow interactions even if a child window is overlapping
	ButtonFlagsFlattenChildren ButtonFlagsPrivate = 2048
	// require previous frame HoveredId to either match id or be null before being usable.
	ButtonFlagsAllowOverlap ButtonFlagsPrivate = 4096
	// vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
	ButtonFlagsAlignTextBaseLine ButtonFlagsPrivate = 32768
	// disable mouse interaction if a key modifier is held
	ButtonFlagsNoKeyModsAllowed ButtonFlagsPrivate = 65536
	// don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
	ButtonFlagsNoHoldingActiveId ButtonFlagsPrivate = 131072
	// don't override navigation focus when activated (FIXME: this is essentially used every time an item uses ImGuiItemFlags_NoNav, but because legacy specs don't requires LastItemData to be set ButtonBehavior(), we can't poll g.LastItemData.ItemFlags)
	ButtonFlagsNoNavFocus ButtonFlagsPrivate = 262144
	// don't report as hovered when nav focus is on this item
	ButtonFlagsNoHoveredOnFocus ButtonFlagsPrivate = 524288
	// don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)
	ButtonFlagsNoSetKeyOwner ButtonFlagsPrivate = 1048576
	// don't test key/input owner when polling the key (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)
	ButtonFlagsNoTestKeyOwner ButtonFlagsPrivate = 2097152
	// [EXPERIMENTAL: Not very well specced]. Don't focus parent window when clicking.
	ButtonFlagsNoFocus          ButtonFlagsPrivate = 4194304
	ButtonFlagsPressedOnMask    ButtonFlagsPrivate = 1008
	ButtonFlagsPressedOnDefault ButtonFlagsPrivate = 32
)

// Flags for InvisibleButton() [extended in imgui_internal.h]
// original name: ImGuiButtonFlags_
type ButtonFlags int32

const (
	ButtonFlagsNone ButtonFlags = 0
	// React on left mouse button (default)
	ButtonFlagsMouseButtonLeft ButtonFlags = 1
	// React on right mouse button
	ButtonFlagsMouseButtonRight ButtonFlags = 2
	// React on center mouse button
	ButtonFlagsMouseButtonMiddle ButtonFlags = 4
	// [Internal]
	ButtonFlagsMouseButtonMask ButtonFlags = 7
	// InvisibleButton(): do not disable navigation/tabbing. Otherwise disabled by default.
	ButtonFlagsEnableNav ButtonFlags = 8
)

// Flags for ImGui::BeginChild()
// (Legacy: bit 0 must always correspond to ImGuiChildFlags_Borders to be backward compatible with old API using 'bool border = false'.)
// About using AutoResizeX/AutoResizeY flags:
// - May be combined with SetNextWindowSizeConstraints() to set a min/max size for each axis (see "Demo->Child->Auto-resize with Constraints").
// - Size measurement for a given axis is only performed when the child window is within visible boundaries, or is just appearing.
//   - This allows BeginChild() to return false when not within boundaries (e.g. when scrolling), which is more optimal. BUT it won't update its auto-size while clipped.
//     While not perfect, it is a better default behavior as the always-on performance gain is more valuable than the occasional "resizing after becoming visible again" glitch.
//   - You may also use ImGuiChildFlags_AlwaysAutoResize to force an update even when child window is not in view.
//     HOWEVER PLEASE UNDERSTAND THAT DOING SO WILL PREVENT BeginChild() FROM EVER RETURNING FALSE, disabling benefits of coarse clipping.
//
// original name: ImGuiChildFlags_
type ChildFlags int32

const (
	ChildFlagsNone ChildFlags = 0
	// Show an outer border and enable WindowPadding. (IMPORTANT: this is always == 1 == true for legacy reason)
	ChildFlagsBorders ChildFlags = 1
	// Pad with style.WindowPadding even if no border are drawn (no padding by default for non-bordered child windows because it makes more sense)
	ChildFlagsAlwaysUseWindowPadding ChildFlags = 2
	// Allow resize from right border (layout direction). Enable .ini saving (unless ImGuiWindowFlags_NoSavedSettings passed to window flags)
	ChildFlagsResizeX ChildFlags = 4
	// Allow resize from bottom border (layout direction). "
	ChildFlagsResizeY ChildFlags = 8
	// Enable auto-resizing width. Read "IMPORTANT: Size measurement" details above.
	ChildFlagsAutoResizeX ChildFlags = 16
	// Enable auto-resizing height. Read "IMPORTANT: Size measurement" details above.
	ChildFlagsAutoResizeY ChildFlags = 32
	// Combined with AutoResizeX/AutoResizeY. Always measure size even when child is hidden, always return true, always disable clipping optimization! NOT RECOMMENDED.
	ChildFlagsAlwaysAutoResize ChildFlags = 64
	// Style the child window like a framed item: use FrameBg, FrameRounding, FrameBorderSize, FramePadding instead of ChildBg, ChildRounding, ChildBorderSize, WindowPadding.
	ChildFlagsFrameStyle ChildFlags = 128
	// [BETA] Share focus scope, allow keyboard/gamepad navigation to cross over parent border to this child or between sibling child windows.
	ChildFlagsNavFlattened ChildFlags = 256
)

// Enumeration for PushStyleColor() / PopStyleColor()
// original name: ImGuiCol_
type Col int32

const (
	ColText         Col = 0
	ColTextDisabled Col = 1
	// Background of normal windows
	ColWindowBg Col = 2
	// Background of child windows
	ColChildBg Col = 3
	// Background of popups, menus, tooltips windows
	ColPopupBg      Col = 4
	ColBorder       Col = 5
	ColBorderShadow Col = 6
	// Background of checkbox, radio button, plot, slider, text input
	ColFrameBg        Col = 7
	ColFrameBgHovered Col = 8
	ColFrameBgActive  Col = 9
	// Title bar
	ColTitleBg Col = 10
	// Title bar when focused
	ColTitleBgActive Col = 11
	// Title bar when collapsed
	ColTitleBgCollapsed     Col = 12
	ColMenuBarBg            Col = 13
	ColScrollbarBg          Col = 14
	ColScrollbarGrab        Col = 15
	ColScrollbarGrabHovered Col = 16
	ColScrollbarGrabActive  Col = 17
	// Checkbox tick and RadioButton circle
	ColCheckMark        Col = 18
	ColSliderGrab       Col = 19
	ColSliderGrabActive Col = 20
	ColButton           Col = 21
	ColButtonHovered    Col = 22
	ColButtonActive     Col = 23
	// Header* colors are used for CollapsingHeader, TreeNode, Selectable, MenuItem
	ColHeader           Col = 24
	ColHeaderHovered    Col = 25
	ColHeaderActive     Col = 26
	ColSeparator        Col = 27
	ColSeparatorHovered Col = 28
	ColSeparatorActive  Col = 29
	// Resize grip in lower-right and lower-left corners of windows.
	ColResizeGrip        Col = 30
	ColResizeGripHovered Col = 31
	ColResizeGripActive  Col = 32
	// InputText cursor/caret
	ColInputTextCursor Col = 33
	// Tab background, when hovered
	ColTabHovered Col = 34
	// Tab background, when tab-bar is focused & tab is unselected
	ColTab Col = 35
	// Tab background, when tab-bar is focused & tab is selected
	ColTabSelected Col = 36
	// Tab horizontal overline, when tab-bar is focused & tab is selected
	ColTabSelectedOverline Col = 37
	// Tab background, when tab-bar is unfocused & tab is unselected
	ColTabDimmed Col = 38
	// Tab background, when tab-bar is unfocused & tab is selected
	ColTabDimmedSelected Col = 39
	//..horizontal overline, when tab-bar is unfocused & tab is selected
	ColTabDimmedSelectedOverline Col = 40
	// Preview overlay color when about to docking something
	ColDockingPreview Col = 41
	// Background color for empty node (e.g. CentralNode with no window docked into it)
	ColDockingEmptyBg       Col = 42
	ColPlotLines            Col = 43
	ColPlotLinesHovered     Col = 44
	ColPlotHistogram        Col = 45
	ColPlotHistogramHovered Col = 46
	// Table header background
	ColTableHeaderBg Col = 47
	// Table outer and header borders (prefer using Alpha=1.0 here)
	ColTableBorderStrong Col = 48
	// Table inner borders (prefer using Alpha=1.0 here)
	ColTableBorderLight Col = 49
	// Table row background (even rows)
	ColTableRowBg Col = 50
	// Table row background (odd rows)
	ColTableRowBgAlt Col = 51
	// Hyperlink color
	ColTextLink Col = 52
	// Selected text inside an InputText
	ColTextSelectedBg Col = 53
	// Tree node hierarchy outlines when using ImGuiTreeNodeFlags_DrawLines
	ColTreeLines Col = 54
	// Rectangle highlighting a drop target
	ColDragDropTarget Col = 55
	// Color of keyboard/gamepad navigation cursor/rectangle, when visible
	ColNavCursor Col = 56
	// Highlight window when using CTRL+TAB
	ColNavWindowingHighlight Col = 57
	// Darken/colorize entire screen behind the CTRL+TAB window list, when active
	ColNavWindowingDimBg Col = 58
	// Darken/colorize entire screen behind a modal window, when one is active
	ColModalWindowDimBg Col = 59
	ColCOUNT            Col = 60
)

// Flags for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()
// original name: ImGuiColorEditFlags_
type ColorEditFlags int32

const (
	ColorEditFlagsNone ColorEditFlags = 0
	//              // ColorEdit, ColorPicker, ColorButton: ignore Alpha component (will only read 3 components from the input pointer).
	ColorEditFlagsNoAlpha ColorEditFlags = 2
	//              // ColorEdit: disable picker when clicking on color square.
	ColorEditFlagsNoPicker ColorEditFlags = 4
	//              // ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.
	ColorEditFlagsNoOptions ColorEditFlags = 8
	//              // ColorEdit, ColorPicker: disable color square preview next to the inputs. (e.g. to show only the inputs)
	ColorEditFlagsNoSmallPreview ColorEditFlags = 16
	//              // ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview color square).
	ColorEditFlagsNoInputs ColorEditFlags = 32
	//              // ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.
	ColorEditFlagsNoTooltip ColorEditFlags = 64
	//              // ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker).
	ColorEditFlagsNoLabel ColorEditFlags = 128
	//              // ColorPicker: disable bigger color preview on right side of the picker, use small color square preview instead.
	ColorEditFlagsNoSidePreview ColorEditFlags = 256
	//              // ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source.
	ColorEditFlagsNoDragDrop ColorEditFlags = 512
	//              // ColorButton: disable border (which is enforced by default)
	ColorEditFlagsNoBorder ColorEditFlags = 1024
	//              // ColorEdit, ColorPicker, ColorButton: disable alpha in the preview,. Contrary to _NoAlpha it may still be edited when calling ColorEdit4()/ColorPicker4(). For ColorButton() this does the same as _NoAlpha.
	ColorEditFlagsAlphaOpaque ColorEditFlags = 2048
	//              // ColorEdit, ColorPicker, ColorButton: disable rendering a checkerboard background behind transparent color.
	ColorEditFlagsAlphaNoBg ColorEditFlags = 4096
	//              // ColorEdit, ColorPicker, ColorButton: display half opaque / half transparent preview.
	ColorEditFlagsAlphaPreviewHalf ColorEditFlags = 8192
	//              // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.
	ColorEditFlagsAlphaBar ColorEditFlags = 65536
	//              // (WIP) ColorEdit: Currently only disable 0.0f..1.0f limits in RGBA edition (note: you probably want to use ImGuiColorEditFlags_Float flag as well).
	ColorEditFlagsHDR ColorEditFlags = 524288
	// [Display]    // ColorEdit: override _display_ type among RGB/HSV/Hex. ColorPicker: select any combination using one or more of RGB/HSV/Hex.
	ColorEditFlagsDisplayRGB ColorEditFlags = 1048576
	// [Display]    // "
	ColorEditFlagsDisplayHSV ColorEditFlags = 2097152
	// [Display]    // "
	ColorEditFlagsDisplayHex ColorEditFlags = 4194304
	// [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.
	ColorEditFlagsUint8 ColorEditFlags = 8388608
	// [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers.
	ColorEditFlagsFloat ColorEditFlags = 16777216
	// [Picker]     // ColorPicker: bar for Hue, rectangle for Sat/Value.
	ColorEditFlagsPickerHueBar ColorEditFlags = 33554432
	// [Picker]     // ColorPicker: wheel for Hue, triangle for Sat/Value.
	ColorEditFlagsPickerHueWheel ColorEditFlags = 67108864
	// [Input]      // ColorEdit, ColorPicker: input and output data in RGB format.
	ColorEditFlagsInputRGB ColorEditFlags = 134217728
	// [Input]      // ColorEdit, ColorPicker: input and output data in HSV format.
	ColorEditFlagsInputHSV       ColorEditFlags = 268435456
	ColorEditFlagsDefaultOptions ColorEditFlags = 177209344
	ColorEditFlagsAlphaMask      ColorEditFlags = 14338
	ColorEditFlagsDisplayMask    ColorEditFlags = 7340032
	ColorEditFlagsDataTypeMask   ColorEditFlags = 25165824
	ColorEditFlagsPickerMask     ColorEditFlags = 100663296
	ColorEditFlagsInputMask      ColorEditFlags = 402653184
)

// Extend ImGuiComboFlags_
// original name: ImGuiComboFlagsPrivate_
type ComboFlagsPrivate int32

const (
	// enable BeginComboPreview()
	ComboFlagsCustomPreview ComboFlagsPrivate = 1048576
)

// Flags for ImGui::BeginCombo()
// original name: ImGuiComboFlags_
type ComboFlags int32

const (
	ComboFlagsNone ComboFlags = 0
	// Align the popup toward the left by default
	ComboFlagsPopupAlignLeft ComboFlags = 1
	// Max ~4 items visible. Tip: If you want your combo popup to be a specific size you can use SetNextWindowSizeConstraints() prior to calling BeginCombo()
	ComboFlagsHeightSmall ComboFlags = 2
	// Max ~8 items visible (default)
	ComboFlagsHeightRegular ComboFlags = 4
	// Max ~20 items visible
	ComboFlagsHeightLarge ComboFlags = 8
	// As many fitting items as possible
	ComboFlagsHeightLargest ComboFlags = 16
	// Display on the preview box without the square arrow button
	ComboFlagsNoArrowButton ComboFlags = 32
	// Display only a square arrow button
	ComboFlagsNoPreview ComboFlags = 64
	// Width dynamically calculated from preview contents
	ComboFlagsWidthFitPreview ComboFlags = 128
	ComboFlagsHeightMask      ComboFlags = 30
)

// Enumeration for ImGui::SetNextWindow***(), SetWindow***(), SetNextItem***() functions
// Represent a condition.
// Important: Treat as a regular enum! Do NOT combine multiple values using binary operators! All the functions above treat 0 as a shortcut to ImGuiCond_Always.
// original name: ImGuiCond_
type Cond int32

const (
	// No condition (always set the variable), same as _Always
	CondNone Cond = 0
	// No condition (always set the variable), same as _None
	CondAlways Cond = 1
	// Set the variable once per runtime session (only the first call will succeed)
	CondOnce Cond = 2
	// Set the variable if the object/window has no persistently saved data (no entry in .ini file)
	CondFirstUseEver Cond = 4
	// Set the variable if the object/window is appearing after being hidden/inactive (or the first time)
	CondAppearing Cond = 8
)

// Configuration flags stored in io.ConfigFlags. Set by user/application.
// original name: ImGuiConfigFlags_
type ConfigFlags int32

const (
	ConfigFlagsNone ConfigFlags = 0
	// Master keyboard navigation enable flag. Enable full Tabbing + directional arrows + space/enter to activate.
	ConfigFlagsNavEnableKeyboard ConfigFlags = 1
	// Master gamepad navigation enable flag. Backend also needs to set ImGuiBackendFlags_HasGamepad.
	ConfigFlagsNavEnableGamepad ConfigFlags = 2
	// Instruct dear imgui to disable mouse inputs and interactions.
	ConfigFlagsNoMouse ConfigFlags = 16
	// Instruct backend to not alter mouse cursor shape and visibility. Use if the backend cursor changes are interfering with yours and you don't want to use SetMouseCursor() to change mouse cursor. You may want to honor requests from imgui by reading GetMouseCursor() yourself instead.
	ConfigFlagsNoMouseCursorChange ConfigFlags = 32
	// Instruct dear imgui to disable keyboard inputs and interactions. This is done by ignoring keyboard events and clearing existing states.
	ConfigFlagsNoKeyboard ConfigFlags = 64
	// Docking enable flags.
	ConfigFlagsDockingEnable ConfigFlags = 128
	// Viewport enable flags (require both ImGuiBackendFlags_PlatformHasViewports + ImGuiBackendFlags_RendererHasViewports set by the respective backends)
	ConfigFlagsViewportsEnable ConfigFlags = 1024
	// Application is SRGB-aware.
	ConfigFlagsIsSRGB ConfigFlags = 1048576
	// Application is using a touch screen instead of a mouse.
	ConfigFlagsIsTouchScreen ConfigFlags = 2097152
)

// original name: ImGuiContextHookType
type ContextHookType int32

const (
	ContextHookTypeNewFramePre    ContextHookType = 0
	ContextHookTypeNewFramePost   ContextHookType = 1
	ContextHookTypeEndFramePre    ContextHookType = 2
	ContextHookTypeEndFramePost   ContextHookType = 3
	ContextHookTypeRenderPre      ContextHookType = 4
	ContextHookTypeRenderPost     ContextHookType = 5
	ContextHookTypeShutdown       ContextHookType = 6
	ContextHookTypePendingRemoval ContextHookType = 7
)

// Store the source authority (dock node vs window) of a field
// original name: ImGuiDataAuthority_
type DataAuthority int32

const (
	DataAuthorityAuto     DataAuthority = 0
	DataAuthorityDockNode DataAuthority = 1
	DataAuthorityWindow   DataAuthority = 2
)

// Extend ImGuiDataType_
// original name: ImGuiDataTypePrivate_
type DataTypePrivate int32

const (
	DataTypePointer DataTypePrivate = 12
	DataTypeID      DataTypePrivate = 13
)

// A primary data type
// original name: ImGuiDataType_
type DataType int32

const (
	// signed char / char (with sensible compilers)
	DataTypeS8 DataType = 0
	// unsigned char
	DataTypeU8 DataType = 1
	// short
	DataTypeS16 DataType = 2
	// unsigned short
	DataTypeU16 DataType = 3
	// int
	DataTypeS32 DataType = 4
	// unsigned int
	DataTypeU32 DataType = 5
	// long long / __int64
	DataTypeS64 DataType = 6
	// unsigned long long / unsigned __int64
	DataTypeU64 DataType = 7
	// float
	DataTypeFloat DataType = 8
	// double
	DataTypeDouble DataType = 9
	// bool (provided for user convenience, not supported by scalar widgets)
	DataTypeBool DataType = 10
	// char* (provided for user convenience, not supported by scalar widgets)
	DataTypeString DataType = 11
	DataTypeCOUNT  DataType = 12
)

// See IMGUI_DEBUG_LOG() and IMGUI_DEBUG_LOG_XXX() macros.
// original name: ImGuiDebugLogFlags_
type DebugLogFlags int32

const (
	DebugLogFlagsNone DebugLogFlags = 0
	// Error submitted by IM_ASSERT_USER_ERROR()
	DebugLogFlagsEventError        DebugLogFlags = 1
	DebugLogFlagsEventActiveId     DebugLogFlags = 2
	DebugLogFlagsEventFocus        DebugLogFlags = 4
	DebugLogFlagsEventPopup        DebugLogFlags = 8
	DebugLogFlagsEventNav          DebugLogFlags = 16
	DebugLogFlagsEventClipper      DebugLogFlags = 32
	DebugLogFlagsEventSelection    DebugLogFlags = 64
	DebugLogFlagsEventIO           DebugLogFlags = 128
	DebugLogFlagsEventFont         DebugLogFlags = 256
	DebugLogFlagsEventInputRouting DebugLogFlags = 512
	DebugLogFlagsEventDocking      DebugLogFlags = 1024
	DebugLogFlagsEventViewport     DebugLogFlags = 2048
	DebugLogFlagsEventMask         DebugLogFlags = 4095
	// Also send output to TTY
	DebugLogFlagsOutputToTTY DebugLogFlags = 1048576
	// Also send output to Test Engine
	DebugLogFlagsOutputToTestEngine DebugLogFlags = 2097152
)

// A cardinal direction
// original name: ImGuiDir
type Dir int32

const (
	DirNone  Dir = -1
	DirLeft  Dir = 0
	DirRight Dir = 1
	DirUp    Dir = 2
	DirDown  Dir = 3
	DirCOUNT Dir = 4
)

// Extend ImGuiDockNodeFlags_
// original name: ImGuiDockNodeFlagsPrivate_
type DockNodeFlagsPrivate int32

const (
	// Saved // A dockspace is a node that occupy space within an existing user window. Otherwise the node is floating and create its own window.
	DockNodeFlagsDockSpace DockNodeFlagsPrivate = 1024
	// Saved // The central node has 2 main properties: stay visible when empty, only use "remaining" spaces from its neighbor.
	DockNodeFlagsCentralNode DockNodeFlagsPrivate = 2048
	// Saved // Tab bar is completely unavailable. No triangle in the corner to enable it back.
	DockNodeFlagsNoTabBar DockNodeFlagsPrivate = 4096
	// Saved // Tab bar is hidden, with a triangle in the corner to show it again (NB: actual tab-bar instance may be destroyed as this is only used for single-window tab bar)
	DockNodeFlagsHiddenTabBar DockNodeFlagsPrivate = 8192
	// Saved // Disable window/docking menu (that one that appears instead of the collapse button)
	DockNodeFlagsNoWindowMenuButton DockNodeFlagsPrivate = 16384
	// Saved // Disable close button
	DockNodeFlagsNoCloseButton DockNodeFlagsPrivate = 32768
	//       //
	DockNodeFlagsNoResizeX DockNodeFlagsPrivate = 65536
	//       //
	DockNodeFlagsNoResizeY DockNodeFlagsPrivate = 131072
	//       // Any docked window will be automatically be focus-route chained (window->ParentWindowForFocusRoute set to this) so Shortcut() in this window can run when any docked window is focused.
	DockNodeFlagsDockedWindowsInFocusRoute DockNodeFlagsPrivate = 262144
	//       // Disable this node from splitting other windows/nodes.
	DockNodeFlagsNoDockingSplitOther DockNodeFlagsPrivate = 524288
	//       // Disable other windows/nodes from being docked over this node.
	DockNodeFlagsNoDockingOverMe DockNodeFlagsPrivate = 1048576
	//       // Disable this node from being docked over another window or non-empty node.
	DockNodeFlagsNoDockingOverOther DockNodeFlagsPrivate = 2097152
	//       // Disable this node from being docked over an empty node (e.g. DockSpace with no other windows)
	DockNodeFlagsNoDockingOverEmpty     DockNodeFlagsPrivate = 4194304
	DockNodeFlagsNoDocking              DockNodeFlagsPrivate = 7864336
	DockNodeFlagsSharedFlagsInheritMask DockNodeFlagsPrivate = -1
	DockNodeFlagsNoResizeFlagsMask      DockNodeFlagsPrivate = 196640
	DockNodeFlagsLocalFlagsTransferMask DockNodeFlagsPrivate = 260208
	DockNodeFlagsSavedFlagsMask         DockNodeFlagsPrivate = 261152
)

// Flags for ImGui::DockSpace(), shared/inherited by child nodes.
// (Some flags can be applied to individual nodes directly)
// FIXME-DOCK: Also see ImGuiDockNodeFlagsPrivate_ which may involve using the WIP and internal DockBuilder api.
// original name: ImGuiDockNodeFlags_
type DockNodeFlags int32

const (
	DockNodeFlagsNone DockNodeFlags = 0
	//       // Don't display the dockspace node but keep it alive. Windows docked into this dockspace node won't be undocked.
	DockNodeFlagsKeepAliveOnly DockNodeFlags = 1
	//       // Disable docking over the Central Node, which will be always kept empty.
	DockNodeFlagsNoDockingOverCentralNode DockNodeFlags = 4
	//       // Enable passthru dockspace: 1) DockSpace() will render a ImGuiCol_WindowBg background covering everything excepted the Central Node when empty. Meaning the host window should probably use SetNextWindowBgAlpha(0.0f) prior to Begin() when using this. 2) When Central Node is empty: let inputs pass-through + won't display a DockingEmptyBg background. See demo for details.
	DockNodeFlagsPassthruCentralNode DockNodeFlags = 8
	//       // Disable other windows/nodes from splitting this node.
	DockNodeFlagsNoDockingSplit DockNodeFlags = 16
	// Saved // Disable resizing node using the splitter/separators. Useful with programmatically setup dockspaces.
	DockNodeFlagsNoResize DockNodeFlags = 32
	//       // Tab bar will automatically hide when there is a single window in the dock node.
	DockNodeFlagsAutoHideTabBar DockNodeFlags = 64
	//       // Disable undocking this node.
	DockNodeFlagsNoUndocking DockNodeFlags = 128
)

// original name: ImGuiDockNodeState
type DockNodeState int32

const (
	DockNodeStateUnknown                                   DockNodeState = 0
	DockNodeStateHostWindowHiddenBecauseSingleWindow       DockNodeState = 1
	DockNodeStateHostWindowHiddenBecauseWindowsAreResizing DockNodeState = 2
	DockNodeStateHostWindowVisible                         DockNodeState = 3
)

// Flags for ImGui::BeginDragDropSource(), ImGui::AcceptDragDropPayload()
// original name: ImGuiDragDropFlags_
type DragDropFlags int32

const (
	DragDropFlagsNone DragDropFlags = 0
	// Disable preview tooltip. By default, a successful call to BeginDragDropSource opens a tooltip so you can display a preview or description of the source contents. This flag disables this behavior.
	DragDropFlagsSourceNoPreviewTooltip DragDropFlags = 1
	// By default, when dragging we clear data so that IsItemHovered() will return false, to avoid subsequent user code submitting tooltips. This flag disables this behavior so you can still call IsItemHovered() on the source item.
	DragDropFlagsSourceNoDisableHover DragDropFlags = 2
	// Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item.
	DragDropFlagsSourceNoHoldToOpenOthers DragDropFlags = 4
	// Allow items such as Text(), Image() that have no unique identifier to be used as drag source, by manufacturing a temporary identifier based on their window-relative position. This is extremely unusual within the dear imgui ecosystem and so we made it explicit.
	DragDropFlagsSourceAllowNullID DragDropFlags = 8
	// External source (from outside of dear imgui), won't attempt to read current item/window info. Will always return true. Only one Extern source can be active simultaneously.
	DragDropFlagsSourceExtern DragDropFlags = 16
	// Automatically expire the payload if the source cease to be submitted (otherwise payloads are persisting while being dragged)
	DragDropFlagsPayloadAutoExpire DragDropFlags = 32
	// Hint to specify that the payload may not be copied outside current dear imgui context.
	DragDropFlagsPayloadNoCrossContext DragDropFlags = 64
	// Hint to specify that the payload may not be copied outside current process.
	DragDropFlagsPayloadNoCrossProcess DragDropFlags = 128
	// AcceptDragDropPayload() will returns true even before the mouse button is released. You can then call IsDelivery() to test if the payload needs to be delivered.
	DragDropFlagsAcceptBeforeDelivery DragDropFlags = 1024
	// Do not draw the default highlight rectangle when hovering over target.
	DragDropFlagsAcceptNoDrawDefaultRect DragDropFlags = 2048
	// Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site.
	DragDropFlagsAcceptNoPreviewTooltip DragDropFlags = 4096
	// For peeking ahead and inspecting the payload before delivery.
	DragDropFlagsAcceptPeekOnly DragDropFlags = 3072
)

// Flags for FocusWindow(). This is not called ImGuiFocusFlags to avoid confusion with public-facing ImGuiFocusedFlags.
// FIXME: Once we finishing replacing more uses of GetTopMostPopupModal()+IsWindowWithinBeginStackOf()
// and FindBlockingModal() with this, we may want to change the flag to be opt-out instead of opt-in.
// original name: ImGuiFocusRequestFlags_
type FocusRequestFlags int32

const (
	FocusRequestFlagsNone FocusRequestFlags = 0
	// Find last focused child (if any) and focus it instead.
	FocusRequestFlagsRestoreFocusedChild FocusRequestFlags = 1
	// Do not set focus if the window is below a modal.
	FocusRequestFlagsUnlessBelowModal FocusRequestFlags = 2
)

// Flags for ImGui::IsWindowFocused()
// original name: ImGuiFocusedFlags_
type FocusedFlags int32

const (
	FocusedFlagsNone FocusedFlags = 0
	// Return true if any children of the window is focused
	FocusedFlagsChildWindows FocusedFlags = 1
	// Test from root window (top most parent of the current hierarchy)
	FocusedFlagsRootWindow FocusedFlags = 2
	// Return true if any window is focused. Important: If you are trying to tell how to dispatch your low-level inputs, do NOT use this. Use 'io.WantCaptureMouse' instead! Please read the FAQ!
	FocusedFlagsAnyWindow FocusedFlags = 4
	// Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow)
	FocusedFlagsNoPopupHierarchy FocusedFlags = 8
	// Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow)
	FocusedFlagsDockHierarchy       FocusedFlags = 16
	FocusedFlagsRootAndChildWindows FocusedFlags = 3
)

// original name: ImGuiFreeTypeLoaderFlags_
type FreeTypeLoaderFlags int32

const (
	// Disable hinting. This generally generates 'blurrier' bitmap glyphs when the glyph are rendered in any of the anti-aliased modes.
	FreeTypeLoaderFlagsNoHinting FreeTypeLoaderFlags = 1
	// Disable auto-hinter.
	FreeTypeLoaderFlagsNoAutoHint FreeTypeLoaderFlags = 2
	// Indicates that the auto-hinter is preferred over the font's native hinter.
	FreeTypeLoaderFlagsForceAutoHint FreeTypeLoaderFlags = 4
	// A lighter hinting algorithm for gray-level modes. Many generated glyphs are fuzzier but better resemble their original shape. This is achieved by snapping glyphs to the pixel grid only vertically (Y-axis), as is done by Microsoft's ClearType and Adobe's proprietary font renderer. This preserves inter-glyph spacing in horizontal text.
	FreeTypeLoaderFlagsLightHinting FreeTypeLoaderFlags = 8
	// Strong hinting algorithm that should only be used for monochrome output.
	FreeTypeLoaderFlagsMonoHinting FreeTypeLoaderFlags = 16
	// Styling: Should we artificially embolden the font?
	FreeTypeLoaderFlagsBold FreeTypeLoaderFlags = 32
	// Styling: Should we slant the font, emulating italic style?
	FreeTypeLoaderFlagsOblique FreeTypeLoaderFlags = 64
	// Disable anti-aliasing. Combine this with MonoHinting for best results!
	FreeTypeLoaderFlagsMonochrome FreeTypeLoaderFlags = 128
	// Enable FreeType color-layered glyphs
	FreeTypeLoaderFlagsLoadColor FreeTypeLoaderFlags = 256
	// Enable FreeType bitmap glyphs
	FreeTypeLoaderFlagsBitmap FreeTypeLoaderFlags = 512
)

// Extend ImGuiHoveredFlags_
// original name: ImGuiHoveredFlagsPrivate_
type HoveredFlagsPrivate int32

const (
	HoveredFlagsDelayMask                     HoveredFlagsPrivate = 245760
	HoveredFlagsAllowedMaskForIsWindowHovered HoveredFlagsPrivate = 12479
	HoveredFlagsAllowedMaskForIsItemHovered   HoveredFlagsPrivate = 262048
)

// Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered()
// Note: if you are trying to check whether your mouse should be dispatched to Dear ImGui or to your app, you should use 'io.WantCaptureMouse' instead! Please read the FAQ!
// Note: windows with the ImGuiWindowFlags_NoInputs flag are ignored by IsWindowHovered() calls.
// original name: ImGuiHoveredFlags_
type HoveredFlags int32

const (
	// Return true if directly over the item/window, not obstructed by another window, not obstructed by an active popup or modal blocking inputs under them.
	HoveredFlagsNone HoveredFlags = 0
	// IsWindowHovered() only: Return true if any children of the window is hovered
	HoveredFlagsChildWindows HoveredFlags = 1
	// IsWindowHovered() only: Test from root window (top most parent of the current hierarchy)
	HoveredFlagsRootWindow HoveredFlags = 2
	// IsWindowHovered() only: Return true if any window is hovered
	HoveredFlagsAnyWindow HoveredFlags = 4
	// IsWindowHovered() only: Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow)
	HoveredFlagsNoPopupHierarchy HoveredFlags = 8
	// IsWindowHovered() only: Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow)
	HoveredFlagsDockHierarchy HoveredFlags = 16
	// Return true even if a popup window is normally blocking access to this item/window
	HoveredFlagsAllowWhenBlockedByPopup HoveredFlags = 32
	// Return true even if an active item is blocking access to this item/window. Useful for Drag and Drop patterns.
	HoveredFlagsAllowWhenBlockedByActiveItem HoveredFlags = 128
	// IsItemHovered() only: Return true even if the item uses AllowOverlap mode and is overlapped by another hoverable item.
	HoveredFlagsAllowWhenOverlappedByItem HoveredFlags = 256
	// IsItemHovered() only: Return true even if the position is obstructed or overlapped by another window.
	HoveredFlagsAllowWhenOverlappedByWindow HoveredFlags = 512
	// IsItemHovered() only: Return true even if the item is disabled
	HoveredFlagsAllowWhenDisabled HoveredFlags = 1024
	// IsItemHovered() only: Disable using keyboard/gamepad navigation state when active, always query mouse
	HoveredFlagsNoNavOverride       HoveredFlags = 2048
	HoveredFlagsAllowWhenOverlapped HoveredFlags = 768
	HoveredFlagsRectOnly            HoveredFlags = 928
	HoveredFlagsRootAndChildWindows HoveredFlags = 3
	// Shortcut for standard flags when using IsItemHovered() + SetTooltip() sequence.
	HoveredFlagsForTooltip HoveredFlags = 4096
	// Require mouse to be stationary for style.HoverStationaryDelay (~0.15 sec) _at least one time_. After this, can move on same item/window. Using the stationary test tends to reduces the need for a long delay.
	HoveredFlagsStationary HoveredFlags = 8192
	// IsItemHovered() only: Return true immediately (default). As this is the default you generally ignore this.
	HoveredFlagsDelayNone HoveredFlags = 16384
	// IsItemHovered() only: Return true after style.HoverDelayShort elapsed (~0.15 sec) (shared between items) + requires mouse to be stationary for style.HoverStationaryDelay (once per item).
	HoveredFlagsDelayShort HoveredFlags = 32768
	// IsItemHovered() only: Return true after style.HoverDelayNormal elapsed (~0.40 sec) (shared between items) + requires mouse to be stationary for style.HoverStationaryDelay (once per item).
	HoveredFlagsDelayNormal HoveredFlags = 65536
	// IsItemHovered() only: Disable shared delay system where moving from one item to the next keeps the previous timer for a short time (standard for tooltips with long delays)
	HoveredFlagsNoSharedDelay HoveredFlags = 131072
)

// [Internal] Key ranges
// [Internal] Named shortcuts for Navigation
// original name: ImGuiInputEventType
type InputEventType int32

const (
	InputEventTypeNone          InputEventType = 0
	InputEventTypeMousePos      InputEventType = 1
	InputEventTypeMouseWheel    InputEventType = 2
	InputEventTypeMouseButton   InputEventType = 3
	InputEventTypeMouseViewport InputEventType = 4
	InputEventTypeKey           InputEventType = 5
	InputEventTypeText          InputEventType = 6
	InputEventTypeFocus         InputEventType = 7
	InputEventTypeCOUNT         InputEventType = 8
)

// Extend ImGuiInputFlags_
// Flags for extended versions of IsKeyPressed(), IsMouseClicked(), Shortcut(), SetKeyOwner(), SetItemKeyOwner()
// Don't mistake with ImGuiInputTextFlags! (which is for ImGui::InputText() function)
// original name: ImGuiInputFlagsPrivate_
type InputFlagsPrivate int32

const (
	// Repeat rate: Regular (default)
	InputFlagsRepeatRateDefault InputFlagsPrivate = 2
	// Repeat rate: Fast
	InputFlagsRepeatRateNavMove InputFlagsPrivate = 4
	// Repeat rate: Faster
	InputFlagsRepeatRateNavTweak InputFlagsPrivate = 8
	// Stop repeating when released (default for all functions except Shortcut). This only exists to allow overriding Shortcut() default behavior.
	InputFlagsRepeatUntilRelease InputFlagsPrivate = 16
	// Stop repeating when released OR if keyboard mods are changed (default for Shortcut)
	InputFlagsRepeatUntilKeyModsChange InputFlagsPrivate = 32
	// Stop repeating when released OR if keyboard mods are leaving the None state. Allows going from Mod+Key to Key by releasing Mod.
	InputFlagsRepeatUntilKeyModsChangeFromNone InputFlagsPrivate = 64
	// Stop repeating when released OR if any other keyboard key is pressed during the repeat
	InputFlagsRepeatUntilOtherKeyPress InputFlagsPrivate = 128
	// Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared at end of frame.
	InputFlagsLockThisFrame InputFlagsPrivate = 1048576
	// Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared when the key is released or at end of each frame if key is released.
	InputFlagsLockUntilRelease InputFlagsPrivate = 2097152
	// Only set if item is hovered (default to both)
	InputFlagsCondHovered InputFlagsPrivate = 4194304
	// Only set if item is active (default to both)
	InputFlagsCondActive                     InputFlagsPrivate = 8388608
	InputFlagsCondDefault                    InputFlagsPrivate = 12582912
	InputFlagsRepeatRateMask                 InputFlagsPrivate = 14
	InputFlagsRepeatUntilMask                InputFlagsPrivate = 240
	InputFlagsRepeatMask                     InputFlagsPrivate = 255
	InputFlagsCondMask                       InputFlagsPrivate = 12582912
	InputFlagsRouteTypeMask                  InputFlagsPrivate = 15360
	InputFlagsRouteOptionsMask               InputFlagsPrivate = 245760
	InputFlagsSupportedByIsKeyPressed        InputFlagsPrivate = 255
	InputFlagsSupportedByIsMouseClicked      InputFlagsPrivate = 1
	InputFlagsSupportedByShortcut            InputFlagsPrivate = 261375
	InputFlagsSupportedBySetNextItemShortcut InputFlagsPrivate = 523519
	InputFlagsSupportedBySetKeyOwner         InputFlagsPrivate = 3145728
	InputFlagsSupportedBySetItemKeyOwner     InputFlagsPrivate = 15728640
)

// Flags for Shortcut(), SetNextItemShortcut(),
// (and for upcoming extended versions of IsKeyPressed(), IsMouseClicked(), Shortcut(), SetKeyOwner(), SetItemKeyOwner() that are still in imgui_internal.h)
// Don't mistake with ImGuiInputTextFlags! (which is for ImGui::InputText() function)
// original name: ImGuiInputFlags_
type InputFlags int32

const (
	InputFlagsNone InputFlags = 0
	// Enable repeat. Return true on successive repeats. Default for legacy IsKeyPressed(). NOT Default for legacy IsMouseClicked(). MUST BE == 1.
	InputFlagsRepeat InputFlags = 1
	// Route to active item only.
	InputFlagsRouteActive InputFlags = 1024
	// Route to windows in the focus stack (DEFAULT). Deep-most focused window takes inputs. Active item takes inputs over deep-most focused window.
	InputFlagsRouteFocused InputFlags = 2048
	// Global route (unless a focused window or active item registered the route).
	InputFlagsRouteGlobal InputFlags = 4096
	// Do not register route, poll keys directly.
	InputFlagsRouteAlways InputFlags = 8192
	// Option: global route: higher priority than focused route (unless active item in focused route).
	InputFlagsRouteOverFocused InputFlags = 16384
	// Option: global route: higher priority than active item. Unlikely you need to use that: will interfere with every active items, e.g. CTRL+A registered by InputText will be overridden by this. May not be fully honored as user/internal code is likely to always assume they can access keys when active.
	InputFlagsRouteOverActive InputFlags = 32768
	// Option: global route: will not be applied if underlying background/void is focused (== no Dear ImGui windows are focused). Useful for overlay applications.
	InputFlagsRouteUnlessBgFocused InputFlags = 65536
	// Option: route evaluated from the point of view of root window rather than current window.
	InputFlagsRouteFromRootWindow InputFlags = 131072
	// Automatically display a tooltip when hovering item [BETA] Unsure of right api (opt-in/opt-out)
	InputFlagsTooltip InputFlags = 262144
)

// original name: ImGuiInputSource
type InputSource int32

const (
	InputSourceNone InputSource = 0
	// Note: may be Mouse or TouchScreen or Pen. See io.MouseSource to distinguish them.
	InputSourceMouse    InputSource = 1
	InputSourceKeyboard InputSource = 2
	InputSourceGamepad  InputSource = 3
	InputSourceCOUNT    InputSource = 4
)

// Extend ImGuiInputTextFlags_
// original name: ImGuiInputTextFlagsPrivate_
type InputTextFlagsPrivate int32

const (
	// For internal use by InputTextMultiline()
	InputTextFlagsMultiline InputTextFlagsPrivate = 67108864
	// For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match.
	InputTextFlagsMergedItem InputTextFlagsPrivate = 134217728
	// For internal use by InputScalar() and TempInputScalar()
	InputTextFlagsLocalizeDecimalPoint InputTextFlagsPrivate = 268435456
)

// Flags for ImGui::InputText()
// (Those are per-item flags. There are shared flags in ImGuiIO: io.ConfigInputTextCursorBlink and io.ConfigInputTextEnterKeepActive)
// original name: ImGuiInputTextFlags_
type InputTextFlags int32

const (
	InputTextFlagsNone InputTextFlags = 0
	// Allow 0123456789.+-*/
	InputTextFlagsCharsDecimal InputTextFlags = 1
	// Allow 0123456789ABCDEFabcdef
	InputTextFlagsCharsHexadecimal InputTextFlags = 2
	// Allow 0123456789.+-*/eE (Scientific notation input)
	InputTextFlagsCharsScientific InputTextFlags = 4
	// Turn a..z into A..Z
	InputTextFlagsCharsUppercase InputTextFlags = 8
	// Filter out spaces, tabs
	InputTextFlagsCharsNoBlank InputTextFlags = 16
	// Pressing TAB input a '\t' character into the text field
	InputTextFlagsAllowTabInput InputTextFlags = 32
	// Return 'true' when Enter is pressed (as opposed to every time the value was modified). Consider using IsItemDeactivatedAfterEdit() instead!
	InputTextFlagsEnterReturnsTrue InputTextFlags = 64
	// Escape key clears content if not empty, and deactivate otherwise (contrast to default behavior of Escape to revert)
	InputTextFlagsEscapeClearsAll InputTextFlags = 128
	// In multi-line mode, validate with Enter, add new line with Ctrl+Enter (default is opposite: validate with Ctrl+Enter, add line with Enter).
	InputTextFlagsCtrlEnterForNewLine InputTextFlags = 256
	// Read-only mode
	InputTextFlagsReadOnly InputTextFlags = 512
	// Password mode, display all characters as '*', disable copy
	InputTextFlagsPassword InputTextFlags = 1024
	// Overwrite mode
	InputTextFlagsAlwaysOverwrite InputTextFlags = 2048
	// Select entire text when first taking mouse focus
	InputTextFlagsAutoSelectAll InputTextFlags = 4096
	// InputFloat(), InputInt(), InputScalar() etc. only: parse empty string as zero value.
	InputTextFlagsParseEmptyRefVal InputTextFlags = 8192
	// InputFloat(), InputInt(), InputScalar() etc. only: when value is zero, do not display it. Generally used with ImGuiInputTextFlags_ParseEmptyRefVal.
	InputTextFlagsDisplayEmptyRefVal InputTextFlags = 16384
	// Disable following the cursor horizontally
	InputTextFlagsNoHorizontalScroll InputTextFlags = 32768
	// Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID().
	InputTextFlagsNoUndoRedo InputTextFlags = 65536
	// When text doesn't fit, elide left side to ensure right side stays visible. Useful for path/filenames. Single-line only!
	InputTextFlagsElideLeft InputTextFlags = 131072
	// Callback on pressing TAB (for completion handling)
	InputTextFlagsCallbackCompletion InputTextFlags = 262144
	// Callback on pressing Up/Down arrows (for history handling)
	InputTextFlagsCallbackHistory InputTextFlags = 524288
	// Callback on each iteration. User code may query cursor position, modify text buffer.
	InputTextFlagsCallbackAlways InputTextFlags = 1048576
	// Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard.
	InputTextFlagsCallbackCharFilter InputTextFlags = 2097152
	// Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow. Notify when the string wants to be resized (for string types which hold a cache of their Size). You will be provided a new BufSize in the callback and NEED to honor it. (see misc/cpp/imgui_stdlib.h for an example of using this)
	InputTextFlagsCallbackResize InputTextFlags = 4194304
	// Callback on any edit. Note that InputText() already returns true on edit + you can always use IsItemEdited(). The callback is useful to manipulate the underlying buffer while focus is active.
	InputTextFlagsCallbackEdit InputTextFlags = 8388608
	// InputTextMultine(): word-wrap lines that are too long.
	InputTextFlagsWordWrap InputTextFlags = 16777216
)

// Extend ImGuiItemFlags
// - input: PushItemFlag() manipulates g.CurrentItemFlags, g.NextItemData.ItemFlags, ItemAdd() calls may add extra flags too.
// - output: stored in g.LastItemData.ItemFlags
// original name: ImGuiItemFlagsPrivate_
type ItemFlagsPrivate int32

const (
	// false     // Disable interactions (DOES NOT affect visuals. DO NOT mix direct use of this with BeginDisabled(). See BeginDisabled()/EndDisabled() for full disable feature, and github #211).
	ItemFlagsDisabled ItemFlagsPrivate = 1024
	// false     // [ALPHA] Allow hovering interactions but underlying value is not changed.
	ItemFlagsReadOnly ItemFlagsPrivate = 2048
	// false     // [BETA] Represent a mixed/indeterminate value, generally multi-selection where values differ. Currently only supported by Checkbox() (later should support all sorts of widgets)
	ItemFlagsMixedValue ItemFlagsPrivate = 4096
	// false     // Disable hoverable check in ItemHoverable()
	ItemFlagsNoWindowHoverableCheck ItemFlagsPrivate = 8192
	// false     // Allow being overlapped by another widget. Not-hovered to Hovered transition deferred by a frame.
	ItemFlagsAllowOverlap ItemFlagsPrivate = 16384
	// false     // Nav keyboard/gamepad mode doesn't disable hover highlight (behave as if NavHighlightItemUnderNav==false).
	ItemFlagsNoNavDisableMouseHover ItemFlagsPrivate = 32768
	// false     // Skip calling MarkItemEdited()
	ItemFlagsNoMarkEdited ItemFlagsPrivate = 65536
	// false     // [EXPERIMENTAL: Not very well specced] Clicking doesn't take focus. Automatically sets ImGuiButtonFlags_NoFocus + ImGuiButtonFlags_NoNavFocus in ButtonBehavior().
	ItemFlagsNoFocus ItemFlagsPrivate = 131072
	// false     // [WIP] Auto-activate input mode when tab focused. Currently only used and supported by a few items before it becomes a generic feature.
	ItemFlagsInputable ItemFlagsPrivate = 1048576
	// false     // Set by SetNextItemSelectionUserData()
	ItemFlagsHasSelectionUserData ItemFlagsPrivate = 2097152
	// false     // Set by SetNextItemSelectionUserData()
	ItemFlagsIsMultiSelect ItemFlagsPrivate = 4194304
	// Please don't change, use PushItemFlag() instead.
	ItemFlagsDefault ItemFlagsPrivate = 16
)

// Flags for ImGui::PushItemFlag()
// (Those are shared by all items)
// original name: ImGuiItemFlags_
type ItemFlags int32

const (
	// (Default)
	ItemFlagsNone ItemFlags = 0
	// false    // Disable keyboard tabbing. This is a "lighter" version of ImGuiItemFlags_NoNav.
	ItemFlagsNoTabStop ItemFlags = 1
	// false    // Disable any form of focusing (keyboard/gamepad directional navigation and SetKeyboardFocusHere() calls).
	ItemFlagsNoNav ItemFlags = 2
	// false    // Disable item being a candidate for default focus (e.g. used by title bar items).
	ItemFlagsNoNavDefaultFocus ItemFlags = 4
	// false    // Any button-like behavior will have repeat mode enabled (based on io.KeyRepeatDelay and io.KeyRepeatRate values). Note that you can also call IsItemActive() after any button to tell if it is being held.
	ItemFlagsButtonRepeat ItemFlags = 8
	// true     // MenuItem()/Selectable() automatically close their parent popup window.
	ItemFlagsAutoClosePopups ItemFlags = 16
	// false    // Allow submitting an item with the same identifier as an item already submitted this frame without triggering a warning tooltip if io.ConfigDebugHighlightIdConflicts is set.
	ItemFlagsAllowDuplicateId ItemFlags = 32
)

// Status flags for an already submitted item
// - output: stored in g.LastItemData.StatusFlags
// original name: ImGuiItemStatusFlags_
type ItemStatusFlags int32

const (
	ItemStatusFlagsNone ItemStatusFlags = 0
	// Mouse position is within item rectangle (does NOT mean that the window is in correct z-order and can be hovered!, this is only one part of the most-common IsItemHovered test)
	ItemStatusFlagsHoveredRect ItemStatusFlags = 1
	// g.LastItemData.DisplayRect is valid
	ItemStatusFlagsHasDisplayRect ItemStatusFlags = 2
	// Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
	ItemStatusFlagsEdited ItemStatusFlags = 4
	// Set when Selectable(), TreeNode() reports toggling a selection. We can't report "Selected", only state changes, in order to easily handle clipping with less issues.
	ItemStatusFlagsToggledSelection ItemStatusFlags = 8
	// Set when TreeNode() reports toggling their open state.
	ItemStatusFlagsToggledOpen ItemStatusFlags = 16
	// Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag.
	ItemStatusFlagsHasDeactivated ItemStatusFlags = 32
	// Only valid if ImGuiItemStatusFlags_HasDeactivated is set.
	ItemStatusFlagsDeactivated ItemStatusFlags = 64
	// Override the HoveredWindow test to allow cross-window hover testing.
	ItemStatusFlagsHoveredWindow ItemStatusFlags = 128
	// [WIP] Set when item is overlapping the current clipping rectangle (Used internally. Please don't use yet: API/system will change as we refactor Itemadd()).
	ItemStatusFlagsVisible ItemStatusFlags = 256
	// g.LastItemData.ClipRect is valid.
	ItemStatusFlagsHasClipRect ItemStatusFlags = 512
	// g.LastItemData.Shortcut valid. Set by SetNextItemShortcut() -> ItemAdd().
	ItemStatusFlagsHasShortcut ItemStatusFlags = 1024
)

// A key identifier (ImGuiKey_XXX or ImGuiMod_XXX value): can represent Keyboard, Mouse and Gamepad values.
// All our named keys are >= 512. Keys value 0 to 511 are left unused and were legacy native/opaque key values (< 1.87).
// Support for legacy keys was completely removed in 1.91.5.
// Read details about the 1.87+ transition : https://github.com/ocornut/imgui/issues/4921
// Note that "Keys" related to physical keys and are not the same concept as input "Characters", the later are submitted via io.AddInputCharacter().
// The keyboard key enum values are named after the keys on a standard US keyboard, and on other keyboard types the keys reported may not match the keycaps.
// original name: ImGuiKey
type Key int32

const (
	KeyNone Key = 0
	// First valid key value (other than 0)
	KeyNamedKeyBEGIN Key = 512
	// == ImGuiKey_NamedKey_BEGIN
	KeyTab        Key = 512
	KeyLeftArrow  Key = 513
	KeyRightArrow Key = 514
	KeyUpArrow    Key = 515
	KeyDownArrow  Key = 516
	KeyPageUp     Key = 517
	KeyPageDown   Key = 518
	KeyHome       Key = 519
	KeyEnd        Key = 520
	KeyInsert     Key = 521
	KeyDelete     Key = 522
	KeyBackspace  Key = 523
	KeySpace      Key = 524
	KeyEnter      Key = 525
	KeyEscape     Key = 526
	KeyLeftCtrl   Key = 527
	KeyLeftShift  Key = 528
	KeyLeftAlt    Key = 529
	// Also see ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiMod_Alt, ImGuiMod_Super below!
	KeyLeftSuper  Key = 530
	KeyRightCtrl  Key = 531
	KeyRightShift Key = 532
	KeyRightAlt   Key = 533
	KeyRightSuper Key = 534
	KeyMenu       Key = 535
	Key0          Key = 536
	Key1          Key = 537
	Key2          Key = 538
	Key3          Key = 539
	Key4          Key = 540
	Key5          Key = 541
	Key6          Key = 542
	Key7          Key = 543
	Key8          Key = 544
	Key9          Key = 545
	KeyA          Key = 546
	KeyB          Key = 547
	KeyC          Key = 548
	KeyD          Key = 549
	KeyE          Key = 550
	KeyF          Key = 551
	KeyG          Key = 552
	KeyH          Key = 553
	KeyI          Key = 554
	KeyJ          Key = 555
	KeyK          Key = 556
	KeyL          Key = 557
	KeyM          Key = 558
	KeyN          Key = 559
	KeyO          Key = 560
	KeyP          Key = 561
	KeyQ          Key = 562
	KeyR          Key = 563
	KeyS          Key = 564
	KeyT          Key = 565
	KeyU          Key = 566
	KeyV          Key = 567
	KeyW          Key = 568
	KeyX          Key = 569
	KeyY          Key = 570
	KeyZ          Key = 571
	KeyF1         Key = 572
	KeyF2         Key = 573
	KeyF3         Key = 574
	KeyF4         Key = 575
	KeyF5         Key = 576
	KeyF6         Key = 577
	KeyF7         Key = 578
	KeyF8         Key = 579
	KeyF9         Key = 580
	KeyF10        Key = 581
	KeyF11        Key = 582
	KeyF12        Key = 583
	KeyF13        Key = 584
	KeyF14        Key = 585
	KeyF15        Key = 586
	KeyF16        Key = 587
	KeyF17        Key = 588
	KeyF18        Key = 589
	KeyF19        Key = 590
	KeyF20        Key = 591
	KeyF21        Key = 592
	KeyF22        Key = 593
	KeyF23        Key = 594
	KeyF24        Key = 595
	// '
	KeyApostrophe Key = 596
	// ,
	KeyComma Key = 597
	// -
	KeyMinus Key = 598
	// .
	KeyPeriod Key = 599
	// /
	KeySlash Key = 600
	// ;
	KeySemicolon Key = 601
	// =
	KeyEqual Key = 602
	// [
	KeyLeftBracket Key = 603
	// \ (this text inhibit multiline comment caused by backslash)
	KeyBackslash Key = 604
	// ]
	KeyRightBracket Key = 605
	// `
	KeyGraveAccent    Key = 606
	KeyCapsLock       Key = 607
	KeyScrollLock     Key = 608
	KeyNumLock        Key = 609
	KeyPrintScreen    Key = 610
	KeyPause          Key = 611
	KeyKeypad0        Key = 612
	KeyKeypad1        Key = 613
	KeyKeypad2        Key = 614
	KeyKeypad3        Key = 615
	KeyKeypad4        Key = 616
	KeyKeypad5        Key = 617
	KeyKeypad6        Key = 618
	KeyKeypad7        Key = 619
	KeyKeypad8        Key = 620
	KeyKeypad9        Key = 621
	KeyKeypadDecimal  Key = 622
	KeyKeypadDivide   Key = 623
	KeyKeypadMultiply Key = 624
	KeyKeypadSubtract Key = 625
	KeyKeypadAdd      Key = 626
	KeyKeypadEnter    Key = 627
	KeyKeypadEqual    Key = 628
	// Available on some keyboard/mouses. Often referred as "Browser Back"
	KeyAppBack    Key = 629
	KeyAppForward Key = 630
	// Non-US backslash.
	KeyOem102 Key = 631
	// Menu        | +       | Options  |
	KeyGamepadStart Key = 632
	// View        | -       | Share    |
	KeyGamepadBack Key = 633
	// X           | Y       | Square   | Tap: Toggle Menu. Hold: Windowing mode (Focus/Move/Resize windows)
	KeyGamepadFaceLeft Key = 634
	// B           | A       | Circle   | Cancel / Close / Exit
	KeyGamepadFaceRight Key = 635
	// Y           | X       | Triangle | Text Input / On-screen Keyboard
	KeyGamepadFaceUp Key = 636
	// A           | B       | Cross    | Activate / Open / Toggle / Tweak
	KeyGamepadFaceDown Key = 637
	// D-pad Left  | "       | "        | Move / Tweak / Resize Window (in Windowing mode)
	KeyGamepadDpadLeft Key = 638
	// D-pad Right | "       | "        | Move / Tweak / Resize Window (in Windowing mode)
	KeyGamepadDpadRight Key = 639
	// D-pad Up    | "       | "        | Move / Tweak / Resize Window (in Windowing mode)
	KeyGamepadDpadUp Key = 640
	// D-pad Down  | "       | "        | Move / Tweak / Resize Window (in Windowing mode)
	KeyGamepadDpadDown Key = 641
	// L Bumper    | L       | L1       | Tweak Slower / Focus Previous (in Windowing mode)
	KeyGamepadL1 Key = 642
	// R Bumper    | R       | R1       | Tweak Faster / Focus Next (in Windowing mode)
	KeyGamepadR1 Key = 643
	// L Trigger   | ZL      | L2       | [Analog]
	KeyGamepadL2 Key = 644
	// R Trigger   | ZR      | R2       | [Analog]
	KeyGamepadR2 Key = 645
	// L Stick     | L3      | L3       |
	KeyGamepadL3 Key = 646
	// R Stick     | R3      | R3       |
	KeyGamepadR3 Key = 647
	//             |         |          | [Analog] Move Window (in Windowing mode)
	KeyGamepadLStickLeft Key = 648
	//             |         |          | [Analog] Move Window (in Windowing mode)
	KeyGamepadLStickRight Key = 649
	//             |         |          | [Analog] Move Window (in Windowing mode)
	KeyGamepadLStickUp Key = 650
	//             |         |          | [Analog] Move Window (in Windowing mode)
	KeyGamepadLStickDown Key = 651
	//             |         |          | [Analog]
	KeyGamepadRStickLeft Key = 652
	//             |         |          | [Analog]
	KeyGamepadRStickRight Key = 653
	//             |         |          | [Analog]
	KeyGamepadRStickUp Key = 654
	//             |         |          | [Analog]
	KeyGamepadRStickDown   Key = 655
	KeyMouseLeft           Key = 656
	KeyMouseRight          Key = 657
	KeyMouseMiddle         Key = 658
	KeyMouseX1             Key = 659
	KeyMouseX2             Key = 660
	KeyMouseWheelX         Key = 661
	KeyMouseWheelY         Key = 662
	KeyReservedForModCtrl  Key = 663
	KeyReservedForModShift Key = 664
	KeyReservedForModAlt   Key = 665
	KeyReservedForModSuper Key = 666
	KeyNamedKeyEND         Key = 667
	KeyNamedKeyCOUNT       Key = 155
	ModNone                Key = 0
	// Ctrl (non-macOS), Cmd (macOS)
	ModCtrl Key = 4096
	// Shift
	ModShift Key = 8192
	// Option/Menu
	ModAlt Key = 16384
	// Windows/Super (non-macOS), Ctrl (macOS)
	ModSuper Key = 32768
	// 4-bits
	ModMask Key = 61440
)

// FIXME: this is in development, not exposed/functional as a generic feature yet.
// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2
// original name: ImGuiLayoutType_
type LayoutType int32

const (
	LayoutTypeHorizontal LayoutType = 0
	LayoutTypeVertical   LayoutType = 1
)

// Flags for ImGuiListClipper (currently not fully exposed in function calls: a future refactor will likely add this to ImGuiListClipper::Begin function equivalent)
// original name: ImGuiListClipperFlags_
type ListClipperFlags int32

const (
	ListClipperFlagsNone ListClipperFlags = 0
	// [Internal] Disabled modifying table row counters. Avoid assumption that 1 clipper item == 1 table row.
	ListClipperFlagsNoSetTableRowCounters ListClipperFlags = 1
)

// This is experimental and not officially supported, it'll probably fall short of features, if/when it does we may backtrack.
// original name: ImGuiLocKey
type LocKey int32

const (
	LocKeyVersionStr                    LocKey = 0
	LocKeyTableSizeOne                  LocKey = 1
	LocKeyTableSizeAllFit               LocKey = 2
	LocKeyTableSizeAllDefault           LocKey = 3
	LocKeyTableResetOrder               LocKey = 4
	LocKeyWindowingMainMenuBar          LocKey = 5
	LocKeyWindowingPopup                LocKey = 6
	LocKeyWindowingUntitled             LocKey = 7
	LocKeyOpenLinks                     LocKey = 8
	LocKeyCopyLink                      LocKey = 9
	LocKeyDockingHideTabBar             LocKey = 10
	LocKeyDockingHoldShiftToDock        LocKey = 11
	LocKeyDockingDragToUndockOrMoveNode LocKey = 12
	LocKeyCOUNT                         LocKey = 13
)

// Flags for LogBegin() text capturing function
// original name: ImGuiLogFlags_
type LogFlags int32

const (
	LogFlagsNone            LogFlags = 0
	LogFlagsOutputTTY       LogFlags = 1
	LogFlagsOutputFile      LogFlags = 2
	LogFlagsOutputBuffer    LogFlags = 4
	LogFlagsOutputClipboard LogFlags = 8
	LogFlagsOutputMask      LogFlags = 15
)

// Identify a mouse button.
// Those values are guaranteed to be stable and we frequently use 0/1 directly. Named enums provided for convenience.
// original name: ImGuiMouseButton_
type MouseButton int32

const (
	MouseButtonLeft   MouseButton = 0
	MouseButtonRight  MouseButton = 1
	MouseButtonMiddle MouseButton = 2
	MouseButtonCOUNT  MouseButton = 5
)

// Enumeration for GetMouseCursor()
// User code may request backend to display given cursor by calling SetMouseCursor(), which is why we have some cursors that are marked unused here
// original name: ImGuiMouseCursor_
type MouseCursor int32

const (
	MouseCursorNone  MouseCursor = -1
	MouseCursorArrow MouseCursor = 0
	// When hovering over InputText, etc.
	MouseCursorTextInput MouseCursor = 1
	// (Unused by Dear ImGui functions)
	MouseCursorResizeAll MouseCursor = 2
	// When hovering over a horizontal border
	MouseCursorResizeNS MouseCursor = 3
	// When hovering over a vertical border or a column
	MouseCursorResizeEW MouseCursor = 4
	// When hovering over the bottom-left corner of a window
	MouseCursorResizeNESW MouseCursor = 5
	// When hovering over the bottom-right corner of a window
	MouseCursorResizeNWSE MouseCursor = 6
	// (Unused by Dear ImGui functions. Use for e.g. hyperlinks)
	MouseCursorHand MouseCursor = 7
	// When waiting for something to process/load.
	MouseCursorWait MouseCursor = 8
	// When waiting for something to process/load, but application is still interactive.
	MouseCursorProgress MouseCursor = 9
	// When hovering something with disallowed interaction. Usually a crossed circle.
	MouseCursorNotAllowed MouseCursor = 10
	MouseCursorCOUNT      MouseCursor = 11
)

// Enumeration for AddMouseSourceEvent() actual source of Mouse Input data.
// Historically we use "Mouse" terminology everywhere to indicate pointer data, e.g. MousePos, IsMousePressed(), io.AddMousePosEvent()
// But that "Mouse" data can come from different source which occasionally may be useful for application to know about.
// You can submit a change of pointer type using io.AddMouseSourceEvent().
// original name: ImGuiMouseSource
type MouseSource int32

const (
	// Input is coming from an actual mouse.
	MouseSourceMouse MouseSource = 0
	// Input is coming from a touch screen (no hovering prior to initial press, less precise initial press aiming, dual-axis wheeling possible).
	MouseSourceTouchScreen MouseSource = 1
	// Input is coming from a pressure/magnetic pen (often used in conjunction with high-sampling rates).
	MouseSourcePen   MouseSource = 2
	MouseSourceCOUNT MouseSource = 3
)

// Flags for BeginMultiSelect()
// original name: ImGuiMultiSelectFlags_
type MultiSelectFlags int32

const (
	MultiSelectFlagsNone MultiSelectFlags = 0
	// Disable selecting more than one item. This is available to allow single-selection code to share same code/logic if desired. It essentially disables the main purpose of BeginMultiSelect() tho!
	MultiSelectFlagsSingleSelect MultiSelectFlags = 1
	// Disable CTRL+A shortcut to select all.
	MultiSelectFlagsNoSelectAll MultiSelectFlags = 2
	// Disable Shift+selection mouse/keyboard support (useful for unordered 2D selection). With BoxSelect is also ensure contiguous SetRange requests are not combined into one. This allows not handling interpolation in SetRange requests.
	MultiSelectFlagsNoRangeSelect MultiSelectFlags = 4
	// Disable selecting items when navigating (useful for e.g. supporting range-select in a list of checkboxes).
	MultiSelectFlagsNoAutoSelect MultiSelectFlags = 8
	// Disable clearing selection when navigating or selecting another one (generally used with ImGuiMultiSelectFlags_NoAutoSelect. useful for e.g. supporting range-select in a list of checkboxes).
	MultiSelectFlagsNoAutoClear MultiSelectFlags = 16
	// Disable clearing selection when clicking/selecting an already selected item.
	MultiSelectFlagsNoAutoClearOnReselect MultiSelectFlags = 32
	// Enable box-selection with same width and same x pos items (e.g. full row Selectable()). Box-selection works better with little bit of spacing between items hit-box in order to be able to aim at empty space.
	MultiSelectFlagsBoxSelect1d MultiSelectFlags = 64
	// Enable box-selection with varying width or varying x pos items support (e.g. different width labels, or 2D layout/grid). This is slower: alters clipping logic so that e.g. horizontal movements will update selection of normally clipped items.
	MultiSelectFlagsBoxSelect2d MultiSelectFlags = 128
	// Disable scrolling when box-selecting near edges of scope.
	MultiSelectFlagsBoxSelectNoScroll MultiSelectFlags = 256
	// Clear selection when pressing Escape while scope is focused.
	MultiSelectFlagsClearOnEscape MultiSelectFlags = 512
	// Clear selection when clicking on empty location within scope.
	MultiSelectFlagsClearOnClickVoid MultiSelectFlags = 1024
	// Scope for _BoxSelect and _ClearOnClickVoid is whole window (Default). Use if BeginMultiSelect() covers a whole window or used a single time in same window.
	MultiSelectFlagsScopeWindow MultiSelectFlags = 2048
	// Scope for _BoxSelect and _ClearOnClickVoid is rectangle encompassing BeginMultiSelect()/EndMultiSelect(). Use if BeginMultiSelect() is called multiple times in same window.
	MultiSelectFlagsScopeRect MultiSelectFlags = 4096
	// Apply selection on mouse down when clicking on unselected item. (Default)
	MultiSelectFlagsSelectOnClick MultiSelectFlags = 8192
	// Apply selection on mouse release when clicking an unselected item. Allow dragging an unselected item without altering selection.
	MultiSelectFlagsSelectOnClickRelease MultiSelectFlags = 16384
	// [Temporary] Enable navigation wrapping on X axis. Provided as a convenience because we don't have a design for the general Nav API for this yet. When the more general feature be public we may obsolete this flag in favor of new one.
	MultiSelectFlagsNavWrapX MultiSelectFlags = 65536
)

// original name: ImGuiNavLayer
type NavLayer int32

const (
	// Main scrolling layer
	NavLayerMain NavLayer = 0
	// Menu layer (access with Alt)
	NavLayerMenu  NavLayer = 1
	NavLayerCOUNT NavLayer = 2
)

// original name: ImGuiNavMoveFlags_
type NavMoveFlags int32

const (
	NavMoveFlagsNone NavMoveFlags = 0
	// On failed request, restart from opposite side
	NavMoveFlagsLoopX NavMoveFlags = 1
	NavMoveFlagsLoopY NavMoveFlags = 2
	// On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
	NavMoveFlagsWrapX NavMoveFlags = 4
	// This is not super useful but provided for completeness
	NavMoveFlagsWrapY    NavMoveFlags = 8
	NavMoveFlagsWrapMask NavMoveFlags = 15
	// Allow scoring and considering the current NavId as a move target candidate. This is used when the move source is offset (e.g. pressing PageDown actually needs to send a Up move request, if we are pressing PageDown from the bottom-most item we need to stay in place)
	NavMoveFlagsAllowCurrentNavId NavMoveFlags = 16
	// Store alternate result in NavMoveResultLocalVisible that only comprise elements that are already fully visible (used by PageUp/PageDown)
	NavMoveFlagsAlsoScoreVisibleSet NavMoveFlags = 32
	// Force scrolling to min/max (used by Home/End) // FIXME-NAV: Aim to remove or reword, probably unnecessary
	NavMoveFlagsScrollToEdgeY NavMoveFlags = 64
	NavMoveFlagsForwarded     NavMoveFlags = 128
	// Dummy scoring for debug purpose, don't apply result
	NavMoveFlagsDebugNoResult NavMoveFlags = 256
	// Requests from focus API can land/focus/activate items even if they are marked with _NoTabStop (see NavProcessItemForTabbingRequest() for details)
	NavMoveFlagsFocusApi NavMoveFlags = 512
	// == Focus + Activate if item is Inputable + DontChangeNavHighlight
	NavMoveFlagsIsTabbing NavMoveFlags = 1024
	// Identify a PageDown/PageUp request.
	NavMoveFlagsIsPageMove NavMoveFlags = 2048
	// Activate/select target item.
	NavMoveFlagsActivate NavMoveFlags = 4096
	// Don't trigger selection by not setting g.NavJustMovedTo
	NavMoveFlagsNoSelect NavMoveFlags = 8192
	// Do not alter the nav cursor visible state
	NavMoveFlagsNoSetNavCursorVisible NavMoveFlags = 16384
	// (Experimental) Do not clear active id when applying move result
	NavMoveFlagsNoClearActiveId NavMoveFlags = 32768
)

// original name: ImGuiNavRenderCursorFlags_
type NavRenderCursorFlags int32

const (
	NavRenderCursorFlagsNone NavRenderCursorFlags = 0
	// Compact highlight, no padding/distance from focused item
	NavRenderCursorFlagsCompact NavRenderCursorFlags = 2
	// Draw rectangular highlight if (g.NavId == id) even when g.NavCursorVisible == false, aka even when using the mouse.
	NavRenderCursorFlagsAlwaysDraw NavRenderCursorFlags = 4
	NavRenderCursorFlagsNoRounding NavRenderCursorFlags = 8
)

// original name: ImGuiNextItemDataFlags_
type NextItemDataFlags int32

const (
	NextItemDataFlagsNone         NextItemDataFlags = 0
	NextItemDataFlagsHasWidth     NextItemDataFlags = 1
	NextItemDataFlagsHasOpen      NextItemDataFlags = 2
	NextItemDataFlagsHasShortcut  NextItemDataFlags = 4
	NextItemDataFlagsHasRefVal    NextItemDataFlags = 8
	NextItemDataFlagsHasStorageID NextItemDataFlags = 16
)

// original name: ImGuiNextWindowDataFlags_
type NextWindowDataFlags int32

const (
	NextWindowDataFlagsNone              NextWindowDataFlags = 0
	NextWindowDataFlagsHasPos            NextWindowDataFlags = 1
	NextWindowDataFlagsHasSize           NextWindowDataFlags = 2
	NextWindowDataFlagsHasContentSize    NextWindowDataFlags = 4
	NextWindowDataFlagsHasCollapsed      NextWindowDataFlags = 8
	NextWindowDataFlagsHasSizeConstraint NextWindowDataFlags = 16
	NextWindowDataFlagsHasFocus          NextWindowDataFlags = 32
	NextWindowDataFlagsHasBgAlpha        NextWindowDataFlags = 64
	NextWindowDataFlagsHasScroll         NextWindowDataFlags = 128
	NextWindowDataFlagsHasWindowFlags    NextWindowDataFlags = 256
	NextWindowDataFlagsHasChildFlags     NextWindowDataFlags = 512
	NextWindowDataFlagsHasRefreshPolicy  NextWindowDataFlags = 1024
	NextWindowDataFlagsHasViewport       NextWindowDataFlags = 2048
	NextWindowDataFlagsHasDock           NextWindowDataFlags = 4096
	NextWindowDataFlagsHasWindowClass    NextWindowDataFlags = 8192
)

// Flags for internal's BeginColumns(). This is an obsolete API. Prefer using BeginTable() nowadays!
// original name: ImGuiOldColumnFlags_
type OldColumnFlags int32

const (
	OldColumnFlagsNone OldColumnFlags = 0
	// Disable column dividers
	OldColumnFlagsNoBorder OldColumnFlags = 1
	// Disable resizing columns when clicking on the dividers
	OldColumnFlagsNoResize OldColumnFlags = 2
	// Disable column width preservation when adjusting columns
	OldColumnFlagsNoPreserveWidths OldColumnFlags = 4
	// Disable forcing columns to fit within window
	OldColumnFlagsNoForceWithinWindow OldColumnFlags = 8
	// Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
	OldColumnFlagsGrowParentContentsSize OldColumnFlags = 16
)

// original name: ImGuiPlotType
type PlotType int32

const (
	PlotTypeLines     PlotType = 0
	PlotTypeHistogram PlotType = 1
)

// Flags for OpenPopup*(), BeginPopupContext*(), IsPopupOpen() functions.
//   - To be backward compatible with older API which took an 'int mouse_button = 1' argument instead of 'ImGuiPopupFlags flags',
//     we need to treat small flags values as a mouse button index, so we encode the mouse button in the first few bits of the flags.
//     It is therefore guaranteed to be legal to pass a mouse button index in ImGuiPopupFlags.
//   - For the same reason, we exceptionally default the ImGuiPopupFlags argument of BeginPopupContextXXX functions to 1 instead of 0.
//     IMPORTANT: because the default parameter is 1 (==ImGuiPopupFlags_MouseButtonRight), if you rely on the default parameter
//     and want to use another flag, you need to pass in the ImGuiPopupFlags_MouseButtonRight flag explicitly.
//   - Multiple buttons currently cannot be combined/or-ed in those functions (we could allow it later).
//
// original name: ImGuiPopupFlags_
type PopupFlags int32

const (
	PopupFlagsNone PopupFlags = 0
	// For BeginPopupContext*(): open on Left Mouse release. Guaranteed to always be == 0 (same as ImGuiMouseButton_Left)
	PopupFlagsMouseButtonLeft PopupFlags = 0
	// For BeginPopupContext*(): open on Right Mouse release. Guaranteed to always be == 1 (same as ImGuiMouseButton_Right)
	PopupFlagsMouseButtonRight PopupFlags = 1
	// For BeginPopupContext*(): open on Middle Mouse release. Guaranteed to always be == 2 (same as ImGuiMouseButton_Middle)
	PopupFlagsMouseButtonMiddle  PopupFlags = 2
	PopupFlagsMouseButtonMask    PopupFlags = 31
	PopupFlagsMouseButtonDefault PopupFlags = 1
	// For OpenPopup*(), BeginPopupContext*(): don't reopen same popup if already open (won't reposition, won't reinitialize navigation)
	PopupFlagsNoReopen PopupFlags = 32
	// For OpenPopup*(), BeginPopupContext*(): don't open if there's already a popup at the same level of the popup stack
	PopupFlagsNoOpenOverExistingPopup PopupFlags = 128
	// For BeginPopupContextWindow(): don't return true when hovering items, only when hovering empty space
	PopupFlagsNoOpenOverItems PopupFlags = 256
	// For IsPopupOpen(): ignore the ImGuiID parameter and test for any popup.
	PopupFlagsAnyPopupId PopupFlags = 1024
	// For IsPopupOpen(): search/test at any level of the popup stack (default test in the current level)
	PopupFlagsAnyPopupLevel PopupFlags = 2048
	PopupFlagsAnyPopup      PopupFlags = 3072
)

// original name: ImGuiPopupPositionPolicy
type PopupPositionPolicy int32

const (
	PopupPositionPolicyDefault  PopupPositionPolicy = 0
	PopupPositionPolicyComboBox PopupPositionPolicy = 1
	PopupPositionPolicyTooltip  PopupPositionPolicy = 2
)

// Early work-in-progress API for ScrollToItem()
// original name: ImGuiScrollFlags_
type ScrollFlags int32

const (
	ScrollFlagsNone ScrollFlags = 0
	// If item is not visible: scroll as little as possible on X axis to bring item back into view [default for X axis]
	ScrollFlagsKeepVisibleEdgeX ScrollFlags = 1
	// If item is not visible: scroll as little as possible on Y axis to bring item back into view [default for Y axis for windows that are already visible]
	ScrollFlagsKeepVisibleEdgeY ScrollFlags = 2
	// If item is not visible: scroll to make the item centered on X axis [rarely used]
	ScrollFlagsKeepVisibleCenterX ScrollFlags = 4
	// If item is not visible: scroll to make the item centered on Y axis
	ScrollFlagsKeepVisibleCenterY ScrollFlags = 8
	// Always center the result item on X axis [rarely used]
	ScrollFlagsAlwaysCenterX ScrollFlags = 16
	// Always center the result item on Y axis [default for Y axis for appearing window)
	ScrollFlagsAlwaysCenterY ScrollFlags = 32
	// Disable forwarding scrolling to parent window if required to keep item/rect visible (only scroll window the function was applied to).
	ScrollFlagsNoScrollParent ScrollFlags = 64
	ScrollFlagsMaskX          ScrollFlags = 21
	ScrollFlagsMaskY          ScrollFlags = 42
)

// Extend ImGuiSelectableFlags_
// original name: ImGuiSelectableFlagsPrivate_
type SelectableFlagsPrivate int32

const (
	SelectableFlagsNoHoldingActiveID SelectableFlagsPrivate = 1048576
	// Override button behavior to react on Click (default is Click+Release)
	SelectableFlagsSelectOnClick SelectableFlagsPrivate = 4194304
	// Override button behavior to react on Release (default is Click+Release)
	SelectableFlagsSelectOnRelease SelectableFlagsPrivate = 8388608
	// Span all avail width even if we declared less for layout purpose. FIXME: We may be able to remove this (added in 6251d379, 2bcafc86 for menus)
	SelectableFlagsSpanAvailWidth SelectableFlagsPrivate = 16777216
	// Set Nav/Focus ID on mouse hover (used by MenuItem)
	SelectableFlagsSetNavIdOnHover SelectableFlagsPrivate = 33554432
	// Disable padding each side with ItemSpacing * 0.5f
	SelectableFlagsNoPadWithHalfSpacing SelectableFlagsPrivate = 67108864
	// Don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)
	SelectableFlagsNoSetKeyOwner SelectableFlagsPrivate = 134217728
)

// Flags for ImGui::Selectable()
// original name: ImGuiSelectableFlags_
type SelectableFlags int32

const (
	SelectableFlagsNone SelectableFlags = 0
	// Clicking this doesn't close parent popup window (overrides ImGuiItemFlags_AutoClosePopups)
	SelectableFlagsNoAutoClosePopups SelectableFlags = 1
	// Frame will span all columns of its container table (text will still fit in current column)
	SelectableFlagsSpanAllColumns SelectableFlags = 2
	// Generate press events on double clicks too
	SelectableFlagsAllowDoubleClick SelectableFlags = 4
	// Cannot be selected, display grayed out text
	SelectableFlagsDisabled SelectableFlags = 8
	// (WIP) Hit testing to allow subsequent widgets to overlap this one
	SelectableFlagsAllowOverlap SelectableFlags = 16
	// Make the item be displayed as if it is hovered
	SelectableFlagsHighlight SelectableFlags = 32
	// Auto-select when moved into, unless Ctrl is held. Automatic when in a BeginMultiSelect() block.
	SelectableFlagsSelectOnNav SelectableFlags = 64
)

// Selection request type
// original name: ImGuiSelectionRequestType
type SelectionRequestType int32

const (
	SelectionRequestTypeNone SelectionRequestType = 0
	// Request app to clear selection (if Selected==false) or select all items (if Selected==true). We cannot set RangeFirstItem/RangeLastItem as its contents is entirely up to user (not necessarily an index)
	SelectionRequestTypeSetAll SelectionRequestType = 1
	// Request app to select/unselect [RangeFirstItem..RangeLastItem] items (inclusive) based on value of Selected. Only EndMultiSelect() request this, app code can read after BeginMultiSelect() and it will always be false.
	SelectionRequestTypeSetRange SelectionRequestType = 2
)

// original name: ImGuiSeparatorFlags_
type SeparatorFlags int32

const (
	SeparatorFlagsNone SeparatorFlags = 0
	// Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
	SeparatorFlagsHorizontal SeparatorFlags = 1
	SeparatorFlagsVertical   SeparatorFlags = 2
	// Make separator cover all columns of a legacy Columns() set.
	SeparatorFlagsSpanAllColumns SeparatorFlags = 4
)

// Extend ImGuiSliderFlags_
// original name: ImGuiSliderFlagsPrivate_
type SliderFlagsPrivate int32

const (
	// Should this slider be orientated vertically?
	SliderFlagsVertical SliderFlagsPrivate = 1048576
	// Consider using g.NextItemData.ItemFlags |= ImGuiItemFlags_ReadOnly instead.
	SliderFlagsReadOnly SliderFlagsPrivate = 2097152
)

// Flags for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.
// We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.
// (Those are per-item flags. There is shared behavior flag too: ImGuiIO: io.ConfigDragClickToInputText)
// original name: ImGuiSliderFlags_
type SliderFlags int32

const (
	SliderFlagsNone SliderFlags = 0
	// Make the widget logarithmic (linear otherwise). Consider using ImGuiSliderFlags_NoRoundToFormat with this if using a format-string with small amount of digits.
	SliderFlagsLogarithmic SliderFlags = 32
	// Disable rounding underlying value to match precision of the display format string (e.g. %.3f values are rounded to those 3 digits).
	SliderFlagsNoRoundToFormat SliderFlags = 64
	// Disable CTRL+Click or Enter key allowing to input text directly into the widget.
	SliderFlagsNoInput SliderFlags = 128
	// Enable wrapping around from max to min and from min to max. Only supported by DragXXX() functions for now.
	SliderFlagsWrapAround SliderFlags = 256
	// Clamp value to min/max bounds when input manually with CTRL+Click. By default CTRL+Click allows going out of bounds.
	SliderFlagsClampOnInput SliderFlags = 512
	// Clamp even if min==max==0.0f. Otherwise due to legacy reason DragXXX functions don't clamp with those values. When your clamping limits are dynamic you almost always want to use it.
	SliderFlagsClampZeroRange SliderFlags = 1024
	// Disable keyboard modifiers altering tweak speed. Useful if you want to alter tweak speed yourself based on your own logic.
	SliderFlagsNoSpeedTweaks SliderFlags = 2048
	SliderFlagsAlwaysClamp   SliderFlags = 1536
	// [Internal] We treat using those bits as being potentially a 'float power' argument from the previous API that has got miscast to this enum, and will trigger an assert if needed.
	SliderFlagsInvalidMask SliderFlags = 1879048207
)

// A sorting direction
// original name: ImGuiSortDirection
type SortDirection int32

const (
	SortDirectionNone SortDirection = 0
	// Ascending = 0->9, A->Z etc.
	SortDirectionAscending SortDirection = 1
	// Descending = 9->0, Z->A etc.
	SortDirectionDescending SortDirection = 2
)

// Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.
//   - The enum only refers to fields of ImGuiStyle which makes sense to be pushed/popped inside UI code.
//     During initialization or between frames, feel free to just poke into ImGuiStyle directly.
//   - Tip: Use your programming IDE navigation facilities on the names in the _second column_ below to find the actual members and their description.
//   - In Visual Studio: CTRL+comma ("Edit.GoToAll") can follow symbols inside comments, whereas CTRL+F12 ("Edit.GoToImplementation") cannot.
//   - In Visual Studio w/ Visual Assist installed: ALT+G ("VAssistX.GoToImplementation") can also follow symbols inside comments.
//   - In VS Code, CLion, etc.: CTRL+click can follow symbols inside comments.
//   - When changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type.
//
// original name: ImGuiStyleVar_
type StyleVar int32

const (
	// float     Alpha
	StyleVarAlpha StyleVar = 0
	// float     DisabledAlpha
	StyleVarDisabledAlpha StyleVar = 1
	// ImVec2    WindowPadding
	StyleVarWindowPadding StyleVar = 2
	// float     WindowRounding
	StyleVarWindowRounding StyleVar = 3
	// float     WindowBorderSize
	StyleVarWindowBorderSize StyleVar = 4
	// ImVec2    WindowMinSize
	StyleVarWindowMinSize StyleVar = 5
	// ImVec2    WindowTitleAlign
	StyleVarWindowTitleAlign StyleVar = 6
	// float     ChildRounding
	StyleVarChildRounding StyleVar = 7
	// float     ChildBorderSize
	StyleVarChildBorderSize StyleVar = 8
	// float     PopupRounding
	StyleVarPopupRounding StyleVar = 9
	// float     PopupBorderSize
	StyleVarPopupBorderSize StyleVar = 10
	// ImVec2    FramePadding
	StyleVarFramePadding StyleVar = 11
	// float     FrameRounding
	StyleVarFrameRounding StyleVar = 12
	// float     FrameBorderSize
	StyleVarFrameBorderSize StyleVar = 13
	// ImVec2    ItemSpacing
	StyleVarItemSpacing StyleVar = 14
	// ImVec2    ItemInnerSpacing
	StyleVarItemInnerSpacing StyleVar = 15
	// float     IndentSpacing
	StyleVarIndentSpacing StyleVar = 16
	// ImVec2    CellPadding
	StyleVarCellPadding StyleVar = 17
	// float     ScrollbarSize
	StyleVarScrollbarSize StyleVar = 18
	// float     ScrollbarRounding
	StyleVarScrollbarRounding StyleVar = 19
	// float     ScrollbarPadding
	StyleVarScrollbarPadding StyleVar = 20
	// float     GrabMinSize
	StyleVarGrabMinSize StyleVar = 21
	// float     GrabRounding
	StyleVarGrabRounding StyleVar = 22
	// float     ImageBorderSize
	StyleVarImageBorderSize StyleVar = 23
	// float     TabRounding
	StyleVarTabRounding StyleVar = 24
	// float     TabBorderSize
	StyleVarTabBorderSize StyleVar = 25
	// float     TabMinWidthBase
	StyleVarTabMinWidthBase StyleVar = 26
	// float     TabMinWidthShrink
	StyleVarTabMinWidthShrink StyleVar = 27
	// float     TabBarBorderSize
	StyleVarTabBarBorderSize StyleVar = 28
	// float     TabBarOverlineSize
	StyleVarTabBarOverlineSize StyleVar = 29
	// float     TableAngledHeadersAngle
	StyleVarTableAngledHeadersAngle StyleVar = 30
	// ImVec2  TableAngledHeadersTextAlign
	StyleVarTableAngledHeadersTextAlign StyleVar = 31
	// float     TreeLinesSize
	StyleVarTreeLinesSize StyleVar = 32
	// float     TreeLinesRounding
	StyleVarTreeLinesRounding StyleVar = 33
	// ImVec2    ButtonTextAlign
	StyleVarButtonTextAlign StyleVar = 34
	// ImVec2    SelectableTextAlign
	StyleVarSelectableTextAlign StyleVar = 35
	// float     SeparatorTextBorderSize
	StyleVarSeparatorTextBorderSize StyleVar = 36
	// ImVec2    SeparatorTextAlign
	StyleVarSeparatorTextAlign StyleVar = 37
	// ImVec2    SeparatorTextPadding
	StyleVarSeparatorTextPadding StyleVar = 38
	// float     DockingSeparatorSize
	StyleVarDockingSeparatorSize StyleVar = 39
	StyleVarCOUNT                StyleVar = 40
)

// Extend ImGuiTabBarFlags_
// original name: ImGuiTabBarFlagsPrivate_
type TabBarFlagsPrivate int32

const (
	// Part of a dock node [we don't use this in the master branch but it facilitate branch syncing to keep this around]
	TabBarFlagsDockNode  TabBarFlagsPrivate = 1048576
	TabBarFlagsIsFocused TabBarFlagsPrivate = 2097152
	// FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs
	TabBarFlagsSaveSettings TabBarFlagsPrivate = 4194304
)

// Flags for ImGui::BeginTabBar()
// original name: ImGuiTabBarFlags_
type TabBarFlags int32

const (
	TabBarFlagsNone TabBarFlags = 0
	// Allow manually dragging tabs to re-order them + New tabs are appended at the end of list
	TabBarFlagsReorderable TabBarFlags = 1
	// Automatically select new tabs when they appear
	TabBarFlagsAutoSelectNewTabs TabBarFlags = 2
	// Disable buttons to open the tab list popup
	TabBarFlagsTabListPopupButton TabBarFlags = 4
	// Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You may handle this behavior manually on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
	TabBarFlagsNoCloseWithMiddleMouseButton TabBarFlags = 8
	// Disable scrolling buttons (apply when fitting policy is ImGuiTabBarFlags_FittingPolicyScroll)
	TabBarFlagsNoTabListScrollingButtons TabBarFlags = 16
	// Disable tooltips when hovering a tab
	TabBarFlagsNoTooltip TabBarFlags = 32
	// Draw selected overline markers over selected tab
	TabBarFlagsDrawSelectedOverline TabBarFlags = 64
	// Shrink down tabs when they don't fit, until width is style.TabMinWidthShrink, then enable scrolling buttons.
	TabBarFlagsFittingPolicyMixed TabBarFlags = 128
	// Shrink down tabs when they don't fit
	TabBarFlagsFittingPolicyShrink TabBarFlags = 256
	// Enable scrolling buttons when tabs don't fit
	TabBarFlagsFittingPolicyScroll  TabBarFlags = 512
	TabBarFlagsFittingPolicyMask    TabBarFlags = 896
	TabBarFlagsFittingPolicyDefault TabBarFlags = 128
)

// Extend ImGuiTabItemFlags_
// original name: ImGuiTabItemFlagsPrivate_
type TabItemFlagsPrivate int32

const (
	TabItemFlagsSectionMask TabItemFlagsPrivate = 192
	// Track whether p_open was set or not (we'll need this info on the next frame to recompute ContentWidth during layout)
	TabItemFlagsNoCloseButton TabItemFlagsPrivate = 1048576
	// Used by TabItemButton, change the tab item behavior to mimic a button
	TabItemFlagsButton TabItemFlagsPrivate = 2097152
	// To reserve space e.g. with ImGuiTabItemFlags_Leading
	TabItemFlagsInvisible TabItemFlagsPrivate = 4194304
	// [Docking] Trailing tabs with the _Unsorted flag will be sorted based on the DockOrder of their Window.
	TabItemFlagsUnsorted TabItemFlagsPrivate = 8388608
)

// Flags for ImGui::BeginTabItem()
// original name: ImGuiTabItemFlags_
type TabItemFlags int32

const (
	TabItemFlagsNone TabItemFlags = 0
	// Display a dot next to the title + set ImGuiTabItemFlags_NoAssumedClosure.
	TabItemFlagsUnsavedDocument TabItemFlags = 1
	// Trigger flag to programmatically make the tab selected when calling BeginTabItem()
	TabItemFlagsSetSelected TabItemFlags = 2
	// Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You may handle this behavior manually on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
	TabItemFlagsNoCloseWithMiddleMouseButton TabItemFlags = 4
	// Don't call PushID()/PopID() on BeginTabItem()/EndTabItem()
	TabItemFlagsNoPushId TabItemFlags = 8
	// Disable tooltip for the given tab
	TabItemFlagsNoTooltip TabItemFlags = 16
	// Disable reordering this tab or having another tab cross over this tab
	TabItemFlagsNoReorder TabItemFlags = 32
	// Enforce the tab position to the left of the tab bar (after the tab list popup button)
	TabItemFlagsLeading TabItemFlags = 64
	// Enforce the tab position to the right of the tab bar (before the scrolling buttons)
	TabItemFlagsTrailing TabItemFlags = 128
	// Tab is selected when trying to close + closure is not immediately assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar.
	TabItemFlagsNoAssumedClosure TabItemFlags = 256
)

// Enum for ImGui::TableSetBgColor()
// Background colors are rendering in 3 layers:
//   - Layer 0: draw with RowBg0 color if set, otherwise draw with ColumnBg0 if set.
//   - Layer 1: draw with RowBg1 color if set, otherwise draw with ColumnBg1 if set.
//   - Layer 2: draw with CellBg color if set.
//
// The purpose of the two row/columns layers is to let you decide if a background color change should override or blend with the existing color.
// When using ImGuiTableFlags_RowBg on the table, each row has the RowBg0 color automatically set for odd/even rows.
// If you set the color of RowBg0 target, your color will override the existing RowBg0 color.
// If you set the color of RowBg1 or ColumnBg1 target, your color will blend over the RowBg0 color.
// original name: ImGuiTableBgTarget_
type TableBgTarget int32

const (
	TableBgTargetNone TableBgTarget = 0
	// Set row background color 0 (generally used for background, automatically set when ImGuiTableFlags_RowBg is used)
	TableBgTargetRowBg0 TableBgTarget = 1
	// Set row background color 1 (generally used for selection marking)
	TableBgTargetRowBg1 TableBgTarget = 2
	// Set cell background color (top-most color)
	TableBgTargetCellBg TableBgTarget = 3
)

// Flags for ImGui::TableSetupColumn()
// original name: ImGuiTableColumnFlags_
type TableColumnFlags int32

const (
	TableColumnFlagsNone TableColumnFlags = 0
	// Overriding/master disable flag: hide column, won't show in context menu (unlike calling TableSetColumnEnabled() which manipulates the user accessible state)
	TableColumnFlagsDisabled TableColumnFlags = 1
	// Default as a hidden/disabled column.
	TableColumnFlagsDefaultHide TableColumnFlags = 2
	// Default as a sorting column.
	TableColumnFlagsDefaultSort TableColumnFlags = 4
	// Column will stretch. Preferable with horizontal scrolling disabled (default if table sizing policy is _SizingStretchSame or _SizingStretchProp).
	TableColumnFlagsWidthStretch TableColumnFlags = 8
	// Column will not stretch. Preferable with horizontal scrolling enabled (default if table sizing policy is _SizingFixedFit and table is resizable).
	TableColumnFlagsWidthFixed TableColumnFlags = 16
	// Disable manual resizing.
	TableColumnFlagsNoResize TableColumnFlags = 32
	// Disable manual reordering this column, this will also prevent other columns from crossing over this column.
	TableColumnFlagsNoReorder TableColumnFlags = 64
	// Disable ability to hide/disable this column.
	TableColumnFlagsNoHide TableColumnFlags = 128
	// Disable clipping for this column (all NoClip columns will render in a same draw command).
	TableColumnFlagsNoClip TableColumnFlags = 256
	// Disable ability to sort on this field (even if ImGuiTableFlags_Sortable is set on the table).
	TableColumnFlagsNoSort TableColumnFlags = 512
	// Disable ability to sort in the ascending direction.
	TableColumnFlagsNoSortAscending TableColumnFlags = 1024
	// Disable ability to sort in the descending direction.
	TableColumnFlagsNoSortDescending TableColumnFlags = 2048
	// TableHeadersRow() will submit an empty label for this column. Convenient for some small columns. Name will still appear in context menu or in angled headers. You may append into this cell by calling TableSetColumnIndex() right after the TableHeadersRow() call.
	TableColumnFlagsNoHeaderLabel TableColumnFlags = 4096
	// Disable header text width contribution to automatic column width.
	TableColumnFlagsNoHeaderWidth TableColumnFlags = 8192
	// Make the initial sort direction Ascending when first sorting on this column (default).
	TableColumnFlagsPreferSortAscending TableColumnFlags = 16384
	// Make the initial sort direction Descending when first sorting on this column.
	TableColumnFlagsPreferSortDescending TableColumnFlags = 32768
	// Use current Indent value when entering cell (default for column 0).
	TableColumnFlagsIndentEnable TableColumnFlags = 65536
	// Ignore current Indent value when entering cell (default for columns > 0). Indentation changes _within_ the cell will still be honored.
	TableColumnFlagsIndentDisable TableColumnFlags = 131072
	// TableHeadersRow() will submit an angled header row for this column. Note this will add an extra row.
	TableColumnFlagsAngledHeader TableColumnFlags = 262144
	// Status: is enabled == not hidden by user/api (referred to as "Hide" in _DefaultHide and _NoHide) flags.
	TableColumnFlagsIsEnabled TableColumnFlags = 16777216
	// Status: is visible == is enabled AND not clipped by scrolling.
	TableColumnFlagsIsVisible TableColumnFlags = 33554432
	// Status: is currently part of the sort specs
	TableColumnFlagsIsSorted TableColumnFlags = 67108864
	// Status: is hovered by mouse
	TableColumnFlagsIsHovered  TableColumnFlags = 134217728
	TableColumnFlagsWidthMask  TableColumnFlags = 24
	TableColumnFlagsIndentMask TableColumnFlags = 196608
	TableColumnFlagsStatusMask TableColumnFlags = 251658240
	// [Internal] Disable user resizing this column directly (it may however we resized indirectly from its left edge)
	TableColumnFlagsNoDirectResize TableColumnFlags = 1073741824
)

// Flags for ImGui::BeginTable()
//   - Important! Sizing policies have complex and subtle side effects, much more so than you would expect.
//     Read comments/demos carefully + experiment with live demos to get acquainted with them.
//   - The DEFAULT sizing policies are:
//   - Default to ImGuiTableFlags_SizingFixedFit    if ScrollX is on, or if host window has ImGuiWindowFlags_AlwaysAutoResize.
//   - Default to ImGuiTableFlags_SizingStretchSame if ScrollX is off.
//   - When ScrollX is off:
//   - Table defaults to ImGuiTableFlags_SizingStretchSame -> all Columns defaults to ImGuiTableColumnFlags_WidthStretch with same weight.
//   - Columns sizing policy allowed: Stretch (default), Fixed/Auto.
//   - Fixed Columns (if any) will generally obtain their requested width (unless the table cannot fit them all).
//   - Stretch Columns will share the remaining width according to their respective weight.
//   - Mixed Fixed/Stretch columns is possible but has various side-effects on resizing behaviors.
//     The typical use of mixing sizing policies is: any number of LEADING Fixed columns, followed by one or two TRAILING Stretch columns.
//     (this is because the visible order of columns have subtle but necessary effects on how they react to manual resizing).
//   - When ScrollX is on:
//   - Table defaults to ImGuiTableFlags_SizingFixedFit -> all Columns defaults to ImGuiTableColumnFlags_WidthFixed
//   - Columns sizing policy allowed: Fixed/Auto mostly.
//   - Fixed Columns can be enlarged as needed. Table will show a horizontal scrollbar if needed.
//   - When using auto-resizing (non-resizable) fixed columns, querying the content width to use item right-alignment e.g. SetNextItemWidth(-FLT_MIN) doesn't make sense, would create a feedback loop.
//   - Using Stretch columns OFTEN DOES NOT MAKE SENSE if ScrollX is on, UNLESS you have specified a value for 'inner_width' in BeginTable().
//     If you specify a value for 'inner_width' then effectively the scrolling space is known and Stretch or mixed Fixed/Stretch columns become meaningful again.
//   - Read on documentation at the top of imgui_tables.cpp for details.
//
// original name: ImGuiTableFlags_
type TableFlags int32

const (
	TableFlagsNone TableFlags = 0
	// Enable resizing columns.
	TableFlagsResizable TableFlags = 1
	// Enable reordering columns in header row (need calling TableSetupColumn() + TableHeadersRow() to display headers)
	TableFlagsReorderable TableFlags = 2
	// Enable hiding/disabling columns in context menu.
	TableFlagsHideable TableFlags = 4
	// Enable sorting. Call TableGetSortSpecs() to obtain sort specs. Also see ImGuiTableFlags_SortMulti and ImGuiTableFlags_SortTristate.
	TableFlagsSortable TableFlags = 8
	// Disable persisting columns order, width and sort settings in the .ini file.
	TableFlagsNoSavedSettings TableFlags = 16
	// Right-click on columns body/contents will display table context menu. By default it is available in TableHeadersRow().
	TableFlagsContextMenuInBody TableFlags = 32
	// Set each RowBg color with ImGuiCol_TableRowBg or ImGuiCol_TableRowBgAlt (equivalent of calling TableSetBgColor with ImGuiTableBgFlags_RowBg0 on each row manually)
	TableFlagsRowBg TableFlags = 64
	// Draw horizontal borders between rows.
	TableFlagsBordersInnerH TableFlags = 128
	// Draw horizontal borders at the top and bottom.
	TableFlagsBordersOuterH TableFlags = 256
	// Draw vertical borders between columns.
	TableFlagsBordersInnerV TableFlags = 512
	// Draw vertical borders on the left and right sides.
	TableFlagsBordersOuterV TableFlags = 1024
	// Draw horizontal borders.
	TableFlagsBordersH TableFlags = 384
	// Draw vertical borders.
	TableFlagsBordersV TableFlags = 1536
	// Draw inner borders.
	TableFlagsBordersInner TableFlags = 640
	// Draw outer borders.
	TableFlagsBordersOuter TableFlags = 1280
	// Draw all borders.
	TableFlagsBorders TableFlags = 1920
	// [ALPHA] Disable vertical borders in columns Body (borders will always appear in Headers). -> May move to style
	TableFlagsNoBordersInBody TableFlags = 2048
	// [ALPHA] Disable vertical borders in columns Body until hovered for resize (borders will always appear in Headers). -> May move to style
	TableFlagsNoBordersInBodyUntilResize TableFlags = 4096
	// Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching contents width.
	TableFlagsSizingFixedFit TableFlags = 8192
	// Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching the maximum contents width of all columns. Implicitly enable ImGuiTableFlags_NoKeepColumnsVisible.
	TableFlagsSizingFixedSame TableFlags = 16384
	// Columns default to _WidthStretch with default weights proportional to each columns contents widths.
	TableFlagsSizingStretchProp TableFlags = 24576
	// Columns default to _WidthStretch with default weights all equal, unless overridden by TableSetupColumn().
	TableFlagsSizingStretchSame TableFlags = 32768
	// Make outer width auto-fit to columns, overriding outer_size.x value. Only available when ScrollX/ScrollY are disabled and Stretch columns are not used.
	TableFlagsNoHostExtendX TableFlags = 65536
	// Make outer height stop exactly at outer_size.y (prevent auto-extending table past the limit). Only available when ScrollX/ScrollY are disabled. Data below the limit will be clipped and not visible.
	TableFlagsNoHostExtendY TableFlags = 131072
	// Disable keeping column always minimally visible when ScrollX is off and table gets too small. Not recommended if columns are resizable.
	TableFlagsNoKeepColumnsVisible TableFlags = 262144
	// Disable distributing remainder width to stretched columns (width allocation on a 100-wide table with 3 columns: Without this flag: 33,33,34. With this flag: 33,33,33). With larger number of columns, resizing will appear to be less smooth.
	TableFlagsPreciseWidths TableFlags = 524288
	// Disable clipping rectangle for every individual columns (reduce draw command count, items will be able to overflow into other columns). Generally incompatible with TableSetupScrollFreeze().
	TableFlagsNoClip TableFlags = 1048576
	// Default if BordersOuterV is on. Enable outermost padding. Generally desirable if you have headers.
	TableFlagsPadOuterX TableFlags = 2097152
	// Default if BordersOuterV is off. Disable outermost padding.
	TableFlagsNoPadOuterX TableFlags = 4194304
	// Disable inner padding between columns (double inner padding if BordersOuterV is on, single inner padding if BordersOuterV is off).
	TableFlagsNoPadInnerX TableFlags = 8388608
	// Enable horizontal scrolling. Require 'outer_size' parameter of BeginTable() to specify the container size. Changes default sizing policy. Because this creates a child window, ScrollY is currently generally recommended when using ScrollX.
	TableFlagsScrollX TableFlags = 16777216
	// Enable vertical scrolling. Require 'outer_size' parameter of BeginTable() to specify the container size.
	TableFlagsScrollY TableFlags = 33554432
	// Hold shift when clicking headers to sort on multiple column. TableGetSortSpecs() may return specs where (SpecsCount > 1).
	TableFlagsSortMulti TableFlags = 67108864
	// Allow no sorting, disable default sorting. TableGetSortSpecs() may return specs where (SpecsCount == 0).
	TableFlagsSortTristate TableFlags = 134217728
	// Highlight column headers when hovered (may evolve into a fuller highlight)
	TableFlagsHighlightHoveredColumn TableFlags = 268435456
	TableFlagsSizingMask             TableFlags = 57344
)

// Flags for ImGui::TableNextRow()
// original name: ImGuiTableRowFlags_
type TableRowFlags int32

const (
	TableRowFlagsNone TableRowFlags = 0
	// Identify header row (set default background color + width of its contents accounted differently for auto column width)
	TableRowFlagsHeaders TableRowFlags = 1
)

// original name: ImGuiTextFlags_
type TextFlags int32

const (
	TextFlagsNone                       TextFlags = 0
	TextFlagsNoWidthForLargeClippedText TextFlags = 1
)

// original name: ImGuiTooltipFlags_
type TooltipFlags int32

const (
	TooltipFlagsNone TooltipFlags = 0
	// Clear/ignore previously submitted tooltip (defaults to append)
	TooltipFlagsOverridePrevious TooltipFlags = 2
)

// Extend ImGuiTreeNodeFlags_
// original name: ImGuiTreeNodeFlagsPrivate_
type TreeNodeFlagsPrivate int32

const (
	// Don't claim nav focus when interacting with this item (#8551)
	TreeNodeFlagsNoNavFocus TreeNodeFlagsPrivate = 134217728
	// FIXME-WIP: Hard-coded for CollapsingHeader()
	TreeNodeFlagsClipLabelForTrailingButton TreeNodeFlagsPrivate = 268435456
	// FIXME-WIP: Turn Down arrow into an Up arrow, for reversed trees (#6517)
	TreeNodeFlagsUpsideDownArrow TreeNodeFlagsPrivate = 536870912
	TreeNodeFlagsOpenOnMask      TreeNodeFlagsPrivate = 192
	TreeNodeFlagsDrawLinesMask   TreeNodeFlagsPrivate = 1835008
)

// Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*()
// original name: ImGuiTreeNodeFlags_
type TreeNodeFlags int32

const (
	TreeNodeFlagsNone TreeNodeFlags = 0
	// Draw as selected
	TreeNodeFlagsSelected TreeNodeFlags = 1
	// Draw frame with background (e.g. for CollapsingHeader)
	TreeNodeFlagsFramed TreeNodeFlags = 2
	// Hit testing to allow subsequent widgets to overlap this one
	TreeNodeFlagsAllowOverlap TreeNodeFlags = 4
	// Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack
	TreeNodeFlagsNoTreePushOnOpen TreeNodeFlags = 8
	// Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)
	TreeNodeFlagsNoAutoOpenOnLog TreeNodeFlags = 16
	// Default node to be open
	TreeNodeFlagsDefaultOpen TreeNodeFlags = 32
	// Open on double-click instead of simple click (default for multi-select unless any _OpenOnXXX behavior is set explicitly). Both behaviors may be combined.
	TreeNodeFlagsOpenOnDoubleClick TreeNodeFlags = 64
	// Open when clicking on the arrow part (default for multi-select unless any _OpenOnXXX behavior is set explicitly). Both behaviors may be combined.
	TreeNodeFlagsOpenOnArrow TreeNodeFlags = 128
	// No collapsing, no arrow (use as a convenience for leaf nodes).
	TreeNodeFlagsLeaf TreeNodeFlags = 256
	// Display a bullet instead of arrow. IMPORTANT: node can still be marked open/close if you don't set the _Leaf flag!
	TreeNodeFlagsBullet TreeNodeFlags = 512
	// Use FramePadding (even for an unframed text node) to vertically align text baseline to regular widget height. Equivalent to calling AlignTextToFramePadding() before the node.
	TreeNodeFlagsFramePadding TreeNodeFlags = 1024
	// Extend hit box to the right-most edge, even if not framed. This is not the default in order to allow adding other items on the same line without using AllowOverlap mode.
	TreeNodeFlagsSpanAvailWidth TreeNodeFlags = 2048
	// Extend hit box to the left-most and right-most edges (cover the indent area).
	TreeNodeFlagsSpanFullWidth TreeNodeFlags = 4096
	// Narrow hit box + narrow hovering highlight, will only cover the label text.
	TreeNodeFlagsSpanLabelWidth TreeNodeFlags = 8192
	// Frame will span all columns of its container table (label will still fit in current column)
	TreeNodeFlagsSpanAllColumns TreeNodeFlags = 16384
	// Label will span all columns of its container table
	TreeNodeFlagsLabelSpanAllColumns TreeNodeFlags = 32768
	// Nav: left arrow moves back to parent. This is processed in TreePop() when there's an unfullfilled Left nav request remaining.
	TreeNodeFlagsNavLeftJumpsToParent TreeNodeFlags = 131072
	TreeNodeFlagsCollapsingHeader     TreeNodeFlags = 26
	// No lines drawn
	TreeNodeFlagsDrawLinesNone TreeNodeFlags = 262144
	// Horizontal lines to child nodes. Vertical line drawn down to TreePop() position: cover full contents. Faster (for large trees).
	TreeNodeFlagsDrawLinesFull TreeNodeFlags = 524288
	// Horizontal lines to child nodes. Vertical line drawn down to bottom-most child node. Slower (for large trees).
	TreeNodeFlagsDrawLinesToNodes TreeNodeFlags = 1048576
)

// Flags for GetTypingSelectRequest()
// original name: ImGuiTypingSelectFlags_
type TypingSelectFlags int32

const (
	TypingSelectFlagsNone TypingSelectFlags = 0
	// Backspace to delete character inputs. If using: ensure GetTypingSelectRequest() is not called more than once per frame (filter by e.g. focus state)
	TypingSelectFlagsAllowBackspace TypingSelectFlags = 1
	// Allow "single char" search mode which is activated when pressing the same character multiple times.
	TypingSelectFlagsAllowSingleCharMode TypingSelectFlags = 2
)

// Flags stored in ImGuiViewport::Flags, giving indications to the platform backends.
// original name: ImGuiViewportFlags_
type ViewportFlags int32

const (
	ViewportFlagsNone ViewportFlags = 0
	// Represent a Platform Window
	ViewportFlagsIsPlatformWindow ViewportFlags = 1
	// Represent a Platform Monitor (unused yet)
	ViewportFlagsIsPlatformMonitor ViewportFlags = 2
	// Platform Window: Is created/managed by the user application? (rather than our backend)
	ViewportFlagsOwnedByApp ViewportFlags = 4
	// Platform Window: Disable platform decorations: title bar, borders, etc. (generally set all windows, but if ImGuiConfigFlags_ViewportsDecoration is set we only set this on popups/tooltips)
	ViewportFlagsNoDecoration ViewportFlags = 8
	// Platform Window: Disable platform task bar icon (generally set on popups/tooltips, or all windows if ImGuiConfigFlags_ViewportsNoTaskBarIcon is set)
	ViewportFlagsNoTaskBarIcon ViewportFlags = 16
	// Platform Window: Don't take focus when created.
	ViewportFlagsNoFocusOnAppearing ViewportFlags = 32
	// Platform Window: Don't take focus when clicked on.
	ViewportFlagsNoFocusOnClick ViewportFlags = 64
	// Platform Window: Make mouse pass through so we can drag this window while peaking behind it.
	ViewportFlagsNoInputs ViewportFlags = 128
	// Platform Window: Renderer doesn't need to clear the framebuffer ahead (because we will fill it entirely).
	ViewportFlagsNoRendererClear ViewportFlags = 256
	// Platform Window: Avoid merging this window into another host window. This can only be set via ImGuiWindowClass viewport flags override (because we need to now ahead if we are going to create a viewport in the first place!).
	ViewportFlagsNoAutoMerge ViewportFlags = 512
	// Platform Window: Display on top (for tooltips only).
	ViewportFlagsTopMost ViewportFlags = 1024
	// Viewport can host multiple imgui windows (secondary viewports are associated to a single window). // FIXME: In practice there's still probably code making the assumption that this is always and only on the MainViewport. Will fix once we add support for "no main viewport".
	ViewportFlagsCanHostOtherWindows ViewportFlags = 2048
	// Platform Window: Window is minimized, can skip render. When minimized we tend to avoid using the viewport pos/size for clipping window or testing if they are contained in the viewport.
	ViewportFlagsIsMinimized ViewportFlags = 4096
	// Platform Window: Window is focused (last call to Platform_GetWindowFocus() returned true)
	ViewportFlagsIsFocused ViewportFlags = 8192
)

// List of colors that are stored at the time of Begin() into Docked Windows.
// We currently store the packed colors in a simple array window->DockStyle.Colors[].
// A better solution may involve appending into a log of colors in ImGuiContext + store offsets into those arrays in ImGuiWindow,
// but it would be more complex as we'd need to double-buffer both as e.g. drop target may refer to window from last frame.
// original name: ImGuiWindowDockStyleCol
type WindowDockStyleCol int32

const (
	WindowDockStyleColText                      WindowDockStyleCol = 0
	WindowDockStyleColTabHovered                WindowDockStyleCol = 1
	WindowDockStyleColTabFocused                WindowDockStyleCol = 2
	WindowDockStyleColTabSelected               WindowDockStyleCol = 3
	WindowDockStyleColTabSelectedOverline       WindowDockStyleCol = 4
	WindowDockStyleColTabDimmed                 WindowDockStyleCol = 5
	WindowDockStyleColTabDimmedSelected         WindowDockStyleCol = 6
	WindowDockStyleColTabDimmedSelectedOverline WindowDockStyleCol = 7
	WindowDockStyleColCOUNT                     WindowDockStyleCol = 8
)

// Flags for ImGui::Begin()
// (Those are per-window flags. There are shared flags in ImGuiIO: io.ConfigWindowsResizeFromEdges and io.ConfigWindowsMoveFromTitleBarOnly)
// original name: ImGuiWindowFlags_
type WindowFlags int32

const (
	WindowFlagsNone WindowFlags = 0
	// Disable title-bar
	WindowFlagsNoTitleBar WindowFlags = 1
	// Disable user resizing with the lower-right grip
	WindowFlagsNoResize WindowFlags = 2
	// Disable user moving the window
	WindowFlagsNoMove WindowFlags = 4
	// Disable scrollbars (window can still scroll with mouse or programmatically)
	WindowFlagsNoScrollbar WindowFlags = 8
	// Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set.
	WindowFlagsNoScrollWithMouse WindowFlags = 16
	// Disable user collapsing window by double-clicking on it. Also referred to as Window Menu Button (e.g. within a docking node).
	WindowFlagsNoCollapse WindowFlags = 32
	// Resize every window to its content every frame
	WindowFlagsAlwaysAutoResize WindowFlags = 64
	// Disable drawing background color (WindowBg, etc.) and outside border. Similar as using SetNextWindowBgAlpha(0.0f).
	WindowFlagsNoBackground WindowFlags = 128
	// Never load/save settings in .ini file
	WindowFlagsNoSavedSettings WindowFlags = 256
	// Disable catching mouse, hovering test with pass through.
	WindowFlagsNoMouseInputs WindowFlags = 512
	// Has a menu-bar
	WindowFlagsMenuBar WindowFlags = 1024
	// Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the "Horizontal Scrolling" section.
	WindowFlagsHorizontalScrollbar WindowFlags = 2048
	// Disable taking focus when transitioning from hidden to visible state
	WindowFlagsNoFocusOnAppearing WindowFlags = 4096
	// Disable bringing window to front when taking focus (e.g. clicking on it or programmatically giving it focus)
	WindowFlagsNoBringToFrontOnFocus WindowFlags = 8192
	// Always show vertical scrollbar (even if ContentSize.y < Size.y)
	WindowFlagsAlwaysVerticalScrollbar WindowFlags = 16384
	// Always show horizontal scrollbar (even if ContentSize.x < Size.x)
	WindowFlagsAlwaysHorizontalScrollbar WindowFlags = 32768
	// No keyboard/gamepad navigation within the window
	WindowFlagsNoNavInputs WindowFlags = 65536
	// No focusing toward this window with keyboard/gamepad navigation (e.g. skipped by CTRL+TAB)
	WindowFlagsNoNavFocus WindowFlags = 131072
	// Display a dot next to the title. When used in a tab/docking context, tab is selected when clicking the X + closure is not assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar.
	WindowFlagsUnsavedDocument WindowFlags = 262144
	// Disable docking of this window
	WindowFlagsNoDocking    WindowFlags = 524288
	WindowFlagsNoNav        WindowFlags = 196608
	WindowFlagsNoDecoration WindowFlags = 43
	WindowFlagsNoInputs     WindowFlags = 197120
	// Don't use! For internal use by Begin()/NewFrame()
	WindowFlagsDockNodeHost WindowFlags = 8388608
	// Don't use! For internal use by BeginChild()
	WindowFlagsChildWindow WindowFlags = 16777216
	// Don't use! For internal use by BeginTooltip()
	WindowFlagsTooltip WindowFlags = 33554432
	// Don't use! For internal use by BeginPopup()
	WindowFlagsPopup WindowFlags = 67108864
	// Don't use! For internal use by BeginPopupModal()
	WindowFlagsModal WindowFlags = 134217728
	// Don't use! For internal use by BeginMenu()
	WindowFlagsChildMenu WindowFlags = 268435456
)

// original name: ImGuiWindowRefreshFlags_
type WindowRefreshFlags int32

const (
	WindowRefreshFlagsNone WindowRefreshFlags = 0
	// [EXPERIMENTAL] Try to keep existing contents, USER MUST NOT HONOR BEGIN() RETURNING FALSE AND NOT APPEND.
	WindowRefreshFlagsTryToAvoidRefresh WindowRefreshFlags = 1
	// [EXPERIMENTAL] Always refresh on hover
	WindowRefreshFlagsRefreshOnHover WindowRefreshFlags = 2
	// [EXPERIMENTAL] Always refresh on focus
	WindowRefreshFlagsRefreshOnFocus WindowRefreshFlags = 4
)

// We intentionally support a limited amount of texture formats to limit burden on CPU-side code and extension.
// Most standard backends only support RGBA32 but we provide a single channel option for low-resource/embedded systems.
// original name: ImTextureFormat
type TextureFormat int32

const (
	// 4 components per pixel, each is unsigned 8-bit. Total size = TexWidth * TexHeight * 4
	TextureFormatRGBA32 TextureFormat = 0
	// 1 component per pixel, each is unsigned 8-bit. Total size = TexWidth * TexHeight
	TextureFormatAlpha8 TextureFormat = 1
)

// Status of a texture to communicate with Renderer Backend.
// original name: ImTextureStatus
type TextureStatus int32

const (
	TextureStatusOK TextureStatus = 0
	// Backend destroyed the texture.
	TextureStatusDestroyed TextureStatus = 1
	// Requesting backend to create the texture. Set status OK when done.
	TextureStatusWantCreate TextureStatus = 2
	// Requesting backend to update specific blocks of pixels (write to texture portions which have never been used before). Set status OK when done.
	TextureStatusWantUpdates TextureStatus = 3
	// Requesting backend to destroy the texture. Set status to Destroyed when done.
	TextureStatusWantDestroy TextureStatus = 4
)
