ReaImGui Documentation

Generated for version 0.9.3.2 · API version 0.9.3

Forum thread · Source repository · Issue tracker

Button
1. Cardinal Directions
2. Flags
Color Edit
1. Flags
  1. User Options
Combo & List
1. Combo Box (Dropdown)
2. List Boxes
3. Selectables
Context
1. Flags
2. Options
Drag & Drop
1. Flags
  1. Payload
  2. Source
Drag & Slider
1. Drag Sliders
2. Flags
3. Regular Sliders
Draw List
1. Primitives
2. Splitter
3. Stateful Path
Font
Function
Image
1. Image Set
Item & Status
1. Dimensions
2. Focus & Activation
3. Hovered Flags
  1. For IsItemHovered
    1. Mouse Hovering Delays
  2. For IsWindowHovered
4. Item/Widgets Utilities and Query Functions
Keyboard & Mouse
1. Keyboard
  1. Named Keys
2. Mouse
  1. Mouse Cursor
3. Shortcuts
  1. Flags
    1. Routing policies
Layout
1. Clipping
2. Layout Cursor Positioning
List Clipper
Menu
Plot
Popup & Modal
1. Flags
2. Open+Begin Combined Helpers
3. Tooltips
Style
1. Colors
2. Variables
Tab Bar
1. Tab Item
Table
1. Background
2. Header & Columns
  1. Column Flags
    1. Input Configuration
    2. Output Status
3. Sorting
4. Table Flags
Text
Text & Scalar Input
1. Flags
2. InputText Callback
Text Filter
Tree Node
1. Flags
Utility
1. Clipboard
2. Color Conversion
3. Conditions
4. ID Stack/Scope
5. Logging/Capture
Viewport
1. Work Area
Window
1. Child Windows
  1. Child Flags
2. Content Region
3. Debug Windows
4. Docking
5. Flags
6. Properties
  1. Focused Flags
  2. Size Callback
7. Scrolling

Button

Most widgets return true when the value has been changed or when pressed/selected.

You may also use one of the many IsItem* functions (e.g. IsItemActive, IsItemHovered, etc.) to query widget state.

Function: ArrowButton

C++	`bool ImGui::ArrowButton(ImGui_Context* ctx, const char* str_id, int dir)`
EEL	`bool ImGui_ArrowButton(ImGui_Context ctx, "str_id", int dir)`
Legacy EEL	`bool extension_api("ImGui_ArrowButton", ImGui_Context ctx, "str_id", int dir)`
Lua	`boolean retval = ImGui.ArrowButton(ImGui_Context ctx, string str_id, integer dir)`
Python	`bool retval = ImGui.ArrowButton(ImGui_Context ctx, str str_id, int dir)`

Square button with an arrow shape. 'dir' is one of the Dir_* values

View source · v0.1+

Function: Button

C++	`bool ImGui::Button(ImGui_Context* ctx, const char* label, double size_wInOptional = 0.0, double size_hInOptional = 0.0)`
EEL	`bool ImGui_Button(ImGui_Context ctx, "label", size_w = 0.0, size_h = 0.0)`
Legacy EEL	`bool extension_api("ImGui_Button", ImGui_Context ctx, "label", size_w = 0.0, size_h = 0.0)`
Lua	`boolean retval = ImGui.Button(ImGui_Context ctx, string label, number size_w = 0.0, number size_h = 0.0)`
Python	`bool retval = ImGui.Button(ImGui_Context ctx, str label, float size_w = 0.0, float size_h = 0.0)`

View source · v0.1+

Function: Checkbox

C++	`bool ImGui::Checkbox(ImGui_Context* ctx, const char* label, bool* vInOut)`
EEL	`bool ImGui_Checkbox(ImGui_Context ctx, "label", bool &v)`
Legacy EEL	`bool extension_api("ImGui_Checkbox", ImGui_Context ctx, "label", bool &v)`
Lua	`boolean retval, boolean v = ImGui.Checkbox(ImGui_Context ctx, string label, boolean v)`
Python	`(bool retval, bool v) = ImGui.Checkbox(ImGui_Context ctx, str label, bool v)`

View source · v0.1+

Function: CheckboxFlags

C++	`bool ImGui::CheckboxFlags(ImGui_Context* ctx, const char* label, int* flagsInOut, int flags_value)`
EEL	`bool ImGui_CheckboxFlags(ImGui_Context ctx, "label", int &flags, int flags_value)`
Legacy EEL	`bool extension_api("ImGui_CheckboxFlags", ImGui_Context ctx, "label", int &flags, int flags_value)`
Lua	`boolean retval, integer flags = ImGui.CheckboxFlags(ImGui_Context ctx, string label, integer flags, integer flags_value)`
Python	`(bool retval, int flags) = ImGui.CheckboxFlags(ImGui_Context ctx, str label, int flags, int flags_value)`

View source · v0.1+

Function: InvisibleButton

C++	`bool ImGui::InvisibleButton(ImGui_Context* ctx, const char* str_id, double size_w, double size_h, int flagsInOptional = ButtonFlags_None)`
EEL	`bool ImGui_InvisibleButton(ImGui_Context ctx, "str_id", size_w, size_h, int flags = ButtonFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InvisibleButton", ImGui_Context ctx, "str_id", size_w, size_h, int flags = ButtonFlags_None)`
Lua	`boolean retval = ImGui.InvisibleButton(ImGui_Context ctx, string str_id, number size_w, number size_h, integer flags = ButtonFlags_None)`
Python	`bool retval = ImGui.InvisibleButton(ImGui_Context ctx, str str_id, float size_w, float size_h, int flags = ButtonFlags_None)`

Flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.).

View source · v0.1+

Function: PopButtonRepeat

C++	`void ImGui::PopButtonRepeat(ImGui_Context* ctx)`
EEL	`ImGui_PopButtonRepeat(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopButtonRepeat", ImGui_Context ctx)`
Lua	`ImGui.PopButtonRepeat(ImGui_Context ctx)`
Python	`ImGui.PopButtonRepeat(ImGui_Context ctx)`

See PushButtonRepeat

View source · v0.1+

Function: PushButtonRepeat

C++	`void ImGui::PushButtonRepeat(ImGui_Context* ctx, bool repeat)`
EEL	`ImGui_PushButtonRepeat(ImGui_Context ctx, bool repeat)`
Legacy EEL	`extension_api("ImGui_PushButtonRepeat", ImGui_Context ctx, bool repeat)`
Lua	`ImGui.PushButtonRepeat(ImGui_Context ctx, boolean repeat)`
Python	`ImGui.PushButtonRepeat(ImGui_Context ctx, bool repeat)`

In 'repeat' mode, Button*() functions return repeated true in a typematic manner (using ConfigVar_KeyRepeatDelay/ConfigVar_KeyRepeatRate settings).

Note that you can call IsItemActive after any Button to tell if the button is held in the current frame.

View source · v0.1+

Function: RadioButton

C++	`bool ImGui::RadioButton(ImGui_Context* ctx, const char* label, bool active)`
EEL	`bool ImGui_RadioButton(ImGui_Context ctx, "label", bool active)`
Legacy EEL	`bool extension_api("ImGui_RadioButton", ImGui_Context ctx, "label", bool active)`
Lua	`boolean retval = ImGui.RadioButton(ImGui_Context ctx, string label, boolean active)`
Python	`bool retval = ImGui.RadioButton(ImGui_Context ctx, str label, bool active)`

Use with e.g. if (RadioButton("one", my_value==1)) { my_value = 1; }

View source · v0.1+

Function: RadioButtonEx

C++	`bool ImGui::RadioButtonEx(ImGui_Context* ctx, const char* label, int* vInOut, int v_button)`
EEL	`bool ImGui_RadioButtonEx(ImGui_Context ctx, "label", int &v, int v_button)`
Legacy EEL	`bool extension_api("ImGui_RadioButtonEx", ImGui_Context ctx, "label", int &v, int v_button)`
Lua	`boolean retval, integer v = ImGui.RadioButtonEx(ImGui_Context ctx, string label, integer v, integer v_button)`
Python	`(bool retval, int v) = ImGui.RadioButtonEx(ImGui_Context ctx, str label, int v, int v_button)`

Shortcut to handle RadioButton's example pattern when value is an integer

View source · v0.1+

Function: SmallButton

C++	`bool ImGui::SmallButton(ImGui_Context* ctx, const char* label)`
EEL	`bool ImGui_SmallButton(ImGui_Context ctx, "label")`
Legacy EEL	`bool extension_api("ImGui_SmallButton", ImGui_Context ctx, "label")`
Lua	`boolean retval = ImGui.SmallButton(ImGui_Context ctx, string label)`
Python	`bool retval = ImGui.SmallButton(ImGui_Context ctx, str label)`

Button with StyleVar_FramePadding.y == 0 to easily embed within text.

View source · v0.1+

Cardinal Directions

For ArrowButton.

Constant: Dir_Down

C++	`int ImGui::Dir_Down`
EEL	`int ImGui_Dir_Down()`
Legacy EEL	`int extension_api("ImGui_Dir_Down")`
Lua	`integer ImGui.Dir_Down`
Python	`int retval = ImGui.Dir_Down()`

View source · v0.1+

Constant: Dir_Left

C++	`int ImGui::Dir_Left`
EEL	`int ImGui_Dir_Left()`
Legacy EEL	`int extension_api("ImGui_Dir_Left")`
Lua	`integer ImGui.Dir_Left`
Python	`int retval = ImGui.Dir_Left()`

View source · v0.1+

Constant: Dir_None

C++	`int ImGui::Dir_None`
EEL	`int ImGui_Dir_None()`
Legacy EEL	`int extension_api("ImGui_Dir_None")`
Lua	`integer ImGui.Dir_None`
Python	`int retval = ImGui.Dir_None()`

View source · v0.1+

Constant: Dir_Right

C++	`int ImGui::Dir_Right`
EEL	`int ImGui_Dir_Right()`
Legacy EEL	`int extension_api("ImGui_Dir_Right")`
Lua	`integer ImGui.Dir_Right`
Python	`int retval = ImGui.Dir_Right()`

View source · v0.1+

Constant: Dir_Up

C++	`int ImGui::Dir_Up`
EEL	`int ImGui_Dir_Up()`
Legacy EEL	`int extension_api("ImGui_Dir_Up")`
Lua	`integer ImGui.Dir_Up`
Python	`int retval = ImGui.Dir_Up()`

View source · v0.1+

Flags

For InvisibleButton.

Constant: ButtonFlags_MouseButtonLeft

C++	`int ImGui::ButtonFlags_MouseButtonLeft`
EEL	`int ImGui_ButtonFlags_MouseButtonLeft()`
Legacy EEL	`int extension_api("ImGui_ButtonFlags_MouseButtonLeft")`
Lua	`integer ImGui.ButtonFlags_MouseButtonLeft`
Python	`int retval = ImGui.ButtonFlags_MouseButtonLeft()`

React on left mouse button (default).

View source · v0.1+

Constant: ButtonFlags_MouseButtonMiddle

C++	`int ImGui::ButtonFlags_MouseButtonMiddle`
EEL	`int ImGui_ButtonFlags_MouseButtonMiddle()`
Legacy EEL	`int extension_api("ImGui_ButtonFlags_MouseButtonMiddle")`
Lua	`integer ImGui.ButtonFlags_MouseButtonMiddle`
Python	`int retval = ImGui.ButtonFlags_MouseButtonMiddle()`

React on center mouse button.

View source · v0.1+

Constant: ButtonFlags_MouseButtonRight

C++	`int ImGui::ButtonFlags_MouseButtonRight`
EEL	`int ImGui_ButtonFlags_MouseButtonRight()`
Legacy EEL	`int extension_api("ImGui_ButtonFlags_MouseButtonRight")`
Lua	`integer ImGui.ButtonFlags_MouseButtonRight`
Python	`int retval = ImGui.ButtonFlags_MouseButtonRight()`

React on right mouse button.

View source · v0.1+

Constant: ButtonFlags_None

C++	`int ImGui::ButtonFlags_None`
EEL	`int ImGui_ButtonFlags_None()`
Legacy EEL	`int extension_api("ImGui_ButtonFlags_None")`
Lua	`integer ImGui.ButtonFlags_None`
Python	`int retval = ImGui.ButtonFlags_None()`

View source · v0.1+

Color Edit

Tip: the ColorEdit* functions have a little color square that can be left-clicked to open a picker, and right-clicked to open an option menu.

Function: ColorButton

C++	`bool ImGui::ColorButton(ImGui_Context* ctx, const char* desc_id, int col_rgba, int flagsInOptional = ColorEditFlags_None, double size_wInOptional = 0.0, double size_hInOptional = 0.0)`
EEL	`bool ImGui_ColorButton(ImGui_Context ctx, "desc_id", int col_rgba, int flags = ColorEditFlags_None, size_w = 0.0, size_h = 0.0)`
Legacy EEL	`bool extension_api("ImGui_ColorButton", ImGui_Context ctx, "desc_id", int col_rgba, int flags = ColorEditFlags_None, size_w = 0.0, size_h = 0.0)`
Lua	`boolean retval = ImGui.ColorButton(ImGui_Context ctx, string desc_id, integer col_rgba, integer flags = ColorEditFlags_None, number size_w = 0.0, number size_h = 0.0)`
Python	`bool retval = ImGui.ColorButton(ImGui_Context ctx, str desc_id, int col_rgba, int flags = ColorEditFlags_None, float size_w = 0.0, float size_h = 0.0)`

Display a color square/button, hover for details, return true when pressed. Color is in 0xRRGGBBAA or, if ColorEditFlags_NoAlpha is set, 0xRRGGBB.

View source · v0.1+

Function: ColorEdit3

C++	`bool ImGui::ColorEdit3(ImGui_Context* ctx, const char* label, int* col_rgbInOut, int flagsInOptional = ColorEditFlags_None)`
EEL	`bool ImGui_ColorEdit3(ImGui_Context ctx, "label", int &col_rgb, int flags = ColorEditFlags_None)`
Legacy EEL	`bool extension_api("ImGui_ColorEdit3", ImGui_Context ctx, "label", int &col_rgb, int flags = ColorEditFlags_None)`
Lua	`boolean retval, integer col_rgb = ImGui.ColorEdit3(ImGui_Context ctx, string label, integer col_rgb, integer flags = ColorEditFlags_None)`
Python	`(bool retval, int col_rgb) = ImGui.ColorEdit3(ImGui_Context ctx, str label, int col_rgb, int flags = ColorEditFlags_None)`

Color is in 0xXXRRGGBB. XX is ignored and will not be modified.

View source · v0.1+

Function: ColorEdit4

C++	`bool ImGui::ColorEdit4(ImGui_Context* ctx, const char* label, int* col_rgbaInOut, int flagsInOptional = ColorEditFlags_None)`
EEL	`bool ImGui_ColorEdit4(ImGui_Context ctx, "label", int &col_rgba, int flags = ColorEditFlags_None)`
Legacy EEL	`bool extension_api("ImGui_ColorEdit4", ImGui_Context ctx, "label", int &col_rgba, int flags = ColorEditFlags_None)`
Lua	`boolean retval, integer col_rgba = ImGui.ColorEdit4(ImGui_Context ctx, string label, integer col_rgba, integer flags = ColorEditFlags_None)`
Python	`(bool retval, int col_rgba) = ImGui.ColorEdit4(ImGui_Context ctx, str label, int col_rgba, int flags = ColorEditFlags_None)`

Color is in 0xRRGGBBAA or, if ColorEditFlags_NoAlpha is set, 0xXXRRGGBB (XX is ignored and will not be modified).

View source · v0.1+

Function: ColorPicker3

C++	`bool ImGui::ColorPicker3(ImGui_Context* ctx, const char* label, int* col_rgbInOut, int flagsInOptional = ColorEditFlags_None)`
EEL	`bool ImGui_ColorPicker3(ImGui_Context ctx, "label", int &col_rgb, int flags = ColorEditFlags_None)`
Legacy EEL	`bool extension_api("ImGui_ColorPicker3", ImGui_Context ctx, "label", int &col_rgb, int flags = ColorEditFlags_None)`
Lua	`boolean retval, integer col_rgb = ImGui.ColorPicker3(ImGui_Context ctx, string label, integer col_rgb, integer flags = ColorEditFlags_None)`
Python	`(bool retval, int col_rgb) = ImGui.ColorPicker3(ImGui_Context ctx, str label, int col_rgb, int flags = ColorEditFlags_None)`

Color is in 0xXXRRGGBB. XX is ignored and will not be modified.

View source · v0.1+

Function: ColorPicker4

C++	`bool ImGui::ColorPicker4(ImGui_Context* ctx, const char* label, int* col_rgbaInOut, int flagsInOptional = ColorEditFlags_None, int ref_colInOptional = nullptr)`
EEL	`bool ImGui_ColorPicker4(ImGui_Context ctx, "label", int &col_rgba, int flags = ColorEditFlags_None, int ref_col = 0)`
Legacy EEL	`bool extension_api("ImGui_ColorPicker4", ImGui_Context ctx, "label", int &col_rgba, int flags = ColorEditFlags_None, int ref_col = 0)`
Lua	`boolean retval, integer col_rgba = ImGui.ColorPicker4(ImGui_Context ctx, string label, integer col_rgba, integer flags = ColorEditFlags_None, integer ref_col = nil)`
Python	`(bool retval, int col_rgba) = ImGui.ColorPicker4(ImGui_Context ctx, str label, int col_rgba, int flags = ColorEditFlags_None, int ref_col = None)`

View source · v0.1+

Function: SetColorEditOptions

C++	`void ImGui::SetColorEditOptions(ImGui_Context* ctx, int flags)`
EEL	`ImGui_SetColorEditOptions(ImGui_Context ctx, int flags)`
Legacy EEL	`extension_api("ImGui_SetColorEditOptions", ImGui_Context ctx, int flags)`
Lua	`ImGui.SetColorEditOptions(ImGui_Context ctx, integer flags)`
Python	`ImGui.SetColorEditOptions(ImGui_Context ctx, int flags)`

Picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls.

View source · v0.1+

Flags

Constant: ColorEditFlags_NoAlpha

C++	`int ImGui::ColorEditFlags_NoAlpha`
EEL	`int ImGui_ColorEditFlags_NoAlpha()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoAlpha")`
Lua	`integer ImGui.ColorEditFlags_NoAlpha`
Python	`int retval = ImGui.ColorEditFlags_NoAlpha()`

ColorEdit, ColorPicker, ColorButton: ignore Alpha component (will only read 3 components from the input pointer).

View source · v0.1+

Constant: ColorEditFlags_NoBorder

C++	`int ImGui::ColorEditFlags_NoBorder`
EEL	`int ImGui_ColorEditFlags_NoBorder()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoBorder")`
Lua	`integer ImGui.ColorEditFlags_NoBorder`
Python	`int retval = ImGui.ColorEditFlags_NoBorder()`

ColorButton: disable border (which is enforced by default).

View source · v0.1+

Constant: ColorEditFlags_NoDragDrop

C++	`int ImGui::ColorEditFlags_NoDragDrop`
EEL	`int ImGui_ColorEditFlags_NoDragDrop()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoDragDrop")`
Lua	`integer ImGui.ColorEditFlags_NoDragDrop`
Python	`int retval = ImGui.ColorEditFlags_NoDragDrop()`

ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source.

View source · v0.1+

Constant: ColorEditFlags_NoInputs

C++	`int ImGui::ColorEditFlags_NoInputs`
EEL	`int ImGui_ColorEditFlags_NoInputs()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoInputs")`
Lua	`integer ImGui.ColorEditFlags_NoInputs`
Python	`int retval = ImGui.ColorEditFlags_NoInputs()`

ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview color square).

View source · v0.1+

Constant: ColorEditFlags_NoLabel

C++	`int ImGui::ColorEditFlags_NoLabel`
EEL	`int ImGui_ColorEditFlags_NoLabel()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoLabel")`
Lua	`integer ImGui.ColorEditFlags_NoLabel`
Python	`int retval = ImGui.ColorEditFlags_NoLabel()`

ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker).

View source · v0.1+

Constant: ColorEditFlags_NoOptions

C++	`int ImGui::ColorEditFlags_NoOptions`
EEL	`int ImGui_ColorEditFlags_NoOptions()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoOptions")`
Lua	`integer ImGui.ColorEditFlags_NoOptions`
Python	`int retval = ImGui.ColorEditFlags_NoOptions()`

ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.

View source · v0.1+

Constant: ColorEditFlags_NoPicker

C++	`int ImGui::ColorEditFlags_NoPicker`
EEL	`int ImGui_ColorEditFlags_NoPicker()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoPicker")`
Lua	`integer ImGui.ColorEditFlags_NoPicker`
Python	`int retval = ImGui.ColorEditFlags_NoPicker()`

ColorEdit: disable picker when clicking on color square.

View source · v0.1+

Constant: ColorEditFlags_NoSidePreview

C++	`int ImGui::ColorEditFlags_NoSidePreview`
EEL	`int ImGui_ColorEditFlags_NoSidePreview()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoSidePreview")`
Lua	`integer ImGui.ColorEditFlags_NoSidePreview`
Python	`int retval = ImGui.ColorEditFlags_NoSidePreview()`

ColorPicker: disable bigger color preview on right side of the picker, use small color square preview instead.

View source · v0.1+

Constant: ColorEditFlags_NoSmallPreview

C++	`int ImGui::ColorEditFlags_NoSmallPreview`
EEL	`int ImGui_ColorEditFlags_NoSmallPreview()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoSmallPreview")`
Lua	`integer ImGui.ColorEditFlags_NoSmallPreview`
Python	`int retval = ImGui.ColorEditFlags_NoSmallPreview()`

ColorEdit, ColorPicker: disable color square preview next to the inputs. (e.g. to show only the inputs).

View source · v0.1+

Constant: ColorEditFlags_NoTooltip

C++	`int ImGui::ColorEditFlags_NoTooltip`
EEL	`int ImGui_ColorEditFlags_NoTooltip()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_NoTooltip")`
Lua	`integer ImGui.ColorEditFlags_NoTooltip`
Python	`int retval = ImGui.ColorEditFlags_NoTooltip()`

ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.

View source · v0.1+

Constant: ColorEditFlags_None

C++	`int ImGui::ColorEditFlags_None`
EEL	`int ImGui_ColorEditFlags_None()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_None")`
Lua	`integer ImGui.ColorEditFlags_None`
Python	`int retval = ImGui.ColorEditFlags_None()`

View source · v0.1+

User Options

(right-click on widget to change some of them)

Constant: ColorEditFlags_AlphaBar

C++	`int ImGui::ColorEditFlags_AlphaBar`
EEL	`int ImGui_ColorEditFlags_AlphaBar()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_AlphaBar")`
Lua	`integer ImGui.ColorEditFlags_AlphaBar`
Python	`int retval = ImGui.ColorEditFlags_AlphaBar()`

ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.

View source · v0.1+

Constant: ColorEditFlags_AlphaPreview

C++	`int ImGui::ColorEditFlags_AlphaPreview`
EEL	`int ImGui_ColorEditFlags_AlphaPreview()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_AlphaPreview")`
Lua	`integer ImGui.ColorEditFlags_AlphaPreview`
Python	`int retval = ImGui.ColorEditFlags_AlphaPreview()`

ColorEdit, ColorPicker, ColorButton: display preview as a transparent color over a checkerboard, instead of opaque.

View source · v0.1+

Constant: ColorEditFlags_AlphaPreviewHalf

C++	`int ImGui::ColorEditFlags_AlphaPreviewHalf`
EEL	`int ImGui_ColorEditFlags_AlphaPreviewHalf()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_AlphaPreviewHalf")`
Lua	`integer ImGui.ColorEditFlags_AlphaPreviewHalf`
Python	`int retval = ImGui.ColorEditFlags_AlphaPreviewHalf()`

ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard, instead of opaque.

View source · v0.1+

Constant: ColorEditFlags_DisplayHSV

C++	`int ImGui::ColorEditFlags_DisplayHSV`
EEL	`int ImGui_ColorEditFlags_DisplayHSV()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_DisplayHSV")`
Lua	`integer ImGui.ColorEditFlags_DisplayHSV`
Python	`int retval = ImGui.ColorEditFlags_DisplayHSV()`

ColorEdit: override display type to HSV. ColorPicker: select any combination using one or more of RGB/HSV/Hex.

View source · v0.1+

Constant: ColorEditFlags_DisplayHex

C++	`int ImGui::ColorEditFlags_DisplayHex`
EEL	`int ImGui_ColorEditFlags_DisplayHex()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_DisplayHex")`
Lua	`integer ImGui.ColorEditFlags_DisplayHex`
Python	`int retval = ImGui.ColorEditFlags_DisplayHex()`

ColorEdit: override display type to Hex. ColorPicker: select any combination using one or more of RGB/HSV/Hex.

View source · v0.1+

Constant: ColorEditFlags_DisplayRGB

C++	`int ImGui::ColorEditFlags_DisplayRGB`
EEL	`int ImGui_ColorEditFlags_DisplayRGB()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_DisplayRGB")`
Lua	`integer ImGui.ColorEditFlags_DisplayRGB`
Python	`int retval = ImGui.ColorEditFlags_DisplayRGB()`

ColorEdit: override display type to RGB. ColorPicker: select any combination using one or more of RGB/HSV/Hex.

View source · v0.1+

Constant: ColorEditFlags_Float

C++	`int ImGui::ColorEditFlags_Float`
EEL	`int ImGui_ColorEditFlags_Float()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_Float")`
Lua	`integer ImGui.ColorEditFlags_Float`
Python	`int retval = ImGui.ColorEditFlags_Float()`

ColorEdit, ColorPicker, ColorButton: display values formatted as 0.0..1.0 floats instead of 0..255 integers. No round-trip of value via integers.

View source · v0.1+

Constant: ColorEditFlags_InputHSV

C++	`int ImGui::ColorEditFlags_InputHSV`
EEL	`int ImGui_ColorEditFlags_InputHSV()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_InputHSV")`
Lua	`integer ImGui.ColorEditFlags_InputHSV`
Python	`int retval = ImGui.ColorEditFlags_InputHSV()`

ColorEdit, ColorPicker: input and output data in HSV format.

View source · v0.1+

Constant: ColorEditFlags_InputRGB

C++	`int ImGui::ColorEditFlags_InputRGB`
EEL	`int ImGui_ColorEditFlags_InputRGB()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_InputRGB")`
Lua	`integer ImGui.ColorEditFlags_InputRGB`
Python	`int retval = ImGui.ColorEditFlags_InputRGB()`

ColorEdit, ColorPicker: input and output data in RGB format.

View source · v0.1+

Constant: ColorEditFlags_PickerHueBar

C++	`int ImGui::ColorEditFlags_PickerHueBar`
EEL	`int ImGui_ColorEditFlags_PickerHueBar()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_PickerHueBar")`
Lua	`integer ImGui.ColorEditFlags_PickerHueBar`
Python	`int retval = ImGui.ColorEditFlags_PickerHueBar()`

ColorPicker: bar for Hue, rectangle for Sat/Value.

View source · v0.1+

Constant: ColorEditFlags_PickerHueWheel

C++	`int ImGui::ColorEditFlags_PickerHueWheel`
EEL	`int ImGui_ColorEditFlags_PickerHueWheel()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_PickerHueWheel")`
Lua	`integer ImGui.ColorEditFlags_PickerHueWheel`
Python	`int retval = ImGui.ColorEditFlags_PickerHueWheel()`

ColorPicker: wheel for Hue, triangle for Sat/Value.

View source · v0.1+

Constant: ColorEditFlags_Uint8

C++	`int ImGui::ColorEditFlags_Uint8`
EEL	`int ImGui_ColorEditFlags_Uint8()`
Legacy EEL	`int extension_api("ImGui_ColorEditFlags_Uint8")`
Lua	`integer ImGui.ColorEditFlags_Uint8`
Python	`int retval = ImGui.ColorEditFlags_Uint8()`

ColorEdit, ColorPicker, ColorButton: display values formatted as 0..255.

View source · v0.1+

Combo & List

Function: BeginCombo

C++	`bool ImGui::BeginCombo(ImGui_Context* ctx, const char* label, const char* preview_value, int flagsInOptional = ComboFlags_None)`
EEL	`bool ImGui_BeginCombo(ImGui_Context ctx, "label", "preview_value", int flags = ComboFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginCombo", ImGui_Context ctx, "label", "preview_value", int flags = ComboFlags_None)`
Lua	`boolean retval = ImGui.BeginCombo(ImGui_Context ctx, string label, string preview_value, integer flags = ComboFlags_None)`
Python	`bool retval = ImGui.BeginCombo(ImGui_Context ctx, str label, str preview_value, int flags = ComboFlags_None)`

The BeginCombo/EndCombo API allows you to manage your contents and selection state however you want it, by creating e.g. Selectable items.

View source · v0.1+

Function: Combo

C++	`bool ImGui::Combo(ImGui_Context* ctx, const char* label, int* current_itemInOut, const char* items, int items_sz, int popup_max_height_in_itemsInOptional = -1)`
EEL	`bool ImGui_Combo(ImGui_Context ctx, "label", int &current_item, "items", int popup_max_height_in_items = -1)`
Legacy EEL	`bool extension_api("ImGui_Combo", ImGui_Context ctx, "label", int &current_item, "items", int popup_max_height_in_items = -1)`
Lua	`boolean retval, integer current_item = ImGui.Combo(ImGui_Context ctx, string label, integer current_item, string items, integer popup_max_height_in_items = -1)`
Python	`(bool retval, int current_item) = ImGui.Combo(ImGui_Context ctx, str label, int current_item, str items, int popup_max_height_in_items = -1)`

Helper over BeginCombo/EndCombo for convenience purpose. Each item must be null-terminated (requires REAPER v6.44 or newer for EEL and Lua).

View source · v0.7+

Constant: ComboFlags_HeightLarge

C++	`int ImGui::ComboFlags_HeightLarge`
EEL	`int ImGui_ComboFlags_HeightLarge()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_HeightLarge")`
Lua	`integer ImGui.ComboFlags_HeightLarge`
Python	`int retval = ImGui.ComboFlags_HeightLarge()`

Max ~20 items visible.

View source · v0.1+

Constant: ComboFlags_HeightLargest

C++	`int ImGui::ComboFlags_HeightLargest`
EEL	`int ImGui_ComboFlags_HeightLargest()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_HeightLargest")`
Lua	`integer ImGui.ComboFlags_HeightLargest`
Python	`int retval = ImGui.ComboFlags_HeightLargest()`

As many fitting items as possible.

View source · v0.1+

Constant: ComboFlags_HeightRegular

C++	`int ImGui::ComboFlags_HeightRegular`
EEL	`int ImGui_ComboFlags_HeightRegular()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_HeightRegular")`
Lua	`integer ImGui.ComboFlags_HeightRegular`
Python	`int retval = ImGui.ComboFlags_HeightRegular()`

Max ~8 items visible (default).

View source · v0.1+

Constant: ComboFlags_HeightSmall

C++	`int ImGui::ComboFlags_HeightSmall`
EEL	`int ImGui_ComboFlags_HeightSmall()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_HeightSmall")`
Lua	`integer ImGui.ComboFlags_HeightSmall`
Python	`int retval = ImGui.ComboFlags_HeightSmall()`

Max ~4 items visible. Tip: If you want your combo popup to be a specific size you can use SetNextWindowSizeConstraints prior to calling BeginCombo.

View source · v0.1+

Constant: ComboFlags_NoArrowButton

C++	`int ImGui::ComboFlags_NoArrowButton`
EEL	`int ImGui_ComboFlags_NoArrowButton()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_NoArrowButton")`
Lua	`integer ImGui.ComboFlags_NoArrowButton`
Python	`int retval = ImGui.ComboFlags_NoArrowButton()`

Display on the preview box without the square arrow button.

View source · v0.1+

Constant: ComboFlags_NoPreview

C++	`int ImGui::ComboFlags_NoPreview`
EEL	`int ImGui_ComboFlags_NoPreview()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_NoPreview")`
Lua	`integer ImGui.ComboFlags_NoPreview`
Python	`int retval = ImGui.ComboFlags_NoPreview()`

Display only a square arrow button.

View source · v0.1+

Constant: ComboFlags_None

C++	`int ImGui::ComboFlags_None`
EEL	`int ImGui_ComboFlags_None()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_None")`
Lua	`integer ImGui.ComboFlags_None`
Python	`int retval = ImGui.ComboFlags_None()`

View source · v0.1+

Constant: ComboFlags_PopupAlignLeft

C++	`int ImGui::ComboFlags_PopupAlignLeft`
EEL	`int ImGui_ComboFlags_PopupAlignLeft()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_PopupAlignLeft")`
Lua	`integer ImGui.ComboFlags_PopupAlignLeft`
Python	`int retval = ImGui.ComboFlags_PopupAlignLeft()`

Align the popup toward the left by default.

View source · v0.1+

Constant: ComboFlags_WidthFitPreview

C++	`int ImGui::ComboFlags_WidthFitPreview`
EEL	`int ImGui_ComboFlags_WidthFitPreview()`
Legacy EEL	`int extension_api("ImGui_ComboFlags_WidthFitPreview")`
Lua	`integer ImGui.ComboFlags_WidthFitPreview`
Python	`int retval = ImGui.ComboFlags_WidthFitPreview()`

Width dynamically calculated from preview contents.

View source · v0.9+

Function: EndCombo

C++	`void ImGui::EndCombo(ImGui_Context* ctx)`
EEL	`ImGui_EndCombo(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndCombo", ImGui_Context ctx)`
Lua	`ImGui.EndCombo(ImGui_Context ctx)`
Python	`ImGui.EndCombo(ImGui_Context ctx)`

Only call EndCombo() if BeginCombo returns true!

View source · v0.1+

List Boxes

This is essentially a thin wrapper to using BeginChild/EndChild with the ChildFlags_FrameStyle flag for stylistic changes + displaying a label.

Function: BeginListBox

C++	`bool ImGui::BeginListBox(ImGui_Context* ctx, const char* label, double size_wInOptional = 0.0, double size_hInOptional = 0.0)`
EEL	`bool ImGui_BeginListBox(ImGui_Context ctx, "label", size_w = 0.0, size_h = 0.0)`
Legacy EEL	`bool extension_api("ImGui_BeginListBox", ImGui_Context ctx, "label", size_w = 0.0, size_h = 0.0)`
Lua	`boolean retval = ImGui.BeginListBox(ImGui_Context ctx, string label, number size_w = 0.0, number size_h = 0.0)`
Python	`bool retval = ImGui.BeginListBox(ImGui_Context ctx, str label, float size_w = 0.0, float size_h = 0.0)`

Open a framed scrolling region.

You can submit contents and manage your selection state however you want it, by creating e.g. Selectable or any other items.

Choose frame width:
- width > 0.0: custom
- width < 0.0 or -FLT_MIN: right-align
- width = 0.0 (default): use current ItemWidth
Choose frame height:
- height > 0.0: custom
- height < 0.0 or -FLT_MIN: bottom-align
- height = 0.0 (default): arbitrary default height which can fit ~7 items

See EndListBox.

View source · v0.1+

Function: EndListBox

C++	`void ImGui::EndListBox(ImGui_Context* ctx)`
EEL	`ImGui_EndListBox(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndListBox", ImGui_Context ctx)`
Lua	`ImGui.EndListBox(ImGui_Context ctx)`
Python	`ImGui.EndListBox(ImGui_Context ctx)`

Only call EndListBox() if BeginListBox returned true!

View source · v0.1+

Function: ListBox

C++	`bool ImGui::ListBox(ImGui_Context* ctx, const char* label, int* current_itemInOut, const char* items, int items_sz, int height_in_itemsInOptional = -1)`
EEL	`bool ImGui_ListBox(ImGui_Context ctx, "label", int &current_item, "items", int height_in_items = -1)`
Legacy EEL	`bool extension_api("ImGui_ListBox", ImGui_Context ctx, "label", int &current_item, "items", int height_in_items = -1)`
Lua	`boolean retval, integer current_item = ImGui.ListBox(ImGui_Context ctx, string label, integer current_item, string items, integer height_in_items = -1)`
Python	`(bool retval, int current_item) = ImGui.ListBox(ImGui_Context ctx, str label, int current_item, str items, int height_in_items = -1)`

This is an helper over BeginListBox/EndListBox for convenience purpose.

Each item must be null-terminated (requires REAPER v6.44 or newer for EEL and Lua).

View source · v0.7+

Selectables

A selectable highlights when hovered, and can display another color when selected. Neighbors selectable extend their highlight bounds in order to leave no gap between them. This is so a series of selected Selectable appear contiguous.

Function: Selectable

C++	`bool ImGui::Selectable(ImGui_Context* ctx, const char* label, bool* p_selectedInOutOptional = nullptr, int flagsInOptional = SelectableFlags_None, double size_wInOptional = 0.0, double size_hInOptional = 0.0)`
EEL	`bool ImGui_Selectable(ImGui_Context ctx, "label", bool &p_selected = 0, int flags = SelectableFlags_None, size_w = 0.0, size_h = 0.0)`
Legacy EEL	`bool extension_api("ImGui_Selectable", ImGui_Context ctx, "label", bool &p_selected = 0, int flags = SelectableFlags_None, size_w = 0.0, size_h = 0.0)`
Lua	`boolean retval, boolean p_selected = ImGui.Selectable(ImGui_Context ctx, string label, boolean p_selected = nil, integer flags = SelectableFlags_None, number size_w = 0.0, number size_h = 0.0)`
Python	`(bool retval, bool p_selected) = ImGui.Selectable(ImGui_Context ctx, str label, bool p_selected = None, int flags = SelectableFlags_None, float size_w = 0.0, float size_h = 0.0)`

View source · v0.1+

Constant: SelectableFlags_AllowDoubleClick

C++	`int ImGui::SelectableFlags_AllowDoubleClick`
EEL	`int ImGui_SelectableFlags_AllowDoubleClick()`
Legacy EEL	`int extension_api("ImGui_SelectableFlags_AllowDoubleClick")`
Lua	`integer ImGui.SelectableFlags_AllowDoubleClick`
Python	`int retval = ImGui.SelectableFlags_AllowDoubleClick()`

Generate press events on double clicks too.

View source · v0.1+

Constant: SelectableFlags_AllowOverlap

C++	`int ImGui::SelectableFlags_AllowOverlap`
EEL	`int ImGui_SelectableFlags_AllowOverlap()`
Legacy EEL	`int extension_api("ImGui_SelectableFlags_AllowOverlap")`
Lua	`integer ImGui.SelectableFlags_AllowOverlap`
Python	`int retval = ImGui.SelectableFlags_AllowOverlap()`

Hit testing to allow subsequent widgets to overlap this one.

View source · v0.9+

Constant: SelectableFlags_Disabled

C++	`int ImGui::SelectableFlags_Disabled`
EEL	`int ImGui_SelectableFlags_Disabled()`
Legacy EEL	`int extension_api("ImGui_SelectableFlags_Disabled")`
Lua	`integer ImGui.SelectableFlags_Disabled`
Python	`int retval = ImGui.SelectableFlags_Disabled()`

Cannot be selected, display grayed out text.

View source · v0.1+

Constant: SelectableFlags_DontClosePopups

C++	`int ImGui::SelectableFlags_DontClosePopups`
EEL	`int ImGui_SelectableFlags_DontClosePopups()`
Legacy EEL	`int extension_api("ImGui_SelectableFlags_DontClosePopups")`
Lua	`integer ImGui.SelectableFlags_DontClosePopups`
Python	`int retval = ImGui.SelectableFlags_DontClosePopups()`

Clicking this doesn't close parent popup window.

View source · v0.1+

Constant: SelectableFlags_None

C++	`int ImGui::SelectableFlags_None`
EEL	`int ImGui_SelectableFlags_None()`
Legacy EEL	`int extension_api("ImGui_SelectableFlags_None")`
Lua	`integer ImGui.SelectableFlags_None`
Python	`int retval = ImGui.SelectableFlags_None()`

View source · v0.1+

Constant: SelectableFlags_SpanAllColumns

C++	`int ImGui::SelectableFlags_SpanAllColumns`
EEL	`int ImGui_SelectableFlags_SpanAllColumns()`
Legacy EEL	`int extension_api("ImGui_SelectableFlags_SpanAllColumns")`
Lua	`integer ImGui.SelectableFlags_SpanAllColumns`
Python	`int retval = ImGui.SelectableFlags_SpanAllColumns()`

Frame will span all columns of its container table (text will still fit in current column).

View source · v0.1+

Context

Function: Attach

C++	`void ImGui::Attach(ImGui_Context* ctx, ImGui_Resource* obj)`
EEL	`ImGui_Attach(ImGui_Context ctx, ImGui_Resource obj)`
Legacy EEL	`extension_api("ImGui_Attach", ImGui_Context ctx, ImGui_Resource obj)`
Lua	`ImGui.Attach(ImGui_Context ctx, ImGui_Resource obj)`
Python	`ImGui.Attach(ImGui_Context ctx, ImGui_Resource obj)`

Link the object's lifetime to the given context. Objects can be draw list splitters, fonts, images, list clippers, etc. Call Detach to let the object be garbage-collected after unuse again.

List clipper objects may only be attached to the context they were created for.

Fonts are (currently) a special case: they must be attached to the context before usage. Furthermore, fonts may only be attached or detached immediately after the context is created or before any other function calls modifying the context per defer cycle. See "limitations" in the font API documentation.

View source · v0.8+

Function: CreateContext

C++	`ImGui_Context* ImGui::CreateContext(const char* label, int config_flagsInOptional = ConfigFlags_None)`
EEL	`ImGui_Context* ImGui_CreateContext("label", int config_flags = ConfigFlags_None)`
Legacy EEL	`ImGui_Context* extension_api("ImGui_CreateContext", "label", int config_flags = ConfigFlags_None)`
Lua	`ImGui_Context retval = ImGui.CreateContext(string label, integer config_flags = ConfigFlags_None)`
Python	`ImGui_Context retval = ImGui.CreateContext(str label, int config_flags = ConfigFlags_None)`

Create a new ReaImGui context. The context will remain valid as long as it is used in each defer cycle.

The label is used for the tab text when windows are docked in REAPER and also as a unique identifier for storing settings.

View source · v0.5+

Function: Detach

C++	`void ImGui::Detach(ImGui_Context* ctx, ImGui_Resource* obj)`
EEL	`ImGui_Detach(ImGui_Context ctx, ImGui_Resource obj)`
Legacy EEL	`extension_api("ImGui_Detach", ImGui_Context ctx, ImGui_Resource obj)`
Lua	`ImGui.Detach(ImGui_Context ctx, ImGui_Resource obj)`
Python	`ImGui.Detach(ImGui_Context ctx, ImGui_Resource obj)`

Unlink the object's lifetime. Unattached objects are automatically destroyed when left unused. You may check whether an object has been destroyed using ValidatePtr.

View source · v0.8+

Function: GetDeltaTime

C++	`double ImGui::GetDeltaTime(ImGui_Context* ctx)`
EEL	`double ImGui_GetDeltaTime(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetDeltaTime", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetDeltaTime(ImGui_Context ctx)`
Python	`float retval = ImGui.GetDeltaTime(ImGui_Context ctx)`

Time elapsed since last frame, in seconds.

View source · v0.1+

Function: GetFrameCount

C++	`int ImGui::GetFrameCount(ImGui_Context* ctx)`
EEL	`int ImGui_GetFrameCount(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_GetFrameCount", ImGui_Context ctx)`
Lua	`integer retval = ImGui.GetFrameCount(ImGui_Context ctx)`
Python	`int retval = ImGui.GetFrameCount(ImGui_Context ctx)`

Get global imgui frame count. incremented by 1 every frame.

View source · v0.1+

Function: GetFramerate

C++	`double ImGui::GetFramerate(ImGui_Context* ctx)`
EEL	`double ImGui_GetFramerate(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetFramerate", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetFramerate(ImGui_Context ctx)`
Python	`float retval = ImGui.GetFramerate(ImGui_Context ctx)`

Estimate of application framerate (rolling average over 60 frames, based on GetDeltaTime), in frame per second. Solely for convenience.

View source · v0.8+

Function: GetTime

C++	`double ImGui::GetTime(ImGui_Context* ctx)`
EEL	`double ImGui_GetTime(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetTime", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetTime(ImGui_Context ctx)`
Python	`float retval = ImGui.GetTime(ImGui_Context ctx)`

Get global imgui time. Incremented every frame.

View source · v0.1+

Flags

For CreateContext and SetConfigVar(ConfigVar_Flags()).

Constant: ConfigFlags_DockingEnable

C++	`int ImGui::ConfigFlags_DockingEnable`
EEL	`int ImGui_ConfigFlags_DockingEnable()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_DockingEnable")`
Lua	`integer ImGui.ConfigFlags_DockingEnable`
Python	`int retval = ImGui.ConfigFlags_DockingEnable()`

Enable docking functionality.

View source · v0.5+

Constant: ConfigFlags_NavEnableKeyboard

C++	`int ImGui::ConfigFlags_NavEnableKeyboard`
EEL	`int ImGui_ConfigFlags_NavEnableKeyboard()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NavEnableKeyboard")`
Lua	`integer ImGui.ConfigFlags_NavEnableKeyboard`
Python	`int retval = ImGui.ConfigFlags_NavEnableKeyboard()`

Master keyboard navigation enable flag. Enable full Tabbing + directional arrows + space/enter to activate.

View source · v0.1+

Constant: ConfigFlags_NavEnableSetMousePos

C++	`int ImGui::ConfigFlags_NavEnableSetMousePos`
EEL	`int ImGui_ConfigFlags_NavEnableSetMousePos()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NavEnableSetMousePos")`
Lua	`integer ImGui.ConfigFlags_NavEnableSetMousePos`
Python	`int retval = ImGui.ConfigFlags_NavEnableSetMousePos()`

Instruct navigation to move the mouse cursor.

View source · v0.1+

Constant: ConfigFlags_NavNoCaptureKeyboard

C++	`int ImGui::ConfigFlags_NavNoCaptureKeyboard`
EEL	`int ImGui_ConfigFlags_NavNoCaptureKeyboard()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NavNoCaptureKeyboard")`
Lua	`integer ImGui.ConfigFlags_NavNoCaptureKeyboard`
Python	`int retval = ImGui.ConfigFlags_NavNoCaptureKeyboard()`

Instruct navigation to not capture global keyboard input when ConfigFlags_NavEnableKeyboard is set (see SetNextFrameWantCaptureKeyboard).

View source · v0.8+

Constant: ConfigFlags_NoKeyboard

C++	`int ImGui::ConfigFlags_NoKeyboard`
EEL	`int ImGui_ConfigFlags_NoKeyboard()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NoKeyboard")`
Lua	`integer ImGui.ConfigFlags_NoKeyboard`
Python	`int retval = ImGui.ConfigFlags_NoKeyboard()`

Instruct dear imgui to disable keyboard inputs and interactions. This is done by ignoring keyboard events and clearing existing states.

View source · v0.9.2+

Constant: ConfigFlags_NoMouse

C++	`int ImGui::ConfigFlags_NoMouse`
EEL	`int ImGui_ConfigFlags_NoMouse()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NoMouse")`
Lua	`integer ImGui.ConfigFlags_NoMouse`
Python	`int retval = ImGui.ConfigFlags_NoMouse()`

Instruct dear imgui to disable mouse inputs and interactions

View source · v0.1+

Constant: ConfigFlags_NoMouseCursorChange

C++	`int ImGui::ConfigFlags_NoMouseCursorChange`
EEL	`int ImGui_ConfigFlags_NoMouseCursorChange()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NoMouseCursorChange")`
Lua	`integer ImGui.ConfigFlags_NoMouseCursorChange`
Python	`int retval = ImGui.ConfigFlags_NoMouseCursorChange()`

Instruct backend to not alter mouse cursor shape and visibility.

View source · v0.1+

Constant: ConfigFlags_NoSavedSettings

C++	`int ImGui::ConfigFlags_NoSavedSettings`
EEL	`int ImGui_ConfigFlags_NoSavedSettings()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_NoSavedSettings")`
Lua	`integer ImGui.ConfigFlags_NoSavedSettings`
Python	`int retval = ImGui.ConfigFlags_NoSavedSettings()`

Disable state restoration and persistence for the whole context.

View source · v0.4+

Constant: ConfigFlags_None

C++	`int ImGui::ConfigFlags_None`
EEL	`int ImGui_ConfigFlags_None()`
Legacy EEL	`int extension_api("ImGui_ConfigFlags_None")`
Lua	`integer ImGui.ConfigFlags_None`
Python	`int retval = ImGui.ConfigFlags_None()`

View source · v0.1+

Options

Constant: ConfigVar_DebugBeginReturnValueLoop

C++	`int ImGui::ConfigVar_DebugBeginReturnValueLoop`
EEL	`int ImGui_ConfigVar_DebugBeginReturnValueLoop()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_DebugBeginReturnValueLoop")`
Lua	`integer ImGui.ConfigVar_DebugBeginReturnValueLoop`
Python	`int retval = ImGui.ConfigVar_DebugBeginReturnValueLoop()`

Some calls to Begin()/BeginChild() will return false. Will cycle through window depths then repeat. Suggested use: add "SetConfigVar(ConfigVar_DebugBeginReturnValueLoop(), GetKeyMods() == Mod_Shift" in your main loop then occasionally press SHIFT. Windows should be flickering while running.

View source · v0.8.5+

Constant: ConfigVar_DebugBeginReturnValueOnce

C++	`int ImGui::ConfigVar_DebugBeginReturnValueOnce`
EEL	`int ImGui_ConfigVar_DebugBeginReturnValueOnce()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_DebugBeginReturnValueOnce")`
Lua	`integer ImGui.ConfigVar_DebugBeginReturnValueOnce`
Python	`int retval = ImGui.ConfigVar_DebugBeginReturnValueOnce()`

First-time calls to Begin()/BeginChild() will return false. Needs to be set at context startup time if you don't want to miss windows.

View source · v0.8.5+

Constant: ConfigVar_DockingNoSplit

C++	`int ImGui::ConfigVar_DockingNoSplit`
EEL	`int ImGui_ConfigVar_DockingNoSplit()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_DockingNoSplit")`
Lua	`integer ImGui.ConfigVar_DockingNoSplit`
Python	`int retval = ImGui.ConfigVar_DockingNoSplit()`

Simplified docking mode: disable window splitting, so docking is limited to merging multiple windows together into tab-bars.

View source · v0.7+

Constant: ConfigVar_DockingTransparentPayload

C++	`int ImGui::ConfigVar_DockingTransparentPayload`
EEL	`int ImGui_ConfigVar_DockingTransparentPayload()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_DockingTransparentPayload")`
Lua	`integer ImGui.ConfigVar_DockingTransparentPayload`
Python	`int retval = ImGui.ConfigVar_DockingTransparentPayload()`

Make window or viewport transparent when docking and only display docking boxes on the target viewport.

View source · v0.7+

Constant: ConfigVar_DockingWithShift

C++	`int ImGui::ConfigVar_DockingWithShift`
EEL	`int ImGui_ConfigVar_DockingWithShift()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_DockingWithShift")`
Lua	`integer ImGui.ConfigVar_DockingWithShift`
Python	`int retval = ImGui.ConfigVar_DockingWithShift()`

Enable docking with holding Shift key (reduce visual noise, allows dropping in wider space

View source · v0.7+

Constant: ConfigVar_DragClickToInputText

C++	`int ImGui::ConfigVar_DragClickToInputText`
EEL	`int ImGui_ConfigVar_DragClickToInputText()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_DragClickToInputText")`
Lua	`integer ImGui.ConfigVar_DragClickToInputText`
Python	`int retval = ImGui.ConfigVar_DragClickToInputText()`

Enable turning Drag* widgets into text input with a simple mouse click-release (without moving). Not desirable on devices without a keyboard.

View source · v0.7+

Constant: ConfigVar_Flags

C++	`int ImGui::ConfigVar_Flags`
EEL	`int ImGui_ConfigVar_Flags()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_Flags")`
Lua	`integer ImGui.ConfigVar_Flags`
Python	`int retval = ImGui.ConfigVar_Flags()`

ConfigFlags_*

View source · v0.7+

Constant: ConfigVar_HoverDelayNormal

C++	`int ImGui::ConfigVar_HoverDelayNormal`
EEL	`int ImGui_ConfigVar_HoverDelayNormal()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_HoverDelayNormal")`
Lua	`integer ImGui.ConfigVar_HoverDelayNormal`
Python	`int retval = ImGui.ConfigVar_HoverDelayNormal()`

Delay for IsItemHovered(HoveredFlags_DelayNormal). Usually used along with ConfigVar_HoverStationaryDelay.

View source · v0.8+

Constant: ConfigVar_HoverDelayShort

C++	`int ImGui::ConfigVar_HoverDelayShort`
EEL	`int ImGui_ConfigVar_HoverDelayShort()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_HoverDelayShort")`
Lua	`integer ImGui.ConfigVar_HoverDelayShort`
Python	`int retval = ImGui.ConfigVar_HoverDelayShort()`

Delay for IsItemHovered(HoveredFlags_DelayShort). Usually used along with ConfigVar_HoverStationaryDelay.

View source · v0.8+

Constant: ConfigVar_HoverFlagsForTooltipMouse

C++	`int ImGui::ConfigVar_HoverFlagsForTooltipMouse`
EEL	`int ImGui_ConfigVar_HoverFlagsForTooltipMouse()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_HoverFlagsForTooltipMouse")`
Lua	`integer ImGui.ConfigVar_HoverFlagsForTooltipMouse`
Python	`int retval = ImGui.ConfigVar_HoverFlagsForTooltipMouse()`

Default flags when using IsItemHovered(HoveredFlags_ForTooltip) or BeginItemTooltip()/SetItemTooltip() while using mouse.

View source · v0.9+

Constant: ConfigVar_HoverFlagsForTooltipNav

C++	`int ImGui::ConfigVar_HoverFlagsForTooltipNav`
EEL	`int ImGui_ConfigVar_HoverFlagsForTooltipNav()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_HoverFlagsForTooltipNav")`
Lua	`integer ImGui.ConfigVar_HoverFlagsForTooltipNav`
Python	`int retval = ImGui.ConfigVar_HoverFlagsForTooltipNav()`

Default flags when using IsItemHovered(HoveredFlags_ForTooltip) or BeginItemTooltip()/SetItemTooltip() while using keyboard/gamepad.

View source · v0.9+

Constant: ConfigVar_HoverStationaryDelay

C++	`int ImGui::ConfigVar_HoverStationaryDelay`
EEL	`int ImGui_ConfigVar_HoverStationaryDelay()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_HoverStationaryDelay")`
Lua	`integer ImGui.ConfigVar_HoverStationaryDelay`
Python	`int retval = ImGui.ConfigVar_HoverStationaryDelay()`

Delay for IsItemHovered(HoveredFlags_Stationary). Time required to consider mouse stationary.

View source · v0.9+

Constant: ConfigVar_InputTextCursorBlink

C++	`int ImGui::ConfigVar_InputTextCursorBlink`
EEL	`int ImGui_ConfigVar_InputTextCursorBlink()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_InputTextCursorBlink")`
Lua	`integer ImGui.ConfigVar_InputTextCursorBlink`
Python	`int retval = ImGui.ConfigVar_InputTextCursorBlink()`

Enable blinking cursor (optional as some users consider it to be distracting).

View source · v0.7+

Constant: ConfigVar_InputTextEnterKeepActive

C++	`int ImGui::ConfigVar_InputTextEnterKeepActive`
EEL	`int ImGui_ConfigVar_InputTextEnterKeepActive()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_InputTextEnterKeepActive")`
Lua	`integer ImGui.ConfigVar_InputTextEnterKeepActive`
Python	`int retval = ImGui.ConfigVar_InputTextEnterKeepActive()`

Pressing Enter will keep item active and select contents (single-line only).

View source · v0.8+

Constant: ConfigVar_InputTrickleEventQueue

C++	`int ImGui::ConfigVar_InputTrickleEventQueue`
EEL	`int ImGui_ConfigVar_InputTrickleEventQueue()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_InputTrickleEventQueue")`
Lua	`integer ImGui.ConfigVar_InputTrickleEventQueue`
Python	`int retval = ImGui.ConfigVar_InputTrickleEventQueue()`

Enable input queue trickling: some types of events submitted during the same frame (e.g. button down + up) will be spread over multiple frames, improving interactions with low framerates.

Warning: when this option is disabled mouse clicks and key presses faster than a frame will be lost. This affects accessiblity features and some input devices.

View source · v0.7+

Constant: ConfigVar_KeyRepeatDelay

C++	`int ImGui::ConfigVar_KeyRepeatDelay`
EEL	`int ImGui_ConfigVar_KeyRepeatDelay()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_KeyRepeatDelay")`
Lua	`integer ImGui.ConfigVar_KeyRepeatDelay`
Python	`int retval = ImGui.ConfigVar_KeyRepeatDelay()`

When holding a key/button, time before it starts repeating, in seconds (for buttons in Repeat mode, etc.).

View source · v0.7+

Constant: ConfigVar_KeyRepeatRate

C++	`int ImGui::ConfigVar_KeyRepeatRate`
EEL	`int ImGui_ConfigVar_KeyRepeatRate()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_KeyRepeatRate")`
Lua	`integer ImGui.ConfigVar_KeyRepeatRate`
Python	`int retval = ImGui.ConfigVar_KeyRepeatRate()`

When holding a key/button, rate at which it repeats, in seconds.

View source · v0.7+

Constant: ConfigVar_MacOSXBehaviors

C++	`int ImGui::ConfigVar_MacOSXBehaviors`
EEL	`int ImGui_ConfigVar_MacOSXBehaviors()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_MacOSXBehaviors")`
Lua	`integer ImGui.ConfigVar_MacOSXBehaviors`
Python	`int retval = ImGui.ConfigVar_MacOSXBehaviors()`

Enabled by default on macOS. Swap Cmd<>Ctrl keys, OS X style text editing cursor movement using Alt instead of Ctrl, Shortcuts using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows instead of Home/End, Double click selects by word instead of selecting whole text, Multi-selection in lists uses Cmd/Super instead of Ctrl.

View source · v0.7+

Constant: ConfigVar_MouseDoubleClickMaxDist

C++	`int ImGui::ConfigVar_MouseDoubleClickMaxDist`
EEL	`int ImGui_ConfigVar_MouseDoubleClickMaxDist()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_MouseDoubleClickMaxDist")`
Lua	`integer ImGui.ConfigVar_MouseDoubleClickMaxDist`
Python	`int retval = ImGui.ConfigVar_MouseDoubleClickMaxDist()`

Distance threshold to stay in to validate a double-click, in pixels.

View source · v0.7+

Constant: ConfigVar_MouseDoubleClickTime

C++	`int ImGui::ConfigVar_MouseDoubleClickTime`
EEL	`int ImGui_ConfigVar_MouseDoubleClickTime()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_MouseDoubleClickTime")`
Lua	`integer ImGui.ConfigVar_MouseDoubleClickTime`
Python	`int retval = ImGui.ConfigVar_MouseDoubleClickTime()`

Time for a double-click, in seconds.

View source · v0.7+

Constant: ConfigVar_MouseDragThreshold

C++	`int ImGui::ConfigVar_MouseDragThreshold`
EEL	`int ImGui_ConfigVar_MouseDragThreshold()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_MouseDragThreshold")`
Lua	`integer ImGui.ConfigVar_MouseDragThreshold`
Python	`int retval = ImGui.ConfigVar_MouseDragThreshold()`

Distance threshold before considering we are dragging.

View source · v0.7+

Constant: ConfigVar_ViewportsNoDecoration

C++	`int ImGui::ConfigVar_ViewportsNoDecoration`
EEL	`int ImGui_ConfigVar_ViewportsNoDecoration()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_ViewportsNoDecoration")`
Lua	`integer ImGui.ConfigVar_ViewportsNoDecoration`
Python	`int retval = ImGui.ConfigVar_ViewportsNoDecoration()`

Disable default OS window decoration. Enabling decoration can create subsequent issues at OS levels (e.g. minimum window size).

View source · v0.7+

Constant: ConfigVar_WindowsMoveFromTitleBarOnly

C++	`int ImGui::ConfigVar_WindowsMoveFromTitleBarOnly`
EEL	`int ImGui_ConfigVar_WindowsMoveFromTitleBarOnly()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_WindowsMoveFromTitleBarOnly")`
Lua	`integer ImGui.ConfigVar_WindowsMoveFromTitleBarOnly`
Python	`int retval = ImGui.ConfigVar_WindowsMoveFromTitleBarOnly()`

Enable allowing to move windows only when clicking on their title bar. Does not apply to windows without a title bar.

View source · v0.7+

Constant: ConfigVar_WindowsResizeFromEdges

C++	`int ImGui::ConfigVar_WindowsResizeFromEdges`
EEL	`int ImGui_ConfigVar_WindowsResizeFromEdges()`
Legacy EEL	`int extension_api("ImGui_ConfigVar_WindowsResizeFromEdges")`
Lua	`integer ImGui.ConfigVar_WindowsResizeFromEdges`
Python	`int retval = ImGui.ConfigVar_WindowsResizeFromEdges()`

Enable resizing of windows from their edges and from the lower-left corner.

View source · v0.7+

Function: GetConfigVar

C++	`double ImGui::GetConfigVar(ImGui_Context* ctx, int var_idx)`
EEL	`double ImGui_GetConfigVar(ImGui_Context ctx, int var_idx)`
Legacy EEL	`double extension_api("ImGui_GetConfigVar", ImGui_Context ctx, int var_idx)`
Lua	`number retval = ImGui.GetConfigVar(ImGui_Context ctx, integer var_idx)`
Python	`float retval = ImGui.GetConfigVar(ImGui_Context ctx, int var_idx)`

View source · v0.7+

Function: SetConfigVar

C++	`void ImGui::SetConfigVar(ImGui_Context* ctx, int var_idx, double value)`
EEL	`ImGui_SetConfigVar(ImGui_Context ctx, int var_idx, value)`
Legacy EEL	`extension_api("ImGui_SetConfigVar", ImGui_Context ctx, int var_idx, value)`
Lua	`ImGui.SetConfigVar(ImGui_Context ctx, integer var_idx, number value)`
Python	`ImGui.SetConfigVar(ImGui_Context ctx, int var_idx, float value)`

View source · v0.7+

Drag & Drop

On source items, call BeginDragDropSource(), if it returns true also call SetDragDropPayload() + EndDragDropSource().

On target candidates, call BeginDragDropTarget(), if it returns true also call AcceptDragDropPayload() + EndDragDropTarget().

An item can be both a drag source and a drop target.

Function: AcceptDragDropPayload

C++	`bool ImGui::AcceptDragDropPayload(ImGui_Context* ctx, const char* type, char* payloadOutNeedBig, int payloadOutNeedBig_sz, int flagsInOptional = DragDropFlags_None)`
EEL	`bool ImGui_AcceptDragDropPayload(ImGui_Context ctx, "type", #payload, int flags = DragDropFlags_None)`
Legacy EEL	`bool extension_api("ImGui_AcceptDragDropPayload", ImGui_Context ctx, "type", #payload, int flags = DragDropFlags_None)`
Lua	`boolean retval, string payload = ImGui.AcceptDragDropPayload(ImGui_Context ctx, string type, nil, integer flags = DragDropFlags_None)`
Python	`(bool retval, str payload) = ImGui.AcceptDragDropPayload(ImGui_Context ctx, str type, int flags = DragDropFlags_None)`

Accept contents of a given type. If DragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.

View source · v0.1+

Function: AcceptDragDropPayloadFiles

C++	`bool ImGui::AcceptDragDropPayloadFiles(ImGui_Context* ctx, int* countOut, int flagsInOptional = DragDropFlags_None)`
EEL	`bool ImGui_AcceptDragDropPayloadFiles(ImGui_Context ctx, int &count, int flags = DragDropFlags_None)`
Legacy EEL	`bool extension_api("ImGui_AcceptDragDropPayloadFiles", ImGui_Context ctx, int &count, int flags = DragDropFlags_None)`
Lua	`boolean retval, integer count = ImGui.AcceptDragDropPayloadFiles(ImGui_Context ctx, nil, integer flags = DragDropFlags_None)`
Python	`(bool retval, int count) = ImGui.AcceptDragDropPayloadFiles(ImGui_Context ctx, int flags = DragDropFlags_None)`

Accept a list of dropped files. See AcceptDragDropPayload and GetDragDropPayloadFile.

View source · v0.1+

Function: AcceptDragDropPayloadRGB

C++	`bool ImGui::AcceptDragDropPayloadRGB(ImGui_Context* ctx, int* rgbOut, int flagsInOptional = DragDropFlags_None)`
EEL	`bool ImGui_AcceptDragDropPayloadRGB(ImGui_Context ctx, int &rgb, int flags = DragDropFlags_None)`
Legacy EEL	`bool extension_api("ImGui_AcceptDragDropPayloadRGB", ImGui_Context ctx, int &rgb, int flags = DragDropFlags_None)`
Lua	`boolean retval, integer rgb = ImGui.AcceptDragDropPayloadRGB(ImGui_Context ctx, nil, integer flags = DragDropFlags_None)`
Python	`(bool retval, int rgb) = ImGui.AcceptDragDropPayloadRGB(ImGui_Context ctx, int flags = DragDropFlags_None)`

Accept a RGB color. See AcceptDragDropPayload.

View source · v0.1+

Function: AcceptDragDropPayloadRGBA

C++	`bool ImGui::AcceptDragDropPayloadRGBA(ImGui_Context* ctx, int* rgbaOut, int flagsInOptional = DragDropFlags_None)`
EEL	`bool ImGui_AcceptDragDropPayloadRGBA(ImGui_Context ctx, int &rgba, int flags = DragDropFlags_None)`
Legacy EEL	`bool extension_api("ImGui_AcceptDragDropPayloadRGBA", ImGui_Context ctx, int &rgba, int flags = DragDropFlags_None)`
Lua	`boolean retval, integer rgba = ImGui.AcceptDragDropPayloadRGBA(ImGui_Context ctx, nil, integer flags = DragDropFlags_None)`
Python	`(bool retval, int rgba) = ImGui.AcceptDragDropPayloadRGBA(ImGui_Context ctx, int flags = DragDropFlags_None)`

Accept a RGBA color. See AcceptDragDropPayload.

View source · v0.1+

Function: BeginDragDropSource

C++	`bool ImGui::BeginDragDropSource(ImGui_Context* ctx, int flagsInOptional = DragDropFlags_None)`
EEL	`bool ImGui_BeginDragDropSource(ImGui_Context ctx, int flags = DragDropFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginDragDropSource", ImGui_Context ctx, int flags = DragDropFlags_None)`
Lua	`boolean retval = ImGui.BeginDragDropSource(ImGui_Context ctx, integer flags = DragDropFlags_None)`
Python	`bool retval = ImGui.BeginDragDropSource(ImGui_Context ctx, int flags = DragDropFlags_None)`

Call after submitting an item which may be dragged. when this return true, you can call SetDragDropPayload() + EndDragDropSource()

If you stop calling BeginDragDropSource() the payload is preserved however it won't have a preview tooltip (we currently display a fallback "..." tooltip as replacement).

View source · v0.1+

Function: BeginDragDropTarget

C++	`bool ImGui::BeginDragDropTarget(ImGui_Context* ctx)`
EEL	`bool ImGui_BeginDragDropTarget(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_BeginDragDropTarget", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.BeginDragDropTarget(ImGui_Context ctx)`
Python	`bool retval = ImGui.BeginDragDropTarget(ImGui_Context ctx)`

Call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload + EndDragDropTarget.

View source · v0.1+

Function: EndDragDropSource

C++	`void ImGui::EndDragDropSource(ImGui_Context* ctx)`
EEL	`ImGui_EndDragDropSource(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndDragDropSource", ImGui_Context ctx)`
Lua	`ImGui.EndDragDropSource(ImGui_Context ctx)`
Python	`ImGui.EndDragDropSource(ImGui_Context ctx)`

Only call EndDragDropSource() if BeginDragDropSource returns true!

View source · v0.1+

Function: EndDragDropTarget

C++	`void ImGui::EndDragDropTarget(ImGui_Context* ctx)`
EEL	`ImGui_EndDragDropTarget(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndDragDropTarget", ImGui_Context ctx)`
Lua	`ImGui.EndDragDropTarget(ImGui_Context ctx)`
Python	`ImGui.EndDragDropTarget(ImGui_Context ctx)`

Only call EndDragDropTarget() if BeginDragDropTarget returns true!

View source · v0.1+

Function: GetDragDropPayload

C++	`bool ImGui::GetDragDropPayload(ImGui_Context* ctx, char* typeOut, int typeOut_sz, char* payloadOutNeedBig, int payloadOutNeedBig_sz, bool* is_previewOut, bool* is_deliveryOut)`
EEL	`bool ImGui_GetDragDropPayload(ImGui_Context ctx, #type, #payload, bool &is_preview, bool &is_delivery)`
Legacy EEL	`bool extension_api("ImGui_GetDragDropPayload", ImGui_Context ctx, #type, #payload, bool &is_preview, bool &is_delivery)`
Lua	`boolean retval, string type, string payload, boolean is_preview, boolean is_delivery = ImGui.GetDragDropPayload(ImGui_Context ctx)`
Python	`(bool retval, str type, str payload, bool is_preview, bool is_delivery) = ImGui.GetDragDropPayload(ImGui_Context ctx)`

Peek directly into the current payload from anywhere. Returns false when drag and drop is finished or inactive.

View source · v0.1+

Function: GetDragDropPayloadFile

C++	`bool ImGui::GetDragDropPayloadFile(ImGui_Context* ctx, int index, char* filenameOut, int filenameOut_sz)`
EEL	`bool ImGui_GetDragDropPayloadFile(ImGui_Context ctx, int index, #filename)`
Legacy EEL	`bool extension_api("ImGui_GetDragDropPayloadFile", ImGui_Context ctx, int index, #filename)`
Lua	`boolean retval, string filename = ImGui.GetDragDropPayloadFile(ImGui_Context ctx, integer index)`
Python	`(bool retval, str filename) = ImGui.GetDragDropPayloadFile(ImGui_Context ctx, int index)`

Get a filename from the list of dropped files. Returns false if index is out of bounds.

View source · v0.1+

Function: SetDragDropPayload

C++	`bool ImGui::SetDragDropPayload(ImGui_Context* ctx, const char* type, const char* data, int condInOptional = Cond_Always)`
EEL	`bool ImGui_SetDragDropPayload(ImGui_Context ctx, "type", "data", int cond = Cond_Always)`
Legacy EEL	`bool extension_api("ImGui_SetDragDropPayload", ImGui_Context ctx, "type", "data", int cond = Cond_Always)`
Lua	`boolean retval = ImGui.SetDragDropPayload(ImGui_Context ctx, string type, string data, integer cond = Cond_Always)`
Python	`bool retval = ImGui.SetDragDropPayload(ImGui_Context ctx, str type, str data, int cond = Cond_Always)`

The type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types. Data is copied and held by imgui.

View source · v0.1+

Flags

Constant: DragDropFlags_None

C++	`int ImGui::DragDropFlags_None`
EEL	`int ImGui_DragDropFlags_None()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_None")`
Lua	`integer ImGui.DragDropFlags_None`
Python	`int retval = ImGui.DragDropFlags_None()`

View source · v0.1+

Payload

For AcceptDragDropPayload

Constant: DragDropFlags_AcceptBeforeDelivery

C++	`int ImGui::DragDropFlags_AcceptBeforeDelivery`
EEL	`int ImGui_DragDropFlags_AcceptBeforeDelivery()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_AcceptBeforeDelivery")`
Lua	`integer ImGui.DragDropFlags_AcceptBeforeDelivery`
Python	`int retval = ImGui.DragDropFlags_AcceptBeforeDelivery()`

AcceptDragDropPayload will returns true even before the mouse button is released. You can then check GetDragDropPayload/is_delivery to test if the payload needs to be delivered.

View source · v0.1+

Constant: DragDropFlags_AcceptNoDrawDefaultRect

C++	`int ImGui::DragDropFlags_AcceptNoDrawDefaultRect`
EEL	`int ImGui_DragDropFlags_AcceptNoDrawDefaultRect()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_AcceptNoDrawDefaultRect")`
Lua	`integer ImGui.DragDropFlags_AcceptNoDrawDefaultRect`
Python	`int retval = ImGui.DragDropFlags_AcceptNoDrawDefaultRect()`

Do not draw the default highlight rectangle when hovering over target.

View source · v0.1+

Constant: DragDropFlags_AcceptNoPreviewTooltip

C++	`int ImGui::DragDropFlags_AcceptNoPreviewTooltip`
EEL	`int ImGui_DragDropFlags_AcceptNoPreviewTooltip()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_AcceptNoPreviewTooltip")`
Lua	`integer ImGui.DragDropFlags_AcceptNoPreviewTooltip`
Python	`int retval = ImGui.DragDropFlags_AcceptNoPreviewTooltip()`

Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site.

View source · v0.1+

Constant: DragDropFlags_AcceptPeekOnly

C++	`int ImGui::DragDropFlags_AcceptPeekOnly`
EEL	`int ImGui_DragDropFlags_AcceptPeekOnly()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_AcceptPeekOnly")`
Lua	`integer ImGui.DragDropFlags_AcceptPeekOnly`
Python	`int retval = ImGui.DragDropFlags_AcceptPeekOnly()`

For peeking ahead and inspecting the payload before delivery. Equivalent to DragDropFlags_AcceptBeforeDelivery | DragDropFlags_AcceptNoDrawDefaultRect.

View source · v0.1+

Source

For BeginDragDropSource

Constant: DragDropFlags_PayloadAutoExpire

C++	`int ImGui::DragDropFlags_PayloadAutoExpire`
EEL	`int ImGui_DragDropFlags_PayloadAutoExpire()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_PayloadAutoExpire")`
Lua	`integer ImGui.DragDropFlags_PayloadAutoExpire`
Python	`int retval = ImGui.DragDropFlags_PayloadAutoExpire()`

Automatically expire the payload if the source cease to be submitted (otherwise payloads are persisting while being dragged).

View source · v0.9.2+

Constant: DragDropFlags_SourceAllowNullID

C++	`int ImGui::DragDropFlags_SourceAllowNullID`
EEL	`int ImGui_DragDropFlags_SourceAllowNullID()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_SourceAllowNullID")`
Lua	`integer ImGui.DragDropFlags_SourceAllowNullID`
Python	`int retval = ImGui.DragDropFlags_SourceAllowNullID()`

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.

View source · v0.1+

Constant: DragDropFlags_SourceExtern

C++	`int ImGui::DragDropFlags_SourceExtern`
EEL	`int ImGui_DragDropFlags_SourceExtern()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_SourceExtern")`
Lua	`integer ImGui.DragDropFlags_SourceExtern`
Python	`int retval = ImGui.DragDropFlags_SourceExtern()`

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.

View source · v0.1+

Constant: DragDropFlags_SourceNoDisableHover

C++	`int ImGui::DragDropFlags_SourceNoDisableHover`
EEL	`int ImGui_DragDropFlags_SourceNoDisableHover()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_SourceNoDisableHover")`
Lua	`integer ImGui.DragDropFlags_SourceNoDisableHover`
Python	`int retval = ImGui.DragDropFlags_SourceNoDisableHover()`

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.

View source · v0.1+

Constant: DragDropFlags_SourceNoHoldToOpenOthers

C++	`int ImGui::DragDropFlags_SourceNoHoldToOpenOthers`
EEL	`int ImGui_DragDropFlags_SourceNoHoldToOpenOthers()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_SourceNoHoldToOpenOthers")`
Lua	`integer ImGui.DragDropFlags_SourceNoHoldToOpenOthers`
Python	`int retval = ImGui.DragDropFlags_SourceNoHoldToOpenOthers()`

Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item.

View source · v0.1+

Constant: DragDropFlags_SourceNoPreviewTooltip

C++	`int ImGui::DragDropFlags_SourceNoPreviewTooltip`
EEL	`int ImGui_DragDropFlags_SourceNoPreviewTooltip()`
Legacy EEL	`int extension_api("ImGui_DragDropFlags_SourceNoPreviewTooltip")`
Lua	`integer ImGui.DragDropFlags_SourceNoPreviewTooltip`
Python	`int retval = ImGui.DragDropFlags_SourceNoPreviewTooltip()`

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.

View source · v0.1+

Drag & Slider

We use the same sets of flags for Drag*() and Slider*() functions as the features are the same and it makes it easier to swap them.

CTRL+Click on any drag box or slider to turn them into an input box. Manually input values aren't clamped by default and can go off-bounds. Use SliderFlags_AlwaysClamp to always clamp.

Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.

Format string may also be set to nil or use the default format ("%f" or "%d").

Drag Sliders

Speed are per-pixel of mouse movement (v_speed=0.2: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision).

Use v_min < v_max to clamp edits to given limits. Note that CTRL+Click manual input can override those limits if SliderFlags_AlwaysClamp is not used. Use v_max = FLT_MAX / INT_MAX etc to avoid clamping to a maximum, same with v_min = -FLT_MAX / INT_MIN to avoid clamping to a minimum.

Function: DragDouble

C++	`bool ImGui::DragDouble(ImGui_Context* ctx, const char* label, double* vInOut, double v_speedInOptional = 1.0, double v_minInOptional = 0.0, double v_maxInOptional = 0.0, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragDouble(ImGui_Context ctx, "label", &v, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragDouble", ImGui_Context ctx, "label", &v, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v = ImGui.DragDouble(ImGui_Context ctx, string label, number v, number v_speed = 1.0, number v_min = 0.0, number v_max = 0.0, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v) = ImGui.DragDouble(ImGui_Context ctx, str label, float v, float v_speed = 1.0, float v_min = 0.0, float v_max = 0.0, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragDouble2

C++	`bool ImGui::DragDouble2(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double v_speedInOptional = 1.0, double v_minInOptional = 0.0, double v_maxInOptional = 0.0, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragDouble2(ImGui_Context ctx, "label", &v1, &v2, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragDouble2", ImGui_Context ctx, "label", &v1, &v2, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v1, number v2 = ImGui.DragDouble2(ImGui_Context ctx, string label, number v1, number v2, number v_speed = 1.0, number v_min = 0.0, number v_max = 0.0, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v1, float v2) = ImGui.DragDouble2(ImGui_Context ctx, str label, float v1, float v2, float v_speed = 1.0, float v_min = 0.0, float v_max = 0.0, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragDouble3

C++	`bool ImGui::DragDouble3(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double v_speedInOptional = 1.0, double v_minInOptional = 0.0, double v_maxInOptional = 0.0, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragDouble3(ImGui_Context ctx, "label", &v1, &v2, &v3, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragDouble3", ImGui_Context ctx, "label", &v1, &v2, &v3, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v1, number v2, number v3 = ImGui.DragDouble3(ImGui_Context ctx, string label, number v1, number v2, number v3, number v_speed = 1.0, number v_min = 0.0, number v_max = 0.0, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v1, float v2, float v3) = ImGui.DragDouble3(ImGui_Context ctx, str label, float v1, float v2, float v3, float v_speed = 1.0, float v_min = 0.0, float v_max = 0.0, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragDouble4

C++	`bool ImGui::DragDouble4(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v4InOut, double v_speedInOptional = 1.0, double v_minInOptional = 0.0, double v_maxInOptional = 0.0, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragDouble4(ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragDouble4", ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v1, number v2, number v3, number v4 = ImGui.DragDouble4(ImGui_Context ctx, string label, number v1, number v2, number v3, number v4, number v_speed = 1.0, number v_min = 0.0, number v_max = 0.0, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v1, float v2, float v3, float v4) = ImGui.DragDouble4(ImGui_Context ctx, str label, float v1, float v2, float v3, float v4, float v_speed = 1.0, float v_min = 0.0, float v_max = 0.0, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragDoubleN

C++	`bool ImGui::DragDoubleN(ImGui_Context* ctx, const char* label, reaper_array* values, double speedInOptional = 1.0, double minInOptional = 0.0, double maxInOptional = 0.0, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragDoubleN(ImGui_Context ctx, "label", reaper_array values, speed = 1.0, min = 0.0, max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragDoubleN", ImGui_Context ctx, "label", reaper_array values, speed = 1.0, min = 0.0, max = 0.0, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval = ImGui.DragDoubleN(ImGui_Context ctx, string label, reaper.array values, number speed = 1.0, number min = 0.0, number max = 0.0, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`bool retval = ImGui.DragDoubleN(ImGui_Context ctx, str label, reaper_array values, float speed = 1.0, float min = 0.0, float max = 0.0, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragFloatRange2

C++	`bool ImGui::DragFloatRange2(ImGui_Context* ctx, const char* label, double* v_current_minInOut, double* v_current_maxInOut, double v_speedInOptional = 1.0, double v_minInOptional = 0.0, double v_maxInOptional = 0.0, const char* formatInOptional = "%.3f", const char* format_maxInOptional = nullptr, int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragFloatRange2(ImGui_Context ctx, "label", &v_current_min, &v_current_max, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", "format_max" = 0, int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragFloatRange2", ImGui_Context ctx, "label", &v_current_min, &v_current_max, v_speed = 1.0, v_min = 0.0, v_max = 0.0, "format" = "%.3f", "format_max" = 0, int flags = SliderFlags_None)`
Lua	`boolean retval, number v_current_min, number v_current_max = ImGui.DragFloatRange2(ImGui_Context ctx, string label, number v_current_min, number v_current_max, number v_speed = 1.0, number v_min = 0.0, number v_max = 0.0, string format = "%.3f", string format_max = nil, integer flags = SliderFlags_None)`
Python	`(bool retval, float v_current_min, float v_current_max) = ImGui.DragFloatRange2(ImGui_Context ctx, str label, float v_current_min, float v_current_max, float v_speed = 1.0, float v_min = 0.0, float v_max = 0.0, str format = "%.3f", str format_max = None, int flags = SliderFlags_None)`

View source · v0.1+

Function: DragInt

C++	`bool ImGui::DragInt(ImGui_Context* ctx, const char* label, int* vInOut, double v_speedInOptional = 1.0, int v_minInOptional = 0, int v_maxInOptional = 0, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragInt(ImGui_Context ctx, "label", int &v, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragInt", ImGui_Context ctx, "label", int &v, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v = ImGui.DragInt(ImGui_Context ctx, string label, integer v, number v_speed = 1.0, integer v_min = 0, integer v_max = 0, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v) = ImGui.DragInt(ImGui_Context ctx, str label, int v, float v_speed = 1.0, int v_min = 0, int v_max = 0, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragInt2

C++	`bool ImGui::DragInt2(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, double v_speedInOptional = 1.0, int v_minInOptional = 0, int v_maxInOptional = 0, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragInt2(ImGui_Context ctx, "label", int &v1, int &v2, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragInt2", ImGui_Context ctx, "label", int &v1, int &v2, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v1, integer v2 = ImGui.DragInt2(ImGui_Context ctx, string label, integer v1, integer v2, number v_speed = 1.0, integer v_min = 0, integer v_max = 0, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v1, int v2) = ImGui.DragInt2(ImGui_Context ctx, str label, int v1, int v2, float v_speed = 1.0, int v_min = 0, int v_max = 0, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragInt3

C++	`bool ImGui::DragInt3(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, double v_speedInOptional = 1.0, int v_minInOptional = 0, int v_maxInOptional = 0, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragInt3(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragInt3", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v1, integer v2, integer v3 = ImGui.DragInt3(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, number v_speed = 1.0, integer v_min = 0, integer v_max = 0, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v1, int v2, int v3) = ImGui.DragInt3(ImGui_Context ctx, str label, int v1, int v2, int v3, float v_speed = 1.0, int v_min = 0, int v_max = 0, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragInt4

C++	`bool ImGui::DragInt4(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* v4InOut, double v_speedInOptional = 1.0, int v_minInOptional = 0, int v_maxInOptional = 0, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragInt4(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragInt4", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v1, integer v2, integer v3, integer v4 = ImGui.DragInt4(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v4, number v_speed = 1.0, integer v_min = 0, integer v_max = 0, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v1, int v2, int v3, int v4) = ImGui.DragInt4(ImGui_Context ctx, str label, int v1, int v2, int v3, int v4, float v_speed = 1.0, int v_min = 0, int v_max = 0, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: DragIntRange2

C++	`bool ImGui::DragIntRange2(ImGui_Context* ctx, const char* label, int* v_current_minInOut, int* v_current_maxInOut, double v_speedInOptional = 1.0, int v_minInOptional = 0, int v_maxInOptional = 0, const char* formatInOptional = "%d", const char* format_maxInOptional = nullptr, int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_DragIntRange2(ImGui_Context ctx, "label", int &v_current_min, int &v_current_max, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", "format_max" = 0, int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_DragIntRange2", ImGui_Context ctx, "label", int &v_current_min, int &v_current_max, v_speed = 1.0, int v_min = 0, int v_max = 0, "format" = "%d", "format_max" = 0, int flags = SliderFlags_None)`
Lua	`boolean retval, integer v_current_min, integer v_current_max = ImGui.DragIntRange2(ImGui_Context ctx, string label, integer v_current_min, integer v_current_max, number v_speed = 1.0, integer v_min = 0, integer v_max = 0, string format = "%d", string format_max = nil, integer flags = SliderFlags_None)`
Python	`(bool retval, int v_current_min, int v_current_max) = ImGui.DragIntRange2(ImGui_Context ctx, str label, int v_current_min, int v_current_max, float v_speed = 1.0, int v_min = 0, int v_max = 0, str format = "%d", str format_max = None, int flags = SliderFlags_None)`

View source · v0.1+

Flags

For DragDouble, DragInt, SliderDouble, SliderInt etc. (Those are per-item flags. There are shared flags in SetConfigVar: ConfigVar_DragClickToInputText

Constant: SliderFlags_AlwaysClamp

C++	`int ImGui::SliderFlags_AlwaysClamp`
EEL	`int ImGui_SliderFlags_AlwaysClamp()`
Legacy EEL	`int extension_api("ImGui_SliderFlags_AlwaysClamp")`
Lua	`integer ImGui.SliderFlags_AlwaysClamp`
Python	`int retval = ImGui.SliderFlags_AlwaysClamp()`

Clamp value to min/max bounds when input manually with CTRL+Click. By default CTRL+Click allows going out of bounds.

View source · v0.1+

Constant: SliderFlags_Logarithmic

C++	`int ImGui::SliderFlags_Logarithmic`
EEL	`int ImGui_SliderFlags_Logarithmic()`
Legacy EEL	`int extension_api("ImGui_SliderFlags_Logarithmic")`
Lua	`integer ImGui.SliderFlags_Logarithmic`
Python	`int retval = ImGui.SliderFlags_Logarithmic()`

Make the widget logarithmic (linear otherwise). Consider using SliderFlags_NoRoundToFormat with this if using a format-string with small amount of digits.

View source · v0.1+

Constant: SliderFlags_NoInput

C++	`int ImGui::SliderFlags_NoInput`
EEL	`int ImGui_SliderFlags_NoInput()`
Legacy EEL	`int extension_api("ImGui_SliderFlags_NoInput")`
Lua	`integer ImGui.SliderFlags_NoInput`
Python	`int retval = ImGui.SliderFlags_NoInput()`

Disable CTRL+Click or Enter key allowing to input text directly into the widget.

View source · v0.1+

Constant: SliderFlags_NoRoundToFormat

C++	`int ImGui::SliderFlags_NoRoundToFormat`
EEL	`int ImGui_SliderFlags_NoRoundToFormat()`
Legacy EEL	`int extension_api("ImGui_SliderFlags_NoRoundToFormat")`
Lua	`integer ImGui.SliderFlags_NoRoundToFormat`
Python	`int retval = ImGui.SliderFlags_NoRoundToFormat()`

Disable rounding underlying value to match precision of the display format string (e.g. %.3f values are rounded to those 3 digits).

View source · v0.1+

Constant: SliderFlags_None

C++	`int ImGui::SliderFlags_None`
EEL	`int ImGui_SliderFlags_None()`
Legacy EEL	`int extension_api("ImGui_SliderFlags_None")`
Lua	`integer ImGui.SliderFlags_None`
Python	`int retval = ImGui.SliderFlags_None()`

View source · v0.1+

Constant: SliderFlags_WrapAround

C++	`int ImGui::SliderFlags_WrapAround`
EEL	`int ImGui_SliderFlags_WrapAround()`
Legacy EEL	`int extension_api("ImGui_SliderFlags_WrapAround")`
Lua	`integer ImGui.SliderFlags_WrapAround`
Python	`int retval = ImGui.SliderFlags_WrapAround()`

Enable wrapping around from max to min and from min to max (only supported by DragXXX() functions for now).

View source · v0.9.2+

Regular Sliders

Function: SliderAngle

C++	`bool ImGui::SliderAngle(ImGui_Context* ctx, const char* label, double* v_radInOut, double v_degrees_minInOptional = -360.0, double v_degrees_maxInOptional = +360.0, const char* formatInOptional = "%.0f deg", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderAngle(ImGui_Context ctx, "label", &v_rad, v_degrees_min = -360.0, v_degrees_max = +360.0, "format" = "%.0f deg", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderAngle", ImGui_Context ctx, "label", &v_rad, v_degrees_min = -360.0, v_degrees_max = +360.0, "format" = "%.0f deg", int flags = SliderFlags_None)`
Lua	`boolean retval, number v_rad = ImGui.SliderAngle(ImGui_Context ctx, string label, number v_rad, number v_degrees_min = -360.0, number v_degrees_max = +360.0, string format = "%.0f deg", integer flags = SliderFlags_None)`
Python	`(bool retval, float v_rad) = ImGui.SliderAngle(ImGui_Context ctx, str label, float v_rad, float v_degrees_min = -360.0, float v_degrees_max = +360.0, str format = "%.0f deg", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderDouble

C++	`bool ImGui::SliderDouble(ImGui_Context* ctx, const char* label, double* vInOut, double v_min, double v_max, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderDouble(ImGui_Context ctx, "label", &v, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderDouble", ImGui_Context ctx, "label", &v, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v = ImGui.SliderDouble(ImGui_Context ctx, string label, number v, number v_min, number v_max, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v) = ImGui.SliderDouble(ImGui_Context ctx, str label, float v, float v_min, float v_max, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderDouble2

C++	`bool ImGui::SliderDouble2(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double v_min, double v_max, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderDouble2(ImGui_Context ctx, "label", &v1, &v2, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderDouble2", ImGui_Context ctx, "label", &v1, &v2, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v1, number v2 = ImGui.SliderDouble2(ImGui_Context ctx, string label, number v1, number v2, number v_min, number v_max, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v1, float v2) = ImGui.SliderDouble2(ImGui_Context ctx, str label, float v1, float v2, float v_min, float v_max, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderDouble3

C++	`bool ImGui::SliderDouble3(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double v_min, double v_max, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderDouble3(ImGui_Context ctx, "label", &v1, &v2, &v3, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderDouble3", ImGui_Context ctx, "label", &v1, &v2, &v3, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v1, number v2, number v3 = ImGui.SliderDouble3(ImGui_Context ctx, string label, number v1, number v2, number v3, number v_min, number v_max, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v1, float v2, float v3) = ImGui.SliderDouble3(ImGui_Context ctx, str label, float v1, float v2, float v3, float v_min, float v_max, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderDouble4

C++	`bool ImGui::SliderDouble4(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v4InOut, double v_min, double v_max, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderDouble4(ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderDouble4", ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v1, number v2, number v3, number v4 = ImGui.SliderDouble4(ImGui_Context ctx, string label, number v1, number v2, number v3, number v4, number v_min, number v_max, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v1, float v2, float v3, float v4) = ImGui.SliderDouble4(ImGui_Context ctx, str label, float v1, float v2, float v3, float v4, float v_min, float v_max, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderDoubleN

C++	`bool ImGui::SliderDoubleN(ImGui_Context* ctx, const char* label, reaper_array* values, double v_min, double v_max, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderDoubleN(ImGui_Context ctx, "label", reaper_array values, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderDoubleN", ImGui_Context ctx, "label", reaper_array values, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval = ImGui.SliderDoubleN(ImGui_Context ctx, string label, reaper.array values, number v_min, number v_max, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`bool retval = ImGui.SliderDoubleN(ImGui_Context ctx, str label, reaper_array values, float v_min, float v_max, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderInt

C++	`bool ImGui::SliderInt(ImGui_Context* ctx, const char* label, int* vInOut, int v_min, int v_max, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderInt(ImGui_Context ctx, "label", int &v, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderInt", ImGui_Context ctx, "label", int &v, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v = ImGui.SliderInt(ImGui_Context ctx, string label, integer v, integer v_min, integer v_max, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v) = ImGui.SliderInt(ImGui_Context ctx, str label, int v, int v_min, int v_max, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderInt2

C++	`bool ImGui::SliderInt2(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int v_min, int v_max, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderInt2(ImGui_Context ctx, "label", int &v1, int &v2, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderInt2", ImGui_Context ctx, "label", int &v1, int &v2, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v1, integer v2 = ImGui.SliderInt2(ImGui_Context ctx, string label, integer v1, integer v2, integer v_min, integer v_max, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v1, int v2) = ImGui.SliderInt2(ImGui_Context ctx, str label, int v1, int v2, int v_min, int v_max, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderInt3

C++	`bool ImGui::SliderInt3(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int v_min, int v_max, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderInt3(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderInt3", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v1, integer v2, integer v3 = ImGui.SliderInt3(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v_min, integer v_max, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v1, int v2, int v3) = ImGui.SliderInt3(ImGui_Context ctx, str label, int v1, int v2, int v3, int v_min, int v_max, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: SliderInt4

C++	`bool ImGui::SliderInt4(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* v4InOut, int v_min, int v_max, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_SliderInt4(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_SliderInt4", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v1, integer v2, integer v3, integer v4 = ImGui.SliderInt4(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v4, integer v_min, integer v_max, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v1, int v2, int v3, int v4) = ImGui.SliderInt4(ImGui_Context ctx, str label, int v1, int v2, int v3, int v4, int v_min, int v_max, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Function: VSliderDouble

C++	`bool ImGui::VSliderDouble(ImGui_Context* ctx, const char* label, double size_w, double size_h, double* vInOut, double v_min, double v_max, const char* formatInOptional = "%.3f", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_VSliderDouble(ImGui_Context ctx, "label", size_w, size_h, &v, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_VSliderDouble", ImGui_Context ctx, "label", size_w, size_h, &v, v_min, v_max, "format" = "%.3f", int flags = SliderFlags_None)`
Lua	`boolean retval, number v = ImGui.VSliderDouble(ImGui_Context ctx, string label, number size_w, number size_h, number v, number v_min, number v_max, string format = "%.3f", integer flags = SliderFlags_None)`
Python	`(bool retval, float v) = ImGui.VSliderDouble(ImGui_Context ctx, str label, float size_w, float size_h, float v, float v_min, float v_max, str format = "%.3f", int flags = SliderFlags_None)`

View source · v0.1+

Function: VSliderInt

C++	`bool ImGui::VSliderInt(ImGui_Context* ctx, const char* label, double size_w, double size_h, int* vInOut, int v_min, int v_max, const char* formatInOptional = "%d", int flagsInOptional = SliderFlags_None)`
EEL	`bool ImGui_VSliderInt(ImGui_Context ctx, "label", size_w, size_h, int &v, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Legacy EEL	`bool extension_api("ImGui_VSliderInt", ImGui_Context ctx, "label", size_w, size_h, int &v, int v_min, int v_max, "format" = "%d", int flags = SliderFlags_None)`
Lua	`boolean retval, integer v = ImGui.VSliderInt(ImGui_Context ctx, string label, number size_w, number size_h, integer v, integer v_min, integer v_max, string format = "%d", integer flags = SliderFlags_None)`
Python	`(bool retval, int v) = ImGui.VSliderInt(ImGui_Context ctx, str label, float size_w, float size_h, int v, int v_min, int v_max, str format = "%d", int flags = SliderFlags_None)`

View source · v0.1+

Draw List

This is the low-level list of polygons that ImGui functions are filling. At the end of the frame, all draw lists are passed to the GPU for rendering.

Each dear imgui window contains its own Draw List. You can use GetWindowDrawList() to access the current window draw list and draw custom primitives.

The Draw List API uses absolute coordinates (0,0 is the top-left corner of the primary monitor, not of your window!). See GetCursorScreenPos.

Constant: DrawFlags_Closed

C++	`int ImGui::DrawFlags_Closed`
EEL	`int ImGui_DrawFlags_Closed()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_Closed")`
Lua	`integer ImGui.DrawFlags_Closed`
Python	`int retval = ImGui.DrawFlags_Closed()`

DrawList_PathStroke, DrawList_AddPolyline: specify that shape should be closed (Important: this is always == 1 for legacy reason).

View source · v0.2+

Constant: DrawFlags_None

C++	`int ImGui::DrawFlags_None`
EEL	`int ImGui_DrawFlags_None()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_None")`
Lua	`integer ImGui.DrawFlags_None`
Python	`int retval = ImGui.DrawFlags_None()`

View source · v0.2+

Constant: DrawFlags_RoundCornersAll

C++	`int ImGui::DrawFlags_RoundCornersAll`
EEL	`int ImGui_DrawFlags_RoundCornersAll()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersAll")`
Lua	`integer ImGui.DrawFlags_RoundCornersAll`
Python	`int retval = ImGui.DrawFlags_RoundCornersAll()`

View source · v0.2+

Constant: DrawFlags_RoundCornersBottom

C++	`int ImGui::DrawFlags_RoundCornersBottom`
EEL	`int ImGui_DrawFlags_RoundCornersBottom()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersBottom")`
Lua	`integer ImGui.DrawFlags_RoundCornersBottom`
Python	`int retval = ImGui.DrawFlags_RoundCornersBottom()`

View source · v0.2+

Constant: DrawFlags_RoundCornersBottomLeft

C++	`int ImGui::DrawFlags_RoundCornersBottomLeft`
EEL	`int ImGui_DrawFlags_RoundCornersBottomLeft()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersBottomLeft")`
Lua	`integer ImGui.DrawFlags_RoundCornersBottomLeft`
Python	`int retval = ImGui.DrawFlags_RoundCornersBottomLeft()`

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding bottom-left corner only (when rounding > 0.0, we default to all corners).

View source · v0.2+

Constant: DrawFlags_RoundCornersBottomRight

C++	`int ImGui::DrawFlags_RoundCornersBottomRight`
EEL	`int ImGui_DrawFlags_RoundCornersBottomRight()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersBottomRight")`
Lua	`integer ImGui.DrawFlags_RoundCornersBottomRight`
Python	`int retval = ImGui.DrawFlags_RoundCornersBottomRight()`

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding bottom-right corner only (when rounding > 0.0, we default to all corners).

View source · v0.2+

Constant: DrawFlags_RoundCornersLeft

C++	`int ImGui::DrawFlags_RoundCornersLeft`
EEL	`int ImGui_DrawFlags_RoundCornersLeft()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersLeft")`
Lua	`integer ImGui.DrawFlags_RoundCornersLeft`
Python	`int retval = ImGui.DrawFlags_RoundCornersLeft()`

View source · v0.2+

Constant: DrawFlags_RoundCornersNone

C++	`int ImGui::DrawFlags_RoundCornersNone`
EEL	`int ImGui_DrawFlags_RoundCornersNone()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersNone")`
Lua	`integer ImGui.DrawFlags_RoundCornersNone`
Python	`int retval = ImGui.DrawFlags_RoundCornersNone()`

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: disable rounding on all corners (when rounding > 0.0). This is NOT zero, NOT an implicit flag!.

View source · v0.2+

Constant: DrawFlags_RoundCornersRight

C++	`int ImGui::DrawFlags_RoundCornersRight`
EEL	`int ImGui_DrawFlags_RoundCornersRight()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersRight")`
Lua	`integer ImGui.DrawFlags_RoundCornersRight`
Python	`int retval = ImGui.DrawFlags_RoundCornersRight()`

View source · v0.2+

Constant: DrawFlags_RoundCornersTop

C++	`int ImGui::DrawFlags_RoundCornersTop`
EEL	`int ImGui_DrawFlags_RoundCornersTop()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersTop")`
Lua	`integer ImGui.DrawFlags_RoundCornersTop`
Python	`int retval = ImGui.DrawFlags_RoundCornersTop()`

View source · v0.2+

Constant: DrawFlags_RoundCornersTopLeft

C++	`int ImGui::DrawFlags_RoundCornersTopLeft`
EEL	`int ImGui_DrawFlags_RoundCornersTopLeft()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersTopLeft")`
Lua	`integer ImGui.DrawFlags_RoundCornersTopLeft`
Python	`int retval = ImGui.DrawFlags_RoundCornersTopLeft()`

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding top-left corner only (when rounding > 0.0, we default to all corners).

View source · v0.2+

Constant: DrawFlags_RoundCornersTopRight

C++	`int ImGui::DrawFlags_RoundCornersTopRight`
EEL	`int ImGui_DrawFlags_RoundCornersTopRight()`
Legacy EEL	`int extension_api("ImGui_DrawFlags_RoundCornersTopRight")`
Lua	`integer ImGui.DrawFlags_RoundCornersTopRight`
Python	`int retval = ImGui.DrawFlags_RoundCornersTopRight()`

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding top-right corner only (when rounding > 0.0, we default to all corners).

View source · v0.2+

Function: DrawList_PopClipRect

C++	`void ImGui::DrawList_PopClipRect(ImGui_DrawList* draw_list)`
EEL	`ImGui_DrawList_PopClipRect(ImGui_DrawList draw_list)`
Legacy EEL	`extension_api("ImGui_DrawList_PopClipRect", ImGui_DrawList draw_list)`
Lua	`ImGui.DrawList_PopClipRect(ImGui_DrawList draw_list)`
Python	`ImGui.DrawList_PopClipRect(ImGui_DrawList draw_list)`

See DrawList_PushClipRect

View source · v0.1+

Function: DrawList_PushClipRect

C++	`void ImGui::DrawList_PushClipRect(ImGui_DrawList* draw_list, double clip_rect_min_x, double clip_rect_min_y, double clip_rect_max_x, double clip_rect_max_y, bool intersect_with_current_clip_rectInOptional = false)`
EEL	`ImGui_DrawList_PushClipRect(ImGui_DrawList draw_list, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, bool intersect_with_current_clip_rect = false)`
Legacy EEL	`extension_api("ImGui_DrawList_PushClipRect", ImGui_DrawList draw_list, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, bool intersect_with_current_clip_rect = false)`
Lua	`ImGui.DrawList_PushClipRect(ImGui_DrawList draw_list, number clip_rect_min_x, number clip_rect_min_y, number clip_rect_max_x, number clip_rect_max_y, boolean intersect_with_current_clip_rect = false)`
Python	`ImGui.DrawList_PushClipRect(ImGui_DrawList draw_list, float clip_rect_min_x, float clip_rect_min_y, float clip_rect_max_x, float clip_rect_max_y, bool intersect_with_current_clip_rect = false)`

Render-level scissoring. Prefer using higher-level PushClipRect to affect logic (hit-testing and widget culling).

View source · v0.1+

Function: DrawList_PushClipRectFullScreen

C++	`void ImGui::DrawList_PushClipRectFullScreen(ImGui_DrawList* draw_list)`
EEL	`ImGui_DrawList_PushClipRectFullScreen(ImGui_DrawList draw_list)`
Legacy EEL	`extension_api("ImGui_DrawList_PushClipRectFullScreen", ImGui_DrawList draw_list)`
Lua	`ImGui.DrawList_PushClipRectFullScreen(ImGui_DrawList draw_list)`
Python	`ImGui.DrawList_PushClipRectFullScreen(ImGui_DrawList draw_list)`

View source · v0.1+

Function: GetBackgroundDrawList

C++	`ImGui_DrawList* ImGui::GetBackgroundDrawList(ImGui_Context* ctx)`
EEL	`ImGui_DrawList* ImGui_GetBackgroundDrawList(ImGui_Context ctx)`
Legacy EEL	`ImGui_DrawList* extension_api("ImGui_GetBackgroundDrawList", ImGui_Context ctx)`
Lua	`ImGui_DrawList retval = ImGui.GetBackgroundDrawList(ImGui_Context ctx)`
Python	`ImGui_DrawList retval = ImGui.GetBackgroundDrawList(ImGui_Context ctx)`

This draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.

View source · v0.1+

Function: GetForegroundDrawList

C++	`ImGui_DrawList* ImGui::GetForegroundDrawList(ImGui_Context* ctx)`
EEL	`ImGui_DrawList* ImGui_GetForegroundDrawList(ImGui_Context ctx)`
Legacy EEL	`ImGui_DrawList* extension_api("ImGui_GetForegroundDrawList", ImGui_Context ctx)`
Lua	`ImGui_DrawList retval = ImGui.GetForegroundDrawList(ImGui_Context ctx)`
Python	`ImGui_DrawList retval = ImGui.GetForegroundDrawList(ImGui_Context ctx)`

This draw list will be the last rendered one. Useful to quickly draw shapes/text over dear imgui contents.

View source · v0.1+

Function: GetWindowDrawList

C++	`ImGui_DrawList* ImGui::GetWindowDrawList(ImGui_Context* ctx)`
EEL	`ImGui_DrawList* ImGui_GetWindowDrawList(ImGui_Context ctx)`
Legacy EEL	`ImGui_DrawList* extension_api("ImGui_GetWindowDrawList", ImGui_Context ctx)`
Lua	`ImGui_DrawList retval = ImGui.GetWindowDrawList(ImGui_Context ctx)`
Python	`ImGui_DrawList retval = ImGui.GetWindowDrawList(ImGui_Context ctx)`

The draw list associated to the current window, to append your own drawing primitives

View source · v0.1+

Primitives

Filled shapes must always use clockwise winding order! The anti-aliasing fringe depends on it. Counter-clockwise shapes will have "inward" anti-aliasing. So e.g. DrawList_PathArcTo(center, radius, PI * -0.5, PI) is ok, whereas DrawList_PathArcTo(center, radius, PI, PI * -0.5) won't have correct anti-aliasing when followed by DrawList_PathFillConvex.

For rectangular primitives, "p_min" and "p_max" represent the upper-left and lower-right corners.

For circle primitives, use "num_segments == 0" to automatically calculate tessellation (preferred).

Function: DrawList_AddBezierCubic

C++	`void ImGui::DrawList_AddBezierCubic(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int col_rgba, double thickness, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_AddBezierCubic(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, thickness, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddBezierCubic", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, thickness, int num_segments = 0)`
Lua	`ImGui.DrawList_AddBezierCubic(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer col_rgba, number thickness, integer num_segments = 0)`
Python	`ImGui.DrawList_AddBezierCubic(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y, int col_rgba, float thickness, int num_segments = 0)`

Cubic Bezier (4 control points)

View source · v0.1+

Function: DrawList_AddBezierQuadratic

C++	`void ImGui::DrawList_AddBezierQuadratic(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, int col_rgba, double thickness, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_AddBezierQuadratic(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, thickness, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddBezierQuadratic", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, thickness, int num_segments = 0)`
Lua	`ImGui.DrawList_AddBezierQuadratic(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, integer col_rgba, number thickness, integer num_segments = 0)`
Python	`ImGui.DrawList_AddBezierQuadratic(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, int col_rgba, float thickness, int num_segments = 0)`

Quadratic Bezier (3 control points)

View source · v0.1+

Function: DrawList_AddCircle

C++	`void ImGui::DrawList_AddCircle(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int num_segmentsInOptional = 0, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddCircle(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments = 0, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddCircle", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments = 0, thickness = 1.0)`
Lua	`ImGui.DrawList_AddCircle(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, integer num_segments = 0, number thickness = 1.0)`
Python	`ImGui.DrawList_AddCircle(ImGui_DrawList draw_list, float center_x, float center_y, float radius, int col_rgba, int num_segments = 0, float thickness = 1.0)`

Use "num_segments == 0" to automatically calculate tessellation (preferred).

View source · v0.1+

Function: DrawList_AddCircleFilled

C++	`void ImGui::DrawList_AddCircleFilled(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_AddCircleFilled(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddCircleFilled", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments = 0)`
Lua	`ImGui.DrawList_AddCircleFilled(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, integer num_segments = 0)`
Python	`ImGui.DrawList_AddCircleFilled(ImGui_DrawList draw_list, float center_x, float center_y, float radius, int col_rgba, int num_segments = 0)`

Use "num_segments == 0" to automatically calculate tessellation (preferred).

View source · v0.1+

Function: DrawList_AddConcavePolyFilled

C++	`void ImGui::DrawList_AddConcavePolyFilled(ImGui_DrawList* draw_list, reaper_array* points, int col_rgba)`
EEL	`ImGui_DrawList_AddConcavePolyFilled(ImGui_DrawList draw_list, reaper_array points, int col_rgba)`
Legacy EEL	`extension_api("ImGui_DrawList_AddConcavePolyFilled", ImGui_DrawList draw_list, reaper_array points, int col_rgba)`
Lua	`ImGui.DrawList_AddConcavePolyFilled(ImGui_DrawList draw_list, reaper.array points, integer col_rgba)`
Python	`ImGui.DrawList_AddConcavePolyFilled(ImGui_DrawList draw_list, reaper_array points, int col_rgba)`

Concave polygon fill is more expensive than convex one: it has O(N^2) complexity.

View source · v0.9+

Function: DrawList_AddConvexPolyFilled

C++	`void ImGui::DrawList_AddConvexPolyFilled(ImGui_DrawList* draw_list, reaper_array* points, int col_rgba)`
EEL	`ImGui_DrawList_AddConvexPolyFilled(ImGui_DrawList draw_list, reaper_array points, int col_rgba)`
Legacy EEL	`extension_api("ImGui_DrawList_AddConvexPolyFilled", ImGui_DrawList draw_list, reaper_array points, int col_rgba)`
Lua	`ImGui.DrawList_AddConvexPolyFilled(ImGui_DrawList draw_list, reaper.array points, integer col_rgba)`
Python	`ImGui.DrawList_AddConvexPolyFilled(ImGui_DrawList draw_list, reaper_array points, int col_rgba)`

Note: Anti-aliased filling requires points to be in clockwise order.

View source · v0.6+

Function: DrawList_AddEllipse

C++	`void ImGui::DrawList_AddEllipse(ImGui_DrawList* draw_list, double center_x, double center_y, double radius_x, double radius_y, int col_rgba, double rotInOptional = 0.0, int num_segmentsInOptional = 0, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddEllipse(ImGui_DrawList draw_list, center_x, center_y, radius_x, radius_y, int col_rgba, rot = 0.0, int num_segments = 0, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddEllipse", ImGui_DrawList draw_list, center_x, center_y, radius_x, radius_y, int col_rgba, rot = 0.0, int num_segments = 0, thickness = 1.0)`
Lua	`ImGui.DrawList_AddEllipse(ImGui_DrawList draw_list, number center_x, number center_y, number radius_x, number radius_y, integer col_rgba, number rot = 0.0, integer num_segments = 0, number thickness = 1.0)`
Python	`ImGui.DrawList_AddEllipse(ImGui_DrawList draw_list, float center_x, float center_y, float radius_x, float radius_y, int col_rgba, float rot = 0.0, int num_segments = 0, float thickness = 1.0)`

View source · v0.9+

Function: DrawList_AddEllipseFilled

C++	`void ImGui::DrawList_AddEllipseFilled(ImGui_DrawList* draw_list, double center_x, double center_y, double radius_x, double radius_y, int col_rgba, double rotInOptional = 0.0, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_AddEllipseFilled(ImGui_DrawList draw_list, center_x, center_y, radius_x, radius_y, int col_rgba, rot = 0.0, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddEllipseFilled", ImGui_DrawList draw_list, center_x, center_y, radius_x, radius_y, int col_rgba, rot = 0.0, int num_segments = 0)`
Lua	`ImGui.DrawList_AddEllipseFilled(ImGui_DrawList draw_list, number center_x, number center_y, number radius_x, number radius_y, integer col_rgba, number rot = 0.0, integer num_segments = 0)`
Python	`ImGui.DrawList_AddEllipseFilled(ImGui_DrawList draw_list, float center_x, float center_y, float radius_x, float radius_y, int col_rgba, float rot = 0.0, int num_segments = 0)`

View source · v0.9+

Function: DrawList_AddImage

C++	`void ImGui::DrawList_AddImage(ImGui_DrawList* draw_list, ImGui_Image* image, double p_min_x, double p_min_y, double p_max_x, double p_max_y, double uv_min_xInOptional = 0.0, double uv_min_yInOptional = 0.0, double uv_max_xInOptional = 1.0, double uv_max_yInOptional = 1.0, int col_rgbaInOptional = 0xFFFFFFFF)`
EEL	`ImGui_DrawList_AddImage(ImGui_DrawList draw_list, ImGui_Image image, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x = 0.0, uv_min_y = 0.0, uv_max_x = 1.0, uv_max_y = 1.0, int col_rgba = 0xFFFFFFFF)`
Legacy EEL	`extension_api("ImGui_DrawList_AddImage", ImGui_DrawList draw_list, ImGui_Image image, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x = 0.0, uv_min_y = 0.0, uv_max_x = 1.0, uv_max_y = 1.0, int col_rgba = 0xFFFFFFFF)`
Lua	`ImGui.DrawList_AddImage(ImGui_DrawList draw_list, ImGui_Image image, number p_min_x, number p_min_y, number p_max_x, number p_max_y, number uv_min_x = 0.0, number uv_min_y = 0.0, number uv_max_x = 1.0, number uv_max_y = 1.0, integer col_rgba = 0xFFFFFFFF)`
Python	`ImGui.DrawList_AddImage(ImGui_DrawList draw_list, ImGui_Image image, float p_min_x, float p_min_y, float p_max_x, float p_max_y, float uv_min_x = 0.0, float uv_min_y = 0.0, float uv_max_x = 1.0, float uv_max_y = 1.0, int col_rgba = 0xFFFFFFFF)`

View source · v0.8+

Function: DrawList_AddImageQuad

C++	`void ImGui::DrawList_AddImageQuad(ImGui_DrawList* draw_list, ImGui_Image* image, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, double uv1_xInOptional = 0.0, double uv1_yInOptional = 0.0, double uv2_xInOptional = 1.0, double uv2_yInOptional = 0.0, double uv3_xInOptional = 1.0, double uv3_yInOptional = 1.0, double uv4_xInOptional = 0.0, double uv4_yInOptional = 1.0, int col_rgbaInOptional = 0xFFFFFFFF)`
EEL	`ImGui_DrawList_AddImageQuad(ImGui_DrawList draw_list, ImGui_Image image, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, uv1_x = 0.0, uv1_y = 0.0, uv2_x = 1.0, uv2_y = 0.0, uv3_x = 1.0, uv3_y = 1.0, uv4_x = 0.0, uv4_y = 1.0, int col_rgba = 0xFFFFFFFF)`
Legacy EEL	`extension_api("ImGui_DrawList_AddImageQuad", ImGui_DrawList draw_list, ImGui_Image image, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, uv1_x = 0.0, uv1_y = 0.0, uv2_x = 1.0, uv2_y = 0.0, uv3_x = 1.0, uv3_y = 1.0, uv4_x = 0.0, uv4_y = 1.0, int col_rgba = 0xFFFFFFFF)`
Lua	`ImGui.DrawList_AddImageQuad(ImGui_DrawList draw_list, ImGui_Image image, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, number uv1_x = 0.0, number uv1_y = 0.0, number uv2_x = 1.0, number uv2_y = 0.0, number uv3_x = 1.0, number uv3_y = 1.0, number uv4_x = 0.0, number uv4_y = 1.0, integer col_rgba = 0xFFFFFFFF)`
Python	`ImGui.DrawList_AddImageQuad(ImGui_DrawList draw_list, ImGui_Image image, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y, float uv1_x = 0.0, float uv1_y = 0.0, float uv2_x = 1.0, float uv2_y = 0.0, float uv3_x = 1.0, float uv3_y = 1.0, float uv4_x = 0.0, float uv4_y = 1.0, int col_rgba = 0xFFFFFFFF)`

View source · v0.8+

Function: DrawList_AddImageRounded

C++	`void ImGui::DrawList_AddImageRounded(ImGui_DrawList* draw_list, ImGui_Image* image, double p_min_x, double p_min_y, double p_max_x, double p_max_y, double uv_min_x, double uv_min_y, double uv_max_x, double uv_max_y, int col_rgba, double rounding, int flagsInOptional = DrawFlags_None)`
EEL	`ImGui_DrawList_AddImageRounded(ImGui_DrawList draw_list, ImGui_Image image, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x, uv_min_y, uv_max_x, uv_max_y, int col_rgba, rounding, int flags = DrawFlags_None)`
Legacy EEL	`extension_api("ImGui_DrawList_AddImageRounded", ImGui_DrawList draw_list, ImGui_Image image, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x, uv_min_y, uv_max_x, uv_max_y, int col_rgba, rounding, int flags = DrawFlags_None)`
Lua	`ImGui.DrawList_AddImageRounded(ImGui_DrawList draw_list, ImGui_Image image, number p_min_x, number p_min_y, number p_max_x, number p_max_y, number uv_min_x, number uv_min_y, number uv_max_x, number uv_max_y, integer col_rgba, number rounding, integer flags = DrawFlags_None)`
Python	`ImGui.DrawList_AddImageRounded(ImGui_DrawList draw_list, ImGui_Image image, float p_min_x, float p_min_y, float p_max_x, float p_max_y, float uv_min_x, float uv_min_y, float uv_max_x, float uv_max_y, int col_rgba, float rounding, int flags = DrawFlags_None)`

View source · v0.8+

Function: DrawList_AddLine

C++	`void ImGui::DrawList_AddLine(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, int col_rgba, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddLine(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, int col_rgba, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddLine", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, int col_rgba, thickness = 1.0)`
Lua	`ImGui.DrawList_AddLine(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, integer col_rgba, number thickness = 1.0)`
Python	`ImGui.DrawList_AddLine(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, int col_rgba, float thickness = 1.0)`

View source · v0.1+

Function: DrawList_AddNgon

C++	`void ImGui::DrawList_AddNgon(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int num_segments, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddNgon(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddNgon", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments, thickness = 1.0)`
Lua	`ImGui.DrawList_AddNgon(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, integer num_segments, number thickness = 1.0)`
Python	`ImGui.DrawList_AddNgon(ImGui_DrawList draw_list, float center_x, float center_y, float radius, int col_rgba, int num_segments, float thickness = 1.0)`

View source · v0.1+

Function: DrawList_AddNgonFilled

C++	`void ImGui::DrawList_AddNgonFilled(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int num_segments)`
EEL	`ImGui_DrawList_AddNgonFilled(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments)`
Legacy EEL	`extension_api("ImGui_DrawList_AddNgonFilled", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments)`
Lua	`ImGui.DrawList_AddNgonFilled(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, integer num_segments)`
Python	`ImGui.DrawList_AddNgonFilled(ImGui_DrawList draw_list, float center_x, float center_y, float radius, int col_rgba, int num_segments)`

View source · v0.1+

Function: DrawList_AddPolyline

C++	`void ImGui::DrawList_AddPolyline(ImGui_DrawList* draw_list, reaper_array* points, int col_rgba, int flags, double thickness)`
EEL	`ImGui_DrawList_AddPolyline(ImGui_DrawList draw_list, reaper_array points, int col_rgba, int flags, thickness)`
Legacy EEL	`extension_api("ImGui_DrawList_AddPolyline", ImGui_DrawList draw_list, reaper_array points, int col_rgba, int flags, thickness)`
Lua	`ImGui.DrawList_AddPolyline(ImGui_DrawList draw_list, reaper.array points, integer col_rgba, integer flags, number thickness)`
Python	`ImGui.DrawList_AddPolyline(ImGui_DrawList draw_list, reaper_array points, int col_rgba, int flags, float thickness)`

Points is a list of x,y coordinates.

View source · v0.2+

Function: DrawList_AddQuad

C++	`void ImGui::DrawList_AddQuad(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int col_rgba, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddQuad(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddQuad", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, thickness = 1.0)`
Lua	`ImGui.DrawList_AddQuad(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer col_rgba, number thickness = 1.0)`
Python	`ImGui.DrawList_AddQuad(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y, int col_rgba, float thickness = 1.0)`

View source · v0.1+

Function: DrawList_AddQuadFilled

C++	`void ImGui::DrawList_AddQuadFilled(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int col_rgba)`
EEL	`ImGui_DrawList_AddQuadFilled(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba)`
Legacy EEL	`extension_api("ImGui_DrawList_AddQuadFilled", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba)`
Lua	`ImGui.DrawList_AddQuadFilled(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer col_rgba)`
Python	`ImGui.DrawList_AddQuadFilled(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y, int col_rgba)`

View source · v0.1+

Function: DrawList_AddRect

C++	`void ImGui::DrawList_AddRect(ImGui_DrawList* draw_list, double p_min_x, double p_min_y, double p_max_x, double p_max_y, int col_rgba, double roundingInOptional = 0.0, int flagsInOptional = DrawFlags_None, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddRect(ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, rounding = 0.0, int flags = DrawFlags_None, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddRect", ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, rounding = 0.0, int flags = DrawFlags_None, thickness = 1.0)`
Lua	`ImGui.DrawList_AddRect(ImGui_DrawList draw_list, number p_min_x, number p_min_y, number p_max_x, number p_max_y, integer col_rgba, number rounding = 0.0, integer flags = DrawFlags_None, number thickness = 1.0)`
Python	`ImGui.DrawList_AddRect(ImGui_DrawList draw_list, float p_min_x, float p_min_y, float p_max_x, float p_max_y, int col_rgba, float rounding = 0.0, int flags = DrawFlags_None, float thickness = 1.0)`

View source · v0.1+

Function: DrawList_AddRectFilled

C++	`void ImGui::DrawList_AddRectFilled(ImGui_DrawList* draw_list, double p_min_x, double p_min_y, double p_max_x, double p_max_y, int col_rgba, double roundingInOptional = 0.0, int flagsInOptional = DrawFlags_None)`
EEL	`ImGui_DrawList_AddRectFilled(ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, rounding = 0.0, int flags = DrawFlags_None)`
Legacy EEL	`extension_api("ImGui_DrawList_AddRectFilled", ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, rounding = 0.0, int flags = DrawFlags_None)`
Lua	`ImGui.DrawList_AddRectFilled(ImGui_DrawList draw_list, number p_min_x, number p_min_y, number p_max_x, number p_max_y, integer col_rgba, number rounding = 0.0, integer flags = DrawFlags_None)`
Python	`ImGui.DrawList_AddRectFilled(ImGui_DrawList draw_list, float p_min_x, float p_min_y, float p_max_x, float p_max_y, int col_rgba, float rounding = 0.0, int flags = DrawFlags_None)`

View source · v0.1+

Function: DrawList_AddRectFilledMultiColor

C++	`void ImGui::DrawList_AddRectFilledMultiColor(ImGui_DrawList* draw_list, double p_min_x, double p_min_y, double p_max_x, double p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left)`
EEL	`ImGui_DrawList_AddRectFilledMultiColor(ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left)`
Legacy EEL	`extension_api("ImGui_DrawList_AddRectFilledMultiColor", ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left)`
Lua	`ImGui.DrawList_AddRectFilledMultiColor(ImGui_DrawList draw_list, number p_min_x, number p_min_y, number p_max_x, number p_max_y, integer col_upr_left, integer col_upr_right, integer col_bot_right, integer col_bot_left)`
Python	`ImGui.DrawList_AddRectFilledMultiColor(ImGui_DrawList draw_list, float p_min_x, float p_min_y, float p_max_x, float p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left)`

View source · v0.1+

Function: DrawList_AddText

C++	`void ImGui::DrawList_AddText(ImGui_DrawList* draw_list, double x, double y, int col_rgba, const char* text)`
EEL	`ImGui_DrawList_AddText(ImGui_DrawList draw_list, x, y, int col_rgba, "text")`
Legacy EEL	`extension_api("ImGui_DrawList_AddText", ImGui_DrawList draw_list, x, y, int col_rgba, "text")`
Lua	`ImGui.DrawList_AddText(ImGui_DrawList draw_list, number x, number y, integer col_rgba, string text)`
Python	`ImGui.DrawList_AddText(ImGui_DrawList draw_list, float x, float y, int col_rgba, str text)`

View source · v0.1+

Function: DrawList_AddTextEx

C++	`void ImGui::DrawList_AddTextEx(ImGui_DrawList* draw_list, ImGui_Font* font, double font_size, double pos_x, double pos_y, int col_rgba, const char* text, double wrap_widthInOptional = 0.0, double cpu_fine_clip_rect_min_xInOptional = nullptr, double cpu_fine_clip_rect_min_yInOptional = nullptr, double cpu_fine_clip_rect_max_xInOptional = nullptr, double cpu_fine_clip_rect_max_yInOptional = nullptr)`
EEL	`ImGui_DrawList_AddTextEx(ImGui_DrawList draw_list, ImGui_Font font, font_size, pos_x, pos_y, int col_rgba, "text", wrap_width = 0.0, cpu_fine_clip_rect_min_x = 0, cpu_fine_clip_rect_min_y = 0, cpu_fine_clip_rect_max_x = 0, cpu_fine_clip_rect_max_y = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddTextEx", ImGui_DrawList draw_list, ImGui_Font font, font_size, pos_x, pos_y, int col_rgba, "text", wrap_width = 0.0, cpu_fine_clip_rect_min_x = 0, cpu_fine_clip_rect_min_y = 0, cpu_fine_clip_rect_max_x = 0, cpu_fine_clip_rect_max_y = 0)`
Lua	`ImGui.DrawList_AddTextEx(ImGui_DrawList draw_list, ImGui_Font font, number font_size, number pos_x, number pos_y, integer col_rgba, string text, number wrap_width = 0.0, number cpu_fine_clip_rect_min_x = nil, number cpu_fine_clip_rect_min_y = nil, number cpu_fine_clip_rect_max_x = nil, number cpu_fine_clip_rect_max_y = nil)`
Python	`ImGui.DrawList_AddTextEx(ImGui_DrawList draw_list, ImGui_Font font, float font_size, float pos_x, float pos_y, int col_rgba, str text, float wrap_width = 0.0, float cpu_fine_clip_rect_min_x = None, float cpu_fine_clip_rect_min_y = None, float cpu_fine_clip_rect_max_x = None, float cpu_fine_clip_rect_max_y = None)`

The last pushed font is used if font is nil. The size of the last pushed font is used if font_size is 0. cpu_fine_clip_rect_* only takes effect if all four are non-nil.

View source · v0.4+

Function: DrawList_AddTriangle

C++	`void ImGui::DrawList_AddTriangle(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, int col_rgba, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_AddTriangle(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_AddTriangle", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, thickness = 1.0)`
Lua	`ImGui.DrawList_AddTriangle(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, integer col_rgba, number thickness = 1.0)`
Python	`ImGui.DrawList_AddTriangle(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, int col_rgba, float thickness = 1.0)`

View source · v0.1+

Function: DrawList_AddTriangleFilled

C++	`void ImGui::DrawList_AddTriangleFilled(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, int col_rgba)`
EEL	`ImGui_DrawList_AddTriangleFilled(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba)`
Legacy EEL	`extension_api("ImGui_DrawList_AddTriangleFilled", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba)`
Lua	`ImGui.DrawList_AddTriangleFilled(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, integer col_rgba)`
Python	`ImGui.DrawList_AddTriangleFilled(ImGui_DrawList draw_list, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, int col_rgba)`

View source · v0.1+

Splitter

Split/Merge functions are used to split the draw list into different layers which can be drawn into out of order (e.g. submit FG primitives before BG primitives).

Use to minimize draw calls (e.g. if going back-and-forth between multiple clipping rectangles, prefer to append into separate channels then merge at the end).

Usage:

if not ImGui.ValidatePtr(splitter, 'ImGui_DrawListSplitter*') then
  splitter = ImGui.CreateDrawListSplitter(draw_list)
end
ImGui.DrawListSplitter_Split(splitter, 2)
ImGui.DrawListSplitter_SetCurrentChannel(splitter, 0)
ImGui.DrawList_AddRectFilled(draw_list, ...) -- background
ImGui.DrawListSplitter_SetCurrentChannel(splitter, 1)
ImGui.DrawList_AddRectFilled(draw_list, ...) -- foreground
ImGui.DrawListSplitter_SetCurrentChannel(splitter, 0)
ImGui.DrawList_AddRectFilled(draw_list, ...) -- background
ImGui.DrawListSplitter_Merge(splitter)

Function: CreateDrawListSplitter

C++	`ImGui_DrawListSplitter* ImGui::CreateDrawListSplitter(ImGui_DrawList* draw_list)`
EEL	`ImGui_DrawListSplitter* ImGui_CreateDrawListSplitter(ImGui_DrawList draw_list)`
Legacy EEL	`ImGui_DrawListSplitter* extension_api("ImGui_CreateDrawListSplitter", ImGui_DrawList draw_list)`
Lua	`ImGui_DrawListSplitter retval = ImGui.CreateDrawListSplitter(ImGui_DrawList draw_list)`
Python	`ImGui_DrawListSplitter retval = ImGui.CreateDrawListSplitter(ImGui_DrawList draw_list)`

View source · v0.9+

Function: DrawListSplitter_Clear

C++	`void ImGui::DrawListSplitter_Clear(ImGui_DrawListSplitter* splitter)`
EEL	`ImGui_DrawListSplitter_Clear(ImGui_DrawListSplitter splitter)`
Legacy EEL	`extension_api("ImGui_DrawListSplitter_Clear", ImGui_DrawListSplitter splitter)`
Lua	`ImGui.DrawListSplitter_Clear(ImGui_DrawListSplitter splitter)`
Python	`ImGui.DrawListSplitter_Clear(ImGui_DrawListSplitter splitter)`

View source · v0.7.1+

Function: DrawListSplitter_Merge

C++	`void ImGui::DrawListSplitter_Merge(ImGui_DrawListSplitter* splitter)`
EEL	`ImGui_DrawListSplitter_Merge(ImGui_DrawListSplitter splitter)`
Legacy EEL	`extension_api("ImGui_DrawListSplitter_Merge", ImGui_DrawListSplitter splitter)`
Lua	`ImGui.DrawListSplitter_Merge(ImGui_DrawListSplitter splitter)`
Python	`ImGui.DrawListSplitter_Merge(ImGui_DrawListSplitter splitter)`

View source · v0.7.1+

Function: DrawListSplitter_SetCurrentChannel

C++	`void ImGui::DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter* splitter, int channel_idx)`
EEL	`ImGui_DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter splitter, int channel_idx)`
Legacy EEL	`extension_api("ImGui_DrawListSplitter_SetCurrentChannel", ImGui_DrawListSplitter splitter, int channel_idx)`
Lua	`ImGui.DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter splitter, integer channel_idx)`
Python	`ImGui.DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter splitter, int channel_idx)`

View source · v0.7.1+

Function: DrawListSplitter_Split

C++	`void ImGui::DrawListSplitter_Split(ImGui_DrawListSplitter* splitter, int count)`
EEL	`ImGui_DrawListSplitter_Split(ImGui_DrawListSplitter splitter, int count)`
Legacy EEL	`extension_api("ImGui_DrawListSplitter_Split", ImGui_DrawListSplitter splitter, int count)`
Lua	`ImGui.DrawListSplitter_Split(ImGui_DrawListSplitter splitter, integer count)`
Python	`ImGui.DrawListSplitter_Split(ImGui_DrawListSplitter splitter, int count)`

View source · v0.7.1+

Stateful Path

Stateful path API, add points then finish with PathFillConvex() or PathStroke().

Function: DrawList_PathArcTo

C++	`void ImGui::DrawList_PathArcTo(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, double a_min, double a_max, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_PathArcTo(ImGui_DrawList draw_list, center_x, center_y, radius, a_min, a_max, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_PathArcTo", ImGui_DrawList draw_list, center_x, center_y, radius, a_min, a_max, int num_segments = 0)`
Lua	`ImGui.DrawList_PathArcTo(ImGui_DrawList draw_list, number center_x, number center_y, number radius, number a_min, number a_max, integer num_segments = 0)`
Python	`ImGui.DrawList_PathArcTo(ImGui_DrawList draw_list, float center_x, float center_y, float radius, float a_min, float a_max, int num_segments = 0)`

View source · v0.1+

Function: DrawList_PathArcToFast

C++	`void ImGui::DrawList_PathArcToFast(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int a_min_of_12, int a_max_of_12)`
EEL	`ImGui_DrawList_PathArcToFast(ImGui_DrawList draw_list, center_x, center_y, radius, int a_min_of_12, int a_max_of_12)`
Legacy EEL	`extension_api("ImGui_DrawList_PathArcToFast", ImGui_DrawList draw_list, center_x, center_y, radius, int a_min_of_12, int a_max_of_12)`
Lua	`ImGui.DrawList_PathArcToFast(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer a_min_of_12, integer a_max_of_12)`
Python	`ImGui.DrawList_PathArcToFast(ImGui_DrawList draw_list, float center_x, float center_y, float radius, int a_min_of_12, int a_max_of_12)`

Use precomputed angles for a 12 steps circle.

View source · v0.1+

Function: DrawList_PathBezierCubicCurveTo

C++	`void ImGui::DrawList_PathBezierCubicCurveTo(ImGui_DrawList* draw_list, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_PathBezierCubicCurveTo(ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_PathBezierCubicCurveTo", ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int num_segments = 0)`
Lua	`ImGui.DrawList_PathBezierCubicCurveTo(ImGui_DrawList draw_list, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer num_segments = 0)`
Python	`ImGui.DrawList_PathBezierCubicCurveTo(ImGui_DrawList draw_list, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y, int num_segments = 0)`

Cubic Bezier (4 control points)

View source · v0.1+

Function: DrawList_PathBezierQuadraticCurveTo

C++	`void ImGui::DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList* draw_list, double p2_x, double p2_y, double p3_x, double p3_y, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_PathBezierQuadraticCurveTo", ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, int num_segments = 0)`
Lua	`ImGui.DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList draw_list, number p2_x, number p2_y, number p3_x, number p3_y, integer num_segments = 0)`
Python	`ImGui.DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList draw_list, float p2_x, float p2_y, float p3_x, float p3_y, int num_segments = 0)`

Quadratic Bezier (3 control points)

View source · v0.1+

Function: DrawList_PathClear

C++	`void ImGui::DrawList_PathClear(ImGui_DrawList* draw_list)`
EEL	`ImGui_DrawList_PathClear(ImGui_DrawList draw_list)`
Legacy EEL	`extension_api("ImGui_DrawList_PathClear", ImGui_DrawList draw_list)`
Lua	`ImGui.DrawList_PathClear(ImGui_DrawList draw_list)`
Python	`ImGui.DrawList_PathClear(ImGui_DrawList draw_list)`

View source · v0.1+

Function: DrawList_PathEllipticalArcTo

C++	`void ImGui::DrawList_PathEllipticalArcTo(ImGui_DrawList* draw_list, double center_x, double center_y, double radius_x, double radius_y, double rot, double a_min, double a_max, int num_segmentsInOptional = 0)`
EEL	`ImGui_DrawList_PathEllipticalArcTo(ImGui_DrawList draw_list, center_x, center_y, radius_x, radius_y, rot, a_min, a_max, int num_segments = 0)`
Legacy EEL	`extension_api("ImGui_DrawList_PathEllipticalArcTo", ImGui_DrawList draw_list, center_x, center_y, radius_x, radius_y, rot, a_min, a_max, int num_segments = 0)`
Lua	`ImGui.DrawList_PathEllipticalArcTo(ImGui_DrawList draw_list, number center_x, number center_y, number radius_x, number radius_y, number rot, number a_min, number a_max, integer num_segments = 0)`
Python	`ImGui.DrawList_PathEllipticalArcTo(ImGui_DrawList draw_list, float center_x, float center_y, float radius_x, float radius_y, float rot, float a_min, float a_max, int num_segments = 0)`

Ellipse

View source · v0.9+

Function: DrawList_PathFillConcave

C++	`void ImGui::DrawList_PathFillConcave(ImGui_DrawList* draw_list, int col_rgba)`
EEL	`ImGui_DrawList_PathFillConcave(ImGui_DrawList draw_list, int col_rgba)`
Legacy EEL	`extension_api("ImGui_DrawList_PathFillConcave", ImGui_DrawList draw_list, int col_rgba)`
Lua	`ImGui.DrawList_PathFillConcave(ImGui_DrawList draw_list, integer col_rgba)`
Python	`ImGui.DrawList_PathFillConcave(ImGui_DrawList draw_list, int col_rgba)`

View source · v0.9+

Function: DrawList_PathFillConvex

C++	`void ImGui::DrawList_PathFillConvex(ImGui_DrawList* draw_list, int col_rgba)`
EEL	`ImGui_DrawList_PathFillConvex(ImGui_DrawList draw_list, int col_rgba)`
Legacy EEL	`extension_api("ImGui_DrawList_PathFillConvex", ImGui_DrawList draw_list, int col_rgba)`
Lua	`ImGui.DrawList_PathFillConvex(ImGui_DrawList draw_list, integer col_rgba)`
Python	`ImGui.DrawList_PathFillConvex(ImGui_DrawList draw_list, int col_rgba)`

View source · v0.5.1+

Function: DrawList_PathLineTo

C++	`void ImGui::DrawList_PathLineTo(ImGui_DrawList* draw_list, double pos_x, double pos_y)`
EEL	`ImGui_DrawList_PathLineTo(ImGui_DrawList draw_list, pos_x, pos_y)`
Legacy EEL	`extension_api("ImGui_DrawList_PathLineTo", ImGui_DrawList draw_list, pos_x, pos_y)`
Lua	`ImGui.DrawList_PathLineTo(ImGui_DrawList draw_list, number pos_x, number pos_y)`
Python	`ImGui.DrawList_PathLineTo(ImGui_DrawList draw_list, float pos_x, float pos_y)`

View source · v0.1+

Function: DrawList_PathRect

C++	`void ImGui::DrawList_PathRect(ImGui_DrawList* draw_list, double rect_min_x, double rect_min_y, double rect_max_x, double rect_max_y, double roundingInOptional = 0.0, int flagsInOptional = DrawFlags_None)`
EEL	`ImGui_DrawList_PathRect(ImGui_DrawList draw_list, rect_min_x, rect_min_y, rect_max_x, rect_max_y, rounding = 0.0, int flags = DrawFlags_None)`
Legacy EEL	`extension_api("ImGui_DrawList_PathRect", ImGui_DrawList draw_list, rect_min_x, rect_min_y, rect_max_x, rect_max_y, rounding = 0.0, int flags = DrawFlags_None)`
Lua	`ImGui.DrawList_PathRect(ImGui_DrawList draw_list, number rect_min_x, number rect_min_y, number rect_max_x, number rect_max_y, number rounding = 0.0, integer flags = DrawFlags_None)`
Python	`ImGui.DrawList_PathRect(ImGui_DrawList draw_list, float rect_min_x, float rect_min_y, float rect_max_x, float rect_max_y, float rounding = 0.0, int flags = DrawFlags_None)`

View source · v0.1+

Function: DrawList_PathStroke

C++	`void ImGui::DrawList_PathStroke(ImGui_DrawList* draw_list, int col_rgba, int flagsInOptional = DrawFlags_None, double thicknessInOptional = 1.0)`
EEL	`ImGui_DrawList_PathStroke(ImGui_DrawList draw_list, int col_rgba, int flags = DrawFlags_None, thickness = 1.0)`
Legacy EEL	`extension_api("ImGui_DrawList_PathStroke", ImGui_DrawList draw_list, int col_rgba, int flags = DrawFlags_None, thickness = 1.0)`
Lua	`ImGui.DrawList_PathStroke(ImGui_DrawList draw_list, integer col_rgba, integer flags = DrawFlags_None, number thickness = 1.0)`
Python	`ImGui.DrawList_PathStroke(ImGui_DrawList draw_list, int col_rgba, int flags = DrawFlags_None, float thickness = 1.0)`

View source · v0.2+

Font

Supports loading fonts from the system by family name or from a file. Glyphs may contain colors in COLR/CPAL format.

This API currently has multiple limitations (v1.0 blockers):

ReaImGui rasterizes glyphs only from the Basic Latin and Latin Supplement Unicode blocks (U+0020 to U+00FF). UTF-8 is fully supported internally, however characters outside those blocks are displayed as '?'. See issue #5.
Dear ImGui does not support using new fonts in the middle of a frame. Because of this, fonts must first be registered using Attach before any other context functions are used in the same defer cycle. (Attaching a font is a heavy operation and should ideally be done outside of the defer loop.)

Function: CreateFont

C++	`ImGui_Font* ImGui::CreateFont(const char* family_or_file, int size, int flagsInOptional = FontFlags_None)`
EEL	`ImGui_Font* ImGui_CreateFont("family_or_file", int size, int flags = FontFlags_None)`
Legacy EEL	`ImGui_Font* extension_api("ImGui_CreateFont", "family_or_file", int size, int flags = FontFlags_None)`
Lua	`ImGui_Font retval = ImGui.CreateFont(string family_or_file, integer size, integer flags = FontFlags_None)`
Python	`ImGui_Font retval = ImGui.CreateFont(str family_or_file, int size, int flags = FontFlags_None)`

Load a font matching a font family name or from a font file. The font will remain valid while it's attached to a context. See Attach.

The family name can be an installed font or one of the generic fonts: sans-serif, serif, monospace, cursive, fantasy.

If 'family_or_file' specifies a path to a font file (contains a / or \):

The first byte of 'flags' is used as the font index within the file
The font styles in 'flags' are simulated by the font renderer

View source · v0.9+

Function: CreateFontFromMem

C++	`ImGui_Font* ImGui::CreateFontFromMem(const char* data, int data_sz, int size, int flagsInOptional = FontFlags_None)`
EEL	`ImGui_Font* ImGui_CreateFontFromMem("data", int size, int flags = FontFlags_None)`
Legacy EEL	`ImGui_Font* extension_api("ImGui_CreateFontFromMem", "data", int size, int flags = FontFlags_None)`
Lua	`ImGui_Font retval = ImGui.CreateFontFromMem(string data, integer size, integer flags = FontFlags_None)`
Python	`ImGui_Font retval = ImGui.CreateFontFromMem(str data, int size, int flags = FontFlags_None)`

Requires REAPER v6.44 or newer for EEL and Lua. Use CreateFont or explicitely specify data_sz to support older versions.

The first byte of 'flags' is used as the font index within the file
The font styles in 'flags' are simulated by the font renderer

View source · v0.9.3+

Constant: FontFlags_Bold

C++	`int ImGui::FontFlags_Bold`
EEL	`int ImGui_FontFlags_Bold()`
Legacy EEL	`int extension_api("ImGui_FontFlags_Bold")`
Lua	`integer ImGui.FontFlags_Bold`
Python	`int retval = ImGui.FontFlags_Bold()`

View source · v0.4+

Constant: FontFlags_Italic

C++	`int ImGui::FontFlags_Italic`
EEL	`int ImGui_FontFlags_Italic()`
Legacy EEL	`int extension_api("ImGui_FontFlags_Italic")`
Lua	`integer ImGui.FontFlags_Italic`
Python	`int retval = ImGui.FontFlags_Italic()`

View source · v0.4+

Constant: FontFlags_None

C++	`int ImGui::FontFlags_None`
EEL	`int ImGui_FontFlags_None()`
Legacy EEL	`int extension_api("ImGui_FontFlags_None")`
Lua	`integer ImGui.FontFlags_None`
Python	`int retval = ImGui.FontFlags_None()`

View source · v0.4+

Function: GetFont

C++	`ImGui_Font* ImGui::GetFont(ImGui_Context* ctx)`
EEL	`ImGui_Font* ImGui_GetFont(ImGui_Context ctx)`
Legacy EEL	`ImGui_Font* extension_api("ImGui_GetFont", ImGui_Context ctx)`
Lua	`ImGui_Font retval = ImGui.GetFont(ImGui_Context ctx)`
Python	`ImGui_Font retval = ImGui.GetFont(ImGui_Context ctx)`

Get the current font

View source · v0.4+

Function: GetFontSize

C++	`double ImGui::GetFontSize(ImGui_Context* ctx)`
EEL	`double ImGui_GetFontSize(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetFontSize", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetFontSize(ImGui_Context ctx)`
Python	`float retval = ImGui.GetFontSize(ImGui_Context ctx)`

Get current font size (= height in pixels) of current font with current scale applied.

View source · v0.1+

Function: PopFont

C++	`void ImGui::PopFont(ImGui_Context* ctx)`
EEL	`ImGui_PopFont(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopFont", ImGui_Context ctx)`
Lua	`ImGui.PopFont(ImGui_Context ctx)`
Python	`ImGui.PopFont(ImGui_Context ctx)`

See PushFont.

View source · v0.4+

Function: PushFont

C++	`void ImGui::PushFont(ImGui_Context* ctx, ImGui_Font* font)`
EEL	`ImGui_PushFont(ImGui_Context ctx, ImGui_Font font)`
Legacy EEL	`extension_api("ImGui_PushFont", ImGui_Context ctx, ImGui_Font font)`
Lua	`ImGui.PushFont(ImGui_Context ctx, ImGui_Font font)`
Python	`ImGui.PushFont(ImGui_Context ctx, ImGui_Font font)`

Change the current font. Use nil to push the default font. The font object must have been registered using Attach. See PopFont.

View source · v0.4+

Function

Create reusable programs that can passed to and called back from functions such as InputText* and SetNextWindowSizeConstraints.

They can also be used standalone with Function_Execute (eg. faster-than-Lua DSP processing).

Function: CreateFunctionFromEEL

C++	`ImGui_Function* ImGui::CreateFunctionFromEEL(const char* code)`
EEL	`ImGui_Function* ImGui_CreateFunctionFromEEL("code")`
Legacy EEL	`ImGui_Function* extension_api("ImGui_CreateFunctionFromEEL", "code")`
Lua	`ImGui_Function retval = ImGui.CreateFunctionFromEEL(string code)`
Python	`ImGui_Function retval = ImGui.CreateFunctionFromEEL(str code)`

Compile an EEL program.

Standard EEL math and string functions are available in addition to callback-specific functions (see InputTextCallback_*).

View source · v0.9+

Function: Function_Execute

C++	`void ImGui::Function_Execute(ImGui_Function* func)`
EEL	`ImGui_Function_Execute(ImGui_Function func)`
Legacy EEL	`extension_api("ImGui_Function_Execute", ImGui_Function func)`
Lua	`ImGui.Function_Execute(ImGui_Function func)`
Python	`ImGui.Function_Execute(ImGui_Function func)`

View source · v0.8.5+

Function: Function_GetValue

C++	`double ImGui::Function_GetValue(ImGui_Function* func, const char* name)`
EEL	`double ImGui_Function_GetValue(ImGui_Function func, "name")`
Legacy EEL	`double extension_api("ImGui_Function_GetValue", ImGui_Function func, "name")`
Lua	`number retval = ImGui.Function_GetValue(ImGui_Function func, string name)`
Python	`float retval = ImGui.Function_GetValue(ImGui_Function func, str name)`

View source · v0.8.5+

Function: Function_GetValue_Array

C++	`void ImGui::Function_GetValue_Array(ImGui_Function* func, const char* name, reaper_array* values)`
EEL	`ImGui_Function_GetValue_Array(ImGui_Function func, "name", reaper_array values)`
Legacy EEL	`extension_api("ImGui_Function_GetValue_Array", ImGui_Function func, "name", reaper_array values)`
Lua	`ImGui.Function_GetValue_Array(ImGui_Function func, string name, reaper.array values)`
Python	`ImGui.Function_GetValue_Array(ImGui_Function func, str name, reaper_array values)`

Copy the values in the function's memory starting at the address stored in the given variable into the array.

View source · v0.8.5+

Function: Function_GetValue_String

C++	`void ImGui::Function_GetValue_String(ImGui_Function* func, const char* name, char* valueOutNeedBig, int valueOutNeedBig_sz)`
EEL	`ImGui_Function_GetValue_String(ImGui_Function func, "name", #value)`
Legacy EEL	`extension_api("ImGui_Function_GetValue_String", ImGui_Function func, "name", #value)`
Lua	`string value = ImGui.Function_GetValue_String(ImGui_Function func, string name)`
Python	`(str value) = ImGui.Function_GetValue_String(ImGui_Function func, str name)`

Read from a string slot or a named string (when name starts with a #).

View source · v0.8.5+

Function: Function_SetValue

C++	`void ImGui::Function_SetValue(ImGui_Function* func, const char* name, double value)`
EEL	`ImGui_Function_SetValue(ImGui_Function func, "name", value)`
Legacy EEL	`extension_api("ImGui_Function_SetValue", ImGui_Function func, "name", value)`
Lua	`ImGui.Function_SetValue(ImGui_Function func, string name, number value)`
Python	`ImGui.Function_SetValue(ImGui_Function func, str name, float value)`

View source · v0.8.5+

Function: Function_SetValue_Array

C++	`void ImGui::Function_SetValue_Array(ImGui_Function* func, const char* name, reaper_array* values)`
EEL	`ImGui_Function_SetValue_Array(ImGui_Function func, "name", reaper_array values)`
Legacy EEL	`extension_api("ImGui_Function_SetValue_Array", ImGui_Function func, "name", reaper_array values)`
Lua	`ImGui.Function_SetValue_Array(ImGui_Function func, string name, reaper.array values)`
Python	`ImGui.Function_SetValue_Array(ImGui_Function func, str name, reaper_array values)`

Copy the values in the array to the function's memory at the address stored in the given variable.

View source · v0.8.5+

Function: Function_SetValue_String

C++	`void ImGui::Function_SetValue_String(ImGui_Function* func, const char* name, const char* value, int value_sz)`
EEL	`ImGui_Function_SetValue_String(ImGui_Function func, "name", "value")`
Legacy EEL	`extension_api("ImGui_Function_SetValue_String", ImGui_Function func, "name", "value")`
Lua	`ImGui.Function_SetValue_String(ImGui_Function func, string name, string value)`
Python	`ImGui.Function_SetValue_String(ImGui_Function func, str name, str value)`

Write to a string slot or a named string (when name starts with a #).

View source · v0.8.5+

Image

ReaImGui currently supports loading PNG and JPEG bitmap images. Flat vector images may be loaded as fonts, see CreateFont.

UV parameters are texture coordinates in a scale of 0.0 (top/left) to 1.0 (bottom/right). Use values below 0.0 or above 1.0 to tile the image.

Width/height are limited to 8192 pixels.

There are also image functions in the DrawList API such as DrawList_AddImageQuad and DrawList_AddImageRounded.

Function: CreateImage

C++	`ImGui_Image* ImGui::CreateImage(const char* file, int flagsInOptional = nullptr)`
EEL	`ImGui_Image* ImGui_CreateImage("file", int flags = 0)`
Legacy EEL	`ImGui_Image* extension_api("ImGui_CreateImage", "file", int flags = 0)`
Lua	`ImGui_Image retval = ImGui.CreateImage(string file, integer flags = nil)`
Python	`ImGui_Image retval = ImGui.CreateImage(str file, int flags = None)`

The returned object is valid as long as it is used in each defer cycle unless attached to a context (see Attach).

('flags' currently unused and reserved for future expansion)

View source · v0.9+

Function: CreateImageFromLICE

C++	`ImGui_Image* ImGui::CreateImageFromLICE(LICE_IBitmap* bitmap, int flagsInOptional = nullptr)`
EEL	`ImGui_Image* ImGui_CreateImageFromLICE(LICE_IBitmap bitmap, int flags = 0)`
Legacy EEL	`ImGui_Image* extension_api("ImGui_CreateImageFromLICE", LICE_IBitmap bitmap, int flags = 0)`
Lua	`ImGui_Image retval = ImGui.CreateImageFromLICE(LICE_IBitmap bitmap, integer flags = nil)`
Python	`ImGui_Image retval = ImGui.CreateImageFromLICE(LICE_IBitmap bitmap, int flags = None)`

Copies pixel data from a LICE bitmap created using JS_LICE_CreateBitmap.

View source · v0.9.2+

Function: CreateImageFromMem

C++	`ImGui_Image* ImGui::CreateImageFromMem(const char* data, int data_sz, int flagsInOptional = nullptr)`
EEL	`ImGui_Image* ImGui_CreateImageFromMem("data", int flags = 0)`
Legacy EEL	`ImGui_Image* extension_api("ImGui_CreateImageFromMem", "data", int flags = 0)`
Lua	`ImGui_Image retval = ImGui.CreateImageFromMem(string data, integer flags = nil)`
Python	`ImGui_Image retval = ImGui.CreateImageFromMem(str data, int flags = None)`

Requires REAPER v6.44 or newer for EEL and Lua. Load from a file using CreateImage or explicitely specify data_sz to support older versions.

View source · v0.9+

Function: Image

C++	`void ImGui::Image(ImGui_Context* ctx, ImGui_Image* image, double image_size_w, double image_size_h, double uv0_xInOptional = 0.0, double uv0_yInOptional = 0.0, double uv1_xInOptional = 1.0, double uv1_yInOptional = 1.0, int tint_col_rgbaInOptional = 0xFFFFFFFF, int border_col_rgbaInOptional = 0x00000000)`
EEL	`ImGui_Image(ImGui_Context ctx, ImGui_Image image, image_size_w, image_size_h, uv0_x = 0.0, uv0_y = 0.0, uv1_x = 1.0, uv1_y = 1.0, int tint_col_rgba = 0xFFFFFFFF, int border_col_rgba = 0x00000000)`
Legacy EEL	`extension_api("ImGui_Image", ImGui_Context ctx, ImGui_Image image, image_size_w, image_size_h, uv0_x = 0.0, uv0_y = 0.0, uv1_x = 1.0, uv1_y = 1.0, int tint_col_rgba = 0xFFFFFFFF, int border_col_rgba = 0x00000000)`
Lua	`ImGui.Image(ImGui_Context ctx, ImGui_Image image, number image_size_w, number image_size_h, number uv0_x = 0.0, number uv0_y = 0.0, number uv1_x = 1.0, number uv1_y = 1.0, integer tint_col_rgba = 0xFFFFFFFF, integer border_col_rgba = 0x00000000)`
Python	`ImGui.Image(ImGui_Context ctx, ImGui_Image image, float image_size_w, float image_size_h, float uv0_x = 0.0, float uv0_y = 0.0, float uv1_x = 1.0, float uv1_y = 1.0, int tint_col_rgba = 0xFFFFFFFF, int border_col_rgba = 0x00000000)`

Adds 2.0 to the provided size if a border is visible.

View source · v0.8+

Function: ImageButton

C++	`bool ImGui::ImageButton(ImGui_Context* ctx, const char* str_id, ImGui_Image* image, double image_size_w, double image_size_h, double uv0_xInOptional = 0.0, double uv0_yInOptional = 0.0, double uv1_xInOptional = 1.0, double uv1_yInOptional = 1.0, int bg_col_rgbaInOptional = 0x00000000, int tint_col_rgbaInOptional = 0xFFFFFFFF)`
EEL	`bool ImGui_ImageButton(ImGui_Context ctx, "str_id", ImGui_Image image, image_size_w, image_size_h, uv0_x = 0.0, uv0_y = 0.0, uv1_x = 1.0, uv1_y = 1.0, int bg_col_rgba = 0x00000000, int tint_col_rgba = 0xFFFFFFFF)`
Legacy EEL	`bool extension_api("ImGui_ImageButton", ImGui_Context ctx, "str_id", ImGui_Image image, image_size_w, image_size_h, uv0_x = 0.0, uv0_y = 0.0, uv1_x = 1.0, uv1_y = 1.0, int bg_col_rgba = 0x00000000, int tint_col_rgba = 0xFFFFFFFF)`
Lua	`boolean retval = ImGui.ImageButton(ImGui_Context ctx, string str_id, ImGui_Image image, number image_size_w, number image_size_h, number uv0_x = 0.0, number uv0_y = 0.0, number uv1_x = 1.0, number uv1_y = 1.0, integer bg_col_rgba = 0x00000000, integer tint_col_rgba = 0xFFFFFFFF)`
Python	`bool retval = ImGui.ImageButton(ImGui_Context ctx, str str_id, ImGui_Image image, float image_size_w, float image_size_h, float uv0_x = 0.0, float uv0_y = 0.0, float uv1_x = 1.0, float uv1_y = 1.0, int bg_col_rgba = 0x00000000, int tint_col_rgba = 0xFFFFFFFF)`

Adds StyleVar_FramePadding*2.0 to provided size.

View source · v0.8+

Function: Image_GetSize

C++	`void ImGui::Image_GetSize(ImGui_Image* image, double* wOut, double* hOut)`
EEL	`ImGui_Image_GetSize(ImGui_Image image, &w, &h)`
Legacy EEL	`extension_api("ImGui_Image_GetSize", ImGui_Image image, &w, &h)`
Lua	`number w, number h = ImGui.Image_GetSize(ImGui_Image image)`
Python	`(float w, float h) = ImGui.Image_GetSize(ImGui_Image image)`

View source · v0.8+

Image Set

Helper to automatically select and scale an image to the DPI scale of the current window upon usage.

ImageSet objects may be used in any function that expect an image as parameter.

Usage:

local set = ImGui.CreateImageSet()
ImGui.ImageSet_Add(set, 1.0, ImGui.CreateImage('32x32.png'))
ImGui.ImageSet_Add(set, 2.0, ImGui.CreateImage('64x64.png'))

local function frame()
  ImGui.Image(ctx, set, ImGui.Image_GetSize(set))
  -- ...
end

Function: CreateImageSet

C++	`ImGui_ImageSet* ImGui::CreateImageSet()`
EEL	`ImGui_ImageSet* ImGui_CreateImageSet()`
Legacy EEL	`ImGui_ImageSet* extension_api("ImGui_CreateImageSet")`
Lua	`ImGui_ImageSet retval = ImGui.CreateImageSet()`
Python	`ImGui_ImageSet retval = ImGui.CreateImageSet()`

View source · v0.9+

Function: ImageSet_Add

C++	`void ImGui::ImageSet_Add(ImGui_ImageSet* set, double scale, ImGui_Image* image)`
EEL	`ImGui_ImageSet_Add(ImGui_ImageSet set, scale, ImGui_Image image)`
Legacy EEL	`extension_api("ImGui_ImageSet_Add", ImGui_ImageSet set, scale, ImGui_Image image)`
Lua	`ImGui.ImageSet_Add(ImGui_ImageSet set, number scale, ImGui_Image image)`
Python	`ImGui.ImageSet_Add(ImGui_ImageSet set, float scale, ImGui_Image image)`

'img' cannot be another ImageSet.

View source · v0.8+

Item & Status

Function: BeginDisabled

C++	`void ImGui::BeginDisabled(ImGui_Context* ctx, bool disabledInOptional = true)`
EEL	`ImGui_BeginDisabled(ImGui_Context ctx, bool disabled = true)`
Legacy EEL	`extension_api("ImGui_BeginDisabled", ImGui_Context ctx, bool disabled = true)`
Lua	`ImGui.BeginDisabled(ImGui_Context ctx, boolean disabled = true)`
Python	`ImGui.BeginDisabled(ImGui_Context ctx, bool disabled = true)`

Disable all user interactions and dim items visuals (applying StyleVar_DisabledAlpha over current colors).

Those can be nested but it cannot be used to enable an already disabled section (a single BeginDisabled(true) in the stack is enough to keep everything disabled).

Tooltips windows by exception are opted out of disabling.

BeginDisabled(false) essentially does nothing useful but is provided to facilitate use of boolean expressions. If you can avoid calling BeginDisabled(false)/EndDisabled() best to avoid it.

View source · v0.5.5+

Function: DebugStartItemPicker

C++	`void ImGui::DebugStartItemPicker(ImGui_Context* ctx)`
EEL	`ImGui_DebugStartItemPicker(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_DebugStartItemPicker", ImGui_Context ctx)`
Lua	`ImGui.DebugStartItemPicker(ImGui_Context ctx)`
Python	`ImGui.DebugStartItemPicker(ImGui_Context ctx)`

View source · v0.9+

Function: EndDisabled

C++	`void ImGui::EndDisabled(ImGui_Context* ctx)`
EEL	`ImGui_EndDisabled(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndDisabled", ImGui_Context ctx)`
Lua	`ImGui.EndDisabled(ImGui_Context ctx)`
Python	`ImGui.EndDisabled(ImGui_Context ctx)`

See BeginDisabled.

View source · v0.5.5+

Function: SetNextItemAllowOverlap

C++	`void ImGui::SetNextItemAllowOverlap(ImGui_Context* ctx)`
EEL	`ImGui_SetNextItemAllowOverlap(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_SetNextItemAllowOverlap", ImGui_Context ctx)`
Lua	`ImGui.SetNextItemAllowOverlap(ImGui_Context ctx)`
Python	`ImGui.SetNextItemAllowOverlap(ImGui_Context ctx)`

Allow next item to be overlapped by a subsequent item. Useful with invisible buttons, selectable, treenode covering an area where subsequent items may need to be added. Note that both Selectable() and TreeNode() have dedicated flags doing this.

View source · v0.9+

Dimensions

Function: CalcItemWidth

C++	`double ImGui::CalcItemWidth(ImGui_Context* ctx)`
EEL	`double ImGui_CalcItemWidth(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_CalcItemWidth", ImGui_Context ctx)`
Lua	`number retval = ImGui.CalcItemWidth(ImGui_Context ctx)`
Python	`float retval = ImGui.CalcItemWidth(ImGui_Context ctx)`

Width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions.

View source · v0.1+

Function: GetItemRectMax

C++	`void ImGui::GetItemRectMax(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetItemRectMax(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetItemRectMax", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetItemRectMax(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetItemRectMax(ImGui_Context ctx)`

Get lower-right bounding rectangle of the last item (screen space)

View source · v0.1+

Function: GetItemRectMin

C++	`void ImGui::GetItemRectMin(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetItemRectMin(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetItemRectMin", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetItemRectMin(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetItemRectMin(ImGui_Context ctx)`

Get upper-left bounding rectangle of the last item (screen space)

View source · v0.1+

Function: GetItemRectSize

C++	`void ImGui::GetItemRectSize(ImGui_Context* ctx, double* wOut, double* hOut)`
EEL	`ImGui_GetItemRectSize(ImGui_Context ctx, &w, &h)`
Legacy EEL	`extension_api("ImGui_GetItemRectSize", ImGui_Context ctx, &w, &h)`
Lua	`number w, number h = ImGui.GetItemRectSize(ImGui_Context ctx)`
Python	`(float w, float h) = ImGui.GetItemRectSize(ImGui_Context ctx)`

Get size of last item

View source · v0.1+

Function: PopItemWidth

C++	`void ImGui::PopItemWidth(ImGui_Context* ctx)`
EEL	`ImGui_PopItemWidth(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopItemWidth", ImGui_Context ctx)`
Lua	`ImGui.PopItemWidth(ImGui_Context ctx)`
Python	`ImGui.PopItemWidth(ImGui_Context ctx)`

See PushItemWidth

View source · v0.1+

Function: PushItemWidth

C++	`void ImGui::PushItemWidth(ImGui_Context* ctx, double item_width)`
EEL	`ImGui_PushItemWidth(ImGui_Context ctx, item_width)`
Legacy EEL	`extension_api("ImGui_PushItemWidth", ImGui_Context ctx, item_width)`
Lua	`ImGui.PushItemWidth(ImGui_Context ctx, number item_width)`
Python	`ImGui.PushItemWidth(ImGui_Context ctx, float item_width)`

Push width of items for common large "item+label" widgets.

>0.0: width in pixels
<0.0 align xx pixels to the right of window (so -FLT_MIN always align width to the right side)
0.0 = default to ~2/3 of windows width.

View source · v0.1+

Function: SetNextItemWidth

C++	`void ImGui::SetNextItemWidth(ImGui_Context* ctx, double item_width)`
EEL	`ImGui_SetNextItemWidth(ImGui_Context ctx, item_width)`
Legacy EEL	`extension_api("ImGui_SetNextItemWidth", ImGui_Context ctx, item_width)`
Lua	`ImGui.SetNextItemWidth(ImGui_Context ctx, number item_width)`
Python	`ImGui.SetNextItemWidth(ImGui_Context ctx, float item_width)`

Set width of the next common large "item+label" widget.

>0.0: width in pixels
<0.0 align xx pixels to the right of window (so -FLT_MIN always align width to the right side)

View source · v0.1+

Focus & Activation

Prefer using "SetItemDefaultFocus()" over "if(IsWindowAppearing()) SetScrollHereY()" when applicable to signify "this is the default item".

Function: PopTabStop

C++	`void ImGui::PopTabStop(ImGui_Context* ctx)`
EEL	`ImGui_PopTabStop(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopTabStop", ImGui_Context ctx)`
Lua	`ImGui.PopTabStop(ImGui_Context ctx)`
Python	`ImGui.PopTabStop(ImGui_Context ctx)`

See PushTabStop

View source · v0.8.5+

Function: PushTabStop

C++	`void ImGui::PushTabStop(ImGui_Context* ctx, bool tab_stop)`
EEL	`ImGui_PushTabStop(ImGui_Context ctx, bool tab_stop)`
Legacy EEL	`extension_api("ImGui_PushTabStop", ImGui_Context ctx, bool tab_stop)`
Lua	`ImGui.PushTabStop(ImGui_Context ctx, boolean tab_stop)`
Python	`ImGui.PushTabStop(ImGui_Context ctx, bool tab_stop)`

Allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets

View source · v0.8.5+

Function: SetItemDefaultFocus

C++	`void ImGui::SetItemDefaultFocus(ImGui_Context* ctx)`
EEL	`ImGui_SetItemDefaultFocus(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_SetItemDefaultFocus", ImGui_Context ctx)`
Lua	`ImGui.SetItemDefaultFocus(ImGui_Context ctx)`
Python	`ImGui.SetItemDefaultFocus(ImGui_Context ctx)`

Make last item the default focused item of a window.

View source · v0.1+

Function: SetKeyboardFocusHere

C++	`void ImGui::SetKeyboardFocusHere(ImGui_Context* ctx, int offsetInOptional = 0)`
EEL	`ImGui_SetKeyboardFocusHere(ImGui_Context ctx, int offset = 0)`
Legacy EEL	`extension_api("ImGui_SetKeyboardFocusHere", ImGui_Context ctx, int offset = 0)`
Lua	`ImGui.SetKeyboardFocusHere(ImGui_Context ctx, integer offset = 0)`
Python	`ImGui.SetKeyboardFocusHere(ImGui_Context ctx, int offset = 0)`

Focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.

View source · v0.1+

Hovered Flags

For IsItemHovered and IsWindowHovered.

Constant: HoveredFlags_AllowWhenBlockedByActiveItem

C++	`int ImGui::HoveredFlags_AllowWhenBlockedByActiveItem`
EEL	`int ImGui_HoveredFlags_AllowWhenBlockedByActiveItem()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AllowWhenBlockedByActiveItem")`
Lua	`integer ImGui.HoveredFlags_AllowWhenBlockedByActiveItem`
Python	`int retval = ImGui.HoveredFlags_AllowWhenBlockedByActiveItem()`

Return true even if an active item is blocking access to this item/window. Useful for Drag and Drop patterns.

View source · v0.1+

Constant: HoveredFlags_AllowWhenBlockedByPopup

C++	`int ImGui::HoveredFlags_AllowWhenBlockedByPopup`
EEL	`int ImGui_HoveredFlags_AllowWhenBlockedByPopup()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AllowWhenBlockedByPopup")`
Lua	`integer ImGui.HoveredFlags_AllowWhenBlockedByPopup`
Python	`int retval = ImGui.HoveredFlags_AllowWhenBlockedByPopup()`

Return true even if a popup window is normally blocking access to this item/window.

View source · v0.1+

Constant: HoveredFlags_ForTooltip

C++	`int ImGui::HoveredFlags_ForTooltip`
EEL	`int ImGui_HoveredFlags_ForTooltip()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_ForTooltip")`
Lua	`integer ImGui.HoveredFlags_ForTooltip`
Python	`int retval = ImGui.HoveredFlags_ForTooltip()`

Typically used with IsItemHovered() before SetTooltip(). This is a shortcut to pull flags from ConfigVar_HoverFlagsForTooltip* where you can reconfigure the desired behavior.

For frequently actioned or hovered items providing a tooltip, you want may to use this (defaults to stationary + delay) so the tooltip doesn't show too often. For items which main purpose is to be hovered, or items with low affordance, or in less consistent apps, prefer no delay or shorter delay.

View source · v0.9+

Constant: HoveredFlags_NoNavOverride

C++	`int ImGui::HoveredFlags_NoNavOverride`
EEL	`int ImGui_HoveredFlags_NoNavOverride()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_NoNavOverride")`
Lua	`integer ImGui.HoveredFlags_NoNavOverride`
Python	`int retval = ImGui.HoveredFlags_NoNavOverride()`

Disable using gamepad/keyboard navigation state when active, always query mouse.

View source · v0.7+

Constant: HoveredFlags_None

C++	`int ImGui::HoveredFlags_None`
EEL	`int ImGui_HoveredFlags_None()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_None")`
Lua	`integer ImGui.HoveredFlags_None`
Python	`int retval = ImGui.HoveredFlags_None()`

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.

View source · v0.1+

Constant: HoveredFlags_Stationary

C++	`int ImGui::HoveredFlags_Stationary`
EEL	`int ImGui_HoveredFlags_Stationary()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_Stationary")`
Lua	`integer ImGui.HoveredFlags_Stationary`
Python	`int retval = ImGui.HoveredFlags_Stationary()`

Require mouse to be stationary for ConfigVar_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.

View source · v0.9+

For IsItemHovered

Constant: HoveredFlags_AllowWhenDisabled

C++	`int ImGui::HoveredFlags_AllowWhenDisabled`
EEL	`int ImGui_HoveredFlags_AllowWhenDisabled()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AllowWhenDisabled")`
Lua	`integer ImGui.HoveredFlags_AllowWhenDisabled`
Python	`int retval = ImGui.HoveredFlags_AllowWhenDisabled()`

Return true even if the item is disabled.

View source · v0.1+

Constant: HoveredFlags_AllowWhenOverlapped

C++	`int ImGui::HoveredFlags_AllowWhenOverlapped`
EEL	`int ImGui_HoveredFlags_AllowWhenOverlapped()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AllowWhenOverlapped")`
Lua	`integer ImGui.HoveredFlags_AllowWhenOverlapped`
Python	`int retval = ImGui.HoveredFlags_AllowWhenOverlapped()`

HoveredFlags_AllowWhenOverlappedByItem | HoveredFlags_AllowWhenOverlappedByWindow

View source · v0.1+

Constant: HoveredFlags_AllowWhenOverlappedByItem

C++	`int ImGui::HoveredFlags_AllowWhenOverlappedByItem`
EEL	`int ImGui_HoveredFlags_AllowWhenOverlappedByItem()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AllowWhenOverlappedByItem")`
Lua	`integer ImGui.HoveredFlags_AllowWhenOverlappedByItem`
Python	`int retval = ImGui.HoveredFlags_AllowWhenOverlappedByItem()`

Return true even if the item uses AllowOverlap mode and is overlapped by another hoverable item.

View source · v0.9+

Constant: HoveredFlags_AllowWhenOverlappedByWindow

C++	`int ImGui::HoveredFlags_AllowWhenOverlappedByWindow`
EEL	`int ImGui_HoveredFlags_AllowWhenOverlappedByWindow()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AllowWhenOverlappedByWindow")`
Lua	`integer ImGui.HoveredFlags_AllowWhenOverlappedByWindow`
Python	`int retval = ImGui.HoveredFlags_AllowWhenOverlappedByWindow()`

Return true even if the position is obstructed or overlapped by another window.

View source · v0.9+

Constant: HoveredFlags_RectOnly

C++	`int ImGui::HoveredFlags_RectOnly`
EEL	`int ImGui_HoveredFlags_RectOnly()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_RectOnly")`
Lua	`integer ImGui.HoveredFlags_RectOnly`
Python	`int retval = ImGui.HoveredFlags_RectOnly()`

HoveredFlags_AllowWhenBlockedByPopup | HoveredFlags_AllowWhenBlockedByActiveItem | HoveredFlags_AllowWhenOverlapped

View source · v0.1+

Mouse Hovering Delays

Generally you can use HoveredFlags_ForTooltip to use application-standardized flags. Use those if you need specific overrides. See also HoveredFlags_Stationary.

Constant: HoveredFlags_DelayNone

C++	`int ImGui::HoveredFlags_DelayNone`
EEL	`int ImGui_HoveredFlags_DelayNone()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_DelayNone")`
Lua	`integer ImGui.HoveredFlags_DelayNone`
Python	`int retval = ImGui.HoveredFlags_DelayNone()`

Return true immediately (default). As this is the default you generally ignore this.

View source · v0.9+

Constant: HoveredFlags_DelayNormal

C++	`int ImGui::HoveredFlags_DelayNormal`
EEL	`int ImGui_HoveredFlags_DelayNormal()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_DelayNormal")`
Lua	`integer ImGui.HoveredFlags_DelayNormal`
Python	`int retval = ImGui.HoveredFlags_DelayNormal()`

Return true after ConfigVar_HoverDelayNormal elapsed (~0.40 sec) (shared between items) + requires mouse to be stationary for ConfigVar_HoverStationaryDelay (once per item).

View source · v0.8+

Constant: HoveredFlags_DelayShort

C++	`int ImGui::HoveredFlags_DelayShort`
EEL	`int ImGui_HoveredFlags_DelayShort()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_DelayShort")`
Lua	`integer ImGui.HoveredFlags_DelayShort`
Python	`int retval = ImGui.HoveredFlags_DelayShort()`

Return true after ConfigVar_HoverDelayShort elapsed (~0.15 sec) (shared between items) + requires mouse to be stationary for ConfigVar_HoverStationaryDelay (once per item).

View source · v0.8+

Constant: HoveredFlags_NoSharedDelay

C++	`int ImGui::HoveredFlags_NoSharedDelay`
EEL	`int ImGui_HoveredFlags_NoSharedDelay()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_NoSharedDelay")`
Lua	`integer ImGui.HoveredFlags_NoSharedDelay`
Python	`int retval = ImGui.HoveredFlags_NoSharedDelay()`

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

View source · v0.8+

For IsWindowHovered

Constant: HoveredFlags_AnyWindow

C++	`int ImGui::HoveredFlags_AnyWindow`
EEL	`int ImGui_HoveredFlags_AnyWindow()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_AnyWindow")`
Lua	`integer ImGui.HoveredFlags_AnyWindow`
Python	`int retval = ImGui.HoveredFlags_AnyWindow()`

Return true if any window is hovered.

View source · v0.1+

Constant: HoveredFlags_ChildWindows

C++	`int ImGui::HoveredFlags_ChildWindows`
EEL	`int ImGui_HoveredFlags_ChildWindows()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_ChildWindows")`
Lua	`integer ImGui.HoveredFlags_ChildWindows`
Python	`int retval = ImGui.HoveredFlags_ChildWindows()`

Return true if any children of the window is hovered.

View source · v0.1+

Constant: HoveredFlags_DockHierarchy

C++	`int ImGui::HoveredFlags_DockHierarchy`
EEL	`int ImGui_HoveredFlags_DockHierarchy()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_DockHierarchy")`
Lua	`integer ImGui.HoveredFlags_DockHierarchy`
Python	`int retval = ImGui.HoveredFlags_DockHierarchy()`

Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow).

View source · v0.5.10+

Constant: HoveredFlags_NoPopupHierarchy

C++	`int ImGui::HoveredFlags_NoPopupHierarchy`
EEL	`int ImGui_HoveredFlags_NoPopupHierarchy()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_NoPopupHierarchy")`
Lua	`integer ImGui.HoveredFlags_NoPopupHierarchy`
Python	`int retval = ImGui.HoveredFlags_NoPopupHierarchy()`

Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow).

View source · v0.5.10+

Constant: HoveredFlags_RootAndChildWindows

C++	`int ImGui::HoveredFlags_RootAndChildWindows`
EEL	`int ImGui_HoveredFlags_RootAndChildWindows()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_RootAndChildWindows")`
Lua	`integer ImGui.HoveredFlags_RootAndChildWindows`
Python	`int retval = ImGui.HoveredFlags_RootAndChildWindows()`

HoveredFlags_RootWindow | HoveredFlags_ChildWindows

View source · v0.1+

Constant: HoveredFlags_RootWindow

C++	`int ImGui::HoveredFlags_RootWindow`
EEL	`int ImGui_HoveredFlags_RootWindow()`
Legacy EEL	`int extension_api("ImGui_HoveredFlags_RootWindow")`
Lua	`integer ImGui.HoveredFlags_RootWindow`
Python	`int retval = ImGui.HoveredFlags_RootWindow()`

Test from root window (top most parent of the current hierarchy).

View source · v0.1+

Item/Widgets Utilities and Query Functions

Most of the functions are referring to the previous Item that has been submitted.

See Demo Window under "Widgets->Querying Item Status" for an interactive visualization of most of those functions.

Function: IsAnyItemActive

C++	`bool ImGui::IsAnyItemActive(ImGui_Context* ctx)`
EEL	`bool ImGui_IsAnyItemActive(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsAnyItemActive", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsAnyItemActive(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsAnyItemActive(ImGui_Context ctx)`

View source · v0.1+

Function: IsAnyItemFocused

C++	`bool ImGui::IsAnyItemFocused(ImGui_Context* ctx)`
EEL	`bool ImGui_IsAnyItemFocused(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsAnyItemFocused", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsAnyItemFocused(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsAnyItemFocused(ImGui_Context ctx)`

View source · v0.1+

Function: IsAnyItemHovered

C++	`bool ImGui::IsAnyItemHovered(ImGui_Context* ctx)`
EEL	`bool ImGui_IsAnyItemHovered(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsAnyItemHovered", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsAnyItemHovered(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsAnyItemHovered(ImGui_Context ctx)`

View source · v0.1+

Function: IsItemActivated

C++	`bool ImGui::IsItemActivated(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemActivated(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemActivated", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemActivated(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemActivated(ImGui_Context ctx)`

Was the last item just made active (item was previously inactive).

View source · v0.1+

Function: IsItemActive

C++	`bool ImGui::IsItemActive(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemActive(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemActive", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemActive(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemActive(ImGui_Context ctx)`

Is the last item active? (e.g. button being held, text field being edited. This will continuously return true while holding mouse button on an item. Items that don't interact will always return false.

View source · v0.1+

Function: IsItemClicked

C++	`bool ImGui::IsItemClicked(ImGui_Context* ctx, int mouse_buttonInOptional = MouseButton_Left)`
EEL	`bool ImGui_IsItemClicked(ImGui_Context ctx, int mouse_button = MouseButton_Left)`
Legacy EEL	`bool extension_api("ImGui_IsItemClicked", ImGui_Context ctx, int mouse_button = MouseButton_Left)`
Lua	`boolean retval = ImGui.IsItemClicked(ImGui_Context ctx, integer mouse_button = MouseButton_Left)`
Python	`bool retval = ImGui.IsItemClicked(ImGui_Context ctx, int mouse_button = MouseButton_Left)`

Is the last item clicked? (e.g. button/node just clicked on) == IsMouseClicked(mouse_button) && IsItemHovered().

This is NOT equivalent to the behavior of e.g. Button. Most widgets have specific reactions based on mouse-up/down state, mouse position etc.

View source · v0.1+

Function: IsItemDeactivated

C++	`bool ImGui::IsItemDeactivated(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemDeactivated(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemDeactivated", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemDeactivated(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemDeactivated(ImGui_Context ctx)`

Was the last item just made inactive (item was previously active). Useful for Undo/Redo patterns with widgets that require continuous editing.

View source · v0.1+

Function: IsItemDeactivatedAfterEdit

C++	`bool ImGui::IsItemDeactivatedAfterEdit(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemDeactivatedAfterEdit(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemDeactivatedAfterEdit", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemDeactivatedAfterEdit(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemDeactivatedAfterEdit(ImGui_Context ctx)`

Was the last item just made inactive and made a value change when it was active? (e.g. Slider/Drag moved).

Useful for Undo/Redo patterns with widgets that require continuous editing. Note that you may get false positives (some widgets such as Combo/ListBox/Selectable will return true even when clicking an already selected item).

View source · v0.1+

Function: IsItemEdited

C++	`bool ImGui::IsItemEdited(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemEdited(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemEdited", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemEdited(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemEdited(ImGui_Context ctx)`

Did the last item modify its underlying value this frame? or was pressed? This is generally the same as the "bool" return value of many widgets.

View source · v0.1+

Function: IsItemFocused

C++	`bool ImGui::IsItemFocused(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemFocused(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemFocused", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemFocused(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemFocused(ImGui_Context ctx)`

Is the last item focused for keyboard/gamepad navigation?

View source · v0.1+

Function: IsItemHovered

C++	`bool ImGui::IsItemHovered(ImGui_Context* ctx, int flagsInOptional = HoveredFlags_None)`
EEL	`bool ImGui_IsItemHovered(ImGui_Context ctx, int flags = HoveredFlags_None)`
Legacy EEL	`bool extension_api("ImGui_IsItemHovered", ImGui_Context ctx, int flags = HoveredFlags_None)`
Lua	`boolean retval = ImGui.IsItemHovered(ImGui_Context ctx, integer flags = HoveredFlags_None)`
Python	`bool retval = ImGui.IsItemHovered(ImGui_Context ctx, int flags = HoveredFlags_None)`

Is the last item hovered? (and usable, aka not blocked by a popup, etc.). See HoveredFlags_* for more options.

View source · v0.9+

Function: IsItemVisible

C++	`bool ImGui::IsItemVisible(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemVisible(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemVisible", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemVisible(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemVisible(ImGui_Context ctx)`

Is the last item visible? (items may be out of sight because of clipping/scrolling)

View source · v0.1+

Keyboard & Mouse

Keyboard

Function: GetInputQueueCharacter

C++	`bool ImGui::GetInputQueueCharacter(ImGui_Context* ctx, int idx, int* unicode_charOut)`
EEL	`bool ImGui_GetInputQueueCharacter(ImGui_Context ctx, int idx, int &unicode_char)`
Legacy EEL	`bool extension_api("ImGui_GetInputQueueCharacter", ImGui_Context ctx, int idx, int &unicode_char)`
Lua	`boolean retval, integer unicode_char = ImGui.GetInputQueueCharacter(ImGui_Context ctx, integer idx)`
Python	`(bool retval, int unicode_char) = ImGui.GetInputQueueCharacter(ImGui_Context ctx, int idx)`

Read from ImGui's character input queue. Call with increasing idx until false is returned.

View source · v0.1+

Function: GetKeyDownDuration

C++	`double ImGui::GetKeyDownDuration(ImGui_Context* ctx, int key)`
EEL	`double ImGui_GetKeyDownDuration(ImGui_Context ctx, int key)`
Legacy EEL	`double extension_api("ImGui_GetKeyDownDuration", ImGui_Context ctx, int key)`
Lua	`number retval = ImGui.GetKeyDownDuration(ImGui_Context ctx, integer key)`
Python	`float retval = ImGui.GetKeyDownDuration(ImGui_Context ctx, int key)`

Duration the keyboard key has been down (0.0 == just pressed)

View source · v0.9+

Function: GetKeyMods

C++	`int ImGui::GetKeyMods(ImGui_Context* ctx)`
EEL	`int ImGui_GetKeyMods(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_GetKeyMods", ImGui_Context ctx)`
Lua	`integer retval = ImGui.GetKeyMods(ImGui_Context ctx)`
Python	`int retval = ImGui.GetKeyMods(ImGui_Context ctx)`

Flags for the Ctrl/Shift/Alt/Super keys. Uses Mod_* values.

View source · v0.8+

Function: GetKeyPressedAmount

C++	`int ImGui::GetKeyPressedAmount(ImGui_Context* ctx, int key, double repeat_delay, double rate)`
EEL	`int ImGui_GetKeyPressedAmount(ImGui_Context ctx, int key, repeat_delay, rate)`
Legacy EEL	`int extension_api("ImGui_GetKeyPressedAmount", ImGui_Context ctx, int key, repeat_delay, rate)`
Lua	`integer retval = ImGui.GetKeyPressedAmount(ImGui_Context ctx, integer key, number repeat_delay, number rate)`
Python	`int retval = ImGui.GetKeyPressedAmount(ImGui_Context ctx, int key, float repeat_delay, float rate)`

Uses provided repeat rate/delay. Return a count, most often 0 or 1 but might be >1 if ConfigVar_RepeatRate is small enough that GetDeltaTime > RepeatRate.

View source · v0.9+

Function: IsKeyDown

C++	`bool ImGui::IsKeyDown(ImGui_Context* ctx, int key)`
EEL	`bool ImGui_IsKeyDown(ImGui_Context ctx, int key)`
Legacy EEL	`bool extension_api("ImGui_IsKeyDown", ImGui_Context ctx, int key)`
Lua	`boolean retval = ImGui.IsKeyDown(ImGui_Context ctx, integer key)`
Python	`bool retval = ImGui.IsKeyDown(ImGui_Context ctx, int key)`

Is key being held.

View source · v0.9+

Function: IsKeyPressed

C++	`bool ImGui::IsKeyPressed(ImGui_Context* ctx, int key, bool repeatInOptional = true)`
EEL	`bool ImGui_IsKeyPressed(ImGui_Context ctx, int key, bool repeat = true)`
Legacy EEL	`bool extension_api("ImGui_IsKeyPressed", ImGui_Context ctx, int key, bool repeat = true)`
Lua	`boolean retval = ImGui.IsKeyPressed(ImGui_Context ctx, integer key, boolean repeat = true)`
Python	`bool retval = ImGui.IsKeyPressed(ImGui_Context ctx, int key, bool repeat = true)`

Was key pressed (went from !Down to Down)? If repeat=true, uses ConfigVar_KeyRepeatDelay / ConfigVar_KeyRepeatRate.

View source · v0.9+

Function: IsKeyReleased

C++	`bool ImGui::IsKeyReleased(ImGui_Context* ctx, int key)`
EEL	`bool ImGui_IsKeyReleased(ImGui_Context ctx, int key)`
Legacy EEL	`bool extension_api("ImGui_IsKeyReleased", ImGui_Context ctx, int key)`
Lua	`boolean retval = ImGui.IsKeyReleased(ImGui_Context ctx, integer key)`
Python	`bool retval = ImGui.IsKeyReleased(ImGui_Context ctx, int key)`

Was key released (went from Down to !Down)?

View source · v0.9+

Function: SetNextFrameWantCaptureKeyboard

C++	`void ImGui::SetNextFrameWantCaptureKeyboard(ImGui_Context* ctx, bool want_capture_keyboard)`
EEL	`ImGui_SetNextFrameWantCaptureKeyboard(ImGui_Context ctx, bool want_capture_keyboard)`
Legacy EEL	`extension_api("ImGui_SetNextFrameWantCaptureKeyboard", ImGui_Context ctx, bool want_capture_keyboard)`
Lua	`ImGui.SetNextFrameWantCaptureKeyboard(ImGui_Context ctx, boolean want_capture_keyboard)`
Python	`ImGui.SetNextFrameWantCaptureKeyboard(ImGui_Context ctx, bool want_capture_keyboard)`

Request capture of keyboard shortcuts in REAPER's global scope for the next frame.

View source · v0.7+

Named Keys

Keyboard

Constant: Key_0

C++	`int ImGui::Key_0`
EEL	`int ImGui_Key_0()`
Legacy EEL	`int extension_api("ImGui_Key_0")`
Lua	`integer ImGui.Key_0`
Python	`int retval = ImGui.Key_0()`

View source · v0.6+

Constant: Key_1

C++	`int ImGui::Key_1`
EEL	`int ImGui_Key_1()`
Legacy EEL	`int extension_api("ImGui_Key_1")`
Lua	`integer ImGui.Key_1`
Python	`int retval = ImGui.Key_1()`

View source · v0.6+

Constant: Key_2

C++	`int ImGui::Key_2`
EEL	`int ImGui_Key_2()`
Legacy EEL	`int extension_api("ImGui_Key_2")`
Lua	`integer ImGui.Key_2`
Python	`int retval = ImGui.Key_2()`

View source · v0.6+

Constant: Key_3

C++	`int ImGui::Key_3`
EEL	`int ImGui_Key_3()`
Legacy EEL	`int extension_api("ImGui_Key_3")`
Lua	`integer ImGui.Key_3`
Python	`int retval = ImGui.Key_3()`

View source · v0.6+

Constant: Key_4

C++	`int ImGui::Key_4`
EEL	`int ImGui_Key_4()`
Legacy EEL	`int extension_api("ImGui_Key_4")`
Lua	`integer ImGui.Key_4`
Python	`int retval = ImGui.Key_4()`

View source · v0.6+

Constant: Key_5

C++	`int ImGui::Key_5`
EEL	`int ImGui_Key_5()`
Legacy EEL	`int extension_api("ImGui_Key_5")`
Lua	`integer ImGui.Key_5`
Python	`int retval = ImGui.Key_5()`

View source · v0.6+

Constant: Key_6

C++	`int ImGui::Key_6`
EEL	`int ImGui_Key_6()`
Legacy EEL	`int extension_api("ImGui_Key_6")`
Lua	`integer ImGui.Key_6`
Python	`int retval = ImGui.Key_6()`

View source · v0.6+

Constant: Key_7

C++	`int ImGui::Key_7`
EEL	`int ImGui_Key_7()`
Legacy EEL	`int extension_api("ImGui_Key_7")`
Lua	`integer ImGui.Key_7`
Python	`int retval = ImGui.Key_7()`

View source · v0.6+

Constant: Key_8

C++	`int ImGui::Key_8`
EEL	`int ImGui_Key_8()`
Legacy EEL	`int extension_api("ImGui_Key_8")`
Lua	`integer ImGui.Key_8`
Python	`int retval = ImGui.Key_8()`

View source · v0.6+

Constant: Key_9

C++	`int ImGui::Key_9`
EEL	`int ImGui_Key_9()`
Legacy EEL	`int extension_api("ImGui_Key_9")`
Lua	`integer ImGui.Key_9`
Python	`int retval = ImGui.Key_9()`

View source · v0.6+

Constant: Key_A

C++	`int ImGui::Key_A`
EEL	`int ImGui_Key_A()`
Legacy EEL	`int extension_api("ImGui_Key_A")`
Lua	`integer ImGui.Key_A`
Python	`int retval = ImGui.Key_A()`

View source · v0.6+

Constant: Key_Apostrophe

C++	`int ImGui::Key_Apostrophe`
EEL	`int ImGui_Key_Apostrophe()`
Legacy EEL	`int extension_api("ImGui_Key_Apostrophe")`
Lua	`integer ImGui.Key_Apostrophe`
Python	`int retval = ImGui.Key_Apostrophe()`

View source · v0.6+

Constant: Key_AppBack

C++	`int ImGui::Key_AppBack`
EEL	`int ImGui_Key_AppBack()`
Legacy EEL	`int extension_api("ImGui_Key_AppBack")`
Lua	`integer ImGui.Key_AppBack`
Python	`int retval = ImGui.Key_AppBack()`

Available on some keyboard/mouses. Often referred as "Browser Back".

View source · v0.9+

Constant: Key_AppForward

C++	`int ImGui::Key_AppForward`
EEL	`int ImGui_Key_AppForward()`
Legacy EEL	`int extension_api("ImGui_Key_AppForward")`
Lua	`integer ImGui.Key_AppForward`
Python	`int retval = ImGui.Key_AppForward()`

View source · v0.9+

Constant: Key_B

C++	`int ImGui::Key_B`
EEL	`int ImGui_Key_B()`
Legacy EEL	`int extension_api("ImGui_Key_B")`
Lua	`integer ImGui.Key_B`
Python	`int retval = ImGui.Key_B()`

View source · v0.6+

Constant: Key_Backslash

C++	`int ImGui::Key_Backslash`
EEL	`int ImGui_Key_Backslash()`
Legacy EEL	`int extension_api("ImGui_Key_Backslash")`
Lua	`integer ImGui.Key_Backslash`
Python	`int retval = ImGui.Key_Backslash()`

View source · v0.6+

Constant: Key_Backspace

C++	`int ImGui::Key_Backspace`
EEL	`int ImGui_Key_Backspace()`
Legacy EEL	`int extension_api("ImGui_Key_Backspace")`
Lua	`integer ImGui.Key_Backspace`
Python	`int retval = ImGui.Key_Backspace()`

View source · v0.6+

Constant: Key_C

C++	`int ImGui::Key_C`
EEL	`int ImGui_Key_C()`
Legacy EEL	`int extension_api("ImGui_Key_C")`
Lua	`integer ImGui.Key_C`
Python	`int retval = ImGui.Key_C()`

View source · v0.6+

Constant: Key_CapsLock

C++	`int ImGui::Key_CapsLock`
EEL	`int ImGui_Key_CapsLock()`
Legacy EEL	`int extension_api("ImGui_Key_CapsLock")`
Lua	`integer ImGui.Key_CapsLock`
Python	`int retval = ImGui.Key_CapsLock()`

View source · v0.6+

Constant: Key_Comma

C++	`int ImGui::Key_Comma`
EEL	`int ImGui_Key_Comma()`
Legacy EEL	`int extension_api("ImGui_Key_Comma")`
Lua	`integer ImGui.Key_Comma`
Python	`int retval = ImGui.Key_Comma()`

View source · v0.6+

Constant: Key_D

C++	`int ImGui::Key_D`
EEL	`int ImGui_Key_D()`
Legacy EEL	`int extension_api("ImGui_Key_D")`
Lua	`integer ImGui.Key_D`
Python	`int retval = ImGui.Key_D()`

View source · v0.6+

Constant: Key_Delete

C++	`int ImGui::Key_Delete`
EEL	`int ImGui_Key_Delete()`
Legacy EEL	`int extension_api("ImGui_Key_Delete")`
Lua	`integer ImGui.Key_Delete`
Python	`int retval = ImGui.Key_Delete()`

View source · v0.6+

Constant: Key_DownArrow

C++	`int ImGui::Key_DownArrow`
EEL	`int ImGui_Key_DownArrow()`
Legacy EEL	`int extension_api("ImGui_Key_DownArrow")`
Lua	`integer ImGui.Key_DownArrow`
Python	`int retval = ImGui.Key_DownArrow()`

View source · v0.6+

Constant: Key_E

C++	`int ImGui::Key_E`
EEL	`int ImGui_Key_E()`
Legacy EEL	`int extension_api("ImGui_Key_E")`
Lua	`integer ImGui.Key_E`
Python	`int retval = ImGui.Key_E()`

View source · v0.6+

Constant: Key_End

C++	`int ImGui::Key_End`
EEL	`int ImGui_Key_End()`
Legacy EEL	`int extension_api("ImGui_Key_End")`
Lua	`integer ImGui.Key_End`
Python	`int retval = ImGui.Key_End()`

View source · v0.6+

Constant: Key_Enter

C++	`int ImGui::Key_Enter`
EEL	`int ImGui_Key_Enter()`
Legacy EEL	`int extension_api("ImGui_Key_Enter")`
Lua	`integer ImGui.Key_Enter`
Python	`int retval = ImGui.Key_Enter()`

View source · v0.6+

Constant: Key_Equal

C++	`int ImGui::Key_Equal`
EEL	`int ImGui_Key_Equal()`
Legacy EEL	`int extension_api("ImGui_Key_Equal")`
Lua	`integer ImGui.Key_Equal`
Python	`int retval = ImGui.Key_Equal()`

View source · v0.6+

Constant: Key_Escape

C++	`int ImGui::Key_Escape`
EEL	`int ImGui_Key_Escape()`
Legacy EEL	`int extension_api("ImGui_Key_Escape")`
Lua	`integer ImGui.Key_Escape`
Python	`int retval = ImGui.Key_Escape()`

View source · v0.6+

Constant: Key_F

C++	`int ImGui::Key_F`
EEL	`int ImGui_Key_F()`
Legacy EEL	`int extension_api("ImGui_Key_F")`
Lua	`integer ImGui.Key_F`
Python	`int retval = ImGui.Key_F()`

View source · v0.6+

Constant: Key_F1

C++	`int ImGui::Key_F1`
EEL	`int ImGui_Key_F1()`
Legacy EEL	`int extension_api("ImGui_Key_F1")`
Lua	`integer ImGui.Key_F1`
Python	`int retval = ImGui.Key_F1()`

View source · v0.6+

Constant: Key_F10

C++	`int ImGui::Key_F10`
EEL	`int ImGui_Key_F10()`
Legacy EEL	`int extension_api("ImGui_Key_F10")`
Lua	`integer ImGui.Key_F10`
Python	`int retval = ImGui.Key_F10()`

View source · v0.6+

Constant: Key_F11

C++	`int ImGui::Key_F11`
EEL	`int ImGui_Key_F11()`
Legacy EEL	`int extension_api("ImGui_Key_F11")`
Lua	`integer ImGui.Key_F11`
Python	`int retval = ImGui.Key_F11()`

View source · v0.6+

Constant: Key_F12

C++	`int ImGui::Key_F12`
EEL	`int ImGui_Key_F12()`
Legacy EEL	`int extension_api("ImGui_Key_F12")`
Lua	`integer ImGui.Key_F12`
Python	`int retval = ImGui.Key_F12()`

View source · v0.6+

Constant: Key_F13

C++	`int ImGui::Key_F13`
EEL	`int ImGui_Key_F13()`
Legacy EEL	`int extension_api("ImGui_Key_F13")`
Lua	`integer ImGui.Key_F13`
Python	`int retval = ImGui.Key_F13()`

View source · v0.9+

Constant: Key_F14

C++	`int ImGui::Key_F14`
EEL	`int ImGui_Key_F14()`
Legacy EEL	`int extension_api("ImGui_Key_F14")`
Lua	`integer ImGui.Key_F14`
Python	`int retval = ImGui.Key_F14()`

View source · v0.9+

Constant: Key_F15

C++	`int ImGui::Key_F15`
EEL	`int ImGui_Key_F15()`
Legacy EEL	`int extension_api("ImGui_Key_F15")`
Lua	`integer ImGui.Key_F15`
Python	`int retval = ImGui.Key_F15()`

View source · v0.9+

Constant: Key_F16

C++	`int ImGui::Key_F16`
EEL	`int ImGui_Key_F16()`
Legacy EEL	`int extension_api("ImGui_Key_F16")`
Lua	`integer ImGui.Key_F16`
Python	`int retval = ImGui.Key_F16()`

View source · v0.9+

Constant: Key_F17

C++	`int ImGui::Key_F17`
EEL	`int ImGui_Key_F17()`
Legacy EEL	`int extension_api("ImGui_Key_F17")`
Lua	`integer ImGui.Key_F17`
Python	`int retval = ImGui.Key_F17()`

View source · v0.9+

Constant: Key_F18

C++	`int ImGui::Key_F18`
EEL	`int ImGui_Key_F18()`
Legacy EEL	`int extension_api("ImGui_Key_F18")`
Lua	`integer ImGui.Key_F18`
Python	`int retval = ImGui.Key_F18()`

View source · v0.9+

Constant: Key_F19

C++	`int ImGui::Key_F19`
EEL	`int ImGui_Key_F19()`
Legacy EEL	`int extension_api("ImGui_Key_F19")`
Lua	`integer ImGui.Key_F19`
Python	`int retval = ImGui.Key_F19()`

View source · v0.9+

Constant: Key_F2

C++	`int ImGui::Key_F2`
EEL	`int ImGui_Key_F2()`
Legacy EEL	`int extension_api("ImGui_Key_F2")`
Lua	`integer ImGui.Key_F2`
Python	`int retval = ImGui.Key_F2()`

View source · v0.6+

Constant: Key_F20

C++	`int ImGui::Key_F20`
EEL	`int ImGui_Key_F20()`
Legacy EEL	`int extension_api("ImGui_Key_F20")`
Lua	`integer ImGui.Key_F20`
Python	`int retval = ImGui.Key_F20()`

View source · v0.9+

Constant: Key_F21

C++	`int ImGui::Key_F21`
EEL	`int ImGui_Key_F21()`
Legacy EEL	`int extension_api("ImGui_Key_F21")`
Lua	`integer ImGui.Key_F21`
Python	`int retval = ImGui.Key_F21()`

View source · v0.9+

Constant: Key_F22

C++	`int ImGui::Key_F22`
EEL	`int ImGui_Key_F22()`
Legacy EEL	`int extension_api("ImGui_Key_F22")`
Lua	`integer ImGui.Key_F22`
Python	`int retval = ImGui.Key_F22()`

View source · v0.9+

Constant: Key_F23

C++	`int ImGui::Key_F23`
EEL	`int ImGui_Key_F23()`
Legacy EEL	`int extension_api("ImGui_Key_F23")`
Lua	`integer ImGui.Key_F23`
Python	`int retval = ImGui.Key_F23()`

View source · v0.9+

Constant: Key_F24

C++	`int ImGui::Key_F24`
EEL	`int ImGui_Key_F24()`
Legacy EEL	`int extension_api("ImGui_Key_F24")`
Lua	`integer ImGui.Key_F24`
Python	`int retval = ImGui.Key_F24()`

View source · v0.9+

Constant: Key_F3

C++	`int ImGui::Key_F3`
EEL	`int ImGui_Key_F3()`
Legacy EEL	`int extension_api("ImGui_Key_F3")`
Lua	`integer ImGui.Key_F3`
Python	`int retval = ImGui.Key_F3()`

View source · v0.6+

Constant: Key_F4

C++	`int ImGui::Key_F4`
EEL	`int ImGui_Key_F4()`
Legacy EEL	`int extension_api("ImGui_Key_F4")`
Lua	`integer ImGui.Key_F4`
Python	`int retval = ImGui.Key_F4()`

View source · v0.6+

Constant: Key_F5

C++	`int ImGui::Key_F5`
EEL	`int ImGui_Key_F5()`
Legacy EEL	`int extension_api("ImGui_Key_F5")`
Lua	`integer ImGui.Key_F5`
Python	`int retval = ImGui.Key_F5()`

View source · v0.6+

Constant: Key_F6

C++	`int ImGui::Key_F6`
EEL	`int ImGui_Key_F6()`
Legacy EEL	`int extension_api("ImGui_Key_F6")`
Lua	`integer ImGui.Key_F6`
Python	`int retval = ImGui.Key_F6()`

View source · v0.6+

Constant: Key_F7

C++	`int ImGui::Key_F7`
EEL	`int ImGui_Key_F7()`
Legacy EEL	`int extension_api("ImGui_Key_F7")`
Lua	`integer ImGui.Key_F7`
Python	`int retval = ImGui.Key_F7()`

View source · v0.6+

Constant: Key_F8

C++	`int ImGui::Key_F8`
EEL	`int ImGui_Key_F8()`
Legacy EEL	`int extension_api("ImGui_Key_F8")`
Lua	`integer ImGui.Key_F8`
Python	`int retval = ImGui.Key_F8()`

View source · v0.6+

Constant: Key_F9

C++	`int ImGui::Key_F9`
EEL	`int ImGui_Key_F9()`
Legacy EEL	`int extension_api("ImGui_Key_F9")`
Lua	`integer ImGui.Key_F9`
Python	`int retval = ImGui.Key_F9()`

View source · v0.6+

Constant: Key_G

C++	`int ImGui::Key_G`
EEL	`int ImGui_Key_G()`
Legacy EEL	`int extension_api("ImGui_Key_G")`
Lua	`integer ImGui.Key_G`
Python	`int retval = ImGui.Key_G()`

View source · v0.6+

Constant: Key_GraveAccent

C++	`int ImGui::Key_GraveAccent`
EEL	`int ImGui_Key_GraveAccent()`
Legacy EEL	`int extension_api("ImGui_Key_GraveAccent")`
Lua	`integer ImGui.Key_GraveAccent`
Python	`int retval = ImGui.Key_GraveAccent()`

View source · v0.6+

Constant: Key_H

C++	`int ImGui::Key_H`
EEL	`int ImGui_Key_H()`
Legacy EEL	`int extension_api("ImGui_Key_H")`
Lua	`integer ImGui.Key_H`
Python	`int retval = ImGui.Key_H()`

View source · v0.6+

Constant: Key_Home

C++	`int ImGui::Key_Home`
EEL	`int ImGui_Key_Home()`
Legacy EEL	`int extension_api("ImGui_Key_Home")`
Lua	`integer ImGui.Key_Home`
Python	`int retval = ImGui.Key_Home()`

View source · v0.6+

Constant: Key_I

C++	`int ImGui::Key_I`
EEL	`int ImGui_Key_I()`
Legacy EEL	`int extension_api("ImGui_Key_I")`
Lua	`integer ImGui.Key_I`
Python	`int retval = ImGui.Key_I()`

View source · v0.6+

Constant: Key_Insert

C++	`int ImGui::Key_Insert`
EEL	`int ImGui_Key_Insert()`
Legacy EEL	`int extension_api("ImGui_Key_Insert")`
Lua	`integer ImGui.Key_Insert`
Python	`int retval = ImGui.Key_Insert()`

View source · v0.6+

Constant: Key_J

C++	`int ImGui::Key_J`
EEL	`int ImGui_Key_J()`
Legacy EEL	`int extension_api("ImGui_Key_J")`
Lua	`integer ImGui.Key_J`
Python	`int retval = ImGui.Key_J()`

View source · v0.6+

Constant: Key_K

C++	`int ImGui::Key_K`
EEL	`int ImGui_Key_K()`
Legacy EEL	`int extension_api("ImGui_Key_K")`
Lua	`integer ImGui.Key_K`
Python	`int retval = ImGui.Key_K()`

View source · v0.6+

Constant: Key_Keypad0

C++	`int ImGui::Key_Keypad0`
EEL	`int ImGui_Key_Keypad0()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad0")`
Lua	`integer ImGui.Key_Keypad0`
Python	`int retval = ImGui.Key_Keypad0()`

View source · v0.6+

Constant: Key_Keypad1

C++	`int ImGui::Key_Keypad1`
EEL	`int ImGui_Key_Keypad1()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad1")`
Lua	`integer ImGui.Key_Keypad1`
Python	`int retval = ImGui.Key_Keypad1()`

View source · v0.6+

Constant: Key_Keypad2

C++	`int ImGui::Key_Keypad2`
EEL	`int ImGui_Key_Keypad2()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad2")`
Lua	`integer ImGui.Key_Keypad2`
Python	`int retval = ImGui.Key_Keypad2()`

View source · v0.6+

Constant: Key_Keypad3

C++	`int ImGui::Key_Keypad3`
EEL	`int ImGui_Key_Keypad3()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad3")`
Lua	`integer ImGui.Key_Keypad3`
Python	`int retval = ImGui.Key_Keypad3()`

View source · v0.6+

Constant: Key_Keypad4

C++	`int ImGui::Key_Keypad4`
EEL	`int ImGui_Key_Keypad4()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad4")`
Lua	`integer ImGui.Key_Keypad4`
Python	`int retval = ImGui.Key_Keypad4()`

View source · v0.6+

Constant: Key_Keypad5

C++	`int ImGui::Key_Keypad5`
EEL	`int ImGui_Key_Keypad5()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad5")`
Lua	`integer ImGui.Key_Keypad5`
Python	`int retval = ImGui.Key_Keypad5()`

View source · v0.6+

Constant: Key_Keypad6

C++	`int ImGui::Key_Keypad6`
EEL	`int ImGui_Key_Keypad6()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad6")`
Lua	`integer ImGui.Key_Keypad6`
Python	`int retval = ImGui.Key_Keypad6()`

View source · v0.6+

Constant: Key_Keypad7

C++	`int ImGui::Key_Keypad7`
EEL	`int ImGui_Key_Keypad7()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad7")`
Lua	`integer ImGui.Key_Keypad7`
Python	`int retval = ImGui.Key_Keypad7()`

View source · v0.6+

Constant: Key_Keypad8

C++	`int ImGui::Key_Keypad8`
EEL	`int ImGui_Key_Keypad8()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad8")`
Lua	`integer ImGui.Key_Keypad8`
Python	`int retval = ImGui.Key_Keypad8()`

View source · v0.6+

Constant: Key_Keypad9

C++	`int ImGui::Key_Keypad9`
EEL	`int ImGui_Key_Keypad9()`
Legacy EEL	`int extension_api("ImGui_Key_Keypad9")`
Lua	`integer ImGui.Key_Keypad9`
Python	`int retval = ImGui.Key_Keypad9()`

View source · v0.6+

Constant: Key_KeypadAdd

C++	`int ImGui::Key_KeypadAdd`
EEL	`int ImGui_Key_KeypadAdd()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadAdd")`
Lua	`integer ImGui.Key_KeypadAdd`
Python	`int retval = ImGui.Key_KeypadAdd()`

View source · v0.6+

Constant: Key_KeypadDecimal

C++	`int ImGui::Key_KeypadDecimal`
EEL	`int ImGui_Key_KeypadDecimal()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadDecimal")`
Lua	`integer ImGui.Key_KeypadDecimal`
Python	`int retval = ImGui.Key_KeypadDecimal()`

View source · v0.6+

Constant: Key_KeypadDivide

C++	`int ImGui::Key_KeypadDivide`
EEL	`int ImGui_Key_KeypadDivide()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadDivide")`
Lua	`integer ImGui.Key_KeypadDivide`
Python	`int retval = ImGui.Key_KeypadDivide()`

View source · v0.6+

Constant: Key_KeypadEnter

C++	`int ImGui::Key_KeypadEnter`
EEL	`int ImGui_Key_KeypadEnter()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadEnter")`
Lua	`integer ImGui.Key_KeypadEnter`
Python	`int retval = ImGui.Key_KeypadEnter()`

View source · v0.6+

Constant: Key_KeypadEqual

C++	`int ImGui::Key_KeypadEqual`
EEL	`int ImGui_Key_KeypadEqual()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadEqual")`
Lua	`integer ImGui.Key_KeypadEqual`
Python	`int retval = ImGui.Key_KeypadEqual()`

View source · v0.6+

Constant: Key_KeypadMultiply

C++	`int ImGui::Key_KeypadMultiply`
EEL	`int ImGui_Key_KeypadMultiply()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadMultiply")`
Lua	`integer ImGui.Key_KeypadMultiply`
Python	`int retval = ImGui.Key_KeypadMultiply()`

View source · v0.6+

Constant: Key_KeypadSubtract

C++	`int ImGui::Key_KeypadSubtract`
EEL	`int ImGui_Key_KeypadSubtract()`
Legacy EEL	`int extension_api("ImGui_Key_KeypadSubtract")`
Lua	`integer ImGui.Key_KeypadSubtract`
Python	`int retval = ImGui.Key_KeypadSubtract()`

View source · v0.6+

Constant: Key_L

C++	`int ImGui::Key_L`
EEL	`int ImGui_Key_L()`
Legacy EEL	`int extension_api("ImGui_Key_L")`
Lua	`integer ImGui.Key_L`
Python	`int retval = ImGui.Key_L()`

View source · v0.6+

Constant: Key_LeftAlt

C++	`int ImGui::Key_LeftAlt`
EEL	`int ImGui_Key_LeftAlt()`
Legacy EEL	`int extension_api("ImGui_Key_LeftAlt")`
Lua	`integer ImGui.Key_LeftAlt`
Python	`int retval = ImGui.Key_LeftAlt()`

View source · v0.6+

Constant: Key_LeftArrow

C++	`int ImGui::Key_LeftArrow`
EEL	`int ImGui_Key_LeftArrow()`
Legacy EEL	`int extension_api("ImGui_Key_LeftArrow")`
Lua	`integer ImGui.Key_LeftArrow`
Python	`int retval = ImGui.Key_LeftArrow()`

View source · v0.6+

Constant: Key_LeftBracket

C++	`int ImGui::Key_LeftBracket`
EEL	`int ImGui_Key_LeftBracket()`
Legacy EEL	`int extension_api("ImGui_Key_LeftBracket")`
Lua	`integer ImGui.Key_LeftBracket`
Python	`int retval = ImGui.Key_LeftBracket()`

[

View source · v0.6+

Constant: Key_LeftCtrl

C++	`int ImGui::Key_LeftCtrl`
EEL	`int ImGui_Key_LeftCtrl()`
Legacy EEL	`int extension_api("ImGui_Key_LeftCtrl")`
Lua	`integer ImGui.Key_LeftCtrl`
Python	`int retval = ImGui.Key_LeftCtrl()`

View source · v0.6+

Constant: Key_LeftShift

C++	`int ImGui::Key_LeftShift`
EEL	`int ImGui_Key_LeftShift()`
Legacy EEL	`int extension_api("ImGui_Key_LeftShift")`
Lua	`integer ImGui.Key_LeftShift`
Python	`int retval = ImGui.Key_LeftShift()`

View source · v0.6+

Constant: Key_LeftSuper

C++	`int ImGui::Key_LeftSuper`
EEL	`int ImGui_Key_LeftSuper()`
Legacy EEL	`int extension_api("ImGui_Key_LeftSuper")`
Lua	`integer ImGui.Key_LeftSuper`
Python	`int retval = ImGui.Key_LeftSuper()`

View source · v0.6+

Constant: Key_M

C++	`int ImGui::Key_M`
EEL	`int ImGui_Key_M()`
Legacy EEL	`int extension_api("ImGui_Key_M")`
Lua	`integer ImGui.Key_M`
Python	`int retval = ImGui.Key_M()`

View source · v0.6+

Constant: Key_Menu

C++	`int ImGui::Key_Menu`
EEL	`int ImGui_Key_Menu()`
Legacy EEL	`int extension_api("ImGui_Key_Menu")`
Lua	`integer ImGui.Key_Menu`
Python	`int retval = ImGui.Key_Menu()`

View source · v0.6+

Constant: Key_Minus

C++	`int ImGui::Key_Minus`
EEL	`int ImGui_Key_Minus()`
Legacy EEL	`int extension_api("ImGui_Key_Minus")`
Lua	`integer ImGui.Key_Minus`
Python	`int retval = ImGui.Key_Minus()`

View source · v0.6+

Constant: Key_N

C++	`int ImGui::Key_N`
EEL	`int ImGui_Key_N()`
Legacy EEL	`int extension_api("ImGui_Key_N")`
Lua	`integer ImGui.Key_N`
Python	`int retval = ImGui.Key_N()`

View source · v0.6+

Constant: Key_NumLock

C++	`int ImGui::Key_NumLock`
EEL	`int ImGui_Key_NumLock()`
Legacy EEL	`int extension_api("ImGui_Key_NumLock")`
Lua	`integer ImGui.Key_NumLock`
Python	`int retval = ImGui.Key_NumLock()`

View source · v0.6+

Constant: Key_O

C++	`int ImGui::Key_O`
EEL	`int ImGui_Key_O()`
Legacy EEL	`int extension_api("ImGui_Key_O")`
Lua	`integer ImGui.Key_O`
Python	`int retval = ImGui.Key_O()`

View source · v0.6+

Constant: Key_P

C++	`int ImGui::Key_P`
EEL	`int ImGui_Key_P()`
Legacy EEL	`int extension_api("ImGui_Key_P")`
Lua	`integer ImGui.Key_P`
Python	`int retval = ImGui.Key_P()`

View source · v0.6+

Constant: Key_PageDown

C++	`int ImGui::Key_PageDown`
EEL	`int ImGui_Key_PageDown()`
Legacy EEL	`int extension_api("ImGui_Key_PageDown")`
Lua	`integer ImGui.Key_PageDown`
Python	`int retval = ImGui.Key_PageDown()`

View source · v0.6+

Constant: Key_PageUp

C++	`int ImGui::Key_PageUp`
EEL	`int ImGui_Key_PageUp()`
Legacy EEL	`int extension_api("ImGui_Key_PageUp")`
Lua	`integer ImGui.Key_PageUp`
Python	`int retval = ImGui.Key_PageUp()`

View source · v0.6+

Constant: Key_Pause

C++	`int ImGui::Key_Pause`
EEL	`int ImGui_Key_Pause()`
Legacy EEL	`int extension_api("ImGui_Key_Pause")`
Lua	`integer ImGui.Key_Pause`
Python	`int retval = ImGui.Key_Pause()`

View source · v0.6+

Constant: Key_Period

C++	`int ImGui::Key_Period`
EEL	`int ImGui_Key_Period()`
Legacy EEL	`int extension_api("ImGui_Key_Period")`
Lua	`integer ImGui.Key_Period`
Python	`int retval = ImGui.Key_Period()`

View source · v0.6+

Constant: Key_PrintScreen

C++	`int ImGui::Key_PrintScreen`
EEL	`int ImGui_Key_PrintScreen()`
Legacy EEL	`int extension_api("ImGui_Key_PrintScreen")`
Lua	`integer ImGui.Key_PrintScreen`
Python	`int retval = ImGui.Key_PrintScreen()`

View source · v0.6+

Constant: Key_Q

C++	`int ImGui::Key_Q`
EEL	`int ImGui_Key_Q()`
Legacy EEL	`int extension_api("ImGui_Key_Q")`
Lua	`integer ImGui.Key_Q`
Python	`int retval = ImGui.Key_Q()`

View source · v0.6+

Constant: Key_R

C++	`int ImGui::Key_R`
EEL	`int ImGui_Key_R()`
Legacy EEL	`int extension_api("ImGui_Key_R")`
Lua	`integer ImGui.Key_R`
Python	`int retval = ImGui.Key_R()`

View source · v0.6+

Constant: Key_RightAlt

C++	`int ImGui::Key_RightAlt`
EEL	`int ImGui_Key_RightAlt()`
Legacy EEL	`int extension_api("ImGui_Key_RightAlt")`
Lua	`integer ImGui.Key_RightAlt`
Python	`int retval = ImGui.Key_RightAlt()`

View source · v0.6+

Constant: Key_RightArrow

C++	`int ImGui::Key_RightArrow`
EEL	`int ImGui_Key_RightArrow()`
Legacy EEL	`int extension_api("ImGui_Key_RightArrow")`
Lua	`integer ImGui.Key_RightArrow`
Python	`int retval = ImGui.Key_RightArrow()`

View source · v0.6+

Constant: Key_RightBracket

C++	`int ImGui::Key_RightBracket`
EEL	`int ImGui_Key_RightBracket()`
Legacy EEL	`int extension_api("ImGui_Key_RightBracket")`
Lua	`integer ImGui.Key_RightBracket`
Python	`int retval = ImGui.Key_RightBracket()`

]

View source · v0.6+

Constant: Key_RightCtrl

C++	`int ImGui::Key_RightCtrl`
EEL	`int ImGui_Key_RightCtrl()`
Legacy EEL	`int extension_api("ImGui_Key_RightCtrl")`
Lua	`integer ImGui.Key_RightCtrl`
Python	`int retval = ImGui.Key_RightCtrl()`

View source · v0.6+

Constant: Key_RightShift

C++	`int ImGui::Key_RightShift`
EEL	`int ImGui_Key_RightShift()`
Legacy EEL	`int extension_api("ImGui_Key_RightShift")`
Lua	`integer ImGui.Key_RightShift`
Python	`int retval = ImGui.Key_RightShift()`

View source · v0.6+

Constant: Key_RightSuper

C++	`int ImGui::Key_RightSuper`
EEL	`int ImGui_Key_RightSuper()`
Legacy EEL	`int extension_api("ImGui_Key_RightSuper")`
Lua	`integer ImGui.Key_RightSuper`
Python	`int retval = ImGui.Key_RightSuper()`

View source · v0.6+

Constant: Key_S

C++	`int ImGui::Key_S`
EEL	`int ImGui_Key_S()`
Legacy EEL	`int extension_api("ImGui_Key_S")`
Lua	`integer ImGui.Key_S`
Python	`int retval = ImGui.Key_S()`

View source · v0.6+

Constant: Key_ScrollLock

C++	`int ImGui::Key_ScrollLock`
EEL	`int ImGui_Key_ScrollLock()`
Legacy EEL	`int extension_api("ImGui_Key_ScrollLock")`
Lua	`integer ImGui.Key_ScrollLock`
Python	`int retval = ImGui.Key_ScrollLock()`

View source · v0.6+

Constant: Key_Semicolon

C++	`int ImGui::Key_Semicolon`
EEL	`int ImGui_Key_Semicolon()`
Legacy EEL	`int extension_api("ImGui_Key_Semicolon")`
Lua	`integer ImGui.Key_Semicolon`
Python	`int retval = ImGui.Key_Semicolon()`

;

View source · v0.6+

Constant: Key_Slash

C++	`int ImGui::Key_Slash`
EEL	`int ImGui_Key_Slash()`
Legacy EEL	`int extension_api("ImGui_Key_Slash")`
Lua	`integer ImGui.Key_Slash`
Python	`int retval = ImGui.Key_Slash()`

View source · v0.6+

Constant: Key_Space

C++	`int ImGui::Key_Space`
EEL	`int ImGui_Key_Space()`
Legacy EEL	`int extension_api("ImGui_Key_Space")`
Lua	`integer ImGui.Key_Space`
Python	`int retval = ImGui.Key_Space()`

View source · v0.6+

Constant: Key_T

C++	`int ImGui::Key_T`
EEL	`int ImGui_Key_T()`
Legacy EEL	`int extension_api("ImGui_Key_T")`
Lua	`integer ImGui.Key_T`
Python	`int retval = ImGui.Key_T()`

View source · v0.6+

Constant: Key_Tab

C++	`int ImGui::Key_Tab`
EEL	`int ImGui_Key_Tab()`
Legacy EEL	`int extension_api("ImGui_Key_Tab")`
Lua	`integer ImGui.Key_Tab`
Python	`int retval = ImGui.Key_Tab()`

View source · v0.6+

Constant: Key_U

C++	`int ImGui::Key_U`
EEL	`int ImGui_Key_U()`
Legacy EEL	`int extension_api("ImGui_Key_U")`
Lua	`integer ImGui.Key_U`
Python	`int retval = ImGui.Key_U()`

View source · v0.6+

Constant: Key_UpArrow

C++	`int ImGui::Key_UpArrow`
EEL	`int ImGui_Key_UpArrow()`
Legacy EEL	`int extension_api("ImGui_Key_UpArrow")`
Lua	`integer ImGui.Key_UpArrow`
Python	`int retval = ImGui.Key_UpArrow()`

View source · v0.6+

Constant: Key_V

C++	`int ImGui::Key_V`
EEL	`int ImGui_Key_V()`
Legacy EEL	`int extension_api("ImGui_Key_V")`
Lua	`integer ImGui.Key_V`
Python	`int retval = ImGui.Key_V()`

View source · v0.6+

Constant: Key_W

C++	`int ImGui::Key_W`
EEL	`int ImGui_Key_W()`
Legacy EEL	`int extension_api("ImGui_Key_W")`
Lua	`integer ImGui.Key_W`
Python	`int retval = ImGui.Key_W()`

View source · v0.6+

Constant: Key_X

C++	`int ImGui::Key_X`
EEL	`int ImGui_Key_X()`
Legacy EEL	`int extension_api("ImGui_Key_X")`
Lua	`integer ImGui.Key_X`
Python	`int retval = ImGui.Key_X()`

View source · v0.6+

Constant: Key_Y

C++	`int ImGui::Key_Y`
EEL	`int ImGui_Key_Y()`
Legacy EEL	`int extension_api("ImGui_Key_Y")`
Lua	`integer ImGui.Key_Y`
Python	`int retval = ImGui.Key_Y()`

View source · v0.6+

Constant: Key_Z

C++	`int ImGui::Key_Z`
EEL	`int ImGui_Key_Z()`
Legacy EEL	`int extension_api("ImGui_Key_Z")`
Lua	`integer ImGui.Key_Z`
Python	`int retval = ImGui.Key_Z()`

View source · v0.6+

Modifiers

Constant: Mod_Alt

C++	`int ImGui::Mod_Alt`
EEL	`int ImGui_Mod_Alt()`
Legacy EEL	`int extension_api("ImGui_Mod_Alt")`
Lua	`integer ImGui.Mod_Alt`
Python	`int retval = ImGui.Mod_Alt()`

View source · v0.8+

Constant: Mod_Ctrl

C++	`int ImGui::Mod_Ctrl`
EEL	`int ImGui_Mod_Ctrl()`
Legacy EEL	`int extension_api("ImGui_Mod_Ctrl")`
Lua	`integer ImGui.Mod_Ctrl`
Python	`int retval = ImGui.Mod_Ctrl()`

Cmd when ConfigVar_MacOSXBehaviors is enabled.

View source · v0.9.2+

Constant: Mod_None

C++	`int ImGui::Mod_None`
EEL	`int ImGui_Mod_None()`
Legacy EEL	`int extension_api("ImGui_Mod_None")`
Lua	`integer ImGui.Mod_None`
Python	`int retval = ImGui.Mod_None()`

View source · v0.8+

Constant: Mod_Shift

C++	`int ImGui::Mod_Shift`
EEL	`int ImGui_Mod_Shift()`
Legacy EEL	`int extension_api("ImGui_Mod_Shift")`
Lua	`integer ImGui.Mod_Shift`
Python	`int retval = ImGui.Mod_Shift()`

View source · v0.8+

Constant: Mod_Super

C++	`int ImGui::Mod_Super`
EEL	`int ImGui_Mod_Super()`
Legacy EEL	`int extension_api("ImGui_Mod_Super")`
Lua	`integer ImGui.Mod_Super`
Python	`int retval = ImGui.Mod_Super()`

Ctrl when ConfigVar_MacOSXBehaviors is enabled.

View source · v0.9.2+

Mouse Buttons

This is mirroring the data also written accessible via IsMouseDown, GetMouseWheel etc, in a format allowing them to be accessed via standard key API.

Constant: Key_MouseLeft

C++	`int ImGui::Key_MouseLeft`
EEL	`int ImGui_Key_MouseLeft()`
Legacy EEL	`int extension_api("ImGui_Key_MouseLeft")`
Lua	`integer ImGui.Key_MouseLeft`
Python	`int retval = ImGui.Key_MouseLeft()`

View source · v0.8+

Constant: Key_MouseMiddle

C++	`int ImGui::Key_MouseMiddle`
EEL	`int ImGui_Key_MouseMiddle()`
Legacy EEL	`int extension_api("ImGui_Key_MouseMiddle")`
Lua	`integer ImGui.Key_MouseMiddle`
Python	`int retval = ImGui.Key_MouseMiddle()`

View source · v0.8+

Constant: Key_MouseRight

C++	`int ImGui::Key_MouseRight`
EEL	`int ImGui_Key_MouseRight()`
Legacy EEL	`int extension_api("ImGui_Key_MouseRight")`
Lua	`integer ImGui.Key_MouseRight`
Python	`int retval = ImGui.Key_MouseRight()`

View source · v0.8+

Constant: Key_MouseWheelX

C++	`int ImGui::Key_MouseWheelX`
EEL	`int ImGui_Key_MouseWheelX()`
Legacy EEL	`int extension_api("ImGui_Key_MouseWheelX")`
Lua	`integer ImGui.Key_MouseWheelX`
Python	`int retval = ImGui.Key_MouseWheelX()`

View source · v0.8+

Constant: Key_MouseWheelY

C++	`int ImGui::Key_MouseWheelY`
EEL	`int ImGui_Key_MouseWheelY()`
Legacy EEL	`int extension_api("ImGui_Key_MouseWheelY")`
Lua	`integer ImGui.Key_MouseWheelY`
Python	`int retval = ImGui.Key_MouseWheelY()`

View source · v0.8+

Constant: Key_MouseX1

C++	`int ImGui::Key_MouseX1`
EEL	`int ImGui_Key_MouseX1()`
Legacy EEL	`int extension_api("ImGui_Key_MouseX1")`
Lua	`integer ImGui.Key_MouseX1`
Python	`int retval = ImGui.Key_MouseX1()`

View source · v0.8+

Constant: Key_MouseX2

C++	`int ImGui::Key_MouseX2`
EEL	`int ImGui_Key_MouseX2()`
Legacy EEL	`int extension_api("ImGui_Key_MouseX2")`
Lua	`integer ImGui.Key_MouseX2`
Python	`int retval = ImGui.Key_MouseX2()`

View source · v0.8+

Mouse

To refer to a mouse button, you may use named enums in your code e.g. MouseButton_Left, MouseButton_Right.

You can also use regular integer: it is forever guaranteed that 0=Left, 1=Right, 2=Middle. Buttons 3 and 4 do not have a named enum.

Dragging operations are only reported after mouse has moved a certain distance away from the initial clicking position (see 'lock_threshold' parameters and 'ConfigVar_MouseDragThreshold').

Function: GetMouseClickedCount

C++	`int ImGui::GetMouseClickedCount(ImGui_Context* ctx, int button)`
EEL	`int ImGui_GetMouseClickedCount(ImGui_Context ctx, int button)`
Legacy EEL	`int extension_api("ImGui_GetMouseClickedCount", ImGui_Context ctx, int button)`
Lua	`integer retval = ImGui.GetMouseClickedCount(ImGui_Context ctx, integer button)`
Python	`int retval = ImGui.GetMouseClickedCount(ImGui_Context ctx, int button)`

Return the number of successive mouse-clicks at the time where a click happen (otherwise 0).

View source · v0.5.10+

Function: GetMouseClickedPos

C++	`void ImGui::GetMouseClickedPos(ImGui_Context* ctx, int button, double* xOut, double* yOut)`
EEL	`ImGui_GetMouseClickedPos(ImGui_Context ctx, int button, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetMouseClickedPos", ImGui_Context ctx, int button, &x, &y)`
Lua	`number x, number y = ImGui.GetMouseClickedPos(ImGui_Context ctx, integer button)`
Python	`(float x, float y) = ImGui.GetMouseClickedPos(ImGui_Context ctx, int button)`

View source · v0.1+

Function: GetMouseDelta

C++	`void ImGui::GetMouseDelta(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetMouseDelta(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetMouseDelta", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetMouseDelta(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetMouseDelta(ImGui_Context ctx)`

Mouse delta. Note that this is zero if either current or previous position are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have a huge delta.

View source · v0.1+

Function: GetMouseDownDuration

C++	`double ImGui::GetMouseDownDuration(ImGui_Context* ctx, int button)`
EEL	`double ImGui_GetMouseDownDuration(ImGui_Context ctx, int button)`
Legacy EEL	`double extension_api("ImGui_GetMouseDownDuration", ImGui_Context ctx, int button)`
Lua	`number retval = ImGui.GetMouseDownDuration(ImGui_Context ctx, integer button)`
Python	`float retval = ImGui.GetMouseDownDuration(ImGui_Context ctx, int button)`

Duration the mouse button has been down (0.0 == just clicked)

View source · v0.1+

Function: GetMouseDragDelta

C++	`void ImGui::GetMouseDragDelta(ImGui_Context* ctx, double* xOut, double* yOut, int buttonInOptional = MouseButton_Left, double lock_thresholdInOptional = -1.0)`
EEL	`ImGui_GetMouseDragDelta(ImGui_Context ctx, &x, &y, int button = MouseButton_Left, lock_threshold = -1.0)`
Legacy EEL	`extension_api("ImGui_GetMouseDragDelta", ImGui_Context ctx, &x, &y, int button = MouseButton_Left, lock_threshold = -1.0)`
Lua	`number x, number y = ImGui.GetMouseDragDelta(ImGui_Context ctx, nil, nil, integer button = MouseButton_Left, number lock_threshold = -1.0)`
Python	`(float x, float y) = ImGui.GetMouseDragDelta(ImGui_Context ctx, int button = MouseButton_Left, float lock_threshold = -1.0)`

Return the delta from the initial clicking position while the mouse button is pressed or was just released. This is locked and return 0.0 until the mouse moves past a distance threshold at least once (uses ConfigVar_MouseDragThreshold if lock_threshold < 0.0).

View source · v0.1+

Function: GetMousePos

C++	`void ImGui::GetMousePos(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetMousePos(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetMousePos", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetMousePos(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetMousePos(ImGui_Context ctx)`

View source · v0.1+

Function: GetMousePosOnOpeningCurrentPopup

C++	`void ImGui::GetMousePosOnOpeningCurrentPopup(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetMousePosOnOpeningCurrentPopup(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetMousePosOnOpeningCurrentPopup", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetMousePosOnOpeningCurrentPopup(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetMousePosOnOpeningCurrentPopup(ImGui_Context ctx)`

Retrieve mouse position at the time of opening popup we have BeginPopup() into (helper to avoid user backing that value themselves).

View source · v0.1+

Function: GetMouseWheel

C++	`void ImGui::GetMouseWheel(ImGui_Context* ctx, double* verticalOut, double* horizontalOut)`
EEL	`ImGui_GetMouseWheel(ImGui_Context ctx, &vertical, &horizontal)`
Legacy EEL	`extension_api("ImGui_GetMouseWheel", ImGui_Context ctx, &vertical, &horizontal)`
Lua	`number vertical, number horizontal = ImGui.GetMouseWheel(ImGui_Context ctx)`
Python	`(float vertical, float horizontal) = ImGui.GetMouseWheel(ImGui_Context ctx)`

Vertical: 1 unit scrolls about 5 lines text. >0 scrolls Up, <0 scrolls Down. Hold SHIFT to turn vertical scroll into horizontal scroll

Horizontal: >0 scrolls Left, <0 scrolls Right. Most users don't have a mouse with a horizontal wheel.

View source · v0.1+

Function: IsAnyMouseDown

C++	`bool ImGui::IsAnyMouseDown(ImGui_Context* ctx)`
EEL	`bool ImGui_IsAnyMouseDown(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsAnyMouseDown", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsAnyMouseDown(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsAnyMouseDown(ImGui_Context ctx)`

Is any mouse button held?

View source · v0.1+

Function: IsMouseClicked

C++	`bool ImGui::IsMouseClicked(ImGui_Context* ctx, int button, bool repeatInOptional = false)`
EEL	`bool ImGui_IsMouseClicked(ImGui_Context ctx, int button, bool repeat = false)`
Legacy EEL	`bool extension_api("ImGui_IsMouseClicked", ImGui_Context ctx, int button, bool repeat = false)`
Lua	`boolean retval = ImGui.IsMouseClicked(ImGui_Context ctx, integer button, boolean repeat = false)`
Python	`bool retval = ImGui.IsMouseClicked(ImGui_Context ctx, int button, bool repeat = false)`

Did mouse button clicked? (went from !Down to Down). Same as GetMouseClickedCount() == 1.

View source · v0.1+

Function: IsMouseDoubleClicked

C++	`bool ImGui::IsMouseDoubleClicked(ImGui_Context* ctx, int button)`
EEL	`bool ImGui_IsMouseDoubleClicked(ImGui_Context ctx, int button)`
Legacy EEL	`bool extension_api("ImGui_IsMouseDoubleClicked", ImGui_Context ctx, int button)`
Lua	`boolean retval = ImGui.IsMouseDoubleClicked(ImGui_Context ctx, integer button)`
Python	`bool retval = ImGui.IsMouseDoubleClicked(ImGui_Context ctx, int button)`

Did mouse button double-clicked? Same as GetMouseClickedCount() == 2. (Note that a double-click will also report IsMouseClicked() == true)

View source · v0.1+

Function: IsMouseDown

C++	`bool ImGui::IsMouseDown(ImGui_Context* ctx, int button)`
EEL	`bool ImGui_IsMouseDown(ImGui_Context ctx, int button)`
Legacy EEL	`bool extension_api("ImGui_IsMouseDown", ImGui_Context ctx, int button)`
Lua	`boolean retval = ImGui.IsMouseDown(ImGui_Context ctx, integer button)`
Python	`bool retval = ImGui.IsMouseDown(ImGui_Context ctx, int button)`

Is mouse button held?

View source · v0.1+

Function: IsMouseDragging

C++	`bool ImGui::IsMouseDragging(ImGui_Context* ctx, int button, double lock_thresholdInOptional = -1.0)`
EEL	`bool ImGui_IsMouseDragging(ImGui_Context ctx, int button, lock_threshold = -1.0)`
Legacy EEL	`bool extension_api("ImGui_IsMouseDragging", ImGui_Context ctx, int button, lock_threshold = -1.0)`
Lua	`boolean retval = ImGui.IsMouseDragging(ImGui_Context ctx, integer button, number lock_threshold = -1.0)`
Python	`bool retval = ImGui.IsMouseDragging(ImGui_Context ctx, int button, float lock_threshold = -1.0)`

Is mouse dragging? (uses ConfigVar_MouseDragThreshold if lock_threshold < 0.0)

View source · v0.1+

Function: IsMouseHoveringRect

C++	`bool ImGui::IsMouseHoveringRect(ImGui_Context* ctx, double r_min_x, double r_min_y, double r_max_x, double r_max_y, bool clipInOptional = true)`
EEL	`bool ImGui_IsMouseHoveringRect(ImGui_Context ctx, r_min_x, r_min_y, r_max_x, r_max_y, bool clip = true)`
Legacy EEL	`bool extension_api("ImGui_IsMouseHoveringRect", ImGui_Context ctx, r_min_x, r_min_y, r_max_x, r_max_y, bool clip = true)`
Lua	`boolean retval = ImGui.IsMouseHoveringRect(ImGui_Context ctx, number r_min_x, number r_min_y, number r_max_x, number r_max_y, boolean clip = true)`
Python	`bool retval = ImGui.IsMouseHoveringRect(ImGui_Context ctx, float r_min_x, float r_min_y, float r_max_x, float r_max_y, bool clip = true)`

Is mouse hovering given bounding rect (in screen space). Clipped by current clipping settings, but disregarding of other consideration of focus/window ordering/popup-block.

View source · v0.1+

Function: IsMousePosValid

C++	`bool ImGui::IsMousePosValid(ImGui_Context* ctx, double mouse_pos_xInOptional = nullptr, double mouse_pos_yInOptional = nullptr)`
EEL	`bool ImGui_IsMousePosValid(ImGui_Context ctx, mouse_pos_x = 0, mouse_pos_y = 0)`
Legacy EEL	`bool extension_api("ImGui_IsMousePosValid", ImGui_Context ctx, mouse_pos_x = 0, mouse_pos_y = 0)`
Lua	`boolean retval = ImGui.IsMousePosValid(ImGui_Context ctx, number mouse_pos_x = nil, number mouse_pos_y = nil)`
Python	`bool retval = ImGui.IsMousePosValid(ImGui_Context ctx, float mouse_pos_x = None, float mouse_pos_y = None)`

View source · v0.1+

Function: IsMouseReleased

C++	`bool ImGui::IsMouseReleased(ImGui_Context* ctx, int button)`
EEL	`bool ImGui_IsMouseReleased(ImGui_Context ctx, int button)`
Legacy EEL	`bool extension_api("ImGui_IsMouseReleased", ImGui_Context ctx, int button)`
Lua	`boolean retval = ImGui.IsMouseReleased(ImGui_Context ctx, integer button)`
Python	`bool retval = ImGui.IsMouseReleased(ImGui_Context ctx, int button)`

Did mouse button released? (went from Down to !Down)

View source · v0.1+

Constant: MouseButton_Left

C++	`int ImGui::MouseButton_Left`
EEL	`int ImGui_MouseButton_Left()`
Legacy EEL	`int extension_api("ImGui_MouseButton_Left")`
Lua	`integer ImGui.MouseButton_Left`
Python	`int retval = ImGui.MouseButton_Left()`

View source · v0.1+

Constant: MouseButton_Middle

C++	`int ImGui::MouseButton_Middle`
EEL	`int ImGui_MouseButton_Middle()`
Legacy EEL	`int extension_api("ImGui_MouseButton_Middle")`
Lua	`integer ImGui.MouseButton_Middle`
Python	`int retval = ImGui.MouseButton_Middle()`

View source · v0.1+

Constant: MouseButton_Right

C++	`int ImGui::MouseButton_Right`
EEL	`int ImGui_MouseButton_Right()`
Legacy EEL	`int extension_api("ImGui_MouseButton_Right")`
Lua	`integer ImGui.MouseButton_Right`
Python	`int retval = ImGui.MouseButton_Right()`

View source · v0.1+

Function: ResetMouseDragDelta

C++	`void ImGui::ResetMouseDragDelta(ImGui_Context* ctx, int buttonInOptional = MouseButton_Left)`
EEL	`ImGui_ResetMouseDragDelta(ImGui_Context ctx, int button = MouseButton_Left)`
Legacy EEL	`extension_api("ImGui_ResetMouseDragDelta", ImGui_Context ctx, int button = MouseButton_Left)`
Lua	`ImGui.ResetMouseDragDelta(ImGui_Context ctx, integer button = MouseButton_Left)`
Python	`ImGui.ResetMouseDragDelta(ImGui_Context ctx, int button = MouseButton_Left)`

View source · v0.1+

Mouse Cursor

Function: GetMouseCursor

C++	`int ImGui::GetMouseCursor(ImGui_Context* ctx)`
EEL	`int ImGui_GetMouseCursor(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_GetMouseCursor", ImGui_Context ctx)`
Lua	`integer retval = ImGui.GetMouseCursor(ImGui_Context ctx)`
Python	`int retval = ImGui.GetMouseCursor(ImGui_Context ctx)`

Get desired mouse cursor shape, reset every frame. This is updated during the frame.

View source · v0.1+

Constant: MouseCursor_Arrow

C++	`int ImGui::MouseCursor_Arrow`
EEL	`int ImGui_MouseCursor_Arrow()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_Arrow")`
Lua	`integer ImGui.MouseCursor_Arrow`
Python	`int retval = ImGui.MouseCursor_Arrow()`

View source · v0.1+

Constant: MouseCursor_Hand

C++	`int ImGui::MouseCursor_Hand`
EEL	`int ImGui_MouseCursor_Hand()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_Hand")`
Lua	`integer ImGui.MouseCursor_Hand`
Python	`int retval = ImGui.MouseCursor_Hand()`

(Unused by Dear ImGui functions. Use for e.g. hyperlinks)

View source · v0.1+

Constant: MouseCursor_None

C++	`int ImGui::MouseCursor_None`
EEL	`int ImGui_MouseCursor_None()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_None")`
Lua	`integer ImGui.MouseCursor_None`
Python	`int retval = ImGui.MouseCursor_None()`

View source · v0.8.4+

Constant: MouseCursor_NotAllowed

C++	`int ImGui::MouseCursor_NotAllowed`
EEL	`int ImGui_MouseCursor_NotAllowed()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_NotAllowed")`
Lua	`integer ImGui.MouseCursor_NotAllowed`
Python	`int retval = ImGui.MouseCursor_NotAllowed()`

When hovering something with disallowed interaction. Usually a crossed circle.

View source · v0.1+

Constant: MouseCursor_ResizeAll

C++	`int ImGui::MouseCursor_ResizeAll`
EEL	`int ImGui_MouseCursor_ResizeAll()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_ResizeAll")`
Lua	`integer ImGui.MouseCursor_ResizeAll`
Python	`int retval = ImGui.MouseCursor_ResizeAll()`

(Unused by Dear ImGui functions)

View source · v0.1+

Constant: MouseCursor_ResizeEW

C++	`int ImGui::MouseCursor_ResizeEW`
EEL	`int ImGui_MouseCursor_ResizeEW()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_ResizeEW")`
Lua	`integer ImGui.MouseCursor_ResizeEW`
Python	`int retval = ImGui.MouseCursor_ResizeEW()`

When hovering over a vertical border or a column.

View source · v0.1+

Constant: MouseCursor_ResizeNESW

C++	`int ImGui::MouseCursor_ResizeNESW`
EEL	`int ImGui_MouseCursor_ResizeNESW()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_ResizeNESW")`
Lua	`integer ImGui.MouseCursor_ResizeNESW`
Python	`int retval = ImGui.MouseCursor_ResizeNESW()`

When hovering over the bottom-left corner of a window.

View source · v0.1+

Constant: MouseCursor_ResizeNS

C++	`int ImGui::MouseCursor_ResizeNS`
EEL	`int ImGui_MouseCursor_ResizeNS()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_ResizeNS")`
Lua	`integer ImGui.MouseCursor_ResizeNS`
Python	`int retval = ImGui.MouseCursor_ResizeNS()`

When hovering over a horizontal border.

View source · v0.1+

Constant: MouseCursor_ResizeNWSE

C++	`int ImGui::MouseCursor_ResizeNWSE`
EEL	`int ImGui_MouseCursor_ResizeNWSE()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_ResizeNWSE")`
Lua	`integer ImGui.MouseCursor_ResizeNWSE`
Python	`int retval = ImGui.MouseCursor_ResizeNWSE()`

When hovering over the bottom-right corner of a window.

View source · v0.1+

Constant: MouseCursor_TextInput

C++	`int ImGui::MouseCursor_TextInput`
EEL	`int ImGui_MouseCursor_TextInput()`
Legacy EEL	`int extension_api("ImGui_MouseCursor_TextInput")`
Lua	`integer ImGui.MouseCursor_TextInput`
Python	`int retval = ImGui.MouseCursor_TextInput()`

When hovering over InputText, etc.

View source · v0.1+

Function: SetMouseCursor

C++	`void ImGui::SetMouseCursor(ImGui_Context* ctx, int cursor_type)`
EEL	`ImGui_SetMouseCursor(ImGui_Context ctx, int cursor_type)`
Legacy EEL	`extension_api("ImGui_SetMouseCursor", ImGui_Context ctx, int cursor_type)`
Lua	`ImGui.SetMouseCursor(ImGui_Context ctx, integer cursor_type)`
Python	`ImGui.SetMouseCursor(ImGui_Context ctx, int cursor_type)`

Set desired mouse cursor shape. See MouseCursor_* for possible values.

View source · v0.1+

Shortcuts

Key chords can combine a Key_* and a Mod_* value. For example: Mod_Ctrl | Key_C. Only Mod_* values can be combined a Key_* value. Another Key_* value cannot be combined.

Several callers may register interest in a shortcut, and only one owner gets it.

Parent -> call Shortcut(Ctrl+S) // When Parent is focused, Parent gets the shortcut.
Child1 -> call Shortcut(Ctrl+S) // When Child1 is focused, Child1 gets the shortcut (Child1 overrides Parent shortcuts)
Child2 -> no call               // When Child2 is focused, Parent gets the shortcut.

The whole system is order independent, so if Child1 makes its calls before Parent, results will be identical. This is an important property as it facilitate working with foreign code or larger codebase.

To understand the difference:

IsKeyChordPressed compares modifiers and calls IsKeyPressed -> function has no side-effect.
Shortcut submits a route, routes are resolved, if it currently can be routed it calls IsKeyChordPressed -> function has (desirable) side-effects as it can prevents another call from getting the route.

Registered routes may be visualized via Metrics/Debugger > Inputs (ShowMetricsWindow).

Function: IsKeyChordPressed

C++	`bool ImGui::IsKeyChordPressed(ImGui_Context* ctx, int key_chord)`
EEL	`bool ImGui_IsKeyChordPressed(ImGui_Context ctx, int key_chord)`
Legacy EEL	`bool extension_api("ImGui_IsKeyChordPressed", ImGui_Context ctx, int key_chord)`
Lua	`boolean retval = ImGui.IsKeyChordPressed(ImGui_Context ctx, integer key_chord)`
Python	`bool retval = ImGui.IsKeyChordPressed(ImGui_Context ctx, int key_chord)`

Was key chord (mods + key) pressed? You can pass e.g. Mod_Ctrl | Key_S as a key chord. This doesn't do any routing or focus check, consider using the Shortcut function instead.

View source · v0.9+

Function: SetNextItemShortcut

C++	`void ImGui::SetNextItemShortcut(ImGui_Context* ctx, int key_chord, int flagsInOptional = InputFlags_None)`
EEL	`ImGui_SetNextItemShortcut(ImGui_Context ctx, int key_chord, int flags = InputFlags_None)`
Legacy EEL	`extension_api("ImGui_SetNextItemShortcut", ImGui_Context ctx, int key_chord, int flags = InputFlags_None)`
Lua	`ImGui.SetNextItemShortcut(ImGui_Context ctx, integer key_chord, integer flags = InputFlags_None)`
Python	`ImGui.SetNextItemShortcut(ImGui_Context ctx, int key_chord, int flags = InputFlags_None)`

View source · v0.9.2+

Function: Shortcut

C++	`bool ImGui::Shortcut(ImGui_Context* ctx, int key_chord, int flagsInOptional = InputFlags_None)`
EEL	`bool ImGui_Shortcut(ImGui_Context ctx, int key_chord, int flags = InputFlags_None)`
Legacy EEL	`bool extension_api("ImGui_Shortcut", ImGui_Context ctx, int key_chord, int flags = InputFlags_None)`
Lua	`boolean retval = ImGui.Shortcut(ImGui_Context ctx, integer key_chord, integer flags = InputFlags_None)`
Python	`bool retval = ImGui.Shortcut(ImGui_Context ctx, int key_chord, int flags = InputFlags_None)`

View source · v0.9.2+

Flags

Constant: InputFlags_None

C++	`int ImGui::InputFlags_None`
EEL	`int ImGui_InputFlags_None()`
Legacy EEL	`int extension_api("ImGui_InputFlags_None")`
Lua	`integer ImGui.InputFlags_None`
Python	`int retval = ImGui.InputFlags_None()`

View source · v0.9.2+

Constant: InputFlags_Repeat

C++	`int ImGui::InputFlags_Repeat`
EEL	`int ImGui_InputFlags_Repeat()`
Legacy EEL	`int extension_api("ImGui_InputFlags_Repeat")`
Lua	`integer ImGui.InputFlags_Repeat`
Python	`int retval = ImGui.InputFlags_Repeat()`

Enable repeat. Return true on successive repeats.

View source · v0.9.2+

Constant: InputFlags_RouteFromRootWindow

C++	`int ImGui::InputFlags_RouteFromRootWindow`
EEL	`int ImGui_InputFlags_RouteFromRootWindow()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteFromRootWindow")`
Lua	`integer ImGui.InputFlags_RouteFromRootWindow`
Python	`int retval = ImGui.InputFlags_RouteFromRootWindow()`

Option: route evaluated from the point of view of root window rather than current window.

View source · v0.9.2+

Constant: InputFlags_RouteOverActive

C++	`int ImGui::InputFlags_RouteOverActive`
EEL	`int ImGui_InputFlags_RouteOverActive()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteOverActive")`
Lua	`integer ImGui.InputFlags_RouteOverActive`
Python	`int retval = ImGui.InputFlags_RouteOverActive()`

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.

View source · v0.9.2+

Constant: InputFlags_RouteOverFocused

C++	`int ImGui::InputFlags_RouteOverFocused`
EEL	`int ImGui_InputFlags_RouteOverFocused()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteOverFocused")`
Lua	`integer ImGui.InputFlags_RouteOverFocused`
Python	`int retval = ImGui.InputFlags_RouteOverFocused()`

Global route: higher priority than focused route (unless active item in focused route).

View source · v0.9.2+

Constant: InputFlags_RouteUnlessBgFocused

C++	`int ImGui::InputFlags_RouteUnlessBgFocused`
EEL	`int ImGui_InputFlags_RouteUnlessBgFocused()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteUnlessBgFocused")`
Lua	`integer ImGui.InputFlags_RouteUnlessBgFocused`
Python	`int retval = ImGui.InputFlags_RouteUnlessBgFocused()`

Option: global route: will not be applied if underlying background/void is focused (== no Dear ImGui windows are focused). Useful for overlay applications.

View source · v0.9.2+

Constant: InputFlags_Tooltip

C++	`int ImGui::InputFlags_Tooltip`
EEL	`int ImGui_InputFlags_Tooltip()`
Legacy EEL	`int extension_api("ImGui_InputFlags_Tooltip")`
Lua	`integer ImGui.InputFlags_Tooltip`
Python	`int retval = ImGui.InputFlags_Tooltip()`

Automatically display a tooltip when hovering item

View source · v0.9.2+

Routing policies

RouteGlobal+OverActive >> RouteActive or RouteFocused (if owner is active item) >> RouteGlobal+OverFocused >> RouteFocused (if in focused window stack) >> RouteGlobal.

Default policy is RouteFocused. Can select only one policy among all available.

Constant: InputFlags_RouteActive

C++	`int ImGui::InputFlags_RouteActive`
EEL	`int ImGui_InputFlags_RouteActive()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteActive")`
Lua	`integer ImGui.InputFlags_RouteActive`
Python	`int retval = ImGui.InputFlags_RouteActive()`

Route to active item only.

View source · v0.9.2+

Constant: InputFlags_RouteAlways

C++	`int ImGui::InputFlags_RouteAlways`
EEL	`int ImGui_InputFlags_RouteAlways()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteAlways")`
Lua	`integer ImGui.InputFlags_RouteAlways`
Python	`int retval = ImGui.InputFlags_RouteAlways()`

Do not register route, poll keys directly.

View source · v0.9.2+

Constant: InputFlags_RouteFocused

C++	`int ImGui::InputFlags_RouteFocused`
EEL	`int ImGui_InputFlags_RouteFocused()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteFocused")`
Lua	`integer ImGui.InputFlags_RouteFocused`
Python	`int retval = ImGui.InputFlags_RouteFocused()`

Route to windows in the focus stack. Deep-most focused window takes inputs. Active item takes inputs over deep-most focused window.

View source · v0.9.2+

Constant: InputFlags_RouteGlobal

C++	`int ImGui::InputFlags_RouteGlobal`
EEL	`int ImGui_InputFlags_RouteGlobal()`
Legacy EEL	`int extension_api("ImGui_InputFlags_RouteGlobal")`
Lua	`integer ImGui.InputFlags_RouteGlobal`
Python	`int retval = ImGui.InputFlags_RouteGlobal()`

Global route (unless a focused window or active item registered the route).

View source · v0.9.2+

Layout

Function: BeginGroup

C++	`void ImGui::BeginGroup(ImGui_Context* ctx)`
EEL	`ImGui_BeginGroup(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_BeginGroup", ImGui_Context ctx)`
Lua	`ImGui.BeginGroup(ImGui_Context ctx)`
Python	`ImGui.BeginGroup(ImGui_Context ctx)`

Lock horizontal starting position. See EndGroup.

View source · v0.1+

Function: Dummy

C++	`void ImGui::Dummy(ImGui_Context* ctx, double size_w, double size_h)`
EEL	`ImGui_Dummy(ImGui_Context ctx, size_w, size_h)`
Legacy EEL	`extension_api("ImGui_Dummy", ImGui_Context ctx, size_w, size_h)`
Lua	`ImGui.Dummy(ImGui_Context ctx, number size_w, number size_h)`
Python	`ImGui.Dummy(ImGui_Context ctx, float size_w, float size_h)`

Add a dummy item of given size. unlike InvisibleButton, Dummy() won't take the mouse click or be navigable into.

View source · v0.1+

Function: EndGroup

C++	`void ImGui::EndGroup(ImGui_Context* ctx)`
EEL	`ImGui_EndGroup(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndGroup", ImGui_Context ctx)`
Lua	`ImGui.EndGroup(ImGui_Context ctx)`
Python	`ImGui.EndGroup(ImGui_Context ctx)`

Unlock horizontal starting position + capture the whole group bounding box into one "item" (so you can use IsItemHovered or layout primitives such as SameLine on whole group, etc.).

See BeginGroup.

View source · v0.8+

Function: Indent

C++	`void ImGui::Indent(ImGui_Context* ctx, double indent_wInOptional = 0.0)`
EEL	`ImGui_Indent(ImGui_Context ctx, indent_w = 0.0)`
Legacy EEL	`extension_api("ImGui_Indent", ImGui_Context ctx, indent_w = 0.0)`
Lua	`ImGui.Indent(ImGui_Context ctx, number indent_w = 0.0)`
Python	`ImGui.Indent(ImGui_Context ctx, float indent_w = 0.0)`

Move content position toward the right, by 'indent_w', or StyleVar_IndentSpacing if 'indent_w' <= 0. See Unindent.

View source · v0.1+

Function: NewLine

C++	`void ImGui::NewLine(ImGui_Context* ctx)`
EEL	`ImGui_NewLine(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_NewLine", ImGui_Context ctx)`
Lua	`ImGui.NewLine(ImGui_Context ctx)`
Python	`ImGui.NewLine(ImGui_Context ctx)`

Undo a SameLine() or force a new line when in a horizontal-layout context.

View source · v0.1+

Function: SameLine

C++	`void ImGui::SameLine(ImGui_Context* ctx, double offset_from_start_xInOptional = 0.0, double spacingInOptional = -1.0)`
EEL	`ImGui_SameLine(ImGui_Context ctx, offset_from_start_x = 0.0, spacing = -1.0)`
Legacy EEL	`extension_api("ImGui_SameLine", ImGui_Context ctx, offset_from_start_x = 0.0, spacing = -1.0)`
Lua	`ImGui.SameLine(ImGui_Context ctx, number offset_from_start_x = 0.0, number spacing = -1.0)`
Python	`ImGui.SameLine(ImGui_Context ctx, float offset_from_start_x = 0.0, float spacing = -1.0)`

Call between widgets or groups to layout them horizontally. X position given in window coordinates.

View source · v0.1+

Function: Separator

C++	`void ImGui::Separator(ImGui_Context* ctx)`
EEL	`ImGui_Separator(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_Separator", ImGui_Context ctx)`
Lua	`ImGui.Separator(ImGui_Context ctx)`
Python	`ImGui.Separator(ImGui_Context ctx)`

Separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.

View source · v0.1+

Function: SeparatorText

C++	`void ImGui::SeparatorText(ImGui_Context* ctx, const char* label)`
EEL	`ImGui_SeparatorText(ImGui_Context ctx, "label")`
Legacy EEL	`extension_api("ImGui_SeparatorText", ImGui_Context ctx, "label")`
Lua	`ImGui.SeparatorText(ImGui_Context ctx, string label)`
Python	`ImGui.SeparatorText(ImGui_Context ctx, str label)`

Text formatted with an horizontal line

View source · v0.8.4+

Function: Spacing

C++	`void ImGui::Spacing(ImGui_Context* ctx)`
EEL	`ImGui_Spacing(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_Spacing", ImGui_Context ctx)`
Lua	`ImGui.Spacing(ImGui_Context ctx)`
Python	`ImGui.Spacing(ImGui_Context ctx)`

Add vertical spacing.

View source · v0.1+

Function: Unindent

C++	`void ImGui::Unindent(ImGui_Context* ctx, double indent_wInOptional = 0.0)`
EEL	`ImGui_Unindent(ImGui_Context ctx, indent_w = 0.0)`
Legacy EEL	`extension_api("ImGui_Unindent", ImGui_Context ctx, indent_w = 0.0)`
Lua	`ImGui.Unindent(ImGui_Context ctx, number indent_w = 0.0)`
Python	`ImGui.Unindent(ImGui_Context ctx, float indent_w = 0.0)`

Move content position back to the left, by 'indent_w', or StyleVar_IndentSpacing if 'indent_w' <= 0

View source · v0.1+

Clipping

Mouse hovering is affected by PushClipRect() calls, unlike direct calls to DrawList_PushClipRect() which are render only. Coordinates are in screen space.

Function: IsRectVisible

C++	`bool ImGui::IsRectVisible(ImGui_Context* ctx, double size_w, double size_h)`
EEL	`bool ImGui_IsRectVisible(ImGui_Context ctx, size_w, size_h)`
Legacy EEL	`bool extension_api("ImGui_IsRectVisible", ImGui_Context ctx, size_w, size_h)`
Lua	`boolean retval = ImGui.IsRectVisible(ImGui_Context ctx, number size_w, number size_h)`
Python	`bool retval = ImGui.IsRectVisible(ImGui_Context ctx, float size_w, float size_h)`

Test if rectangle (of given size, starting from cursor position) is visible / not clipped.

View source · v0.1+

Function: IsRectVisibleEx

C++	`bool ImGui::IsRectVisibleEx(ImGui_Context* ctx, double rect_min_x, double rect_min_y, double rect_max_x, double rect_max_y)`
EEL	`bool ImGui_IsRectVisibleEx(ImGui_Context ctx, rect_min_x, rect_min_y, rect_max_x, rect_max_y)`
Legacy EEL	`bool extension_api("ImGui_IsRectVisibleEx", ImGui_Context ctx, rect_min_x, rect_min_y, rect_max_x, rect_max_y)`
Lua	`boolean retval = ImGui.IsRectVisibleEx(ImGui_Context ctx, number rect_min_x, number rect_min_y, number rect_max_x, number rect_max_y)`
Python	`bool retval = ImGui.IsRectVisibleEx(ImGui_Context ctx, float rect_min_x, float rect_min_y, float rect_max_x, float rect_max_y)`

Test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.

View source · v0.1+

Function: PopClipRect

C++	`void ImGui::PopClipRect(ImGui_Context* ctx)`
EEL	`ImGui_PopClipRect(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopClipRect", ImGui_Context ctx)`
Lua	`ImGui.PopClipRect(ImGui_Context ctx)`
Python	`ImGui.PopClipRect(ImGui_Context ctx)`

See PushClipRect

View source · v0.1+

Function: PushClipRect

C++	`void ImGui::PushClipRect(ImGui_Context* ctx, double clip_rect_min_x, double clip_rect_min_y, double clip_rect_max_x, double clip_rect_max_y, bool intersect_with_current_clip_rect)`
EEL	`ImGui_PushClipRect(ImGui_Context ctx, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, bool intersect_with_current_clip_rect)`
Legacy EEL	`extension_api("ImGui_PushClipRect", ImGui_Context ctx, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, bool intersect_with_current_clip_rect)`
Lua	`ImGui.PushClipRect(ImGui_Context ctx, number clip_rect_min_x, number clip_rect_min_y, number clip_rect_max_x, number clip_rect_max_y, boolean intersect_with_current_clip_rect)`
Python	`ImGui.PushClipRect(ImGui_Context ctx, float clip_rect_min_x, float clip_rect_min_y, float clip_rect_max_x, float clip_rect_max_y, bool intersect_with_current_clip_rect)`

View source · v0.1+

Layout Cursor Positioning

By "cursor" we mean the current output position. The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down.

You can call SameLine() between widgets to undo the last carriage return and output at the right of the preceding widget.

Function: GetCursorPos

C++	`void ImGui::GetCursorPos(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetCursorPos(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetCursorPos", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetCursorPos(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetCursorPos(ImGui_Context ctx)`

Cursor position in window

View source · v0.1+

Function: GetCursorPosX

C++	`double ImGui::GetCursorPosX(ImGui_Context* ctx)`
EEL	`double ImGui_GetCursorPosX(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetCursorPosX", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetCursorPosX(ImGui_Context ctx)`
Python	`float retval = ImGui.GetCursorPosX(ImGui_Context ctx)`

Cursor X position in window

View source · v0.1+

Function: GetCursorPosY

C++	`double ImGui::GetCursorPosY(ImGui_Context* ctx)`
EEL	`double ImGui_GetCursorPosY(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetCursorPosY", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetCursorPosY(ImGui_Context ctx)`
Python	`float retval = ImGui.GetCursorPosY(ImGui_Context ctx)`

Cursor Y position in window

View source · v0.1+

Function: GetCursorScreenPos

C++	`void ImGui::GetCursorScreenPos(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetCursorScreenPos(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetCursorScreenPos", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetCursorScreenPos(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetCursorScreenPos(ImGui_Context ctx)`

Cursor position in absolute screen coordinates (useful to work with the DrawList API).

View source · v0.1+

Function: GetCursorStartPos

C++	`void ImGui::GetCursorStartPos(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetCursorStartPos(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetCursorStartPos", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetCursorStartPos(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetCursorStartPos(ImGui_Context ctx)`

Initial cursor position in window coordinates.

View source · v0.1+

Function: SetCursorPos

C++	`void ImGui::SetCursorPos(ImGui_Context* ctx, double local_pos_x, double local_pos_y)`
EEL	`ImGui_SetCursorPos(ImGui_Context ctx, local_pos_x, local_pos_y)`
Legacy EEL	`extension_api("ImGui_SetCursorPos", ImGui_Context ctx, local_pos_x, local_pos_y)`
Lua	`ImGui.SetCursorPos(ImGui_Context ctx, number local_pos_x, number local_pos_y)`
Python	`ImGui.SetCursorPos(ImGui_Context ctx, float local_pos_x, float local_pos_y)`

Cursor position in window

View source · v0.1+

Function: SetCursorPosX

C++	`void ImGui::SetCursorPosX(ImGui_Context* ctx, double local_x)`
EEL	`ImGui_SetCursorPosX(ImGui_Context ctx, local_x)`
Legacy EEL	`extension_api("ImGui_SetCursorPosX", ImGui_Context ctx, local_x)`
Lua	`ImGui.SetCursorPosX(ImGui_Context ctx, number local_x)`
Python	`ImGui.SetCursorPosX(ImGui_Context ctx, float local_x)`

Cursor X position in window

View source · v0.1+

Function: SetCursorPosY

C++	`void ImGui::SetCursorPosY(ImGui_Context* ctx, double local_y)`
EEL	`ImGui_SetCursorPosY(ImGui_Context ctx, local_y)`
Legacy EEL	`extension_api("ImGui_SetCursorPosY", ImGui_Context ctx, local_y)`
Lua	`ImGui.SetCursorPosY(ImGui_Context ctx, number local_y)`
Python	`ImGui.SetCursorPosY(ImGui_Context ctx, float local_y)`

Cursor Y position in window

View source · v0.1+

Function: SetCursorScreenPos

C++	`void ImGui::SetCursorScreenPos(ImGui_Context* ctx, double pos_x, double pos_y)`
EEL	`ImGui_SetCursorScreenPos(ImGui_Context ctx, pos_x, pos_y)`
Legacy EEL	`extension_api("ImGui_SetCursorScreenPos", ImGui_Context ctx, pos_x, pos_y)`
Lua	`ImGui.SetCursorScreenPos(ImGui_Context ctx, number pos_x, number pos_y)`
Python	`ImGui.SetCursorScreenPos(ImGui_Context ctx, float pos_x, float pos_y)`

Cursor position in absolute screen coordinates.

View source · v0.1+

List Clipper

Helper to manually clip large list of items.

If you have lots evenly spaced items and you have random access to the list, you can perform coarse clipping based on visibility to only submit items that are in view.

The clipper calculates the range of visible items and advance the cursor to compensate for the non-visible items we have skipped. (Dear ImGui already clip items based on their bounds but: it needs to first layout the item to do so, and generally fetching/submitting your own data incurs additional cost. Coarse clipping using a list clipper allows you to easily scale using lists with tens of thousands of items without a problem.)

Usage:

if not ImGui.ValidatePtr(clipper, 'ImGui_ListClipper*') then
  clipper = ImGui.CreateListClipper(ctx)
end
ImGui.ListClipper_Begin(clipper, 1000) -- We have 1000 elements, evenly spaced
while ImGui.ListClipper_Step(clipper) do
  local display_start, display_end = ImGui.ListClipper_GetDisplayRange(clipper)
  for row = display_start, display_end - 1 do
    ImGui.Text(ctx, ("line number %d"):format(row))
  end
end

Generally what happens is:

Clipper lets you process the first element (DisplayStart = 0, DisplayEnd = 1) regardless of it being visible or not.
User code submit that one element.
Clipper can measure the height of the first element
Clipper calculate the actual range of elements to display based on the current clipping rectangle, position the cursor before the first visible element.
User code submit visible elements.
The clipper also handles various subtleties related to keyboard/gamepad navigation, wrapping etc.

Function: CreateListClipper

C++	`ImGui_ListClipper* ImGui::CreateListClipper(ImGui_Context* ctx)`
EEL	`ImGui_ListClipper* ImGui_CreateListClipper(ImGui_Context ctx)`
Legacy EEL	`ImGui_ListClipper* extension_api("ImGui_CreateListClipper", ImGui_Context ctx)`
Lua	`ImGui_ListClipper retval = ImGui.CreateListClipper(ImGui_Context ctx)`
Python	`ImGui_ListClipper retval = ImGui.CreateListClipper(ImGui_Context ctx)`

The returned clipper object is only valid for the given context and is valid as long as it is used in each defer cycle unless attached (see Attach).

View source · v0.9+

Function: ListClipper_Begin

C++	`void ImGui::ListClipper_Begin(ImGui_ListClipper* clipper, int items_count, double items_heightInOptional = -1.0)`
EEL	`ImGui_ListClipper_Begin(ImGui_ListClipper clipper, int items_count, items_height = -1.0)`
Legacy EEL	`extension_api("ImGui_ListClipper_Begin", ImGui_ListClipper clipper, int items_count, items_height = -1.0)`
Lua	`ImGui.ListClipper_Begin(ImGui_ListClipper clipper, integer items_count, number items_height = -1.0)`
Python	`ImGui.ListClipper_Begin(ImGui_ListClipper clipper, int items_count, float items_height = -1.0)`

items_count: Use INT_MAX if you don't know how many items you have (in which case the cursor won't be advanced in the final step)
items_height: Use -1.0 to be calculated automatically on first step. Otherwise pass in the distance between your items, typically GetTextLineHeightWithSpacing or GetFrameHeightWithSpacing.

View source · v0.1+

Function: ListClipper_End

C++	`void ImGui::ListClipper_End(ImGui_ListClipper* clipper)`
EEL	`ImGui_ListClipper_End(ImGui_ListClipper clipper)`
Legacy EEL	`extension_api("ImGui_ListClipper_End", ImGui_ListClipper clipper)`
Lua	`ImGui.ListClipper_End(ImGui_ListClipper clipper)`
Python	`ImGui.ListClipper_End(ImGui_ListClipper clipper)`

Automatically called on the last call of ListClipper_Step that returns false.

View source · v0.1+

Function: ListClipper_GetDisplayRange

C++	`void ImGui::ListClipper_GetDisplayRange(ImGui_ListClipper* clipper, int* display_startOut, int* display_endOut)`
EEL	`ImGui_ListClipper_GetDisplayRange(ImGui_ListClipper clipper, int &display_start, int &display_end)`
Legacy EEL	`extension_api("ImGui_ListClipper_GetDisplayRange", ImGui_ListClipper clipper, int &display_start, int &display_end)`
Lua	`integer display_start, integer display_end = ImGui.ListClipper_GetDisplayRange(ImGui_ListClipper clipper)`
Python	`(int display_start, int display_end) = ImGui.ListClipper_GetDisplayRange(ImGui_ListClipper clipper)`

View source · v0.3+

Function: ListClipper_IncludeItemByIndex

C++	`void ImGui::ListClipper_IncludeItemByIndex(ImGui_ListClipper* clipper, int item_index)`
EEL	`ImGui_ListClipper_IncludeItemByIndex(ImGui_ListClipper clipper, int item_index)`
Legacy EEL	`extension_api("ImGui_ListClipper_IncludeItemByIndex", ImGui_ListClipper clipper, int item_index)`
Lua	`ImGui.ListClipper_IncludeItemByIndex(ImGui_ListClipper clipper, integer item_index)`
Python	`ImGui.ListClipper_IncludeItemByIndex(ImGui_ListClipper clipper, int item_index)`

Call ListClipper_IncludeItemByIndex or ListClipper_IncludeItemsByIndex before the first call to ListClipper_Step if you need a range of items to be displayed regardless of visibility.

(Due to alignment / padding of certain items it is possible that an extra item may be included on either end of the display range).

View source · v0.9+

Function: ListClipper_IncludeItemsByIndex

C++	`void ImGui::ListClipper_IncludeItemsByIndex(ImGui_ListClipper* clipper, int item_begin, int item_end)`
EEL	`ImGui_ListClipper_IncludeItemsByIndex(ImGui_ListClipper clipper, int item_begin, int item_end)`
Legacy EEL	`extension_api("ImGui_ListClipper_IncludeItemsByIndex", ImGui_ListClipper clipper, int item_begin, int item_end)`
Lua	`ImGui.ListClipper_IncludeItemsByIndex(ImGui_ListClipper clipper, integer item_begin, integer item_end)`
Python	`ImGui.ListClipper_IncludeItemsByIndex(ImGui_ListClipper clipper, int item_begin, int item_end)`

See ListClipper_IncludeItemByIndex.

item_end is exclusive e.g. use (42, 42+1) to make item 42 never clipped.

View source · v0.9+

Function: ListClipper_Step

C++	`bool ImGui::ListClipper_Step(ImGui_ListClipper* clipper)`
EEL	`bool ImGui_ListClipper_Step(ImGui_ListClipper clipper)`
Legacy EEL	`bool extension_api("ImGui_ListClipper_Step", ImGui_ListClipper clipper)`
Lua	`boolean retval = ImGui.ListClipper_Step(ImGui_ListClipper clipper)`
Python	`bool retval = ImGui.ListClipper_Step(ImGui_ListClipper clipper)`

Call until it returns false. The display_start/display_end fields from ListClipper_GetDisplayRange will be set and you can process/draw those items.

View source · v0.1+

Function: BeginMenu

C++	`bool ImGui::BeginMenu(ImGui_Context* ctx, const char* label, bool enabledInOptional = true)`
EEL	`bool ImGui_BeginMenu(ImGui_Context ctx, "label", bool enabled = true)`
Legacy EEL	`bool extension_api("ImGui_BeginMenu", ImGui_Context ctx, "label", bool enabled = true)`
Lua	`boolean retval = ImGui.BeginMenu(ImGui_Context ctx, string label, boolean enabled = true)`
Python	`bool retval = ImGui.BeginMenu(ImGui_Context ctx, str label, bool enabled = true)`

Create a sub-menu entry. only call EndMenu if this returns true!

View source · v0.1+

Function: BeginMenuBar

C++	`bool ImGui::BeginMenuBar(ImGui_Context* ctx)`
EEL	`bool ImGui_BeginMenuBar(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_BeginMenuBar", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.BeginMenuBar(ImGui_Context ctx)`
Python	`bool retval = ImGui.BeginMenuBar(ImGui_Context ctx)`

Append to menu-bar of current window (requires WindowFlags_MenuBar flag set on parent window). See EndMenuBar.

View source · v0.1+

Function: EndMenu

C++	`void ImGui::EndMenu(ImGui_Context* ctx)`
EEL	`ImGui_EndMenu(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndMenu", ImGui_Context ctx)`
Lua	`ImGui.EndMenu(ImGui_Context ctx)`
Python	`ImGui.EndMenu(ImGui_Context ctx)`

Only call EndMenu() if BeginMenu returns true!

View source · v0.1+

Function: EndMenuBar

C++	`void ImGui::EndMenuBar(ImGui_Context* ctx)`
EEL	`ImGui_EndMenuBar(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndMenuBar", ImGui_Context ctx)`
Lua	`ImGui.EndMenuBar(ImGui_Context ctx)`
Python	`ImGui.EndMenuBar(ImGui_Context ctx)`

Only call EndMenuBar if BeginMenuBar returns true!

View source · v0.1+

Function: MenuItem

C++	`bool ImGui::MenuItem(ImGui_Context* ctx, const char* label, const char* shortcutInOptional = nullptr, bool* p_selectedInOutOptional = nullptr, bool enabledInOptional = true)`
EEL	`bool ImGui_MenuItem(ImGui_Context ctx, "label", "shortcut" = 0, bool &p_selected = 0, bool enabled = true)`
Legacy EEL	`bool extension_api("ImGui_MenuItem", ImGui_Context ctx, "label", "shortcut" = 0, bool &p_selected = 0, bool enabled = true)`
Lua	`boolean retval, boolean p_selected = ImGui.MenuItem(ImGui_Context ctx, string label, string shortcut = nil, boolean p_selected = nil, boolean enabled = true)`
Python	`(bool retval, bool p_selected) = ImGui.MenuItem(ImGui_Context ctx, str label, str shortcut = None, bool p_selected = None, bool enabled = true)`

Return true when activated. Shortcuts are displayed for convenience but not processed by ImGui at the moment. Toggle state is written to 'selected' when provided.

View source · v0.1+

Plot

Simple data plotting using reaper_array as data source.

Function: PlotHistogram

C++	`void ImGui::PlotHistogram(ImGui_Context* ctx, const char* label, reaper_array* values, int values_offsetInOptional = 0, const char* overlay_textInOptional = nullptr, double scale_minInOptional = FLT_MAX, double scale_maxInOptional = FLT_MAX, double graph_size_wInOptional = 0.0, double graph_size_hInOptional = 0.0)`
EEL	`ImGui_PlotHistogram(ImGui_Context ctx, "label", reaper_array values, int values_offset = 0, "overlay_text" = 0, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size_w = 0.0, graph_size_h = 0.0)`
Legacy EEL	`extension_api("ImGui_PlotHistogram", ImGui_Context ctx, "label", reaper_array values, int values_offset = 0, "overlay_text" = 0, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size_w = 0.0, graph_size_h = 0.0)`
Lua	`ImGui.PlotHistogram(ImGui_Context ctx, string label, reaper.array values, integer values_offset = 0, string overlay_text = nil, number scale_min = FLT_MAX, number scale_max = FLT_MAX, number graph_size_w = 0.0, number graph_size_h = 0.0)`
Python	`ImGui.PlotHistogram(ImGui_Context ctx, str label, reaper_array values, int values_offset = 0, str overlay_text = None, float scale_min = FLT_MAX, float scale_max = FLT_MAX, float graph_size_w = 0.0, float graph_size_h = 0.0)`

View source · v0.1+

Function: PlotLines

C++	`void ImGui::PlotLines(ImGui_Context* ctx, const char* label, reaper_array* values, int values_offsetInOptional = 0, const char* overlay_textInOptional = nullptr, double scale_minInOptional = FLT_MAX, double scale_maxInOptional = FLT_MAX, double graph_size_wInOptional = 0.0, double graph_size_hInOptional = 0.0)`
EEL	`ImGui_PlotLines(ImGui_Context ctx, "label", reaper_array values, int values_offset = 0, "overlay_text" = 0, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size_w = 0.0, graph_size_h = 0.0)`
Legacy EEL	`extension_api("ImGui_PlotLines", ImGui_Context ctx, "label", reaper_array values, int values_offset = 0, "overlay_text" = 0, scale_min = FLT_MAX, scale_max = FLT_MAX, graph_size_w = 0.0, graph_size_h = 0.0)`
Lua	`ImGui.PlotLines(ImGui_Context ctx, string label, reaper.array values, integer values_offset = 0, string overlay_text = nil, number scale_min = FLT_MAX, number scale_max = FLT_MAX, number graph_size_w = 0.0, number graph_size_h = 0.0)`
Python	`ImGui.PlotLines(ImGui_Context ctx, str label, reaper_array values, int values_offset = 0, str overlay_text = None, float scale_min = FLT_MAX, float scale_max = FLT_MAX, float graph_size_w = 0.0, float graph_size_h = 0.0)`

View source · v0.1+

They block normal mouse hovering detection (and therefore most mouse interactions) behind them.
If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.
Their visibility state (~bool) is held internally instead of being held by the programmer as we are used to with regular Begin*() calls.

The 3 properties above are related: we need to retain popup visibility state in the library because popups may be closed as any time.

You can bypass the hovering restriction by using HoveredFlags_AllowWhenBlockedByPopup when calling IsItemHovered or IsWindowHovered.

IMPORTANT: Popup identifiers are relative to the current ID stack, so OpenPopup and BeginPopup generally needs to be at the same level of the stack.

Function: BeginPopup

C++	`bool ImGui::BeginPopup(ImGui_Context* ctx, const char* str_id, int flagsInOptional = WindowFlags_None)`
EEL	`bool ImGui_BeginPopup(ImGui_Context ctx, "str_id", int flags = WindowFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginPopup", ImGui_Context ctx, "str_id", int flags = WindowFlags_None)`
Lua	`boolean retval = ImGui.BeginPopup(ImGui_Context ctx, string str_id, integer flags = WindowFlags_None)`
Python	`bool retval = ImGui.BeginPopup(ImGui_Context ctx, str str_id, int flags = WindowFlags_None)`

Query popup state, if open start appending into the window. Call EndPopup afterwards if returned true. WindowFlags* are forwarded to the window.

Return true if the popup is open, and you can start outputting to it.

View source · v0.1+

Function: BeginPopupModal

C++	`bool ImGui::BeginPopupModal(ImGui_Context* ctx, const char* name, bool* p_openInOutOptional = nullptr, int flagsInOptional = WindowFlags_None)`
EEL	`bool ImGui_BeginPopupModal(ImGui_Context ctx, "name", bool &p_open = 0, int flags = WindowFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginPopupModal", ImGui_Context ctx, "name", bool &p_open = 0, int flags = WindowFlags_None)`
Lua	`boolean retval, boolean p_open = ImGui.BeginPopupModal(ImGui_Context ctx, string name, boolean p_open = nil, integer flags = WindowFlags_None)`
Python	`(bool retval, bool p_open) = ImGui.BeginPopupModal(ImGui_Context ctx, str name, bool p_open = None, int flags = WindowFlags_None)`

Block every interaction behind the window, cannot be closed by user, add a dimming background, has a title bar. Return true if the modal is open, and you can start outputting to it. See BeginPopup.

View source · v0.1+

Function: CloseCurrentPopup

C++	`void ImGui::CloseCurrentPopup(ImGui_Context* ctx)`
EEL	`ImGui_CloseCurrentPopup(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_CloseCurrentPopup", ImGui_Context ctx)`
Lua	`ImGui.CloseCurrentPopup(ImGui_Context ctx)`
Python	`ImGui.CloseCurrentPopup(ImGui_Context ctx)`

Manually close the popup we have begin-ed into. Use inside the BeginPopup/EndPopup scope to close manually.

CloseCurrentPopup() is called by default by Selectable/MenuItem when activated.

View source · v0.1+

Function: EndPopup

C++	`void ImGui::EndPopup(ImGui_Context* ctx)`
EEL	`ImGui_EndPopup(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndPopup", ImGui_Context ctx)`
Lua	`ImGui.EndPopup(ImGui_Context ctx)`
Python	`ImGui.EndPopup(ImGui_Context ctx)`

Only call EndPopup() if BeginPopup*() returns true!

View source · v0.8+

Function: IsPopupOpen

C++	`bool ImGui::IsPopupOpen(ImGui_Context* ctx, const char* str_id, int flagsInOptional = PopupFlags_None)`
EEL	`bool ImGui_IsPopupOpen(ImGui_Context ctx, "str_id", int flags = PopupFlags_None)`
Legacy EEL	`bool extension_api("ImGui_IsPopupOpen", ImGui_Context ctx, "str_id", int flags = PopupFlags_None)`
Lua	`boolean retval = ImGui.IsPopupOpen(ImGui_Context ctx, string str_id, integer flags = PopupFlags_None)`
Python	`bool retval = ImGui.IsPopupOpen(ImGui_Context ctx, str str_id, int flags = PopupFlags_None)`

Return true if the popup is open at the current BeginPopup level of the popup stack.

With PopupFlags_AnyPopupId: return true if any popup is open at the current BeginPopup() level of the popup stack.
With PopupFlags_AnyPopupId + PopupFlags_AnyPopupLevel: return true if any popup is open.

View source · v0.1+

Function: OpenPopup

C++	`void ImGui::OpenPopup(ImGui_Context* ctx, const char* str_id, int popup_flagsInOptional = PopupFlags_None)`
EEL	`ImGui_OpenPopup(ImGui_Context ctx, "str_id", int popup_flags = PopupFlags_None)`
Legacy EEL	`extension_api("ImGui_OpenPopup", ImGui_Context ctx, "str_id", int popup_flags = PopupFlags_None)`
Lua	`ImGui.OpenPopup(ImGui_Context ctx, string str_id, integer popup_flags = PopupFlags_None)`
Python	`ImGui.OpenPopup(ImGui_Context ctx, str str_id, int popup_flags = PopupFlags_None)`

Set popup state to open (don't call every frame!). ImGuiPopupFlags are available for opening options.

If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.

Use PopupFlags_NoOpenOverExistingPopup to avoid opening a popup if there's already one at the same level.

View source · v0.1+

Function: OpenPopupOnItemClick

C++	`void ImGui::OpenPopupOnItemClick(ImGui_Context* ctx, const char* str_idInOptional = nullptr, int popup_flagsInOptional = PopupFlags_MouseButtonRight)`
EEL	`ImGui_OpenPopupOnItemClick(ImGui_Context ctx, "str_id" = 0, int popup_flags = PopupFlags_MouseButtonRight)`
Legacy EEL	`extension_api("ImGui_OpenPopupOnItemClick", ImGui_Context ctx, "str_id" = 0, int popup_flags = PopupFlags_MouseButtonRight)`
Lua	`ImGui.OpenPopupOnItemClick(ImGui_Context ctx, string str_id = nil, integer popup_flags = PopupFlags_MouseButtonRight)`
Python	`ImGui.OpenPopupOnItemClick(ImGui_Context ctx, str str_id = None, int popup_flags = PopupFlags_MouseButtonRight)`

Helper to open popup when clicked on last item. return true when just opened. (Note: actually triggers on the mouse released event to be consistent with popup behaviors.)

View source · v0.1+

Constant: PopupFlags_None

C++	`int ImGui::PopupFlags_None`
EEL	`int ImGui_PopupFlags_None()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_None")`
Lua	`integer ImGui.PopupFlags_None`
Python	`int retval = ImGui.PopupFlags_None()`

View source · v0.1+

Constant: PopupFlags_MouseButtonLeft

C++	`int ImGui::PopupFlags_MouseButtonLeft`
EEL	`int ImGui_PopupFlags_MouseButtonLeft()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_MouseButtonLeft")`
Lua	`integer ImGui.PopupFlags_MouseButtonLeft`
Python	`int retval = ImGui.PopupFlags_MouseButtonLeft()`

Open on Left Mouse release. Guaranteed to always be == 0 (same as MouseButton_Left).

View source · v0.1+

Constant: PopupFlags_MouseButtonMiddle

C++	`int ImGui::PopupFlags_MouseButtonMiddle`
EEL	`int ImGui_PopupFlags_MouseButtonMiddle()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_MouseButtonMiddle")`
Lua	`integer ImGui.PopupFlags_MouseButtonMiddle`
Python	`int retval = ImGui.PopupFlags_MouseButtonMiddle()`

Open on Middle Mouse release. Guaranteed to always be == 2 (same as MouseButton_Middle).

View source · v0.1+

Constant: PopupFlags_MouseButtonRight

C++	`int ImGui::PopupFlags_MouseButtonRight`
EEL	`int ImGui_PopupFlags_MouseButtonRight()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_MouseButtonRight")`
Lua	`integer ImGui.PopupFlags_MouseButtonRight`
Python	`int retval = ImGui.PopupFlags_MouseButtonRight()`

Open on Right Mouse release. Guaranteed to always be == 1 (same as MouseButton_Right).

View source · v0.1+

Constant: PopupFlags_NoOpenOverItems

C++	`int ImGui::PopupFlags_NoOpenOverItems`
EEL	`int ImGui_PopupFlags_NoOpenOverItems()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_NoOpenOverItems")`
Lua	`integer ImGui.PopupFlags_NoOpenOverItems`
Python	`int retval = ImGui.PopupFlags_NoOpenOverItems()`

For BeginPopupContextWindow: don't return true when hovering items, only when hovering empty space.

View source · v0.1+

Constant: PopupFlags_AnyPopup

C++	`int ImGui::PopupFlags_AnyPopup`
EEL	`int ImGui_PopupFlags_AnyPopup()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_AnyPopup")`
Lua	`integer ImGui.PopupFlags_AnyPopup`
Python	`int retval = ImGui.PopupFlags_AnyPopup()`

PopupFlags_AnyPopupId | PopupFlags_AnyPopupLevel

View source · v0.1+

Constant: PopupFlags_AnyPopupId

C++	`int ImGui::PopupFlags_AnyPopupId`
EEL	`int ImGui_PopupFlags_AnyPopupId()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_AnyPopupId")`
Lua	`integer ImGui.PopupFlags_AnyPopupId`
Python	`int retval = ImGui.PopupFlags_AnyPopupId()`

Ignore the str_id parameter and test for any popup.

View source · v0.1+

Constant: PopupFlags_AnyPopupLevel

C++	`int ImGui::PopupFlags_AnyPopupLevel`
EEL	`int ImGui_PopupFlags_AnyPopupLevel()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_AnyPopupLevel")`
Lua	`integer ImGui.PopupFlags_AnyPopupLevel`
Python	`int retval = ImGui.PopupFlags_AnyPopupLevel()`

Search/test at any level of the popup stack (default test in the current level).

View source · v0.1+

Constant: PopupFlags_NoOpenOverExistingPopup

C++	`int ImGui::PopupFlags_NoOpenOverExistingPopup`
EEL	`int ImGui_PopupFlags_NoOpenOverExistingPopup()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_NoOpenOverExistingPopup")`
Lua	`integer ImGui.PopupFlags_NoOpenOverExistingPopup`
Python	`int retval = ImGui.PopupFlags_NoOpenOverExistingPopup()`

Don't open if there's already a popup at the same level of the popup stack.

View source · v0.1+

Constant: PopupFlags_NoReopen

C++	`int ImGui::PopupFlags_NoReopen`
EEL	`int ImGui_PopupFlags_NoReopen()`
Legacy EEL	`int extension_api("ImGui_PopupFlags_NoReopen")`
Lua	`integer ImGui.PopupFlags_NoReopen`
Python	`int retval = ImGui.PopupFlags_NoReopen()`

Don't reopen same popup if already open (won't reposition, won't reinitialize navigation).

View source · v0.9+

Helpers to do OpenPopup+BeginPopup where the Open action is triggered by e.g. hovering an item and right-clicking. They are convenient to easily create context menus, hence the name.

Notice that BeginPopupContext* takes PopupFlags_* just like OpenPopup and unlike BeginPopup.

We exceptionally default their flags to 1 (== PopupFlags_MouseButtonRight) for backward compatibility with older API taking 'int mouse_button = 1' parameter, so if you add other flags remember to re-add the PopupFlags_MouseButtonRight.

Function: BeginPopupContextItem

C++	`bool ImGui::BeginPopupContextItem(ImGui_Context* ctx, const char* str_idInOptional = nullptr, int popup_flagsInOptional = PopupFlags_MouseButtonRight)`
EEL	`bool ImGui_BeginPopupContextItem(ImGui_Context ctx, "str_id" = 0, int popup_flags = PopupFlags_MouseButtonRight)`
Legacy EEL	`bool extension_api("ImGui_BeginPopupContextItem", ImGui_Context ctx, "str_id" = 0, int popup_flags = PopupFlags_MouseButtonRight)`
Lua	`boolean retval = ImGui.BeginPopupContextItem(ImGui_Context ctx, string str_id = nil, integer popup_flags = PopupFlags_MouseButtonRight)`
Python	`bool retval = ImGui.BeginPopupContextItem(ImGui_Context ctx, str str_id = None, int popup_flags = PopupFlags_MouseButtonRight)`

This is a helper to handle the simplest case of associating one named popup to one given widget. You can pass a nil str_id to use the identifier of the last item. This is essentially the same as calling OpenPopupOnItemClick + BeginPopup but written to avoid computing the ID twice because BeginPopupContext* functions may be called very frequently.

If you want to use that on a non-interactive item such as Text you need to pass in an explicit ID here.

View source · v0.1+

Function: BeginPopupContextWindow

C++	`bool ImGui::BeginPopupContextWindow(ImGui_Context* ctx, const char* str_idInOptional = nullptr, int popup_flagsInOptional = PopupFlags_MouseButtonRight)`
EEL	`bool ImGui_BeginPopupContextWindow(ImGui_Context ctx, "str_id" = 0, int popup_flags = PopupFlags_MouseButtonRight)`
Legacy EEL	`bool extension_api("ImGui_BeginPopupContextWindow", ImGui_Context ctx, "str_id" = 0, int popup_flags = PopupFlags_MouseButtonRight)`
Lua	`boolean retval = ImGui.BeginPopupContextWindow(ImGui_Context ctx, string str_id = nil, integer popup_flags = PopupFlags_MouseButtonRight)`
Python	`bool retval = ImGui.BeginPopupContextWindow(ImGui_Context ctx, str str_id = None, int popup_flags = PopupFlags_MouseButtonRight)`

Open+begin popup when clicked on current window.

View source · v0.1+

Tooltips are windows following the mouse. They do not take focus away. A tooltip window can contain items of any type.

Function: BeginItemTooltip

C++	`bool ImGui::BeginItemTooltip(ImGui_Context* ctx)`
EEL	`bool ImGui_BeginItemTooltip(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_BeginItemTooltip", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.BeginItemTooltip(ImGui_Context ctx)`
Python	`bool retval = ImGui.BeginItemTooltip(ImGui_Context ctx)`

Begin/append a tooltip window if preceding item was hovered. Shortcut for IsItemHovered(HoveredFlags_ForTooltip) && BeginTooltip().

View source · v0.9+

Function: BeginTooltip

C++	`bool ImGui::BeginTooltip(ImGui_Context* ctx)`
EEL	`bool ImGui_BeginTooltip(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_BeginTooltip", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.BeginTooltip(ImGui_Context ctx)`
Python	`bool retval = ImGui.BeginTooltip(ImGui_Context ctx)`

Begin/append a tooltip window.

View source · v0.1+

Function: EndTooltip

C++	`void ImGui::EndTooltip(ImGui_Context* ctx)`
EEL	`ImGui_EndTooltip(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndTooltip", ImGui_Context ctx)`
Lua	`ImGui.EndTooltip(ImGui_Context ctx)`
Python	`ImGui.EndTooltip(ImGui_Context ctx)`

Only call EndTooltip() if BeginTooltip()/BeginItemTooltip() returns true.

View source · v0.8+

Function: SetItemTooltip

C++	`void ImGui::SetItemTooltip(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_SetItemTooltip(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_SetItemTooltip", ImGui_Context ctx, "text")`
Lua	`ImGui.SetItemTooltip(ImGui_Context ctx, string text)`
Python	`ImGui.SetItemTooltip(ImGui_Context ctx, str text)`

Set a text-only tooltip if preceding item was hovered. Override any previous call to SetTooltip(). Shortcut for if (IsItemHovered(HoveredFlags_ForTooltip)) { SetTooltip(...); }.

View source · v0.9+

Function: SetTooltip

C++	`void ImGui::SetTooltip(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_SetTooltip(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_SetTooltip", ImGui_Context ctx, "text")`
Lua	`ImGui.SetTooltip(ImGui_Context ctx, string text)`
Python	`ImGui.SetTooltip(ImGui_Context ctx, str text)`

Set a text-only tooltip. Often used after a IsItemHovered() check. Override any previous call to SetTooltip.

Shortcut for if (BeginTooltip()) { Text(...); EndTooltip(); }.

View source · v0.1+

Style

Colors

Constant: Col_Border

C++	`int ImGui::Col_Border`
EEL	`int ImGui_Col_Border()`
Legacy EEL	`int extension_api("ImGui_Col_Border")`
Lua	`integer ImGui.Col_Border`
Python	`int retval = ImGui.Col_Border()`

View source · v0.1+

Constant: Col_BorderShadow

C++	`int ImGui::Col_BorderShadow`
EEL	`int ImGui_Col_BorderShadow()`
Legacy EEL	`int extension_api("ImGui_Col_BorderShadow")`
Lua	`integer ImGui.Col_BorderShadow`
Python	`int retval = ImGui.Col_BorderShadow()`

View source · v0.1+

Constant: Col_Button

C++	`int ImGui::Col_Button`
EEL	`int ImGui_Col_Button()`
Legacy EEL	`int extension_api("ImGui_Col_Button")`
Lua	`integer ImGui.Col_Button`
Python	`int retval = ImGui.Col_Button()`

View source · v0.1+

Constant: Col_ButtonActive

C++	`int ImGui::Col_ButtonActive`
EEL	`int ImGui_Col_ButtonActive()`
Legacy EEL	`int extension_api("ImGui_Col_ButtonActive")`
Lua	`integer ImGui.Col_ButtonActive`
Python	`int retval = ImGui.Col_ButtonActive()`

View source · v0.1+

Constant: Col_ButtonHovered

C++	`int ImGui::Col_ButtonHovered`
EEL	`int ImGui_Col_ButtonHovered()`
Legacy EEL	`int extension_api("ImGui_Col_ButtonHovered")`
Lua	`integer ImGui.Col_ButtonHovered`
Python	`int retval = ImGui.Col_ButtonHovered()`

View source · v0.1+

Constant: Col_CheckMark

C++	`int ImGui::Col_CheckMark`
EEL	`int ImGui_Col_CheckMark()`
Legacy EEL	`int extension_api("ImGui_Col_CheckMark")`
Lua	`integer ImGui.Col_CheckMark`
Python	`int retval = ImGui.Col_CheckMark()`

Checkbox tick and RadioButton circle

View source · v0.1+

Constant: Col_ChildBg

C++	`int ImGui::Col_ChildBg`
EEL	`int ImGui_Col_ChildBg()`
Legacy EEL	`int extension_api("ImGui_Col_ChildBg")`
Lua	`integer ImGui.Col_ChildBg`
Python	`int retval = ImGui.Col_ChildBg()`

Background of child windows.

View source · v0.1+

Constant: Col_DockingEmptyBg

C++	`int ImGui::Col_DockingEmptyBg`
EEL	`int ImGui_Col_DockingEmptyBg()`
Legacy EEL	`int extension_api("ImGui_Col_DockingEmptyBg")`
Lua	`integer ImGui.Col_DockingEmptyBg`
Python	`int retval = ImGui.Col_DockingEmptyBg()`

Background color for empty node (e.g. CentralNode with no window docked into it).

View source · v0.5+

Constant: Col_DockingPreview

C++	`int ImGui::Col_DockingPreview`
EEL	`int ImGui_Col_DockingPreview()`
Legacy EEL	`int extension_api("ImGui_Col_DockingPreview")`
Lua	`integer ImGui.Col_DockingPreview`
Python	`int retval = ImGui.Col_DockingPreview()`

Preview overlay color when about to docking something.

View source · v0.5+

Constant: Col_DragDropTarget

C++	`int ImGui::Col_DragDropTarget`
EEL	`int ImGui_Col_DragDropTarget()`
Legacy EEL	`int extension_api("ImGui_Col_DragDropTarget")`
Lua	`integer ImGui.Col_DragDropTarget`
Python	`int retval = ImGui.Col_DragDropTarget()`

Rectangle highlighting a drop target

View source · v0.1+

Constant: Col_FrameBg

C++	`int ImGui::Col_FrameBg`
EEL	`int ImGui_Col_FrameBg()`
Legacy EEL	`int extension_api("ImGui_Col_FrameBg")`
Lua	`integer ImGui.Col_FrameBg`
Python	`int retval = ImGui.Col_FrameBg()`

Background of checkbox, radio button, plot, slider, text input.

View source · v0.1+

Constant: Col_FrameBgActive

C++	`int ImGui::Col_FrameBgActive`
EEL	`int ImGui_Col_FrameBgActive()`
Legacy EEL	`int extension_api("ImGui_Col_FrameBgActive")`
Lua	`integer ImGui.Col_FrameBgActive`
Python	`int retval = ImGui.Col_FrameBgActive()`

View source · v0.1+

Constant: Col_FrameBgHovered

C++	`int ImGui::Col_FrameBgHovered`
EEL	`int ImGui_Col_FrameBgHovered()`
Legacy EEL	`int extension_api("ImGui_Col_FrameBgHovered")`
Lua	`integer ImGui.Col_FrameBgHovered`
Python	`int retval = ImGui.Col_FrameBgHovered()`

View source · v0.1+

Constant: Col_Header

C++	`int ImGui::Col_Header`
EEL	`int ImGui_Col_Header()`
Legacy EEL	`int extension_api("ImGui_Col_Header")`
Lua	`integer ImGui.Col_Header`
Python	`int retval = ImGui.Col_Header()`

Header* colors are used for CollapsingHeader, TreeNode, Selectable, MenuItem.

View source · v0.1+

Constant: Col_HeaderActive

C++	`int ImGui::Col_HeaderActive`
EEL	`int ImGui_Col_HeaderActive()`
Legacy EEL	`int extension_api("ImGui_Col_HeaderActive")`
Lua	`integer ImGui.Col_HeaderActive`
Python	`int retval = ImGui.Col_HeaderActive()`

View source · v0.1+

Constant: Col_HeaderHovered

C++	`int ImGui::Col_HeaderHovered`
EEL	`int ImGui_Col_HeaderHovered()`
Legacy EEL	`int extension_api("ImGui_Col_HeaderHovered")`
Lua	`integer ImGui.Col_HeaderHovered`
Python	`int retval = ImGui.Col_HeaderHovered()`

View source · v0.1+

Constant: Col_MenuBarBg

C++	`int ImGui::Col_MenuBarBg`
EEL	`int ImGui_Col_MenuBarBg()`
Legacy EEL	`int extension_api("ImGui_Col_MenuBarBg")`
Lua	`integer ImGui.Col_MenuBarBg`
Python	`int retval = ImGui.Col_MenuBarBg()`

View source · v0.1+

Constant: Col_ModalWindowDimBg

C++	`int ImGui::Col_ModalWindowDimBg`
EEL	`int ImGui_Col_ModalWindowDimBg()`
Legacy EEL	`int extension_api("ImGui_Col_ModalWindowDimBg")`
Lua	`integer ImGui.Col_ModalWindowDimBg`
Python	`int retval = ImGui.Col_ModalWindowDimBg()`

Darken/colorize entire screen behind a modal window, when one is active.

View source · v0.1+

Constant: Col_NavHighlight

C++	`int ImGui::Col_NavHighlight`
EEL	`int ImGui_Col_NavHighlight()`
Legacy EEL	`int extension_api("ImGui_Col_NavHighlight")`
Lua	`integer ImGui.Col_NavHighlight`
Python	`int retval = ImGui.Col_NavHighlight()`

Gamepad/keyboard: current highlighted item.

View source · v0.1+

Constant: Col_NavWindowingDimBg

C++	`int ImGui::Col_NavWindowingDimBg`
EEL	`int ImGui_Col_NavWindowingDimBg()`
Legacy EEL	`int extension_api("ImGui_Col_NavWindowingDimBg")`
Lua	`integer ImGui.Col_NavWindowingDimBg`
Python	`int retval = ImGui.Col_NavWindowingDimBg()`

Darken/colorize entire screen behind the CTRL+TAB window list, when active.

View source · v0.1+

Constant: Col_NavWindowingHighlight

C++	`int ImGui::Col_NavWindowingHighlight`
EEL	`int ImGui_Col_NavWindowingHighlight()`
Legacy EEL	`int extension_api("ImGui_Col_NavWindowingHighlight")`
Lua	`integer ImGui.Col_NavWindowingHighlight`
Python	`int retval = ImGui.Col_NavWindowingHighlight()`

Highlight window when using CTRL+TAB.

View source · v0.1+

Constant: Col_PlotHistogram

C++	`int ImGui::Col_PlotHistogram`
EEL	`int ImGui_Col_PlotHistogram()`
Legacy EEL	`int extension_api("ImGui_Col_PlotHistogram")`
Lua	`integer ImGui.Col_PlotHistogram`
Python	`int retval = ImGui.Col_PlotHistogram()`

View source · v0.1+

Constant: Col_PlotHistogramHovered

C++	`int ImGui::Col_PlotHistogramHovered`
EEL	`int ImGui_Col_PlotHistogramHovered()`
Legacy EEL	`int extension_api("ImGui_Col_PlotHistogramHovered")`
Lua	`integer ImGui.Col_PlotHistogramHovered`
Python	`int retval = ImGui.Col_PlotHistogramHovered()`

View source · v0.1+

Constant: Col_PlotLines

C++	`int ImGui::Col_PlotLines`
EEL	`int ImGui_Col_PlotLines()`
Legacy EEL	`int extension_api("ImGui_Col_PlotLines")`
Lua	`integer ImGui.Col_PlotLines`
Python	`int retval = ImGui.Col_PlotLines()`

View source · v0.1+

Constant: Col_PlotLinesHovered

C++	`int ImGui::Col_PlotLinesHovered`
EEL	`int ImGui_Col_PlotLinesHovered()`
Legacy EEL	`int extension_api("ImGui_Col_PlotLinesHovered")`
Lua	`integer ImGui.Col_PlotLinesHovered`
Python	`int retval = ImGui.Col_PlotLinesHovered()`

View source · v0.1+

Constant: Col_PopupBg

C++	`int ImGui::Col_PopupBg`
EEL	`int ImGui_Col_PopupBg()`
Legacy EEL	`int extension_api("ImGui_Col_PopupBg")`
Lua	`integer ImGui.Col_PopupBg`
Python	`int retval = ImGui.Col_PopupBg()`

Background of popups, menus, tooltips windows.

View source · v0.1+

Constant: Col_ResizeGrip

C++	`int ImGui::Col_ResizeGrip`
EEL	`int ImGui_Col_ResizeGrip()`
Legacy EEL	`int extension_api("ImGui_Col_ResizeGrip")`
Lua	`integer ImGui.Col_ResizeGrip`
Python	`int retval = ImGui.Col_ResizeGrip()`

Resize grip in lower-right and lower-left corners of windows.

View source · v0.1+

Constant: Col_ResizeGripActive

C++	`int ImGui::Col_ResizeGripActive`
EEL	`int ImGui_Col_ResizeGripActive()`
Legacy EEL	`int extension_api("ImGui_Col_ResizeGripActive")`
Lua	`integer ImGui.Col_ResizeGripActive`
Python	`int retval = ImGui.Col_ResizeGripActive()`

View source · v0.1+

Constant: Col_ResizeGripHovered

C++	`int ImGui::Col_ResizeGripHovered`
EEL	`int ImGui_Col_ResizeGripHovered()`
Legacy EEL	`int extension_api("ImGui_Col_ResizeGripHovered")`
Lua	`integer ImGui.Col_ResizeGripHovered`
Python	`int retval = ImGui.Col_ResizeGripHovered()`

View source · v0.1+

Constant: Col_ScrollbarBg

C++	`int ImGui::Col_ScrollbarBg`
EEL	`int ImGui_Col_ScrollbarBg()`
Legacy EEL	`int extension_api("ImGui_Col_ScrollbarBg")`
Lua	`integer ImGui.Col_ScrollbarBg`
Python	`int retval = ImGui.Col_ScrollbarBg()`

View source · v0.1+

Constant: Col_ScrollbarGrab

C++	`int ImGui::Col_ScrollbarGrab`
EEL	`int ImGui_Col_ScrollbarGrab()`
Legacy EEL	`int extension_api("ImGui_Col_ScrollbarGrab")`
Lua	`integer ImGui.Col_ScrollbarGrab`
Python	`int retval = ImGui.Col_ScrollbarGrab()`

View source · v0.1+

Constant: Col_ScrollbarGrabActive

C++	`int ImGui::Col_ScrollbarGrabActive`
EEL	`int ImGui_Col_ScrollbarGrabActive()`
Legacy EEL	`int extension_api("ImGui_Col_ScrollbarGrabActive")`
Lua	`integer ImGui.Col_ScrollbarGrabActive`
Python	`int retval = ImGui.Col_ScrollbarGrabActive()`

View source · v0.1+

Constant: Col_ScrollbarGrabHovered

C++	`int ImGui::Col_ScrollbarGrabHovered`
EEL	`int ImGui_Col_ScrollbarGrabHovered()`
Legacy EEL	`int extension_api("ImGui_Col_ScrollbarGrabHovered")`
Lua	`integer ImGui.Col_ScrollbarGrabHovered`
Python	`int retval = ImGui.Col_ScrollbarGrabHovered()`

View source · v0.1+

Constant: Col_Separator

C++	`int ImGui::Col_Separator`
EEL	`int ImGui_Col_Separator()`
Legacy EEL	`int extension_api("ImGui_Col_Separator")`
Lua	`integer ImGui.Col_Separator`
Python	`int retval = ImGui.Col_Separator()`

View source · v0.1+

Constant: Col_SeparatorActive

C++	`int ImGui::Col_SeparatorActive`
EEL	`int ImGui_Col_SeparatorActive()`
Legacy EEL	`int extension_api("ImGui_Col_SeparatorActive")`
Lua	`integer ImGui.Col_SeparatorActive`
Python	`int retval = ImGui.Col_SeparatorActive()`

View source · v0.1+

Constant: Col_SeparatorHovered

C++	`int ImGui::Col_SeparatorHovered`
EEL	`int ImGui_Col_SeparatorHovered()`
Legacy EEL	`int extension_api("ImGui_Col_SeparatorHovered")`
Lua	`integer ImGui.Col_SeparatorHovered`
Python	`int retval = ImGui.Col_SeparatorHovered()`

View source · v0.1+

Constant: Col_SliderGrab

C++	`int ImGui::Col_SliderGrab`
EEL	`int ImGui_Col_SliderGrab()`
Legacy EEL	`int extension_api("ImGui_Col_SliderGrab")`
Lua	`integer ImGui.Col_SliderGrab`
Python	`int retval = ImGui.Col_SliderGrab()`

View source · v0.1+

Constant: Col_SliderGrabActive

C++	`int ImGui::Col_SliderGrabActive`
EEL	`int ImGui_Col_SliderGrabActive()`
Legacy EEL	`int extension_api("ImGui_Col_SliderGrabActive")`
Lua	`integer ImGui.Col_SliderGrabActive`
Python	`int retval = ImGui.Col_SliderGrabActive()`

View source · v0.1+

Constant: Col_Tab

C++	`int ImGui::Col_Tab`
EEL	`int ImGui_Col_Tab()`
Legacy EEL	`int extension_api("ImGui_Col_Tab")`
Lua	`integer ImGui.Col_Tab`
Python	`int retval = ImGui.Col_Tab()`

Tab background, when tab-bar is focused & tab is unselected

View source · v0.1+

Constant: Col_TabDimmed

C++	`int ImGui::Col_TabDimmed`
EEL	`int ImGui_Col_TabDimmed()`
Legacy EEL	`int extension_api("ImGui_Col_TabDimmed")`
Lua	`integer ImGui.Col_TabDimmed`
Python	`int retval = ImGui.Col_TabDimmed()`

Tab background, when tab-bar is unfocused & tab is unselected

View source · v0.9.2+

Constant: Col_TabDimmedSelected

C++	`int ImGui::Col_TabDimmedSelected`
EEL	`int ImGui_Col_TabDimmedSelected()`
Legacy EEL	`int extension_api("ImGui_Col_TabDimmedSelected")`
Lua	`integer ImGui.Col_TabDimmedSelected`
Python	`int retval = ImGui.Col_TabDimmedSelected()`

Tab background, when tab-bar is unfocused & tab is selected

View source · v0.9.2+

Constant: Col_TabDimmedSelectedOverline

C++	`int ImGui::Col_TabDimmedSelectedOverline`
EEL	`int ImGui_Col_TabDimmedSelectedOverline()`
Legacy EEL	`int extension_api("ImGui_Col_TabDimmedSelectedOverline")`
Lua	`integer ImGui.Col_TabDimmedSelectedOverline`
Python	`int retval = ImGui.Col_TabDimmedSelectedOverline()`

Horizontal overline, when tab-bar is unfocused & tab is selected

View source · v0.9.2+

Constant: Col_TabHovered

C++	`int ImGui::Col_TabHovered`
EEL	`int ImGui_Col_TabHovered()`
Legacy EEL	`int extension_api("ImGui_Col_TabHovered")`
Lua	`integer ImGui.Col_TabHovered`
Python	`int retval = ImGui.Col_TabHovered()`

Tab background, when hovered

View source · v0.1+

Constant: Col_TabSelected

C++	`int ImGui::Col_TabSelected`
EEL	`int ImGui_Col_TabSelected()`
Legacy EEL	`int extension_api("ImGui_Col_TabSelected")`
Lua	`integer ImGui.Col_TabSelected`
Python	`int retval = ImGui.Col_TabSelected()`

Tab background, when tab-bar is focused & tab is selected

View source · v0.9.2+

Constant: Col_TabSelectedOverline

C++	`int ImGui::Col_TabSelectedOverline`
EEL	`int ImGui_Col_TabSelectedOverline()`
Legacy EEL	`int extension_api("ImGui_Col_TabSelectedOverline")`
Lua	`integer ImGui.Col_TabSelectedOverline`
Python	`int retval = ImGui.Col_TabSelectedOverline()`

Tab horizontal overline, when tab-bar is focused & tab is selected

View source · v0.9.2+

Constant: Col_TableBorderLight

C++	`int ImGui::Col_TableBorderLight`
EEL	`int ImGui_Col_TableBorderLight()`
Legacy EEL	`int extension_api("ImGui_Col_TableBorderLight")`
Lua	`integer ImGui.Col_TableBorderLight`
Python	`int retval = ImGui.Col_TableBorderLight()`

Table inner borders (prefer using Alpha=1.0 here).

View source · v0.1+

Constant: Col_TableBorderStrong

C++	`int ImGui::Col_TableBorderStrong`
EEL	`int ImGui_Col_TableBorderStrong()`
Legacy EEL	`int extension_api("ImGui_Col_TableBorderStrong")`
Lua	`integer ImGui.Col_TableBorderStrong`
Python	`int retval = ImGui.Col_TableBorderStrong()`

Table outer and header borders (prefer using Alpha=1.0 here).

View source · v0.1+

Constant: Col_TableHeaderBg

C++	`int ImGui::Col_TableHeaderBg`
EEL	`int ImGui_Col_TableHeaderBg()`
Legacy EEL	`int extension_api("ImGui_Col_TableHeaderBg")`
Lua	`integer ImGui.Col_TableHeaderBg`
Python	`int retval = ImGui.Col_TableHeaderBg()`

Table header background.

View source · v0.1+

Constant: Col_TableRowBg

C++	`int ImGui::Col_TableRowBg`
EEL	`int ImGui_Col_TableRowBg()`
Legacy EEL	`int extension_api("ImGui_Col_TableRowBg")`
Lua	`integer ImGui.Col_TableRowBg`
Python	`int retval = ImGui.Col_TableRowBg()`

Table row background (even rows).

View source · v0.1+

Constant: Col_TableRowBgAlt

C++	`int ImGui::Col_TableRowBgAlt`
EEL	`int ImGui_Col_TableRowBgAlt()`
Legacy EEL	`int extension_api("ImGui_Col_TableRowBgAlt")`
Lua	`integer ImGui.Col_TableRowBgAlt`
Python	`int retval = ImGui.Col_TableRowBgAlt()`

Table row background (odd rows).

View source · v0.1+

Constant: Col_Text

C++	`int ImGui::Col_Text`
EEL	`int ImGui_Col_Text()`
Legacy EEL	`int extension_api("ImGui_Col_Text")`
Lua	`integer ImGui.Col_Text`
Python	`int retval = ImGui.Col_Text()`

View source · v0.1+

Constant: Col_TextDisabled

C++	`int ImGui::Col_TextDisabled`
EEL	`int ImGui_Col_TextDisabled()`
Legacy EEL	`int extension_api("ImGui_Col_TextDisabled")`
Lua	`integer ImGui.Col_TextDisabled`
Python	`int retval = ImGui.Col_TextDisabled()`

View source · v0.1+

Constant: Col_TextSelectedBg

C++	`int ImGui::Col_TextSelectedBg`
EEL	`int ImGui_Col_TextSelectedBg()`
Legacy EEL	`int extension_api("ImGui_Col_TextSelectedBg")`
Lua	`integer ImGui.Col_TextSelectedBg`
Python	`int retval = ImGui.Col_TextSelectedBg()`

View source · v0.1+

Constant: Col_TitleBg

C++	`int ImGui::Col_TitleBg`
EEL	`int ImGui_Col_TitleBg()`
Legacy EEL	`int extension_api("ImGui_Col_TitleBg")`
Lua	`integer ImGui.Col_TitleBg`
Python	`int retval = ImGui.Col_TitleBg()`

Title bar

View source · v0.1+

Constant: Col_TitleBgActive

C++	`int ImGui::Col_TitleBgActive`
EEL	`int ImGui_Col_TitleBgActive()`
Legacy EEL	`int extension_api("ImGui_Col_TitleBgActive")`
Lua	`integer ImGui.Col_TitleBgActive`
Python	`int retval = ImGui.Col_TitleBgActive()`

Title bar when focused

View source · v0.1+

Constant: Col_TitleBgCollapsed

C++	`int ImGui::Col_TitleBgCollapsed`
EEL	`int ImGui_Col_TitleBgCollapsed()`
Legacy EEL	`int extension_api("ImGui_Col_TitleBgCollapsed")`
Lua	`integer ImGui.Col_TitleBgCollapsed`
Python	`int retval = ImGui.Col_TitleBgCollapsed()`

Title bar when collapsed

View source · v0.1+

Constant: Col_WindowBg

C++	`int ImGui::Col_WindowBg`
EEL	`int ImGui_Col_WindowBg()`
Legacy EEL	`int extension_api("ImGui_Col_WindowBg")`
Lua	`integer ImGui.Col_WindowBg`
Python	`int retval = ImGui.Col_WindowBg()`

Background of normal windows. See also WindowFlags_NoBackground.

View source · v0.1+

Function: DebugFlashStyleColor

C++	`void ImGui::DebugFlashStyleColor(ImGui_Context* ctx, int idx)`
EEL	`ImGui_DebugFlashStyleColor(ImGui_Context ctx, int idx)`
Legacy EEL	`extension_api("ImGui_DebugFlashStyleColor", ImGui_Context ctx, int idx)`
Lua	`ImGui.DebugFlashStyleColor(ImGui_Context ctx, integer idx)`
Python	`ImGui.DebugFlashStyleColor(ImGui_Context ctx, int idx)`

View source · v0.9+

Function: GetColor

C++	`int ImGui::GetColor(ImGui_Context* ctx, int idx, double alpha_mulInOptional = 1.0)`
EEL	`int ImGui_GetColor(ImGui_Context ctx, int idx, alpha_mul = 1.0)`
Legacy EEL	`int extension_api("ImGui_GetColor", ImGui_Context ctx, int idx, alpha_mul = 1.0)`
Lua	`integer retval = ImGui.GetColor(ImGui_Context ctx, integer idx, number alpha_mul = 1.0)`
Python	`int retval = ImGui.GetColor(ImGui_Context ctx, int idx, float alpha_mul = 1.0)`

Retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value (RGBA). See Col_* for available style colors.

View source · v0.1+

Function: GetColorEx

C++	`int ImGui::GetColorEx(ImGui_Context* ctx, int col_rgba, double alpha_mulInOptional = 1.0)`
EEL	`int ImGui_GetColorEx(ImGui_Context ctx, int col_rgba, alpha_mul = 1.0)`
Legacy EEL	`int extension_api("ImGui_GetColorEx", ImGui_Context ctx, int col_rgba, alpha_mul = 1.0)`
Lua	`integer retval = ImGui.GetColorEx(ImGui_Context ctx, integer col_rgba, number alpha_mul = 1.0)`
Python	`int retval = ImGui.GetColorEx(ImGui_Context ctx, int col_rgba, float alpha_mul = 1.0)`

Retrieve given color with style alpha applied, packed as a 32-bit value (RGBA).

View source · v0.1+

Function: GetStyleColor

C++	`int ImGui::GetStyleColor(ImGui_Context* ctx, int idx)`
EEL	`int ImGui_GetStyleColor(ImGui_Context ctx, int idx)`
Legacy EEL	`int extension_api("ImGui_GetStyleColor", ImGui_Context ctx, int idx)`
Lua	`integer retval = ImGui.GetStyleColor(ImGui_Context ctx, integer idx)`
Python	`int retval = ImGui.GetStyleColor(ImGui_Context ctx, int idx)`

Retrieve style color as stored in ImGuiStyle structure. Use to feed back into PushStyleColor, Otherwise use GetColor to get style color with style alpha baked in. See Col_* for available style colors.

View source · v0.1+

Function: PopStyleColor

C++	`void ImGui::PopStyleColor(ImGui_Context* ctx, int countInOptional = 1)`
EEL	`ImGui_PopStyleColor(ImGui_Context ctx, int count = 1)`
Legacy EEL	`extension_api("ImGui_PopStyleColor", ImGui_Context ctx, int count = 1)`
Lua	`ImGui.PopStyleColor(ImGui_Context ctx, integer count = 1)`
Python	`ImGui.PopStyleColor(ImGui_Context ctx, int count = 1)`

View source · v0.1+

Function: PushStyleColor

C++	`void ImGui::PushStyleColor(ImGui_Context* ctx, int idx, int col_rgba)`
EEL	`ImGui_PushStyleColor(ImGui_Context ctx, int idx, int col_rgba)`
Legacy EEL	`extension_api("ImGui_PushStyleColor", ImGui_Context ctx, int idx, int col_rgba)`
Lua	`ImGui.PushStyleColor(ImGui_Context ctx, integer idx, integer col_rgba)`
Python	`ImGui.PushStyleColor(ImGui_Context ctx, int idx, int col_rgba)`

Temporarily modify a style color. Call PopStyleColor to undo after use (before the end of the frame). See Col_* for available style colors.

View source · v0.1+

Variables

Function: GetStyleVar

C++	`void ImGui::GetStyleVar(ImGui_Context* ctx, int var_idx, double* val1Out, double* val2Out)`
EEL	`ImGui_GetStyleVar(ImGui_Context ctx, int var_idx, &val1, &val2)`
Legacy EEL	`extension_api("ImGui_GetStyleVar", ImGui_Context ctx, int var_idx, &val1, &val2)`
Lua	`number val1, number val2 = ImGui.GetStyleVar(ImGui_Context ctx, integer var_idx)`
Python	`(float val1, float val2) = ImGui.GetStyleVar(ImGui_Context ctx, int var_idx)`

View source · v0.1+

Function: PopStyleVar

C++	`void ImGui::PopStyleVar(ImGui_Context* ctx, int countInOptional = 1)`
EEL	`ImGui_PopStyleVar(ImGui_Context ctx, int count = 1)`
Legacy EEL	`extension_api("ImGui_PopStyleVar", ImGui_Context ctx, int count = 1)`
Lua	`ImGui.PopStyleVar(ImGui_Context ctx, integer count = 1)`
Python	`ImGui.PopStyleVar(ImGui_Context ctx, int count = 1)`

Reset a style variable.

View source · v0.1+

Function: PushStyleVar

C++	`void ImGui::PushStyleVar(ImGui_Context* ctx, int var_idx, double val1, double val2InOptional = nullptr)`
EEL	`ImGui_PushStyleVar(ImGui_Context ctx, int var_idx, val1, val2 = 0)`
Legacy EEL	`extension_api("ImGui_PushStyleVar", ImGui_Context ctx, int var_idx, val1, val2 = 0)`
Lua	`ImGui.PushStyleVar(ImGui_Context ctx, integer var_idx, number val1, number val2 = nil)`
Python	`ImGui.PushStyleVar(ImGui_Context ctx, int var_idx, float val1, float val2 = None)`

Temporarily modify a style variable. Call PopStyleVar to undo after use (before the end of the frame). See StyleVar_* for possible values of 'var_idx'.

View source · v0.1+

Constant: StyleVar_Alpha

C++	`int ImGui::StyleVar_Alpha`
EEL	`int ImGui_StyleVar_Alpha()`
Legacy EEL	`int extension_api("ImGui_StyleVar_Alpha")`
Lua	`integer ImGui.StyleVar_Alpha`
Python	`int retval = ImGui.StyleVar_Alpha()`

Global alpha applies to everything in Dear ImGui.

View source · v0.1+

Constant: StyleVar_ButtonTextAlign

C++	`int ImGui::StyleVar_ButtonTextAlign`
EEL	`int ImGui_StyleVar_ButtonTextAlign()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ButtonTextAlign")`
Lua	`integer ImGui.StyleVar_ButtonTextAlign`
Python	`int retval = ImGui.StyleVar_ButtonTextAlign()`

Alignment of button text when button is larger than text. Defaults to (0.5, 0.5) (centered).

View source · v0.1+

Constant: StyleVar_CellPadding

C++	`int ImGui::StyleVar_CellPadding`
EEL	`int ImGui_StyleVar_CellPadding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_CellPadding")`
Lua	`integer ImGui.StyleVar_CellPadding`
Python	`int retval = ImGui.StyleVar_CellPadding()`

Padding within a table cell. CellPadding.x is locked for entire table. CellPadding.y may be altered between different rows.

View source · v0.1+

Constant: StyleVar_ChildBorderSize

C++	`int ImGui::StyleVar_ChildBorderSize`
EEL	`int ImGui_StyleVar_ChildBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ChildBorderSize")`
Lua	`integer ImGui.StyleVar_ChildBorderSize`
Python	`int retval = ImGui.StyleVar_ChildBorderSize()`

Thickness of border around child windows. Generally set to 0.0 or 1.0. (Other values are not well tested and more CPU/GPU costly).

View source · v0.1+

Constant: StyleVar_ChildRounding

C++	`int ImGui::StyleVar_ChildRounding`
EEL	`int ImGui_StyleVar_ChildRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ChildRounding")`
Lua	`integer ImGui.StyleVar_ChildRounding`
Python	`int retval = ImGui.StyleVar_ChildRounding()`

Radius of child window corners rounding. Set to 0.0 to have rectangular windows.

View source · v0.1+

Constant: StyleVar_DisabledAlpha

C++	`int ImGui::StyleVar_DisabledAlpha`
EEL	`int ImGui_StyleVar_DisabledAlpha()`
Legacy EEL	`int extension_api("ImGui_StyleVar_DisabledAlpha")`
Lua	`integer ImGui.StyleVar_DisabledAlpha`
Python	`int retval = ImGui.StyleVar_DisabledAlpha()`

Additional alpha multiplier applied by BeginDisabled. Multiply over current value of Alpha.

View source · v0.5.5+

Constant: StyleVar_FrameBorderSize

C++	`int ImGui::StyleVar_FrameBorderSize`
EEL	`int ImGui_StyleVar_FrameBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_FrameBorderSize")`
Lua	`integer ImGui.StyleVar_FrameBorderSize`
Python	`int retval = ImGui.StyleVar_FrameBorderSize()`

Thickness of border around frames. Generally set to 0.0 or 1.0. (Other values are not well tested and more CPU/GPU costly).

View source · v0.1+

Constant: StyleVar_FramePadding

C++	`int ImGui::StyleVar_FramePadding`
EEL	`int ImGui_StyleVar_FramePadding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_FramePadding")`
Lua	`integer ImGui.StyleVar_FramePadding`
Python	`int retval = ImGui.StyleVar_FramePadding()`

Padding within a framed rectangle (used by most widgets).

View source · v0.1+

Constant: StyleVar_FrameRounding

C++	`int ImGui::StyleVar_FrameRounding`
EEL	`int ImGui_StyleVar_FrameRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_FrameRounding")`
Lua	`integer ImGui.StyleVar_FrameRounding`
Python	`int retval = ImGui.StyleVar_FrameRounding()`

Radius of frame corners rounding. Set to 0.0 to have rectangular frame (used by most widgets).

View source · v0.1+

Constant: StyleVar_GrabMinSize

C++	`int ImGui::StyleVar_GrabMinSize`
EEL	`int ImGui_StyleVar_GrabMinSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_GrabMinSize")`
Lua	`integer ImGui.StyleVar_GrabMinSize`
Python	`int retval = ImGui.StyleVar_GrabMinSize()`

Minimum width/height of a grab box for slider/scrollbar.

View source · v0.1+

Constant: StyleVar_GrabRounding

C++	`int ImGui::StyleVar_GrabRounding`
EEL	`int ImGui_StyleVar_GrabRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_GrabRounding")`
Lua	`integer ImGui.StyleVar_GrabRounding`
Python	`int retval = ImGui.StyleVar_GrabRounding()`

Radius of grabs corners rounding. Set to 0.0 to have rectangular slider grabs.

View source · v0.1+

Constant: StyleVar_IndentSpacing

C++	`int ImGui::StyleVar_IndentSpacing`
EEL	`int ImGui_StyleVar_IndentSpacing()`
Legacy EEL	`int extension_api("ImGui_StyleVar_IndentSpacing")`
Lua	`integer ImGui.StyleVar_IndentSpacing`
Python	`int retval = ImGui.StyleVar_IndentSpacing()`

Horizontal indentation when e.g. entering a tree node. Generally == (GetFontSize + StyleVar_FramePadding.x*2).

View source · v0.1+

Constant: StyleVar_ItemInnerSpacing

C++	`int ImGui::StyleVar_ItemInnerSpacing`
EEL	`int ImGui_StyleVar_ItemInnerSpacing()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ItemInnerSpacing")`
Lua	`integer ImGui.StyleVar_ItemInnerSpacing`
Python	`int retval = ImGui.StyleVar_ItemInnerSpacing()`

Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).

View source · v0.1+

Constant: StyleVar_ItemSpacing

C++	`int ImGui::StyleVar_ItemSpacing`
EEL	`int ImGui_StyleVar_ItemSpacing()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ItemSpacing")`
Lua	`integer ImGui.StyleVar_ItemSpacing`
Python	`int retval = ImGui.StyleVar_ItemSpacing()`

Horizontal and vertical spacing between widgets/lines.

View source · v0.1+

Constant: StyleVar_PopupBorderSize

C++	`int ImGui::StyleVar_PopupBorderSize`
EEL	`int ImGui_StyleVar_PopupBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_PopupBorderSize")`
Lua	`integer ImGui.StyleVar_PopupBorderSize`
Python	`int retval = ImGui.StyleVar_PopupBorderSize()`

Thickness of border around popup/tooltip windows. Generally set to 0.0 or 1.0. (Other values are not well tested and more CPU/GPU costly).

View source · v0.1+

Constant: StyleVar_PopupRounding

C++	`int ImGui::StyleVar_PopupRounding`
EEL	`int ImGui_StyleVar_PopupRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_PopupRounding")`
Lua	`integer ImGui.StyleVar_PopupRounding`
Python	`int retval = ImGui.StyleVar_PopupRounding()`

Radius of popup window corners rounding. (Note that tooltip windows use StyleVar_WindowRounding.)

View source · v0.1+

Constant: StyleVar_ScrollbarRounding

C++	`int ImGui::StyleVar_ScrollbarRounding`
EEL	`int ImGui_StyleVar_ScrollbarRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ScrollbarRounding")`
Lua	`integer ImGui.StyleVar_ScrollbarRounding`
Python	`int retval = ImGui.StyleVar_ScrollbarRounding()`

Radius of grab corners for scrollbar.

View source · v0.1+

Constant: StyleVar_ScrollbarSize

C++	`int ImGui::StyleVar_ScrollbarSize`
EEL	`int ImGui_StyleVar_ScrollbarSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_ScrollbarSize")`
Lua	`integer ImGui.StyleVar_ScrollbarSize`
Python	`int retval = ImGui.StyleVar_ScrollbarSize()`

Width of the vertical scrollbar, Height of the horizontal scrollbar.

View source · v0.1+

Constant: StyleVar_SelectableTextAlign

C++	`int ImGui::StyleVar_SelectableTextAlign`
EEL	`int ImGui_StyleVar_SelectableTextAlign()`
Legacy EEL	`int extension_api("ImGui_StyleVar_SelectableTextAlign")`
Lua	`integer ImGui.StyleVar_SelectableTextAlign`
Python	`int retval = ImGui.StyleVar_SelectableTextAlign()`

Alignment of selectable text. Defaults to (0.0, 0.0) (top-left aligned). It's generally important to keep this left-aligned if you want to lay multiple items on a same line.

View source · v0.1+

Constant: StyleVar_SeparatorTextAlign

C++	`int ImGui::StyleVar_SeparatorTextAlign`
EEL	`int ImGui_StyleVar_SeparatorTextAlign()`
Legacy EEL	`int extension_api("ImGui_StyleVar_SeparatorTextAlign")`
Lua	`integer ImGui.StyleVar_SeparatorTextAlign`
Python	`int retval = ImGui.StyleVar_SeparatorTextAlign()`

Alignment of text within the separator. Defaults to (0.0, 0.5) (left aligned, center).

View source · v0.8.4+

Constant: StyleVar_SeparatorTextBorderSize

C++	`int ImGui::StyleVar_SeparatorTextBorderSize`
EEL	`int ImGui_StyleVar_SeparatorTextBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_SeparatorTextBorderSize")`
Lua	`integer ImGui.StyleVar_SeparatorTextBorderSize`
Python	`int retval = ImGui.StyleVar_SeparatorTextBorderSize()`

Thickness of border in SeparatorText()

View source · v0.8.4+

Constant: StyleVar_SeparatorTextPadding

C++	`int ImGui::StyleVar_SeparatorTextPadding`
EEL	`int ImGui_StyleVar_SeparatorTextPadding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_SeparatorTextPadding")`
Lua	`integer ImGui.StyleVar_SeparatorTextPadding`
Python	`int retval = ImGui.StyleVar_SeparatorTextPadding()`

Horizontal offset of text from each edge of the separator + spacing on other axis. Generally small values. .y is recommended to be == StyleVar_FramePadding.y.

View source · v0.8.4+

Constant: StyleVar_TabBarBorderSize

C++	`int ImGui::StyleVar_TabBarBorderSize`
EEL	`int ImGui_StyleVar_TabBarBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_TabBarBorderSize")`
Lua	`integer ImGui.StyleVar_TabBarBorderSize`
Python	`int retval = ImGui.StyleVar_TabBarBorderSize()`

Thickness of tab-bar separator, which takes on the tab active color to denote focus.

View source · v0.9+

Constant: StyleVar_TabBorderSize

C++	`int ImGui::StyleVar_TabBorderSize`
EEL	`int ImGui_StyleVar_TabBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_TabBorderSize")`
Lua	`integer ImGui.StyleVar_TabBorderSize`
Python	`int retval = ImGui.StyleVar_TabBorderSize()`

Thickness of border around tabs.

View source · v0.9+

Constant: StyleVar_TabRounding

C++	`int ImGui::StyleVar_TabRounding`
EEL	`int ImGui_StyleVar_TabRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_TabRounding")`
Lua	`integer ImGui.StyleVar_TabRounding`
Python	`int retval = ImGui.StyleVar_TabRounding()`

Radius of upper corners of a tab. Set to 0.0 to have rectangular tabs.

View source · v0.1+

Constant: StyleVar_TableAngledHeadersAngle

C++	`int ImGui::StyleVar_TableAngledHeadersAngle`
EEL	`int ImGui_StyleVar_TableAngledHeadersAngle()`
Legacy EEL	`int extension_api("ImGui_StyleVar_TableAngledHeadersAngle")`
Lua	`integer ImGui.StyleVar_TableAngledHeadersAngle`
Python	`int retval = ImGui.StyleVar_TableAngledHeadersAngle()`

Angle of angled headers (supported values range from -50.0 degrees to +50.0 degrees).

View source · v0.9+

Constant: StyleVar_TableAngledHeadersTextAlign

C++	`int ImGui::StyleVar_TableAngledHeadersTextAlign`
EEL	`int ImGui_StyleVar_TableAngledHeadersTextAlign()`
Legacy EEL	`int extension_api("ImGui_StyleVar_TableAngledHeadersTextAlign")`
Lua	`integer ImGui.StyleVar_TableAngledHeadersTextAlign`
Python	`int retval = ImGui.StyleVar_TableAngledHeadersTextAlign()`

Alignment of angled headers within the cell

View source · v0.9.1+

Constant: StyleVar_WindowBorderSize

C++	`int ImGui::StyleVar_WindowBorderSize`
EEL	`int ImGui_StyleVar_WindowBorderSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_WindowBorderSize")`
Lua	`integer ImGui.StyleVar_WindowBorderSize`
Python	`int retval = ImGui.StyleVar_WindowBorderSize()`

Thickness of border around windows. Generally set to 0.0 or 1.0. (Other values are not well tested and more CPU/GPU costly).

View source · v0.1+

Constant: StyleVar_WindowMinSize

C++	`int ImGui::StyleVar_WindowMinSize`
EEL	`int ImGui_StyleVar_WindowMinSize()`
Legacy EEL	`int extension_api("ImGui_StyleVar_WindowMinSize")`
Lua	`integer ImGui.StyleVar_WindowMinSize`
Python	`int retval = ImGui.StyleVar_WindowMinSize()`

Minimum window size. This is a global setting. If you want to constrain individual windows, use SetNextWindowSizeConstraints.

View source · v0.1+

Constant: StyleVar_WindowPadding

C++	`int ImGui::StyleVar_WindowPadding`
EEL	`int ImGui_StyleVar_WindowPadding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_WindowPadding")`
Lua	`integer ImGui.StyleVar_WindowPadding`
Python	`int retval = ImGui.StyleVar_WindowPadding()`

Padding within a window.

View source · v0.1+

Constant: StyleVar_WindowRounding

C++	`int ImGui::StyleVar_WindowRounding`
EEL	`int ImGui_StyleVar_WindowRounding()`
Legacy EEL	`int extension_api("ImGui_StyleVar_WindowRounding")`
Lua	`integer ImGui.StyleVar_WindowRounding`
Python	`int retval = ImGui.StyleVar_WindowRounding()`

Radius of window corners rounding. Set to 0.0 to have rectangular windows. Large values tend to lead to variety of artifacts and are not recommended.

View source · v0.1+

Constant: StyleVar_WindowTitleAlign

C++	`int ImGui::StyleVar_WindowTitleAlign`
EEL	`int ImGui_StyleVar_WindowTitleAlign()`
Legacy EEL	`int extension_api("ImGui_StyleVar_WindowTitleAlign")`
Lua	`integer ImGui.StyleVar_WindowTitleAlign`
Python	`int retval = ImGui.StyleVar_WindowTitleAlign()`

Alignment for title bar text. Defaults to (0.0,0.5) for left-aligned,vertically centered.

View source · v0.1+

Tab Bar

Function: BeginTabBar

C++	`bool ImGui::BeginTabBar(ImGui_Context* ctx, const char* str_id, int flagsInOptional = TabBarFlags_None)`
EEL	`bool ImGui_BeginTabBar(ImGui_Context ctx, "str_id", int flags = TabBarFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginTabBar", ImGui_Context ctx, "str_id", int flags = TabBarFlags_None)`
Lua	`boolean retval = ImGui.BeginTabBar(ImGui_Context ctx, string str_id, integer flags = TabBarFlags_None)`
Python	`bool retval = ImGui.BeginTabBar(ImGui_Context ctx, str str_id, int flags = TabBarFlags_None)`

Create and append into a TabBar.

View source · v0.1+

Function: EndTabBar

C++	`void ImGui::EndTabBar(ImGui_Context* ctx)`
EEL	`ImGui_EndTabBar(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndTabBar", ImGui_Context ctx)`
Lua	`ImGui.EndTabBar(ImGui_Context ctx)`
Python	`ImGui.EndTabBar(ImGui_Context ctx)`

Only call EndTabBar() if BeginTabBar() returns true!

View source · v0.1+

Constant: TabBarFlags_AutoSelectNewTabs

C++	`int ImGui::TabBarFlags_AutoSelectNewTabs`
EEL	`int ImGui_TabBarFlags_AutoSelectNewTabs()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_AutoSelectNewTabs")`
Lua	`integer ImGui.TabBarFlags_AutoSelectNewTabs`
Python	`int retval = ImGui.TabBarFlags_AutoSelectNewTabs()`

Automatically select new tabs when they appear.

View source · v0.1+

Constant: TabBarFlags_DrawSelectedOverline

C++	`int ImGui::TabBarFlags_DrawSelectedOverline`
EEL	`int ImGui_TabBarFlags_DrawSelectedOverline()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_DrawSelectedOverline")`
Lua	`integer ImGui.TabBarFlags_DrawSelectedOverline`
Python	`int retval = ImGui.TabBarFlags_DrawSelectedOverline()`

Draw selected overline markers over selected tab

View source · v0.9.2+

Constant: TabBarFlags_FittingPolicyResizeDown

C++	`int ImGui::TabBarFlags_FittingPolicyResizeDown`
EEL	`int ImGui_TabBarFlags_FittingPolicyResizeDown()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_FittingPolicyResizeDown")`
Lua	`integer ImGui.TabBarFlags_FittingPolicyResizeDown`
Python	`int retval = ImGui.TabBarFlags_FittingPolicyResizeDown()`

Resize tabs when they don't fit.

View source · v0.1+

Constant: TabBarFlags_FittingPolicyScroll

C++	`int ImGui::TabBarFlags_FittingPolicyScroll`
EEL	`int ImGui_TabBarFlags_FittingPolicyScroll()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_FittingPolicyScroll")`
Lua	`integer ImGui.TabBarFlags_FittingPolicyScroll`
Python	`int retval = ImGui.TabBarFlags_FittingPolicyScroll()`

Add scroll buttons when tabs don't fit.

View source · v0.1+

Constant: TabBarFlags_NoCloseWithMiddleMouseButton

C++	`int ImGui::TabBarFlags_NoCloseWithMiddleMouseButton`
EEL	`int ImGui_TabBarFlags_NoCloseWithMiddleMouseButton()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_NoCloseWithMiddleMouseButton")`
Lua	`integer ImGui.TabBarFlags_NoCloseWithMiddleMouseButton`
Python	`int retval = ImGui.TabBarFlags_NoCloseWithMiddleMouseButton()`

Disable behavior of closing tabs (that are submitted with p_open != nil) with middle mouse button. You may handle this behavior manually on user's side with if(IsItemHovered() && IsMouseClicked(2)) p_open = false.

View source · v0.1+

Constant: TabBarFlags_NoTabListScrollingButtons

C++	`int ImGui::TabBarFlags_NoTabListScrollingButtons`
EEL	`int ImGui_TabBarFlags_NoTabListScrollingButtons()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_NoTabListScrollingButtons")`
Lua	`integer ImGui.TabBarFlags_NoTabListScrollingButtons`
Python	`int retval = ImGui.TabBarFlags_NoTabListScrollingButtons()`

Disable scrolling buttons (apply when fitting policy is TabBarFlags_FittingPolicyScroll).

View source · v0.1+

Constant: TabBarFlags_NoTooltip

C++	`int ImGui::TabBarFlags_NoTooltip`
EEL	`int ImGui_TabBarFlags_NoTooltip()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_NoTooltip")`
Lua	`integer ImGui.TabBarFlags_NoTooltip`
Python	`int retval = ImGui.TabBarFlags_NoTooltip()`

Disable tooltips when hovering a tab.

View source · v0.1+

Constant: TabBarFlags_None

C++	`int ImGui::TabBarFlags_None`
EEL	`int ImGui_TabBarFlags_None()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_None")`
Lua	`integer ImGui.TabBarFlags_None`
Python	`int retval = ImGui.TabBarFlags_None()`

View source · v0.1+

Constant: TabBarFlags_Reorderable

C++	`int ImGui::TabBarFlags_Reorderable`
EEL	`int ImGui_TabBarFlags_Reorderable()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_Reorderable")`
Lua	`integer ImGui.TabBarFlags_Reorderable`
Python	`int retval = ImGui.TabBarFlags_Reorderable()`

Allow manually dragging tabs to re-order them + New tabs are appended at the end of list.

View source · v0.1+

Constant: TabBarFlags_TabListPopupButton

C++	`int ImGui::TabBarFlags_TabListPopupButton`
EEL	`int ImGui_TabBarFlags_TabListPopupButton()`
Legacy EEL	`int extension_api("ImGui_TabBarFlags_TabListPopupButton")`
Lua	`integer ImGui.TabBarFlags_TabListPopupButton`
Python	`int retval = ImGui.TabBarFlags_TabListPopupButton()`

Disable buttons to open the tab list popup.

View source · v0.1+

Tab Item

Function: BeginTabItem

C++	`bool ImGui::BeginTabItem(ImGui_Context* ctx, const char* label, bool* p_openInOutOptional = nullptr, int flagsInOptional = TabItemFlags_None)`
EEL	`bool ImGui_BeginTabItem(ImGui_Context ctx, "label", bool &p_open = 0, int flags = TabItemFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginTabItem", ImGui_Context ctx, "label", bool &p_open = 0, int flags = TabItemFlags_None)`
Lua	`boolean retval, boolean p_open = ImGui.BeginTabItem(ImGui_Context ctx, string label, boolean p_open = nil, integer flags = TabItemFlags_None)`
Python	`(bool retval, bool p_open) = ImGui.BeginTabItem(ImGui_Context ctx, str label, bool p_open = None, int flags = TabItemFlags_None)`

Create a Tab. Returns true if the Tab is selected. Set 'p_open' to true to enable the close button.

View source · v0.1+

Function: EndTabItem

C++	`void ImGui::EndTabItem(ImGui_Context* ctx)`
EEL	`ImGui_EndTabItem(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndTabItem", ImGui_Context ctx)`
Lua	`ImGui.EndTabItem(ImGui_Context ctx)`
Python	`ImGui.EndTabItem(ImGui_Context ctx)`

Only call EndTabItem() if BeginTabItem() returns true!

View source · v0.1+

Function: SetTabItemClosed

C++	`void ImGui::SetTabItemClosed(ImGui_Context* ctx, const char* tab_or_docked_window_label)`
EEL	`ImGui_SetTabItemClosed(ImGui_Context ctx, "tab_or_docked_window_label")`
Legacy EEL	`extension_api("ImGui_SetTabItemClosed", ImGui_Context ctx, "tab_or_docked_window_label")`
Lua	`ImGui.SetTabItemClosed(ImGui_Context ctx, string tab_or_docked_window_label)`
Python	`ImGui.SetTabItemClosed(ImGui_Context ctx, str tab_or_docked_window_label)`

Notify TabBar or Docking system of a closed tab/window ahead (useful to reduce visual flicker on reorderable tab bars). For tab-bar: call after BeginTabBar and before Tab submissions. Otherwise call with a window name.

View source · v0.1+

Function: TabItemButton

C++	`bool ImGui::TabItemButton(ImGui_Context* ctx, const char* label, int flagsInOptional = TabItemFlags_None)`
EEL	`bool ImGui_TabItemButton(ImGui_Context ctx, "label", int flags = TabItemFlags_None)`
Legacy EEL	`bool extension_api("ImGui_TabItemButton", ImGui_Context ctx, "label", int flags = TabItemFlags_None)`
Lua	`boolean retval = ImGui.TabItemButton(ImGui_Context ctx, string label, integer flags = TabItemFlags_None)`
Python	`bool retval = ImGui.TabItemButton(ImGui_Context ctx, str label, int flags = TabItemFlags_None)`

Create a Tab behaving like a button. Return true when clicked. Cannot be selected in the tab bar.

View source · v0.1+

Constant: TabItemFlags_Leading

C++	`int ImGui::TabItemFlags_Leading`
EEL	`int ImGui_TabItemFlags_Leading()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_Leading")`
Lua	`integer ImGui.TabItemFlags_Leading`
Python	`int retval = ImGui.TabItemFlags_Leading()`

Enforce the tab position to the left of the tab bar (after the tab list popup button).

View source · v0.1+

Constant: TabItemFlags_NoAssumedClosure

C++	`int ImGui::TabItemFlags_NoAssumedClosure`
EEL	`int ImGui_TabItemFlags_NoAssumedClosure()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_NoAssumedClosure")`
Lua	`integer ImGui.TabItemFlags_NoAssumedClosure`
Python	`int retval = ImGui.TabItemFlags_NoAssumedClosure()`

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.

View source · v0.9+

Constant: TabItemFlags_NoCloseWithMiddleMouseButton

C++	`int ImGui::TabItemFlags_NoCloseWithMiddleMouseButton`
EEL	`int ImGui_TabItemFlags_NoCloseWithMiddleMouseButton()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_NoCloseWithMiddleMouseButton")`
Lua	`integer ImGui.TabItemFlags_NoCloseWithMiddleMouseButton`
Python	`int retval = ImGui.TabItemFlags_NoCloseWithMiddleMouseButton()`

Disable behavior of closing tabs (that are submitted with p_open != nil) with middle mouse button. You can still repro this behavior on user's side with if(IsItemHovered() && IsMouseClicked(2)) p_open = false.

View source · v0.1+

Constant: TabItemFlags_NoPushId

C++	`int ImGui::TabItemFlags_NoPushId`
EEL	`int ImGui_TabItemFlags_NoPushId()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_NoPushId")`
Lua	`integer ImGui.TabItemFlags_NoPushId`
Python	`int retval = ImGui.TabItemFlags_NoPushId()`

Don't call PushID()/PopID() on BeginTabItem/EndTabItem.

View source · v0.1+

Constant: TabItemFlags_NoReorder

C++	`int ImGui::TabItemFlags_NoReorder`
EEL	`int ImGui_TabItemFlags_NoReorder()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_NoReorder")`
Lua	`integer ImGui.TabItemFlags_NoReorder`
Python	`int retval = ImGui.TabItemFlags_NoReorder()`

Disable reordering this tab or having another tab cross over this tab.

View source · v0.1+

Constant: TabItemFlags_NoTooltip

C++	`int ImGui::TabItemFlags_NoTooltip`
EEL	`int ImGui_TabItemFlags_NoTooltip()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_NoTooltip")`
Lua	`integer ImGui.TabItemFlags_NoTooltip`
Python	`int retval = ImGui.TabItemFlags_NoTooltip()`

Disable tooltip for the given tab.

View source · v0.1+

Constant: TabItemFlags_None

C++	`int ImGui::TabItemFlags_None`
EEL	`int ImGui_TabItemFlags_None()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_None")`
Lua	`integer ImGui.TabItemFlags_None`
Python	`int retval = ImGui.TabItemFlags_None()`

View source · v0.1+

Constant: TabItemFlags_SetSelected

C++	`int ImGui::TabItemFlags_SetSelected`
EEL	`int ImGui_TabItemFlags_SetSelected()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_SetSelected")`
Lua	`integer ImGui.TabItemFlags_SetSelected`
Python	`int retval = ImGui.TabItemFlags_SetSelected()`

Trigger flag to programmatically make the tab selected when calling BeginTabItem.

View source · v0.1+

Constant: TabItemFlags_Trailing

C++	`int ImGui::TabItemFlags_Trailing`
EEL	`int ImGui_TabItemFlags_Trailing()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_Trailing")`
Lua	`integer ImGui.TabItemFlags_Trailing`
Python	`int retval = ImGui.TabItemFlags_Trailing()`

Enforce the tab position to the right of the tab bar (before the scrolling buttons).

View source · v0.1+

Constant: TabItemFlags_UnsavedDocument

C++	`int ImGui::TabItemFlags_UnsavedDocument`
EEL	`int ImGui_TabItemFlags_UnsavedDocument()`
Legacy EEL	`int extension_api("ImGui_TabItemFlags_UnsavedDocument")`
Lua	`integer ImGui.TabItemFlags_UnsavedDocument`
Python	`int retval = ImGui.TabItemFlags_UnsavedDocument()`

Display a dot next to the title + set TabItemFlags_NoAssumedClosure.

View source · v0.1+

Table

See top of imgui_tables.cpp for general commentary.

See TableFlags* and TableColumnFlags* enums for a description of available flags.

The typical call flow is:

Call BeginTable.
Optionally call TableSetupColumn to submit column name/flags/defaults.
Optionally call TableSetupScrollFreeze to request scroll freezing of columns/rows.
Optionally call TableHeadersRow to submit a header row. Names are pulled from TableSetupColumn data.

Populate contents:

In most situations you can use TableNextRow + TableSetColumnIndex(N) to start appending into a column.
If you are using tables as a sort of grid, where every column is holding the same type of contents, you may prefer using TableNextColumn instead of TableNextRow + TableSetColumnIndex. TableNextColumn will automatically wrap-around into the next row if needed.

Summary of possible call flow:

TableNextRow() -> TableSetColumnIndex(0) -> Text("Hello 0") -> TableSetColumnIndex(1) -> Text("Hello 1")  // OK
TableNextRow() -> TableNextColumn()      -> Text("Hello 0") -> TableNextColumn()      -> Text("Hello 1")  // OK
                  TableNextColumn()      -> Text("Hello 0") -> TableNextColumn()      -> Text("Hello 1")  // OK: TableNextColumn() automatically gets to next row!
TableNextRow()                           -> Text("Hello 0")                                               // Not OK! Missing TableSetColumnIndex() or TableNextColumn()! Text will not appear!

Call EndTable.

Function: BeginTable

C++	`bool ImGui::BeginTable(ImGui_Context* ctx, const char* str_id, int columns, int flagsInOptional = TableFlags_None, double outer_size_wInOptional = 0.0, double outer_size_hInOptional = 0.0, double inner_widthInOptional = 0.0)`
EEL	`bool ImGui_BeginTable(ImGui_Context ctx, "str_id", int columns, int flags = TableFlags_None, outer_size_w = 0.0, outer_size_h = 0.0, inner_width = 0.0)`
Legacy EEL	`bool extension_api("ImGui_BeginTable", ImGui_Context ctx, "str_id", int columns, int flags = TableFlags_None, outer_size_w = 0.0, outer_size_h = 0.0, inner_width = 0.0)`
Lua	`boolean retval = ImGui.BeginTable(ImGui_Context ctx, string str_id, integer columns, integer flags = TableFlags_None, number outer_size_w = 0.0, number outer_size_h = 0.0, number inner_width = 0.0)`
Python	`bool retval = ImGui.BeginTable(ImGui_Context ctx, str str_id, int columns, int flags = TableFlags_None, float outer_size_w = 0.0, float outer_size_h = 0.0, float inner_width = 0.0)`

View source · v0.9+

Function: EndTable

C++	`void ImGui::EndTable(ImGui_Context* ctx)`
EEL	`ImGui_EndTable(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndTable", ImGui_Context ctx)`
Lua	`ImGui.EndTable(ImGui_Context ctx)`
Python	`ImGui.EndTable(ImGui_Context ctx)`

Only call EndTable() if BeginTable() returns true!

View source · v0.8+

Function: TableGetColumnCount

C++	`int ImGui::TableGetColumnCount(ImGui_Context* ctx)`
EEL	`int ImGui_TableGetColumnCount(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_TableGetColumnCount", ImGui_Context ctx)`
Lua	`integer retval = ImGui.TableGetColumnCount(ImGui_Context ctx)`
Python	`int retval = ImGui.TableGetColumnCount(ImGui_Context ctx)`

Return number of columns (value passed to BeginTable).

View source · v0.1+

Function: TableGetColumnIndex

C++	`int ImGui::TableGetColumnIndex(ImGui_Context* ctx)`
EEL	`int ImGui_TableGetColumnIndex(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_TableGetColumnIndex", ImGui_Context ctx)`
Lua	`integer retval = ImGui.TableGetColumnIndex(ImGui_Context ctx)`
Python	`int retval = ImGui.TableGetColumnIndex(ImGui_Context ctx)`

Return current column index.

View source · v0.1+

Function: TableGetRowIndex

C++	`int ImGui::TableGetRowIndex(ImGui_Context* ctx)`
EEL	`int ImGui_TableGetRowIndex(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_TableGetRowIndex", ImGui_Context ctx)`
Lua	`integer retval = ImGui.TableGetRowIndex(ImGui_Context ctx)`
Python	`int retval = ImGui.TableGetRowIndex(ImGui_Context ctx)`

Return current row index.

View source · v0.1+

Function: TableNextColumn

C++	`bool ImGui::TableNextColumn(ImGui_Context* ctx)`
EEL	`bool ImGui_TableNextColumn(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_TableNextColumn", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.TableNextColumn(ImGui_Context ctx)`
Python	`bool retval = ImGui.TableNextColumn(ImGui_Context ctx)`

Append into the next column (or first column of next row if currently in last column). Return true when column is visible.

View source · v0.8+

Function: TableNextRow

C++	`void ImGui::TableNextRow(ImGui_Context* ctx, int row_flagsInOptional = TableRowFlags_None, double min_row_heightInOptional = 0.0)`
EEL	`ImGui_TableNextRow(ImGui_Context ctx, int row_flags = TableRowFlags_None, min_row_height = 0.0)`
Legacy EEL	`extension_api("ImGui_TableNextRow", ImGui_Context ctx, int row_flags = TableRowFlags_None, min_row_height = 0.0)`
Lua	`ImGui.TableNextRow(ImGui_Context ctx, integer row_flags = TableRowFlags_None, number min_row_height = 0.0)`
Python	`ImGui.TableNextRow(ImGui_Context ctx, int row_flags = TableRowFlags_None, float min_row_height = 0.0)`

Append into the first cell of a new row.

View source · v0.9+

Constant: TableRowFlags_Headers

C++	`int ImGui::TableRowFlags_Headers`
EEL	`int ImGui_TableRowFlags_Headers()`
Legacy EEL	`int extension_api("ImGui_TableRowFlags_Headers")`
Lua	`integer ImGui.TableRowFlags_Headers`
Python	`int retval = ImGui.TableRowFlags_Headers()`

Identify header row (set default background color + width of its contents accounted different for auto column width).

View source · v0.1+

Constant: TableRowFlags_None

C++	`int ImGui::TableRowFlags_None`
EEL	`int ImGui_TableRowFlags_None()`
Legacy EEL	`int extension_api("ImGui_TableRowFlags_None")`
Lua	`integer ImGui.TableRowFlags_None`
Python	`int retval = ImGui.TableRowFlags_None()`

For TableNextRow.

View source · v0.1+

Function: TableSetColumnIndex

C++	`bool ImGui::TableSetColumnIndex(ImGui_Context* ctx, int column_n)`
EEL	`bool ImGui_TableSetColumnIndex(ImGui_Context ctx, int column_n)`
Legacy EEL	`bool extension_api("ImGui_TableSetColumnIndex", ImGui_Context ctx, int column_n)`
Lua	`boolean retval = ImGui.TableSetColumnIndex(ImGui_Context ctx, integer column_n)`
Python	`bool retval = ImGui.TableSetColumnIndex(ImGui_Context ctx, int column_n)`

Append into the specified column. Return true when column is visible.

View source · v0.8+

Background

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 TableFlags_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.

Constant: TableBgTarget_CellBg

C++	`int ImGui::TableBgTarget_CellBg`
EEL	`int ImGui_TableBgTarget_CellBg()`
Legacy EEL	`int extension_api("ImGui_TableBgTarget_CellBg")`
Lua	`integer ImGui.TableBgTarget_CellBg`
Python	`int retval = ImGui.TableBgTarget_CellBg()`

Set cell background color (top-most color).

View source · v0.1+

Constant: TableBgTarget_None

C++	`int ImGui::TableBgTarget_None`
EEL	`int ImGui_TableBgTarget_None()`
Legacy EEL	`int extension_api("ImGui_TableBgTarget_None")`
Lua	`integer ImGui.TableBgTarget_None`
Python	`int retval = ImGui.TableBgTarget_None()`

View source · v0.1+

Constant: TableBgTarget_RowBg0

C++	`int ImGui::TableBgTarget_RowBg0`
EEL	`int ImGui_TableBgTarget_RowBg0()`
Legacy EEL	`int extension_api("ImGui_TableBgTarget_RowBg0")`
Lua	`integer ImGui.TableBgTarget_RowBg0`
Python	`int retval = ImGui.TableBgTarget_RowBg0()`

Set row background color 0 (generally used for background, automatically set when TableFlags_RowBg is used).

View source · v0.1+

Constant: TableBgTarget_RowBg1

C++	`int ImGui::TableBgTarget_RowBg1`
EEL	`int ImGui_TableBgTarget_RowBg1()`
Legacy EEL	`int extension_api("ImGui_TableBgTarget_RowBg1")`
Lua	`integer ImGui.TableBgTarget_RowBg1`
Python	`int retval = ImGui.TableBgTarget_RowBg1()`

Set row background color 1 (generally used for selection marking).

View source · v0.1+

Function: TableSetBgColor

C++	`void ImGui::TableSetBgColor(ImGui_Context* ctx, int target, int color_rgba, int column_nInOptional = -1)`
EEL	`ImGui_TableSetBgColor(ImGui_Context ctx, int target, int color_rgba, int column_n = -1)`
Legacy EEL	`extension_api("ImGui_TableSetBgColor", ImGui_Context ctx, int target, int color_rgba, int column_n = -1)`
Lua	`ImGui.TableSetBgColor(ImGui_Context ctx, integer target, integer color_rgba, integer column_n = -1)`
Python	`ImGui.TableSetBgColor(ImGui_Context ctx, int target, int color_rgba, int column_n = -1)`

Change the color of a cell, row, or column. See TableBgTarget_* flags for details.

View source · v0.1+

Header & Columns

Use TableSetupColumn() to specify label, resizing policy, default width/weight, id, various other flags etc.

Use TableHeadersRow() to create a header row and automatically submit a TableHeader() for each column. Headers are required to perform: reordering, sorting, and opening the context menu. The context menu can also be made available in columns body using TableFlags_ContextMenuInBody.

You may manually submit headers using TableNextRow() + TableHeader() calls, but this is only useful in some advanced use cases (e.g. adding custom widgets in header row).

Use TableSetupScrollFreeze() to lock columns/rows so they stay visible when scrolled.

Function: TableAngledHeadersRow

C++	`void ImGui::TableAngledHeadersRow(ImGui_Context* ctx)`
EEL	`ImGui_TableAngledHeadersRow(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_TableAngledHeadersRow", ImGui_Context ctx)`
Lua	`ImGui.TableAngledHeadersRow(ImGui_Context ctx)`
Python	`ImGui.TableAngledHeadersRow(ImGui_Context ctx)`

Submit a row with angled headers for every column with the TableColumnFlags_AngledHeader flag. Must be the first row.

View source · v0.1+

Function: TableGetColumnFlags

C++	`int ImGui::TableGetColumnFlags(ImGui_Context* ctx, int column_nInOptional = -1)`
EEL	`int ImGui_TableGetColumnFlags(ImGui_Context ctx, int column_n = -1)`
Legacy EEL	`int extension_api("ImGui_TableGetColumnFlags", ImGui_Context ctx, int column_n = -1)`
Lua	`integer retval = ImGui.TableGetColumnFlags(ImGui_Context ctx, integer column_n = -1)`
Python	`int retval = ImGui.TableGetColumnFlags(ImGui_Context ctx, int column_n = -1)`

Return column flags so you can query their Enabled/Visible/Sorted/Hovered status flags. Pass -1 to use current column.

View source · v0.1+

Function: TableGetColumnName

C++	`const char* ImGui::TableGetColumnName(ImGui_Context* ctx, int column_nInOptional = -1)`
EEL	`const char* ImGui_TableGetColumnName(ImGui_Context ctx, int column_n = -1)`
Legacy EEL	`const char* extension_api("ImGui_TableGetColumnName", ImGui_Context ctx, int column_n = -1)`
Lua	`string retval = ImGui.TableGetColumnName(ImGui_Context ctx, integer column_n = -1)`
Python	`str retval = ImGui.TableGetColumnName(ImGui_Context ctx, int column_n = -1)`

Return "" if column didn't have a name declared by TableSetupColumn. Pass -1 to use current column.

View source · v0.1+

Function: TableGetHoveredColumn

C++	`int ImGui::TableGetHoveredColumn(ImGui_Context* ctx)`
EEL	`int ImGui_TableGetHoveredColumn(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_TableGetHoveredColumn", ImGui_Context ctx)`
Lua	`integer retval = ImGui.TableGetHoveredColumn(ImGui_Context ctx)`
Python	`int retval = ImGui.TableGetHoveredColumn(ImGui_Context ctx)`

Returns hovered column or -1 when table is not hovered. Returns columns_count if the unused space at the right of visible columns is hovered.

Can also use (TableGetColumnFlags() & TableColumnFlags_IsHovered) instead.

View source · v0.9.2+

Function: TableHeader

C++	`void ImGui::TableHeader(ImGui_Context* ctx, const char* label)`
EEL	`ImGui_TableHeader(ImGui_Context ctx, "label")`
Legacy EEL	`extension_api("ImGui_TableHeader", ImGui_Context ctx, "label")`
Lua	`ImGui.TableHeader(ImGui_Context ctx, string label)`
Python	`ImGui.TableHeader(ImGui_Context ctx, str label)`

Submit one header cell manually (rarely used). See TableSetupColumn.

View source · v0.1+

Function: TableHeadersRow

C++	`void ImGui::TableHeadersRow(ImGui_Context* ctx)`
EEL	`ImGui_TableHeadersRow(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_TableHeadersRow", ImGui_Context ctx)`
Lua	`ImGui.TableHeadersRow(ImGui_Context ctx)`
Python	`ImGui.TableHeadersRow(ImGui_Context ctx)`

Submit a row with headers cells based on data provided to TableSetupColumn

submit context menu.

View source · v0.1+

Function: TableSetColumnEnabled

C++	`void ImGui::TableSetColumnEnabled(ImGui_Context* ctx, int column_n, bool v)`
EEL	`ImGui_TableSetColumnEnabled(ImGui_Context ctx, int column_n, bool v)`
Legacy EEL	`extension_api("ImGui_TableSetColumnEnabled", ImGui_Context ctx, int column_n, bool v)`
Lua	`ImGui.TableSetColumnEnabled(ImGui_Context ctx, integer column_n, boolean v)`
Python	`ImGui.TableSetColumnEnabled(ImGui_Context ctx, int column_n, bool v)`

Change user-accessible enabled/disabled state of a column, set to false to hide the column. Note that end-user can use the context menu to change this themselves (right-click in headers, or right-click in columns body with TableFlags_ContextMenuInBody).

Require table to have the TableFlags_Hideable flag because we are manipulating user accessible state.
Request will be applied during next layout, which happens on the first call to TableNextRow after Begin_Table.
For the getter you can test (TableGetColumnFlags() & TableColumnFlags_IsEnabled) != 0.

View source · v0.4.1+

Function: TableSetupColumn

C++	`void ImGui::TableSetupColumn(ImGui_Context* ctx, const char* label, int flagsInOptional = TableColumnFlags_None, double init_width_or_weightInOptional = 0.0, int user_idInOptional = 0)`
EEL	`ImGui_TableSetupColumn(ImGui_Context ctx, "label", int flags = TableColumnFlags_None, init_width_or_weight = 0.0, int user_id = 0)`
Legacy EEL	`extension_api("ImGui_TableSetupColumn", ImGui_Context ctx, "label", int flags = TableColumnFlags_None, init_width_or_weight = 0.0, int user_id = 0)`
Lua	`ImGui.TableSetupColumn(ImGui_Context ctx, string label, integer flags = TableColumnFlags_None, number init_width_or_weight = 0.0, integer user_id = 0)`
Python	`ImGui.TableSetupColumn(ImGui_Context ctx, str label, int flags = TableColumnFlags_None, float init_width_or_weight = 0.0, int user_id = 0)`

Use to specify label, resizing policy, default width/weight, id, various other flags etc.

View source · v0.1+

Function: TableSetupScrollFreeze

C++	`void ImGui::TableSetupScrollFreeze(ImGui_Context* ctx, int cols, int rows)`
EEL	`ImGui_TableSetupScrollFreeze(ImGui_Context ctx, int cols, int rows)`
Legacy EEL	`extension_api("ImGui_TableSetupScrollFreeze", ImGui_Context ctx, int cols, int rows)`
Lua	`ImGui.TableSetupScrollFreeze(ImGui_Context ctx, integer cols, integer rows)`
Python	`ImGui.TableSetupScrollFreeze(ImGui_Context ctx, int cols, int rows)`

Lock columns/rows so they stay visible when scrolled.

View source · v0.1+

Column Flags

For TableSetupColumn.

Constant: TableColumnFlags_None

C++	`int ImGui::TableColumnFlags_None`
EEL	`int ImGui_TableColumnFlags_None()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_None")`
Lua	`integer ImGui.TableColumnFlags_None`
Python	`int retval = ImGui.TableColumnFlags_None()`

View source · v0.1+

Input Configuration

Constant: TableColumnFlags_AngledHeader

C++	`int ImGui::TableColumnFlags_AngledHeader`
EEL	`int ImGui_TableColumnFlags_AngledHeader()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_AngledHeader")`
Lua	`integer ImGui.TableColumnFlags_AngledHeader`
Python	`int retval = ImGui.TableColumnFlags_AngledHeader()`

TableHeadersRow will submit an angled header row for this column. Note this will add an extra row.

View source · v0.9+

Constant: TableColumnFlags_DefaultHide

C++	`int ImGui::TableColumnFlags_DefaultHide`
EEL	`int ImGui_TableColumnFlags_DefaultHide()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_DefaultHide")`
Lua	`integer ImGui.TableColumnFlags_DefaultHide`
Python	`int retval = ImGui.TableColumnFlags_DefaultHide()`

Default as a hidden/disabled column.

View source · v0.1+

Constant: TableColumnFlags_DefaultSort

C++	`int ImGui::TableColumnFlags_DefaultSort`
EEL	`int ImGui_TableColumnFlags_DefaultSort()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_DefaultSort")`
Lua	`integer ImGui.TableColumnFlags_DefaultSort`
Python	`int retval = ImGui.TableColumnFlags_DefaultSort()`

Default as a sorting column.

View source · v0.1+

Constant: TableColumnFlags_Disabled

C++	`int ImGui::TableColumnFlags_Disabled`
EEL	`int ImGui_TableColumnFlags_Disabled()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_Disabled")`
Lua	`integer ImGui.TableColumnFlags_Disabled`
Python	`int retval = ImGui.TableColumnFlags_Disabled()`

Overriding/master disable flag: hide column, won't show in context menu (unlike calling TableSetColumnEnabled which manipulates the user accessible state).

View source · v0.5.5+

Constant: TableColumnFlags_IndentDisable

C++	`int ImGui::TableColumnFlags_IndentDisable`
EEL	`int ImGui_TableColumnFlags_IndentDisable()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_IndentDisable")`
Lua	`integer ImGui.TableColumnFlags_IndentDisable`
Python	`int retval = ImGui.TableColumnFlags_IndentDisable()`

Ignore current Indent value when entering cell (default for columns > 0). Indentation changes within the cell will still be honored.

View source · v0.1+

Constant: TableColumnFlags_IndentEnable

C++	`int ImGui::TableColumnFlags_IndentEnable`
EEL	`int ImGui_TableColumnFlags_IndentEnable()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_IndentEnable")`
Lua	`integer ImGui.TableColumnFlags_IndentEnable`
Python	`int retval = ImGui.TableColumnFlags_IndentEnable()`

Use current Indent value when entering cell (default for column 0).

View source · v0.1+

Constant: TableColumnFlags_NoClip

C++	`int ImGui::TableColumnFlags_NoClip`
EEL	`int ImGui_TableColumnFlags_NoClip()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoClip")`
Lua	`integer ImGui.TableColumnFlags_NoClip`
Python	`int retval = ImGui.TableColumnFlags_NoClip()`

Disable clipping for this column (all NoClip columns will render in a same draw command).

View source · v0.1+

Constant: TableColumnFlags_NoHeaderLabel

C++	`int ImGui::TableColumnFlags_NoHeaderLabel`
EEL	`int ImGui_TableColumnFlags_NoHeaderLabel()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoHeaderLabel")`
Lua	`integer ImGui.TableColumnFlags_NoHeaderLabel`
Python	`int retval = ImGui.TableColumnFlags_NoHeaderLabel()`

TableHeadersRow will not submit horizontal label for this column. Convenient for some small columns. Name will still appear in context menu or in angled headers.

View source · v0.5.5+

Constant: TableColumnFlags_NoHeaderWidth

C++	`int ImGui::TableColumnFlags_NoHeaderWidth`
EEL	`int ImGui_TableColumnFlags_NoHeaderWidth()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoHeaderWidth")`
Lua	`integer ImGui.TableColumnFlags_NoHeaderWidth`
Python	`int retval = ImGui.TableColumnFlags_NoHeaderWidth()`

Disable header text width contribution to automatic column width.

View source · v0.1+

Constant: TableColumnFlags_NoHide

C++	`int ImGui::TableColumnFlags_NoHide`
EEL	`int ImGui_TableColumnFlags_NoHide()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoHide")`
Lua	`integer ImGui.TableColumnFlags_NoHide`
Python	`int retval = ImGui.TableColumnFlags_NoHide()`

Disable ability to hide/disable this column.

View source · v0.1+

Constant: TableColumnFlags_NoReorder

C++	`int ImGui::TableColumnFlags_NoReorder`
EEL	`int ImGui_TableColumnFlags_NoReorder()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoReorder")`
Lua	`integer ImGui.TableColumnFlags_NoReorder`
Python	`int retval = ImGui.TableColumnFlags_NoReorder()`

Disable manual reordering this column, this will also prevent other columns from crossing over this column.

View source · v0.1+

Constant: TableColumnFlags_NoResize

C++	`int ImGui::TableColumnFlags_NoResize`
EEL	`int ImGui_TableColumnFlags_NoResize()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoResize")`
Lua	`integer ImGui.TableColumnFlags_NoResize`
Python	`int retval = ImGui.TableColumnFlags_NoResize()`

Disable manual resizing.

View source · v0.1+

Constant: TableColumnFlags_NoSort

C++	`int ImGui::TableColumnFlags_NoSort`
EEL	`int ImGui_TableColumnFlags_NoSort()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoSort")`
Lua	`integer ImGui.TableColumnFlags_NoSort`
Python	`int retval = ImGui.TableColumnFlags_NoSort()`

Disable ability to sort on this field (even if TableFlags_Sortable is set on the table).

View source · v0.1+

Constant: TableColumnFlags_NoSortAscending

C++	`int ImGui::TableColumnFlags_NoSortAscending`
EEL	`int ImGui_TableColumnFlags_NoSortAscending()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoSortAscending")`
Lua	`integer ImGui.TableColumnFlags_NoSortAscending`
Python	`int retval = ImGui.TableColumnFlags_NoSortAscending()`

Disable ability to sort in the ascending direction.

View source · v0.1+

Constant: TableColumnFlags_NoSortDescending

C++	`int ImGui::TableColumnFlags_NoSortDescending`
EEL	`int ImGui_TableColumnFlags_NoSortDescending()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_NoSortDescending")`
Lua	`integer ImGui.TableColumnFlags_NoSortDescending`
Python	`int retval = ImGui.TableColumnFlags_NoSortDescending()`

Disable ability to sort in the descending direction.

View source · v0.1+

Constant: TableColumnFlags_PreferSortAscending

C++	`int ImGui::TableColumnFlags_PreferSortAscending`
EEL	`int ImGui_TableColumnFlags_PreferSortAscending()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_PreferSortAscending")`
Lua	`integer ImGui.TableColumnFlags_PreferSortAscending`
Python	`int retval = ImGui.TableColumnFlags_PreferSortAscending()`

Make the initial sort direction Ascending when first sorting on this column (default).

View source · v0.1+

Constant: TableColumnFlags_PreferSortDescending

C++	`int ImGui::TableColumnFlags_PreferSortDescending`
EEL	`int ImGui_TableColumnFlags_PreferSortDescending()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_PreferSortDescending")`
Lua	`integer ImGui.TableColumnFlags_PreferSortDescending`
Python	`int retval = ImGui.TableColumnFlags_PreferSortDescending()`

Make the initial sort direction Descending when first sorting on this column.

View source · v0.1+

Constant: TableColumnFlags_WidthFixed

C++	`int ImGui::TableColumnFlags_WidthFixed`
EEL	`int ImGui_TableColumnFlags_WidthFixed()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_WidthFixed")`
Lua	`integer ImGui.TableColumnFlags_WidthFixed`
Python	`int retval = ImGui.TableColumnFlags_WidthFixed()`

Column will not stretch. Preferable with horizontal scrolling enabled (default if table sizing policy is _SizingFixedFit and table is resizable).

View source · v0.1+

Constant: TableColumnFlags_WidthStretch

C++	`int ImGui::TableColumnFlags_WidthStretch`
EEL	`int ImGui_TableColumnFlags_WidthStretch()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_WidthStretch")`
Lua	`integer ImGui.TableColumnFlags_WidthStretch`
Python	`int retval = ImGui.TableColumnFlags_WidthStretch()`

Column will stretch. Preferable with horizontal scrolling disabled (default if table sizing policy is _SizingStretchSame or _SizingStretchProp).

View source · v0.1+

Output Status

Read-only via TableGetColumnFlags

Constant: TableColumnFlags_IsEnabled

C++	`int ImGui::TableColumnFlags_IsEnabled`
EEL	`int ImGui_TableColumnFlags_IsEnabled()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_IsEnabled")`
Lua	`integer ImGui.TableColumnFlags_IsEnabled`
Python	`int retval = ImGui.TableColumnFlags_IsEnabled()`

Status: is enabled == not hidden by user/api (referred to as "Hide" in _DefaultHide and _NoHide) flags.

View source · v0.1+

Constant: TableColumnFlags_IsHovered

C++	`int ImGui::TableColumnFlags_IsHovered`
EEL	`int ImGui_TableColumnFlags_IsHovered()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_IsHovered")`
Lua	`integer ImGui.TableColumnFlags_IsHovered`
Python	`int retval = ImGui.TableColumnFlags_IsHovered()`

Status: is hovered by mouse.

View source · v0.1+

Constant: TableColumnFlags_IsSorted

C++	`int ImGui::TableColumnFlags_IsSorted`
EEL	`int ImGui_TableColumnFlags_IsSorted()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_IsSorted")`
Lua	`integer ImGui.TableColumnFlags_IsSorted`
Python	`int retval = ImGui.TableColumnFlags_IsSorted()`

Status: is currently part of the sort specs.

View source · v0.1+

Constant: TableColumnFlags_IsVisible

C++	`int ImGui::TableColumnFlags_IsVisible`
EEL	`int ImGui_TableColumnFlags_IsVisible()`
Legacy EEL	`int extension_api("ImGui_TableColumnFlags_IsVisible")`
Lua	`integer ImGui.TableColumnFlags_IsVisible`
Python	`int retval = ImGui.TableColumnFlags_IsVisible()`

Status: is visible == is enabled AND not clipped by scrolling.

View source · v0.1+

Sorting

Constant: SortDirection_Ascending

C++	`int ImGui::SortDirection_Ascending`
EEL	`int ImGui_SortDirection_Ascending()`
Legacy EEL	`int extension_api("ImGui_SortDirection_Ascending")`
Lua	`integer ImGui.SortDirection_Ascending`
Python	`int retval = ImGui.SortDirection_Ascending()`

Ascending = 0->9, A->Z etc.

View source · v0.1+

Constant: SortDirection_Descending

C++	`int ImGui::SortDirection_Descending`
EEL	`int ImGui_SortDirection_Descending()`
Legacy EEL	`int extension_api("ImGui_SortDirection_Descending")`
Lua	`integer ImGui.SortDirection_Descending`
Python	`int retval = ImGui.SortDirection_Descending()`

Descending = 9->0, Z->A etc.

View source · v0.1+

Constant: SortDirection_None

C++	`int ImGui::SortDirection_None`
EEL	`int ImGui_SortDirection_None()`
Legacy EEL	`int extension_api("ImGui_SortDirection_None")`
Lua	`integer ImGui.SortDirection_None`
Python	`int retval = ImGui.SortDirection_None()`

View source · v0.1+

Function: TableGetColumnSortSpecs

C++	`bool ImGui::TableGetColumnSortSpecs(ImGui_Context* ctx, int id, int* column_indexOut, int* column_user_idOut, int* sort_directionOut)`
EEL	`bool ImGui_TableGetColumnSortSpecs(ImGui_Context ctx, int id, int &column_index, int &column_user_id, int &sort_direction)`
Legacy EEL	`bool extension_api("ImGui_TableGetColumnSortSpecs", ImGui_Context ctx, int id, int &column_index, int &column_user_id, int &sort_direction)`
Lua	`boolean retval, integer column_index, integer column_user_id, integer sort_direction = ImGui.TableGetColumnSortSpecs(ImGui_Context ctx, integer id)`
Python	`(bool retval, int column_index, int column_user_id, int sort_direction) = ImGui.TableGetColumnSortSpecs(ImGui_Context ctx, int id)`

Sorting specification for one column of a table. Call while incrementing 'id' from 0 until false is returned.

id: Index of the sorting specification (always stored in order starting from 0, tables sorted on a single criteria will always have a 0 here)
column_index: Index of the column
column_user_id: User ID of the column (if specified by a TableSetupColumn call)
sort_direction: SortDirection_Ascending or SortDirection_Descending

See TableNeedSort.

View source · v0.9+

Function: TableNeedSort

C++	`bool ImGui::TableNeedSort(ImGui_Context* ctx, bool* has_specsOut)`
EEL	`bool ImGui_TableNeedSort(ImGui_Context ctx, bool &has_specs)`
Legacy EEL	`bool extension_api("ImGui_TableNeedSort", ImGui_Context ctx, bool &has_specs)`
Lua	`boolean retval, boolean has_specs = ImGui.TableNeedSort(ImGui_Context ctx)`
Python	`(bool retval, bool has_specs) = ImGui.TableNeedSort(ImGui_Context ctx)`

Return true once when sorting specs have changed since last call, or the first time. 'has_specs' is false when not sorting.

See TableGetColumnSortSpecs.

View source · v0.1+

Table Flags

For BeginTable.

Important! Sizing policies have complex and subtle side effects, 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 TableFlags_SizingFixedFit if ScrollX is on, or if host window has WindowFlags_AlwaysAutoResize.
- Default to TableFlags_SizingStretchSame if ScrollX is off.
When ScrollX is off:
- Table defaults to TableFlags_SizingStretchSame -> all Columns defaults to TableColumnFlags_WidthStretch with same weight.
- Columns sizing policy allowed: Stretch (default), Fixed/Auto.
- Fixed Columns will generally obtain their requested width (unless the table cannot fit them all).
- Stretch Columns will share the remaining width.
- 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 TableFlags_SizingFixedFit -> all Columns defaults to TableColumnFlags_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.

Constant: TableFlags_None

C++	`int ImGui::TableFlags_None`
EEL	`int ImGui_TableFlags_None()`
Legacy EEL	`int extension_api("ImGui_TableFlags_None")`
Lua	`integer ImGui.TableFlags_None`
Python	`int retval = ImGui.TableFlags_None()`

View source · v0.1+

Clipping

Constant: TableFlags_NoClip

C++	`int ImGui::TableFlags_NoClip`
EEL	`int ImGui_TableFlags_NoClip()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoClip")`
Lua	`integer ImGui.TableFlags_NoClip`
Python	`int retval = ImGui.TableFlags_NoClip()`

Disable clipping rectangle for every individual columns (reduce draw command count, items will be able to overflow into other columns). Generally incompatible with TableSetupScrollFreeze.

View source · v0.1+

Decorations

Constant: TableFlags_Borders

C++	`int ImGui::TableFlags_Borders`
EEL	`int ImGui_TableFlags_Borders()`
Legacy EEL	`int extension_api("ImGui_TableFlags_Borders")`
Lua	`integer ImGui.TableFlags_Borders`
Python	`int retval = ImGui.TableFlags_Borders()`

Draw all borders.

View source · v0.1+

Constant: TableFlags_BordersH

C++	`int ImGui::TableFlags_BordersH`
EEL	`int ImGui_TableFlags_BordersH()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersH")`
Lua	`integer ImGui.TableFlags_BordersH`
Python	`int retval = ImGui.TableFlags_BordersH()`

Draw horizontal borders.

View source · v0.1+

Constant: TableFlags_BordersInner

C++	`int ImGui::TableFlags_BordersInner`
EEL	`int ImGui_TableFlags_BordersInner()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersInner")`
Lua	`integer ImGui.TableFlags_BordersInner`
Python	`int retval = ImGui.TableFlags_BordersInner()`

Draw inner borders.

View source · v0.1+

Constant: TableFlags_BordersInnerH

C++	`int ImGui::TableFlags_BordersInnerH`
EEL	`int ImGui_TableFlags_BordersInnerH()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersInnerH")`
Lua	`integer ImGui.TableFlags_BordersInnerH`
Python	`int retval = ImGui.TableFlags_BordersInnerH()`

Draw horizontal borders between rows.

View source · v0.1+

Constant: TableFlags_BordersInnerV

C++	`int ImGui::TableFlags_BordersInnerV`
EEL	`int ImGui_TableFlags_BordersInnerV()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersInnerV")`
Lua	`integer ImGui.TableFlags_BordersInnerV`
Python	`int retval = ImGui.TableFlags_BordersInnerV()`

Draw vertical borders between columns.

View source · v0.1+

Constant: TableFlags_BordersOuter

C++	`int ImGui::TableFlags_BordersOuter`
EEL	`int ImGui_TableFlags_BordersOuter()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersOuter")`
Lua	`integer ImGui.TableFlags_BordersOuter`
Python	`int retval = ImGui.TableFlags_BordersOuter()`

Draw outer borders.

View source · v0.1+

Constant: TableFlags_BordersOuterH

C++	`int ImGui::TableFlags_BordersOuterH`
EEL	`int ImGui_TableFlags_BordersOuterH()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersOuterH")`
Lua	`integer ImGui.TableFlags_BordersOuterH`
Python	`int retval = ImGui.TableFlags_BordersOuterH()`

Draw horizontal borders at the top and bottom.

View source · v0.1+

Constant: TableFlags_BordersOuterV

C++	`int ImGui::TableFlags_BordersOuterV`
EEL	`int ImGui_TableFlags_BordersOuterV()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersOuterV")`
Lua	`integer ImGui.TableFlags_BordersOuterV`
Python	`int retval = ImGui.TableFlags_BordersOuterV()`

Draw vertical borders on the left and right sides.

View source · v0.1+

Constant: TableFlags_BordersV

C++	`int ImGui::TableFlags_BordersV`
EEL	`int ImGui_TableFlags_BordersV()`
Legacy EEL	`int extension_api("ImGui_TableFlags_BordersV")`
Lua	`integer ImGui.TableFlags_BordersV`
Python	`int retval = ImGui.TableFlags_BordersV()`

Draw vertical borders.

View source · v0.1+

Constant: TableFlags_RowBg

C++	`int ImGui::TableFlags_RowBg`
EEL	`int ImGui_TableFlags_RowBg()`
Legacy EEL	`int extension_api("ImGui_TableFlags_RowBg")`
Lua	`integer ImGui.TableFlags_RowBg`
Python	`int retval = ImGui.TableFlags_RowBg()`

Set each RowBg color with Col_TableRowBg or Col_TableRowBgAlt (equivalent of calling TableSetBgColor with TableBgTarget_RowBg0 on each row manually).

View source · v0.1+

Features

Constant: TableFlags_ContextMenuInBody

C++	`int ImGui::TableFlags_ContextMenuInBody`
EEL	`int ImGui_TableFlags_ContextMenuInBody()`
Legacy EEL	`int extension_api("ImGui_TableFlags_ContextMenuInBody")`
Lua	`integer ImGui.TableFlags_ContextMenuInBody`
Python	`int retval = ImGui.TableFlags_ContextMenuInBody()`

Right-click on columns body/contents will display table context menu. By default it is available in TableHeadersRow.

View source · v0.1+

Constant: TableFlags_Hideable

C++	`int ImGui::TableFlags_Hideable`
EEL	`int ImGui_TableFlags_Hideable()`
Legacy EEL	`int extension_api("ImGui_TableFlags_Hideable")`
Lua	`integer ImGui.TableFlags_Hideable`
Python	`int retval = ImGui.TableFlags_Hideable()`

Enable hiding/disabling columns in context menu.

View source · v0.1+

Constant: TableFlags_NoSavedSettings

C++	`int ImGui::TableFlags_NoSavedSettings`
EEL	`int ImGui_TableFlags_NoSavedSettings()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoSavedSettings")`
Lua	`integer ImGui.TableFlags_NoSavedSettings`
Python	`int retval = ImGui.TableFlags_NoSavedSettings()`

Disable persisting columns order, width and sort settings in the .ini file.

View source · v0.4+

Constant: TableFlags_Reorderable

C++	`int ImGui::TableFlags_Reorderable`
EEL	`int ImGui_TableFlags_Reorderable()`
Legacy EEL	`int extension_api("ImGui_TableFlags_Reorderable")`
Lua	`integer ImGui.TableFlags_Reorderable`
Python	`int retval = ImGui.TableFlags_Reorderable()`

Enable reordering columns in header row (need calling TableSetupColumn + TableHeadersRow to display headers).

View source · v0.1+

Constant: TableFlags_Resizable

C++	`int ImGui::TableFlags_Resizable`
EEL	`int ImGui_TableFlags_Resizable()`
Legacy EEL	`int extension_api("ImGui_TableFlags_Resizable")`
Lua	`integer ImGui.TableFlags_Resizable`
Python	`int retval = ImGui.TableFlags_Resizable()`

Enable resizing columns.

View source · v0.1+

Constant: TableFlags_Sortable

C++	`int ImGui::TableFlags_Sortable`
EEL	`int ImGui_TableFlags_Sortable()`
Legacy EEL	`int extension_api("ImGui_TableFlags_Sortable")`
Lua	`integer ImGui.TableFlags_Sortable`
Python	`int retval = ImGui.TableFlags_Sortable()`

Enable sorting. Call TableNeedSort/TableGetColumnSortSpecs to obtain sort specs. Also see TableFlags_SortMulti and TableFlags_SortTristate.

View source · v0.1+

Miscellaneous

Constant: TableFlags_HighlightHoveredColumn

C++	`int ImGui::TableFlags_HighlightHoveredColumn`
EEL	`int ImGui_TableFlags_HighlightHoveredColumn()`
Legacy EEL	`int extension_api("ImGui_TableFlags_HighlightHoveredColumn")`
Lua	`integer ImGui.TableFlags_HighlightHoveredColumn`
Python	`int retval = ImGui.TableFlags_HighlightHoveredColumn()`

Highlight column headers when hovered (may evolve into a fuller highlight.)

View source · v0.9+

Padding

Constant: TableFlags_NoPadInnerX

C++	`int ImGui::TableFlags_NoPadInnerX`
EEL	`int ImGui_TableFlags_NoPadInnerX()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoPadInnerX")`
Lua	`integer ImGui.TableFlags_NoPadInnerX`
Python	`int retval = ImGui.TableFlags_NoPadInnerX()`

Disable inner padding between columns (double inner padding if TableFlags_BordersOuterV is on, single inner padding if BordersOuterV is off).

View source · v0.1+

Constant: TableFlags_NoPadOuterX

C++	`int ImGui::TableFlags_NoPadOuterX`
EEL	`int ImGui_TableFlags_NoPadOuterX()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoPadOuterX")`
Lua	`integer ImGui.TableFlags_NoPadOuterX`
Python	`int retval = ImGui.TableFlags_NoPadOuterX()`

Default if TableFlags_BordersOuterV is off. Disable outermost padding.

View source · v0.1+

Constant: TableFlags_PadOuterX

C++	`int ImGui::TableFlags_PadOuterX`
EEL	`int ImGui_TableFlags_PadOuterX()`
Legacy EEL	`int extension_api("ImGui_TableFlags_PadOuterX")`
Lua	`integer ImGui.TableFlags_PadOuterX`
Python	`int retval = ImGui.TableFlags_PadOuterX()`

Default if TableFlags_BordersOuterV is on. Enable outermost padding. Generally desirable if you have headers.

View source · v0.1+

Scrolling

Constant: TableFlags_ScrollX

C++	`int ImGui::TableFlags_ScrollX`
EEL	`int ImGui_TableFlags_ScrollX()`
Legacy EEL	`int extension_api("ImGui_TableFlags_ScrollX")`
Lua	`integer ImGui.TableFlags_ScrollX`
Python	`int retval = ImGui.TableFlags_ScrollX()`

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.

View source · v0.1+

Constant: TableFlags_ScrollY

C++	`int ImGui::TableFlags_ScrollY`
EEL	`int ImGui_TableFlags_ScrollY()`
Legacy EEL	`int extension_api("ImGui_TableFlags_ScrollY")`
Lua	`integer ImGui.TableFlags_ScrollY`
Python	`int retval = ImGui.TableFlags_ScrollY()`

Enable vertical scrolling. Require 'outer_size' parameter of BeginTable to specify the container size.

View source · v0.1+

Sizing Extra Options

Constant: TableFlags_NoHostExtendX

C++	`int ImGui::TableFlags_NoHostExtendX`
EEL	`int ImGui_TableFlags_NoHostExtendX()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoHostExtendX")`
Lua	`integer ImGui.TableFlags_NoHostExtendX`
Python	`int retval = ImGui.TableFlags_NoHostExtendX()`

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.

View source · v0.1+

Constant: TableFlags_NoHostExtendY

C++	`int ImGui::TableFlags_NoHostExtendY`
EEL	`int ImGui_TableFlags_NoHostExtendY()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoHostExtendY")`
Lua	`integer ImGui.TableFlags_NoHostExtendY`
Python	`int retval = ImGui.TableFlags_NoHostExtendY()`

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.

View source · v0.1+

Constant: TableFlags_NoKeepColumnsVisible

C++	`int ImGui::TableFlags_NoKeepColumnsVisible`
EEL	`int ImGui_TableFlags_NoKeepColumnsVisible()`
Legacy EEL	`int extension_api("ImGui_TableFlags_NoKeepColumnsVisible")`
Lua	`integer ImGui.TableFlags_NoKeepColumnsVisible`
Python	`int retval = ImGui.TableFlags_NoKeepColumnsVisible()`

Disable keeping column always minimally visible when ScrollX is off and table gets too small. Not recommended if columns are resizable.

View source · v0.1+

Constant: TableFlags_PreciseWidths

C++	`int ImGui::TableFlags_PreciseWidths`
EEL	`int ImGui_TableFlags_PreciseWidths()`
Legacy EEL	`int extension_api("ImGui_TableFlags_PreciseWidths")`
Lua	`integer ImGui.TableFlags_PreciseWidths`
Python	`int retval = ImGui.TableFlags_PreciseWidths()`

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.

View source · v0.1+

Sizing Policy

(read above for defaults)

Constant: TableFlags_SizingFixedFit

C++	`int ImGui::TableFlags_SizingFixedFit`
EEL	`int ImGui_TableFlags_SizingFixedFit()`
Legacy EEL	`int extension_api("ImGui_TableFlags_SizingFixedFit")`
Lua	`integer ImGui.TableFlags_SizingFixedFit`
Python	`int retval = ImGui.TableFlags_SizingFixedFit()`

Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching contents width.

View source · v0.1+

Constant: TableFlags_SizingFixedSame

C++	`int ImGui::TableFlags_SizingFixedSame`
EEL	`int ImGui_TableFlags_SizingFixedSame()`
Legacy EEL	`int extension_api("ImGui_TableFlags_SizingFixedSame")`
Lua	`integer ImGui.TableFlags_SizingFixedSame`
Python	`int retval = ImGui.TableFlags_SizingFixedSame()`

Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching the maximum contents width of all columns. Implicitly enable TableFlags_NoKeepColumnsVisible.

View source · v0.1+

Constant: TableFlags_SizingStretchProp

C++	`int ImGui::TableFlags_SizingStretchProp`
EEL	`int ImGui_TableFlags_SizingStretchProp()`
Legacy EEL	`int extension_api("ImGui_TableFlags_SizingStretchProp")`
Lua	`integer ImGui.TableFlags_SizingStretchProp`
Python	`int retval = ImGui.TableFlags_SizingStretchProp()`

Columns default to _WidthStretch with default weights proportional to each columns contents widths.

View source · v0.1+

Constant: TableFlags_SizingStretchSame

C++	`int ImGui::TableFlags_SizingStretchSame`
EEL	`int ImGui_TableFlags_SizingStretchSame()`
Legacy EEL	`int extension_api("ImGui_TableFlags_SizingStretchSame")`
Lua	`integer ImGui.TableFlags_SizingStretchSame`
Python	`int retval = ImGui.TableFlags_SizingStretchSame()`

Columns default to _WidthStretch with default weights all equal, unless overriden by TableSetupColumn.

View source · v0.1+

Sorting

Constant: TableFlags_SortMulti

C++	`int ImGui::TableFlags_SortMulti`
EEL	`int ImGui_TableFlags_SortMulti()`
Legacy EEL	`int extension_api("ImGui_TableFlags_SortMulti")`
Lua	`integer ImGui.TableFlags_SortMulti`
Python	`int retval = ImGui.TableFlags_SortMulti()`

Hold shift when clicking headers to sort on multiple column. TableGetColumnSortSpecs may return specs where (SpecsCount > 1).

View source · v0.1+

Constant: TableFlags_SortTristate

C++	`int ImGui::TableFlags_SortTristate`
EEL	`int ImGui_TableFlags_SortTristate()`
Legacy EEL	`int extension_api("ImGui_TableFlags_SortTristate")`
Lua	`integer ImGui.TableFlags_SortTristate`
Python	`int retval = ImGui.TableFlags_SortTristate()`

Allow no sorting, disable default sorting. TableGetColumnSortSpecs may return specs where (SpecsCount == 0).

View source · v0.1+

Text

Function: AlignTextToFramePadding

C++	`void ImGui::AlignTextToFramePadding(ImGui_Context* ctx)`
EEL	`ImGui_AlignTextToFramePadding(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_AlignTextToFramePadding", ImGui_Context ctx)`
Lua	`ImGui.AlignTextToFramePadding(ImGui_Context ctx)`
Python	`ImGui.AlignTextToFramePadding(ImGui_Context ctx)`

Vertically align upcoming text baseline to StyleVar_FramePadding.y so that it will align properly to regularly framed items (call if you have text on a line before a framed item).

View source · v0.1+

Function: Bullet

C++	`void ImGui::Bullet(ImGui_Context* ctx)`
EEL	`ImGui_Bullet(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_Bullet", ImGui_Context ctx)`
Lua	`ImGui.Bullet(ImGui_Context ctx)`
Python	`ImGui.Bullet(ImGui_Context ctx)`

Draw a small circle + keep the cursor on the same line. Advance cursor x position by GetTreeNodeToLabelSpacing, same distance that TreeNode uses.

View source · v0.1+

Function: BulletText

C++	`void ImGui::BulletText(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_BulletText(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_BulletText", ImGui_Context ctx, "text")`
Lua	`ImGui.BulletText(ImGui_Context ctx, string text)`
Python	`ImGui.BulletText(ImGui_Context ctx, str text)`

Shortcut for Bullet + Text.

View source · v0.1+

Function: CalcTextSize

C++	`void ImGui::CalcTextSize(ImGui_Context* ctx, const char* text, double* wOut, double* hOut, bool hide_text_after_double_hashInOptional = false, double wrap_widthInOptional = -1.0)`
EEL	`ImGui_CalcTextSize(ImGui_Context ctx, "text", &w, &h, bool hide_text_after_double_hash = false, wrap_width = -1.0)`
Legacy EEL	`extension_api("ImGui_CalcTextSize", ImGui_Context ctx, "text", &w, &h, bool hide_text_after_double_hash = false, wrap_width = -1.0)`
Lua	`number w, number h = ImGui.CalcTextSize(ImGui_Context ctx, string text, nil, nil, boolean hide_text_after_double_hash = false, number wrap_width = -1.0)`
Python	`(float w, float h) = ImGui.CalcTextSize(ImGui_Context ctx, str text, bool hide_text_after_double_hash = false, float wrap_width = -1.0)`

View source · v0.1+

Function: DebugTextEncoding

C++	`void ImGui::DebugTextEncoding(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_DebugTextEncoding(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_DebugTextEncoding", ImGui_Context ctx, "text")`
Lua	`ImGui.DebugTextEncoding(ImGui_Context ctx, string text)`
Python	`ImGui.DebugTextEncoding(ImGui_Context ctx, str text)`

Helper tool to diagnose between text encoding issues and font loading issues. Pass your UTF-8 string and verify that there are correct.

View source · v0.7+

Function: GetFrameHeight

C++	`double ImGui::GetFrameHeight(ImGui_Context* ctx)`
EEL	`double ImGui_GetFrameHeight(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetFrameHeight", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetFrameHeight(ImGui_Context ctx)`
Python	`float retval = ImGui.GetFrameHeight(ImGui_Context ctx)`

GetFontSize + StyleVar_FramePadding.y * 2

View source · v0.1+

Function: GetFrameHeightWithSpacing

C++	`double ImGui::GetFrameHeightWithSpacing(ImGui_Context* ctx)`
EEL	`double ImGui_GetFrameHeightWithSpacing(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetFrameHeightWithSpacing", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetFrameHeightWithSpacing(ImGui_Context ctx)`
Python	`float retval = ImGui.GetFrameHeightWithSpacing(ImGui_Context ctx)`

GetFontSize + StyleVar_FramePadding.y * 2 + StyleVar_ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets).

View source · v0.1+

Function: GetTextLineHeight

C++	`double ImGui::GetTextLineHeight(ImGui_Context* ctx)`
EEL	`double ImGui_GetTextLineHeight(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetTextLineHeight", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetTextLineHeight(ImGui_Context ctx)`
Python	`float retval = ImGui.GetTextLineHeight(ImGui_Context ctx)`

Same as GetFontSize

View source · v0.1+

Function: GetTextLineHeightWithSpacing

C++	`double ImGui::GetTextLineHeightWithSpacing(ImGui_Context* ctx)`
EEL	`double ImGui_GetTextLineHeightWithSpacing(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetTextLineHeightWithSpacing", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetTextLineHeightWithSpacing(ImGui_Context ctx)`
Python	`float retval = ImGui.GetTextLineHeightWithSpacing(ImGui_Context ctx)`

GetFontSize + StyleVar_ItemSpacing.y (distance in pixels between 2 consecutive lines of text).

View source · v0.1+

Function: LabelText

C++	`void ImGui::LabelText(ImGui_Context* ctx, const char* label, const char* text)`
EEL	`ImGui_LabelText(ImGui_Context ctx, "label", "text")`
Legacy EEL	`extension_api("ImGui_LabelText", ImGui_Context ctx, "label", "text")`
Lua	`ImGui.LabelText(ImGui_Context ctx, string label, string text)`
Python	`ImGui.LabelText(ImGui_Context ctx, str label, str text)`

Display text+label aligned the same way as value+label widgets

View source · v0.1+

Function: PopTextWrapPos

C++	`void ImGui::PopTextWrapPos(ImGui_Context* ctx)`
EEL	`ImGui_PopTextWrapPos(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopTextWrapPos", ImGui_Context ctx)`
Lua	`ImGui.PopTextWrapPos(ImGui_Context ctx)`
Python	`ImGui.PopTextWrapPos(ImGui_Context ctx)`

View source · v0.1+

Function: PushTextWrapPos

C++	`void ImGui::PushTextWrapPos(ImGui_Context* ctx, double wrap_local_pos_xInOptional = 0.0)`
EEL	`ImGui_PushTextWrapPos(ImGui_Context ctx, wrap_local_pos_x = 0.0)`
Legacy EEL	`extension_api("ImGui_PushTextWrapPos", ImGui_Context ctx, wrap_local_pos_x = 0.0)`
Lua	`ImGui.PushTextWrapPos(ImGui_Context ctx, number wrap_local_pos_x = 0.0)`
Python	`ImGui.PushTextWrapPos(ImGui_Context ctx, float wrap_local_pos_x = 0.0)`

Push word-wrapping position for Text*() commands.

< 0.0: no wrapping
= 0.0: wrap to end of window (or column)
> 0.0: wrap at 'wrap_pos_x' position in window local space.

View source · v0.1+

Function: Text

C++	`void ImGui::Text(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_Text(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_Text", ImGui_Context ctx, "text")`
Lua	`ImGui.Text(ImGui_Context ctx, string text)`
Python	`ImGui.Text(ImGui_Context ctx, str text)`

View source · v0.1+

Function: TextColored

C++	`void ImGui::TextColored(ImGui_Context* ctx, int col_rgba, const char* text)`
EEL	`ImGui_TextColored(ImGui_Context ctx, int col_rgba, "text")`
Legacy EEL	`extension_api("ImGui_TextColored", ImGui_Context ctx, int col_rgba, "text")`
Lua	`ImGui.TextColored(ImGui_Context ctx, integer col_rgba, string text)`
Python	`ImGui.TextColored(ImGui_Context ctx, int col_rgba, str text)`

Shortcut for PushStyleColor(Col_Text, color); Text(text); PopStyleColor();

View source · v0.1+

Function: TextDisabled

C++	`void ImGui::TextDisabled(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_TextDisabled(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_TextDisabled", ImGui_Context ctx, "text")`
Lua	`ImGui.TextDisabled(ImGui_Context ctx, string text)`
Python	`ImGui.TextDisabled(ImGui_Context ctx, str text)`

View source · v0.1+

Function: TextWrapped

C++	`void ImGui::TextWrapped(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_TextWrapped(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_TextWrapped", ImGui_Context ctx, "text")`
Lua	`ImGui.TextWrapped(ImGui_Context ctx, string text)`
Python	`ImGui.TextWrapped(ImGui_Context ctx, str text)`

Shortcut for PushTextWrapPos(0.0); Text(text); PopTextWrapPos();. Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width, yoy may need to set a size using SetNextWindowSize.

View source · v0.1+

Text & Scalar Input

Function: InputDouble

C++	`bool ImGui::InputDouble(ImGui_Context* ctx, const char* label, double* vInOut, double stepInOptional = 0.0, double step_fastInOptional = 0.0, const char* formatInOptional = "%.3f", int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputDouble(ImGui_Context ctx, "label", &v, step = 0.0, step_fast = 0.0, "format" = "%.3f", int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputDouble", ImGui_Context ctx, "label", &v, step = 0.0, step_fast = 0.0, "format" = "%.3f", int flags = InputTextFlags_None)`
Lua	`boolean retval, number v = ImGui.InputDouble(ImGui_Context ctx, string label, number v, number step = 0.0, number step_fast = 0.0, string format = "%.3f", integer flags = InputTextFlags_None)`
Python	`(bool retval, float v) = ImGui.InputDouble(ImGui_Context ctx, str label, float v, float step = 0.0, float step_fast = 0.0, str format = "%.3f", int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputDouble2

C++	`bool ImGui::InputDouble2(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, const char* formatInOptional = "%.3f", int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputDouble2(ImGui_Context ctx, "label", &v1, &v2, "format" = "%.3f", int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputDouble2", ImGui_Context ctx, "label", &v1, &v2, "format" = "%.3f", int flags = InputTextFlags_None)`
Lua	`boolean retval, number v1, number v2 = ImGui.InputDouble2(ImGui_Context ctx, string label, number v1, number v2, string format = "%.3f", integer flags = InputTextFlags_None)`
Python	`(bool retval, float v1, float v2) = ImGui.InputDouble2(ImGui_Context ctx, str label, float v1, float v2, str format = "%.3f", int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputDouble3

C++	`bool ImGui::InputDouble3(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, const char* formatInOptional = "%.3f", int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputDouble3(ImGui_Context ctx, "label", &v1, &v2, &v3, "format" = "%.3f", int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputDouble3", ImGui_Context ctx, "label", &v1, &v2, &v3, "format" = "%.3f", int flags = InputTextFlags_None)`
Lua	`boolean retval, number v1, number v2, number v3 = ImGui.InputDouble3(ImGui_Context ctx, string label, number v1, number v2, number v3, string format = "%.3f", integer flags = InputTextFlags_None)`
Python	`(bool retval, float v1, float v2, float v3) = ImGui.InputDouble3(ImGui_Context ctx, str label, float v1, float v2, float v3, str format = "%.3f", int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputDouble4

C++	`bool ImGui::InputDouble4(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v4InOut, const char* formatInOptional = "%.3f", int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputDouble4(ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, "format" = "%.3f", int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputDouble4", ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, "format" = "%.3f", int flags = InputTextFlags_None)`
Lua	`boolean retval, number v1, number v2, number v3, number v4 = ImGui.InputDouble4(ImGui_Context ctx, string label, number v1, number v2, number v3, number v4, string format = "%.3f", integer flags = InputTextFlags_None)`
Python	`(bool retval, float v1, float v2, float v3, float v4) = ImGui.InputDouble4(ImGui_Context ctx, str label, float v1, float v2, float v3, float v4, str format = "%.3f", int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputDoubleN

C++	`bool ImGui::InputDoubleN(ImGui_Context* ctx, const char* label, reaper_array* values, double stepInOptional = nullptr, double step_fastInOptional = nullptr, const char* formatInOptional = "%.3f", int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputDoubleN(ImGui_Context ctx, "label", reaper_array values, step = 0, step_fast = 0, "format" = "%.3f", int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputDoubleN", ImGui_Context ctx, "label", reaper_array values, step = 0, step_fast = 0, "format" = "%.3f", int flags = InputTextFlags_None)`
Lua	`boolean retval = ImGui.InputDoubleN(ImGui_Context ctx, string label, reaper.array values, number step = nil, number step_fast = nil, string format = "%.3f", integer flags = InputTextFlags_None)`
Python	`bool retval = ImGui.InputDoubleN(ImGui_Context ctx, str label, reaper_array values, float step = None, float step_fast = None, str format = "%.3f", int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputInt

C++	`bool ImGui::InputInt(ImGui_Context* ctx, const char* label, int* vInOut, int stepInOptional = 1, int step_fastInOptional = 100, int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputInt(ImGui_Context ctx, "label", int &v, int step = 1, int step_fast = 100, int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputInt", ImGui_Context ctx, "label", int &v, int step = 1, int step_fast = 100, int flags = InputTextFlags_None)`
Lua	`boolean retval, integer v = ImGui.InputInt(ImGui_Context ctx, string label, integer v, integer step = 1, integer step_fast = 100, integer flags = InputTextFlags_None)`
Python	`(bool retval, int v) = ImGui.InputInt(ImGui_Context ctx, str label, int v, int step = 1, int step_fast = 100, int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputInt2

C++	`bool ImGui::InputInt2(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputInt2(ImGui_Context ctx, "label", int &v1, int &v2, int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputInt2", ImGui_Context ctx, "label", int &v1, int &v2, int flags = InputTextFlags_None)`
Lua	`boolean retval, integer v1, integer v2 = ImGui.InputInt2(ImGui_Context ctx, string label, integer v1, integer v2, integer flags = InputTextFlags_None)`
Python	`(bool retval, int v1, int v2) = ImGui.InputInt2(ImGui_Context ctx, str label, int v1, int v2, int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputInt3

C++	`bool ImGui::InputInt3(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputInt3(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputInt3", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int flags = InputTextFlags_None)`
Lua	`boolean retval, integer v1, integer v2, integer v3 = ImGui.InputInt3(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer flags = InputTextFlags_None)`
Python	`(bool retval, int v1, int v2, int v3) = ImGui.InputInt3(ImGui_Context ctx, str label, int v1, int v2, int v3, int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputInt4

C++	`bool ImGui::InputInt4(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* v4InOut, int flagsInOptional = InputTextFlags_None)`
EEL	`bool ImGui_InputInt4(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, int flags = InputTextFlags_None)`
Legacy EEL	`bool extension_api("ImGui_InputInt4", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, int flags = InputTextFlags_None)`
Lua	`boolean retval, integer v1, integer v2, integer v3, integer v4 = ImGui.InputInt4(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v4, integer flags = InputTextFlags_None)`
Python	`(bool retval, int v1, int v2, int v3, int v4) = ImGui.InputInt4(ImGui_Context ctx, str label, int v1, int v2, int v3, int v4, int flags = InputTextFlags_None)`

View source · v0.1+

Function: InputText

C++	`bool ImGui::InputText(ImGui_Context* ctx, const char* label, char* bufInOutNeedBig, int bufInOutNeedBig_sz, int flagsInOptional = InputTextFlags_None, ImGui_Function* callbackInOptional = nullptr)`
EEL	`bool ImGui_InputText(ImGui_Context ctx, "label", #buf, int flags = InputTextFlags_None, ImGui_Function callback = 0)`
Legacy EEL	`bool extension_api("ImGui_InputText", ImGui_Context ctx, "label", #buf, int flags = InputTextFlags_None, ImGui_Function callback = 0)`
Lua	`boolean retval, string buf = ImGui.InputText(ImGui_Context ctx, string label, string buf, integer flags = InputTextFlags_None, ImGui_Function callback = nil)`
Python	`(bool retval, str buf) = ImGui.InputText(ImGui_Context ctx, str label, str buf, int flags = InputTextFlags_None, ImGui_Function callback = None)`

View source · v0.8.5+

Function: InputTextMultiline

C++	`bool ImGui::InputTextMultiline(ImGui_Context* ctx, const char* label, char* bufInOutNeedBig, int bufInOutNeedBig_sz, double size_wInOptional = 0.0, double size_hInOptional = 0.0, int flagsInOptional = InputTextFlags_None, ImGui_Function* callbackInOptional = nullptr)`
EEL	`bool ImGui_InputTextMultiline(ImGui_Context ctx, "label", #buf, size_w = 0.0, size_h = 0.0, int flags = InputTextFlags_None, ImGui_Function callback = 0)`
Legacy EEL	`bool extension_api("ImGui_InputTextMultiline", ImGui_Context ctx, "label", #buf, size_w = 0.0, size_h = 0.0, int flags = InputTextFlags_None, ImGui_Function callback = 0)`
Lua	`boolean retval, string buf = ImGui.InputTextMultiline(ImGui_Context ctx, string label, string buf, number size_w = 0.0, number size_h = 0.0, integer flags = InputTextFlags_None, ImGui_Function callback = nil)`
Python	`(bool retval, str buf) = ImGui.InputTextMultiline(ImGui_Context ctx, str label, str buf, float size_w = 0.0, float size_h = 0.0, int flags = InputTextFlags_None, ImGui_Function callback = None)`

View source · v0.8.5+

Function: InputTextWithHint

C++	`bool ImGui::InputTextWithHint(ImGui_Context* ctx, const char* label, const char* hint, char* bufInOutNeedBig, int bufInOutNeedBig_sz, int flagsInOptional = InputTextFlags_None, ImGui_Function* callbackInOptional = nullptr)`
EEL	`bool ImGui_InputTextWithHint(ImGui_Context ctx, "label", "hint", #buf, int flags = InputTextFlags_None, ImGui_Function callback = 0)`
Legacy EEL	`bool extension_api("ImGui_InputTextWithHint", ImGui_Context ctx, "label", "hint", #buf, int flags = InputTextFlags_None, ImGui_Function callback = 0)`
Lua	`boolean retval, string buf = ImGui.InputTextWithHint(ImGui_Context ctx, string label, string hint, string buf, integer flags = InputTextFlags_None, ImGui_Function callback = nil)`
Python	`(bool retval, str buf) = ImGui.InputTextWithHint(ImGui_Context ctx, str label, str hint, str buf, int flags = InputTextFlags_None, ImGui_Function callback = None)`

View source · v0.8.5+

Flags

Most of these are only useful for InputText*() and not for InputDoubleX, InputIntX etc.

(Those are per-item flags. There are shared flags in SetConfigVar: ConfigVar_InputTextCursorBlink and ConfigVar_InputTextEnterKeepActive.)

Constant: InputTextFlags_None

C++	`int ImGui::InputTextFlags_None`
EEL	`int ImGui_InputTextFlags_None()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_None")`
Lua	`integer ImGui.InputTextFlags_None`
Python	`int retval = ImGui.InputTextFlags_None()`

View source · v0.1+

Basic filters

Constant: InputTextFlags_CharsDecimal

C++	`int ImGui::InputTextFlags_CharsDecimal`
EEL	`int ImGui_InputTextFlags_CharsDecimal()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CharsDecimal")`
Lua	`integer ImGui.InputTextFlags_CharsDecimal`
Python	`int retval = ImGui.InputTextFlags_CharsDecimal()`

Allow 0123456789.+-*/.

View source · v0.1+

Constant: InputTextFlags_CharsHexadecimal

C++	`int ImGui::InputTextFlags_CharsHexadecimal`
EEL	`int ImGui_InputTextFlags_CharsHexadecimal()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CharsHexadecimal")`
Lua	`integer ImGui.InputTextFlags_CharsHexadecimal`
Python	`int retval = ImGui.InputTextFlags_CharsHexadecimal()`

Allow 0123456789ABCDEFabcdef.

View source · v0.1+

Constant: InputTextFlags_CharsNoBlank

C++	`int ImGui::InputTextFlags_CharsNoBlank`
EEL	`int ImGui_InputTextFlags_CharsNoBlank()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CharsNoBlank")`
Lua	`integer ImGui.InputTextFlags_CharsNoBlank`
Python	`int retval = ImGui.InputTextFlags_CharsNoBlank()`

Filter out spaces, tabs.

View source · v0.1+

Constant: InputTextFlags_CharsScientific

C++	`int ImGui::InputTextFlags_CharsScientific`
EEL	`int ImGui_InputTextFlags_CharsScientific()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CharsScientific")`
Lua	`integer ImGui.InputTextFlags_CharsScientific`
Python	`int retval = ImGui.InputTextFlags_CharsScientific()`

Allow 0123456789.+-*/eE (Scientific notation input).

View source · v0.1+

Constant: InputTextFlags_CharsUppercase

C++	`int ImGui::InputTextFlags_CharsUppercase`
EEL	`int ImGui_InputTextFlags_CharsUppercase()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CharsUppercase")`
Lua	`integer ImGui.InputTextFlags_CharsUppercase`
Python	`int retval = ImGui.InputTextFlags_CharsUppercase()`

Turn a..z into A..Z.

View source · v0.1+

Callback features

Constant: InputTextFlags_CallbackAlways

C++	`int ImGui::InputTextFlags_CallbackAlways`
EEL	`int ImGui_InputTextFlags_CallbackAlways()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CallbackAlways")`
Lua	`integer ImGui.InputTextFlags_CallbackAlways`
Python	`int retval = ImGui.InputTextFlags_CallbackAlways()`

Callback on each iteration. User code may query cursor position, modify text buffer.

View source · v0.8.5+

Constant: InputTextFlags_CallbackCharFilter

C++	`int ImGui::InputTextFlags_CallbackCharFilter`
EEL	`int ImGui_InputTextFlags_CallbackCharFilter()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CallbackCharFilter")`
Lua	`integer ImGui.InputTextFlags_CallbackCharFilter`
Python	`int retval = ImGui.InputTextFlags_CallbackCharFilter()`

Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or 'EventChar = 0' to discard.

View source · v0.8.5+

Constant: InputTextFlags_CallbackCompletion

C++	`int ImGui::InputTextFlags_CallbackCompletion`
EEL	`int ImGui_InputTextFlags_CallbackCompletion()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CallbackCompletion")`
Lua	`integer ImGui.InputTextFlags_CallbackCompletion`
Python	`int retval = ImGui.InputTextFlags_CallbackCompletion()`

Callback on pressing TAB (for completion handling).

View source · v0.8.5+

Constant: InputTextFlags_CallbackEdit

C++	`int ImGui::InputTextFlags_CallbackEdit`
EEL	`int ImGui_InputTextFlags_CallbackEdit()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CallbackEdit")`
Lua	`integer ImGui.InputTextFlags_CallbackEdit`
Python	`int retval = ImGui.InputTextFlags_CallbackEdit()`

Callback on any edit (note that InputText() already returns true on edit, the callback is useful mainly to manipulate the underlying buffer while focus is active).

View source · v0.8.5+

Constant: InputTextFlags_CallbackHistory

C++	`int ImGui::InputTextFlags_CallbackHistory`
EEL	`int ImGui_InputTextFlags_CallbackHistory()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CallbackHistory")`
Lua	`integer ImGui.InputTextFlags_CallbackHistory`
Python	`int retval = ImGui.InputTextFlags_CallbackHistory()`

Callback on pressing Up/Down arrows (for history handling).

View source · v0.8.5+

Inputs

Constant: InputTextFlags_AllowTabInput

C++	`int ImGui::InputTextFlags_AllowTabInput`
EEL	`int ImGui_InputTextFlags_AllowTabInput()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_AllowTabInput")`
Lua	`integer ImGui.InputTextFlags_AllowTabInput`
Python	`int retval = ImGui.InputTextFlags_AllowTabInput()`

Pressing TAB input a '\t' character into the text field.

View source · v0.1+

Constant: InputTextFlags_CtrlEnterForNewLine

C++	`int ImGui::InputTextFlags_CtrlEnterForNewLine`
EEL	`int ImGui_InputTextFlags_CtrlEnterForNewLine()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_CtrlEnterForNewLine")`
Lua	`integer ImGui.InputTextFlags_CtrlEnterForNewLine`
Python	`int retval = ImGui.InputTextFlags_CtrlEnterForNewLine()`

In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter (default is opposite: unfocus with Ctrl+Enter, add line with Enter).

View source · v0.1+

Constant: InputTextFlags_EnterReturnsTrue

C++	`int ImGui::InputTextFlags_EnterReturnsTrue`
EEL	`int ImGui_InputTextFlags_EnterReturnsTrue()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_EnterReturnsTrue")`
Lua	`integer ImGui.InputTextFlags_EnterReturnsTrue`
Python	`int retval = ImGui.InputTextFlags_EnterReturnsTrue()`

Return 'true' when Enter is pressed (as opposed to every time the value was modified). Consider looking at the IsItemDeactivatedAfterEdit function.

View source · v0.1+

Constant: InputTextFlags_EscapeClearsAll

C++	`int ImGui::InputTextFlags_EscapeClearsAll`
EEL	`int ImGui_InputTextFlags_EscapeClearsAll()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_EscapeClearsAll")`
Lua	`integer ImGui.InputTextFlags_EscapeClearsAll`
Python	`int retval = ImGui.InputTextFlags_EscapeClearsAll()`

Escape key clears content if not empty, and deactivate otherwise (constrast to default behavior of Escape to revert).

View source · v0.8+

Other options

Constant: InputTextFlags_AlwaysOverwrite

C++	`int ImGui::InputTextFlags_AlwaysOverwrite`
EEL	`int ImGui_InputTextFlags_AlwaysOverwrite()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_AlwaysOverwrite")`
Lua	`integer ImGui.InputTextFlags_AlwaysOverwrite`
Python	`int retval = ImGui.InputTextFlags_AlwaysOverwrite()`

Overwrite mode.

View source · v0.2+

Constant: InputTextFlags_AutoSelectAll

C++	`int ImGui::InputTextFlags_AutoSelectAll`
EEL	`int ImGui_InputTextFlags_AutoSelectAll()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_AutoSelectAll")`
Lua	`integer ImGui.InputTextFlags_AutoSelectAll`
Python	`int retval = ImGui.InputTextFlags_AutoSelectAll()`

Select entire text when first taking mouse focus.

View source · v0.1+

Constant: InputTextFlags_DisplayEmptyRefVal

C++	`int ImGui::InputTextFlags_DisplayEmptyRefVal`
EEL	`int ImGui_InputTextFlags_DisplayEmptyRefVal()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_DisplayEmptyRefVal")`
Lua	`integer ImGui.InputTextFlags_DisplayEmptyRefVal`
Python	`int retval = ImGui.InputTextFlags_DisplayEmptyRefVal()`

InputDouble(), InputInt() etc. only: when value is zero, do not display it. Generally used with InputTextFlags_ParseEmptyRefVal.

View source · v0.9.2+

Constant: InputTextFlags_NoHorizontalScroll

C++	`int ImGui::InputTextFlags_NoHorizontalScroll`
EEL	`int ImGui_InputTextFlags_NoHorizontalScroll()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_NoHorizontalScroll")`
Lua	`integer ImGui.InputTextFlags_NoHorizontalScroll`
Python	`int retval = ImGui.InputTextFlags_NoHorizontalScroll()`

Disable following the cursor horizontally.

View source · v0.1+

Constant: InputTextFlags_NoUndoRedo

C++	`int ImGui::InputTextFlags_NoUndoRedo`
EEL	`int ImGui_InputTextFlags_NoUndoRedo()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_NoUndoRedo")`
Lua	`integer ImGui.InputTextFlags_NoUndoRedo`
Python	`int retval = ImGui.InputTextFlags_NoUndoRedo()`

Disable undo/redo. Note that input text owns the text data while active.

View source · v0.1+

Constant: InputTextFlags_ParseEmptyRefVal

C++	`int ImGui::InputTextFlags_ParseEmptyRefVal`
EEL	`int ImGui_InputTextFlags_ParseEmptyRefVal()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_ParseEmptyRefVal")`
Lua	`integer ImGui.InputTextFlags_ParseEmptyRefVal`
Python	`int retval = ImGui.InputTextFlags_ParseEmptyRefVal()`

InputDouble(), InputInt() etc. only: parse empty string as zero value.

View source · v0.9.2+

Constant: InputTextFlags_Password

C++	`int ImGui::InputTextFlags_Password`
EEL	`int ImGui_InputTextFlags_Password()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_Password")`
Lua	`integer ImGui.InputTextFlags_Password`
Python	`int retval = ImGui.InputTextFlags_Password()`

Password mode, display all characters as '*'.

View source · v0.1+

Constant: InputTextFlags_ReadOnly

C++	`int ImGui::InputTextFlags_ReadOnly`
EEL	`int ImGui_InputTextFlags_ReadOnly()`
Legacy EEL	`int extension_api("ImGui_InputTextFlags_ReadOnly")`
Lua	`integer ImGui.InputTextFlags_ReadOnly`
Python	`int retval = ImGui.InputTextFlags_ReadOnly()`

Read-only mode.

View source · v0.1+

InputText Callback

The functions and variables documented in this section are only available within the callbacks given to the InputText* functions. See CreateFunctionFromEEL.

local reverseAlphabet = ImGui.CreateFunctionFromEEL([[
  EventChar >= 'a' && EventChar <= 'z' ? EventChar = 'z' - (EventChar - 'a');
]])

local function frame()
  rv, text = ImGui.InputText(ctx, 'Lowercase reversed', text,
    ImGui.InputTextFlags_CallbackCharFilter, reverseAlphabet)
end

Variable access table (R = updated for reading, W = writes are applied, - = unmodified):

	Always	CharFilter	Completion	Edit	History
EventFlag	R/-	R/-	R/-	R/-	R/-
Flags	R/-	R/-	R/-	R/-	R/-
EventChar	-/-	R/W	-/-	-/-	-/-
EventKey	-/-	-/-	R/-	-/-	R/-
Buf	R/-	-/-	R/-	R/-	R/-
CursorPos	R/W	-/-	R/W	R/W	R/W
SelectionStart	R/W	-/-	R/W	R/W	R/W
SelectionEnd	R/W	-/-	R/W	R/W	R/W

The InputTextCallback_* functions should only be used when EventFlag is one of InputTextFlags_CallbackAlways/Completion/Edit/History.

Variable: Buf

EEL	`#Buf`

Current value being edited.

View source · v0.8.5+

Variable: CursorPos

EEL	`int CursorPos`

View source · v0.8.5+

Variable: EventChar

EEL	`int EventChar`

Character input. Replace character with another one, or set to zero to drop.

View source · v0.8.5+

Variable: EventFlag

EEL	`int EventFlag`

One of InputTextFlags_Callback*

View source · v0.8.5+

Variable: EventKey

EEL	`int EventKey`

Key_UpArrow/DownArrow/Tab. Compare against these constants instead of a hard-coded numerical value.

View source · v0.8.5+

Variable: Flags

EEL	`int Flags`

What was passed to InputText()

View source · v0.8.5+

Function: InputTextCallback_ClearSelection

EEL	`InputTextCallback_ClearSelection()`

View source · v0.8.5+

Function: InputTextCallback_DeleteChars

EEL	`InputTextCallback_DeleteChars(int pos, int bytes_count)`

View source · v0.8.5+

Function: InputTextCallback_HasSelection

EEL	`bool InputTextCallback_HasSelection()`

View source · v0.8.5+

Function: InputTextCallback_InsertChars

EEL	`InputTextCallback_InsertChars(int pos, "new_text")`

View source · v0.8.5+

Function: InputTextCallback_SelectAll

EEL	`InputTextCallback_SelectAll()`

View source · v0.8.5+

Variable: SelectionEnd

EEL	`int SelectionEnd`

View source · v0.8.5+

Variable: SelectionStart

EEL	`int SelectionStart`

Equal to SelectionEnd when no selection.

View source · v0.8.5+

Text Filter

Helper to perform simple filtering on text strings. In format "aaaaa[,bbbb][,ccccc]".

Filter usage:

"" display all lines
"xxx" display lines containing "xxx"
"xxx,yyy" display lines containing "xxx" or "yyy"
"-xxx" hide lines containing "xxx"

Function: CreateTextFilter

C++	`ImGui_TextFilter* ImGui::CreateTextFilter(const char* default_filterInOptional = "")`
EEL	`ImGui_TextFilter* ImGui_CreateTextFilter("default_filter" = "")`
Legacy EEL	`ImGui_TextFilter* extension_api("ImGui_CreateTextFilter", "default_filter" = "")`
Lua	`ImGui_TextFilter retval = ImGui.CreateTextFilter(string default_filter = "")`
Python	`ImGui_TextFilter retval = ImGui.CreateTextFilter(str default_filter = "")`

Valid while used every frame unless attached to a context (see Attach).

View source · v0.9+

Function: TextFilter_Clear

C++	`void ImGui::TextFilter_Clear(ImGui_TextFilter* filter)`
EEL	`ImGui_TextFilter_Clear(ImGui_TextFilter filter)`
Legacy EEL	`extension_api("ImGui_TextFilter_Clear", ImGui_TextFilter filter)`
Lua	`ImGui.TextFilter_Clear(ImGui_TextFilter filter)`
Python	`ImGui.TextFilter_Clear(ImGui_TextFilter filter)`

View source · v0.5.6+

Function: TextFilter_Draw

C++	`bool ImGui::TextFilter_Draw(ImGui_TextFilter* filter, ImGui_Context* ctx, const char* labelInOptional = "Filter (inc,-exc)", double widthInOptional = 0.0)`
EEL	`bool ImGui_TextFilter_Draw(ImGui_TextFilter filter, ImGui_Context ctx, "label" = "Filter (inc,-exc)", width = 0.0)`
Legacy EEL	`bool extension_api("ImGui_TextFilter_Draw", ImGui_TextFilter filter, ImGui_Context ctx, "label" = "Filter (inc,-exc)", width = 0.0)`
Lua	`boolean retval = ImGui.TextFilter_Draw(ImGui_TextFilter filter, ImGui_Context ctx, string label = "Filter (inc,-exc)", number width = 0.0)`
Python	`bool retval = ImGui.TextFilter_Draw(ImGui_TextFilter filter, ImGui_Context ctx, str label = "Filter (inc,-exc)", float width = 0.0)`

Helper calling InputText+TextFilter_Set

View source · v0.5.6+

Function: TextFilter_Get

C++	`const char* ImGui::TextFilter_Get(ImGui_TextFilter* filter)`
EEL	`const char* ImGui_TextFilter_Get(ImGui_TextFilter filter)`
Legacy EEL	`const char* extension_api("ImGui_TextFilter_Get", ImGui_TextFilter filter)`
Lua	`string retval = ImGui.TextFilter_Get(ImGui_TextFilter filter)`
Python	`str retval = ImGui.TextFilter_Get(ImGui_TextFilter filter)`

View source · v0.5.6+

Function: TextFilter_IsActive

C++	`bool ImGui::TextFilter_IsActive(ImGui_TextFilter* filter)`
EEL	`bool ImGui_TextFilter_IsActive(ImGui_TextFilter filter)`
Legacy EEL	`bool extension_api("ImGui_TextFilter_IsActive", ImGui_TextFilter filter)`
Lua	`boolean retval = ImGui.TextFilter_IsActive(ImGui_TextFilter filter)`
Python	`bool retval = ImGui.TextFilter_IsActive(ImGui_TextFilter filter)`

View source · v0.5.6+

Function: TextFilter_PassFilter

C++	`bool ImGui::TextFilter_PassFilter(ImGui_TextFilter* filter, const char* text)`
EEL	`bool ImGui_TextFilter_PassFilter(ImGui_TextFilter filter, "text")`
Legacy EEL	`bool extension_api("ImGui_TextFilter_PassFilter", ImGui_TextFilter filter, "text")`
Lua	`boolean retval = ImGui.TextFilter_PassFilter(ImGui_TextFilter filter, string text)`
Python	`bool retval = ImGui.TextFilter_PassFilter(ImGui_TextFilter filter, str text)`

View source · v0.5.6+

Function: TextFilter_Set

C++	`void ImGui::TextFilter_Set(ImGui_TextFilter* filter, const char* filter_text)`
EEL	`ImGui_TextFilter_Set(ImGui_TextFilter filter, "filter_text")`
Legacy EEL	`extension_api("ImGui_TextFilter_Set", ImGui_TextFilter filter, "filter_text")`
Lua	`ImGui.TextFilter_Set(ImGui_TextFilter filter, string filter_text)`
Python	`ImGui.TextFilter_Set(ImGui_TextFilter filter, str filter_text)`

View source · v0.5.6+

Tree Node

Function: CollapsingHeader

C++	`bool ImGui::CollapsingHeader(ImGui_Context* ctx, const char* label, bool* p_visibleInOutOptional = nullptr, int flagsInOptional = TreeNodeFlags_None)`
EEL	`bool ImGui_CollapsingHeader(ImGui_Context ctx, "label", bool &p_visible = 0, int flags = TreeNodeFlags_None)`
Legacy EEL	`bool extension_api("ImGui_CollapsingHeader", ImGui_Context ctx, "label", bool &p_visible = 0, int flags = TreeNodeFlags_None)`
Lua	`boolean retval, boolean p_visible = ImGui.CollapsingHeader(ImGui_Context ctx, string label, boolean p_visible = nil, integer flags = TreeNodeFlags_None)`
Python	`(bool retval, bool p_visible) = ImGui.CollapsingHeader(ImGui_Context ctx, str label, bool p_visible = None, int flags = TreeNodeFlags_None)`

Returns true when opened but do not indent nor push into the ID stack (because of the TreeNodeFlags_NoTreePushOnOpen flag).

This is basically the same as calling TreeNode(label, TreeNodeFlags_CollapsingHeader). You can remove the _NoTreePushOnOpen flag if you want behavior closer to normal TreeNode.

When 'visible' is provided: if 'true' display an additional small close button on upper right of the header which will set the bool to false when clicked, if 'false' don't display the header.

View source · v0.1+

Function: GetTreeNodeToLabelSpacing

C++	`double ImGui::GetTreeNodeToLabelSpacing(ImGui_Context* ctx)`
EEL	`double ImGui_GetTreeNodeToLabelSpacing(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetTreeNodeToLabelSpacing", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetTreeNodeToLabelSpacing(ImGui_Context ctx)`
Python	`float retval = ImGui.GetTreeNodeToLabelSpacing(ImGui_Context ctx)`

Horizontal distance preceding label when using TreeNode*() or Bullet() == (GetFontSize + StyleVar_FramePadding.x*2) for a regular unframed TreeNode.

View source · v0.1+

Function: IsItemToggledOpen

C++	`bool ImGui::IsItemToggledOpen(ImGui_Context* ctx)`
EEL	`bool ImGui_IsItemToggledOpen(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsItemToggledOpen", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsItemToggledOpen(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsItemToggledOpen(ImGui_Context ctx)`

Was the last item open state toggled? Set by TreeNode.

View source · v0.1+

Function: SetNextItemOpen

C++	`void ImGui::SetNextItemOpen(ImGui_Context* ctx, bool is_open, int condInOptional = Cond_Always)`
EEL	`ImGui_SetNextItemOpen(ImGui_Context ctx, bool is_open, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetNextItemOpen", ImGui_Context ctx, bool is_open, int cond = Cond_Always)`
Lua	`ImGui.SetNextItemOpen(ImGui_Context ctx, boolean is_open, integer cond = Cond_Always)`
Python	`ImGui.SetNextItemOpen(ImGui_Context ctx, bool is_open, int cond = Cond_Always)`

Set next TreeNode/CollapsingHeader open state. Can also be done with the TreeNodeFlags_DefaultOpen flag.

View source · v0.1+

Function: TreeNode

C++	`bool ImGui::TreeNode(ImGui_Context* ctx, const char* label, int flagsInOptional = TreeNodeFlags_None)`
EEL	`bool ImGui_TreeNode(ImGui_Context ctx, "label", int flags = TreeNodeFlags_None)`
Legacy EEL	`bool extension_api("ImGui_TreeNode", ImGui_Context ctx, "label", int flags = TreeNodeFlags_None)`
Lua	`boolean retval = ImGui.TreeNode(ImGui_Context ctx, string label, integer flags = TreeNodeFlags_None)`
Python	`bool retval = ImGui.TreeNode(ImGui_Context ctx, str label, int flags = TreeNodeFlags_None)`

TreeNode functions return true when the node is open, in which case you need to also call TreePop when you are finished displaying the tree node contents.

View source · v0.1+

Function: TreeNodeEx

C++	`bool ImGui::TreeNodeEx(ImGui_Context* ctx, const char* str_id, const char* label, int flagsInOptional = TreeNodeFlags_None)`
EEL	`bool ImGui_TreeNodeEx(ImGui_Context ctx, "str_id", "label", int flags = TreeNodeFlags_None)`
Legacy EEL	`bool extension_api("ImGui_TreeNodeEx", ImGui_Context ctx, "str_id", "label", int flags = TreeNodeFlags_None)`
Lua	`boolean retval = ImGui.TreeNodeEx(ImGui_Context ctx, string str_id, string label, integer flags = TreeNodeFlags_None)`
Python	`bool retval = ImGui.TreeNodeEx(ImGui_Context ctx, str str_id, str label, int flags = TreeNodeFlags_None)`

Helper variation to easily decorelate the id from the displayed string. Read the FAQ about why and how to use ID. To align arbitrary text at the same level as a TreeNode you can use Bullet.

View source · v0.1+

Function: TreePop

C++	`void ImGui::TreePop(ImGui_Context* ctx)`
EEL	`ImGui_TreePop(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_TreePop", ImGui_Context ctx)`
Lua	`ImGui.TreePop(ImGui_Context ctx)`
Python	`ImGui.TreePop(ImGui_Context ctx)`

Unindent()+PopID()

View source · v0.1+

Function: TreePush

C++	`void ImGui::TreePush(ImGui_Context* ctx, const char* str_id)`
EEL	`ImGui_TreePush(ImGui_Context ctx, "str_id")`
Legacy EEL	`extension_api("ImGui_TreePush", ImGui_Context ctx, "str_id")`
Lua	`ImGui.TreePush(ImGui_Context ctx, string str_id)`
Python	`ImGui.TreePush(ImGui_Context ctx, str str_id)`

Indent()+PushID(). Already called by TreeNode when returning true, but you can call TreePush/TreePop yourself if desired.

View source · v0.1+

Flags

For TreeNode, TreeNodeEx and CollapsingHeader.

Constant: TreeNodeFlags_AllowOverlap

C++	`int ImGui::TreeNodeFlags_AllowOverlap`
EEL	`int ImGui_TreeNodeFlags_AllowOverlap()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_AllowOverlap")`
Lua	`integer ImGui.TreeNodeFlags_AllowOverlap`
Python	`int retval = ImGui.TreeNodeFlags_AllowOverlap()`

Hit testing to allow subsequent widgets to overlap this one.

View source · v0.9+

Constant: TreeNodeFlags_Bullet

C++	`int ImGui::TreeNodeFlags_Bullet`
EEL	`int ImGui_TreeNodeFlags_Bullet()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_Bullet")`
Lua	`integer ImGui.TreeNodeFlags_Bullet`
Python	`int retval = ImGui.TreeNodeFlags_Bullet()`

Display a bullet instead of arrow. IMPORTANT: node can still be marked open/close if you don't set the _Leaf flag!

View source · v0.1+

Constant: TreeNodeFlags_CollapsingHeader

C++	`int ImGui::TreeNodeFlags_CollapsingHeader`
EEL	`int ImGui_TreeNodeFlags_CollapsingHeader()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_CollapsingHeader")`
Lua	`integer ImGui.TreeNodeFlags_CollapsingHeader`
Python	`int retval = ImGui.TreeNodeFlags_CollapsingHeader()`

TreeNodeFlags_Framed | TreeNodeFlags_NoTreePushOnOpen | TreeNodeFlags_NoAutoOpenOnLog

View source · v0.1+

Constant: TreeNodeFlags_DefaultOpen

C++	`int ImGui::TreeNodeFlags_DefaultOpen`
EEL	`int ImGui_TreeNodeFlags_DefaultOpen()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_DefaultOpen")`
Lua	`integer ImGui.TreeNodeFlags_DefaultOpen`
Python	`int retval = ImGui.TreeNodeFlags_DefaultOpen()`

Default node to be open.

View source · v0.1+

Constant: TreeNodeFlags_FramePadding

C++	`int ImGui::TreeNodeFlags_FramePadding`
EEL	`int ImGui_TreeNodeFlags_FramePadding()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_FramePadding")`
Lua	`integer ImGui.TreeNodeFlags_FramePadding`
Python	`int retval = ImGui.TreeNodeFlags_FramePadding()`

Use FramePadding (even for an unframed text node) to vertically align text baseline to regular widget height. Equivalent to calling AlignTextToFramePadding before the node.

View source · v0.1+

Constant: TreeNodeFlags_Framed

C++	`int ImGui::TreeNodeFlags_Framed`
EEL	`int ImGui_TreeNodeFlags_Framed()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_Framed")`
Lua	`integer ImGui.TreeNodeFlags_Framed`
Python	`int retval = ImGui.TreeNodeFlags_Framed()`

Draw frame with background (e.g. for CollapsingHeader).

View source · v0.1+

Constant: TreeNodeFlags_Leaf

C++	`int ImGui::TreeNodeFlags_Leaf`
EEL	`int ImGui_TreeNodeFlags_Leaf()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_Leaf")`
Lua	`integer ImGui.TreeNodeFlags_Leaf`
Python	`int retval = ImGui.TreeNodeFlags_Leaf()`

No collapsing, no arrow (use as a convenience for leaf nodes).

View source · v0.1+

Constant: TreeNodeFlags_NoAutoOpenOnLog

C++	`int ImGui::TreeNodeFlags_NoAutoOpenOnLog`
EEL	`int ImGui_TreeNodeFlags_NoAutoOpenOnLog()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_NoAutoOpenOnLog")`
Lua	`integer ImGui.TreeNodeFlags_NoAutoOpenOnLog`
Python	`int retval = ImGui.TreeNodeFlags_NoAutoOpenOnLog()`

Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes).

View source · v0.1+

Constant: TreeNodeFlags_NoTreePushOnOpen

C++	`int ImGui::TreeNodeFlags_NoTreePushOnOpen`
EEL	`int ImGui_TreeNodeFlags_NoTreePushOnOpen()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_NoTreePushOnOpen")`
Lua	`integer ImGui.TreeNodeFlags_NoTreePushOnOpen`
Python	`int retval = ImGui.TreeNodeFlags_NoTreePushOnOpen()`

Don't do a TreePush when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack.

View source · v0.1+

Constant: TreeNodeFlags_None

C++	`int ImGui::TreeNodeFlags_None`
EEL	`int ImGui_TreeNodeFlags_None()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_None")`
Lua	`integer ImGui.TreeNodeFlags_None`
Python	`int retval = ImGui.TreeNodeFlags_None()`

View source · v0.1+

Constant: TreeNodeFlags_OpenOnArrow

C++	`int ImGui::TreeNodeFlags_OpenOnArrow`
EEL	`int ImGui_TreeNodeFlags_OpenOnArrow()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_OpenOnArrow")`
Lua	`integer ImGui.TreeNodeFlags_OpenOnArrow`
Python	`int retval = ImGui.TreeNodeFlags_OpenOnArrow()`

Only open when clicking on the arrow part. If TreeNodeFlags_OpenOnDoubleClick is also set, single-click arrow or double-click all box to open.

View source · v0.1+

Constant: TreeNodeFlags_OpenOnDoubleClick

C++	`int ImGui::TreeNodeFlags_OpenOnDoubleClick`
EEL	`int ImGui_TreeNodeFlags_OpenOnDoubleClick()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_OpenOnDoubleClick")`
Lua	`integer ImGui.TreeNodeFlags_OpenOnDoubleClick`
Python	`int retval = ImGui.TreeNodeFlags_OpenOnDoubleClick()`

Need double-click to open node.

View source · v0.1+

Constant: TreeNodeFlags_Selected

C++	`int ImGui::TreeNodeFlags_Selected`
EEL	`int ImGui_TreeNodeFlags_Selected()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_Selected")`
Lua	`integer ImGui.TreeNodeFlags_Selected`
Python	`int retval = ImGui.TreeNodeFlags_Selected()`

Draw as selected.

View source · v0.1+

Constant: TreeNodeFlags_SpanAllColumns

C++	`int ImGui::TreeNodeFlags_SpanAllColumns`
EEL	`int ImGui_TreeNodeFlags_SpanAllColumns()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_SpanAllColumns")`
Lua	`integer ImGui.TreeNodeFlags_SpanAllColumns`
Python	`int retval = ImGui.TreeNodeFlags_SpanAllColumns()`

Frame will span all columns of its container table (text will still fit in current column).

View source · v0.9+

Constant: TreeNodeFlags_SpanAvailWidth

C++	`int ImGui::TreeNodeFlags_SpanAvailWidth`
EEL	`int ImGui_TreeNodeFlags_SpanAvailWidth()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_SpanAvailWidth")`
Lua	`integer ImGui.TreeNodeFlags_SpanAvailWidth`
Python	`int retval = ImGui.TreeNodeFlags_SpanAvailWidth()`

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. In the future we may refactor the hit system to be front-to-back, allowing natural overlaps and then this can become the default.

View source · v0.1+

Constant: TreeNodeFlags_SpanFullWidth

C++	`int ImGui::TreeNodeFlags_SpanFullWidth`
EEL	`int ImGui_TreeNodeFlags_SpanFullWidth()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_SpanFullWidth")`
Lua	`integer ImGui.TreeNodeFlags_SpanFullWidth`
Python	`int retval = ImGui.TreeNodeFlags_SpanFullWidth()`

Extend hit box to the left-most and right-most edges (bypass the indented area).

View source · v0.1+

Constant: TreeNodeFlags_SpanTextWidth

C++	`int ImGui::TreeNodeFlags_SpanTextWidth`
EEL	`int ImGui_TreeNodeFlags_SpanTextWidth()`
Legacy EEL	`int extension_api("ImGui_TreeNodeFlags_SpanTextWidth")`
Lua	`integer ImGui.TreeNodeFlags_SpanTextWidth`
Python	`int retval = ImGui.TreeNodeFlags_SpanTextWidth()`

Narrow hit box + narrow hovering highlight, will only cover the label text.

View source · v0.9.1+

Utility

Function: GetBuiltinPath

C++	`const char* ImGui::GetBuiltinPath()`
EEL	`const char* ImGui_GetBuiltinPath()`
Legacy EEL	`const char* extension_api("ImGui_GetBuiltinPath")`
Lua	`string retval = ImGui.GetBuiltinPath()`
Python	`str retval = ImGui.GetBuiltinPath()`

Returns the path to the directory containing imgui.lua, imgui.py and gfx2imgui.lua.

View source · v0.9+

Function: GetVersion

C++	`void ImGui::GetVersion(char* imgui_versionOut, int imgui_versionOut_sz, int* imgui_version_numOut, char* reaimgui_versionOut, int reaimgui_versionOut_sz)`
EEL	`ImGui_GetVersion(#imgui_version, int &imgui_version_num, #reaimgui_version)`
Legacy EEL	`extension_api("ImGui_GetVersion", #imgui_version, int &imgui_version_num, #reaimgui_version)`
Lua	`string imgui_version, integer imgui_version_num, string reaimgui_version = ImGui.GetVersion()`
Python	`(str imgui_version, int imgui_version_num, str reaimgui_version) = ImGui.GetVersion()`

View source · v0.7+

Function: NumericLimits_Double

C++	`void ImGui::NumericLimits_Double(double* minOut, double* maxOut)`
EEL	`ImGui_NumericLimits_Double(&min, &max)`
Legacy EEL	`extension_api("ImGui_NumericLimits_Double", &min, &max)`
Lua	`number min, number max = ImGui.NumericLimits_Double()`
Python	`(float min, float max) = ImGui.NumericLimits_Double()`

Returns DBL_MIN and DBL_MAX for this system.

View source · v0.8.4+

Function: NumericLimits_Float

C++	`void ImGui::NumericLimits_Float(double* minOut, double* maxOut)`
EEL	`ImGui_NumericLimits_Float(&min, &max)`
Legacy EEL	`extension_api("ImGui_NumericLimits_Float", &min, &max)`
Lua	`number min, number max = ImGui.NumericLimits_Float()`
Python	`(float min, float max) = ImGui.NumericLimits_Float()`

Returns FLT_MIN and FLT_MAX for this system.

View source · v0.4+

Function: NumericLimits_Int

C++	`void ImGui::NumericLimits_Int(int* minOut, int* maxOut)`
EEL	`ImGui_NumericLimits_Int(int &min, int &max)`
Legacy EEL	`extension_api("ImGui_NumericLimits_Int", int &min, int &max)`
Lua	`integer min, integer max = ImGui.NumericLimits_Int()`
Python	`(int min, int max) = ImGui.NumericLimits_Int()`

Returns INT_MIN and INT_MAX for this system.

View source · v0.8.4+

Function: PointConvertNative

C++	`void ImGui::PointConvertNative(ImGui_Context* ctx, double* xInOut, double* yInOut, bool to_nativeInOptional = false)`
EEL	`ImGui_PointConvertNative(ImGui_Context ctx, &x, &y, bool to_native = false)`
Legacy EEL	`extension_api("ImGui_PointConvertNative", ImGui_Context ctx, &x, &y, bool to_native = false)`
Lua	`number x, number y = ImGui.PointConvertNative(ImGui_Context ctx, number x, number y, boolean to_native = false)`
Python	`(float x, float y) = ImGui.PointConvertNative(ImGui_Context ctx, float x, float y, bool to_native = false)`

Convert a position from the current platform's native coordinate position system to ReaImGui global coordinates (or vice versa).

This effectively flips the Y coordinate on macOS and applies HiDPI scaling on Windows and Linux.

View source · v0.5.1+

Function: ProgressBar

C++	`void ImGui::ProgressBar(ImGui_Context* ctx, double fraction, double size_arg_wInOptional = -FLT_MIN, double size_arg_hInOptional = 0.0, const char* overlayInOptional = nullptr)`
EEL	`ImGui_ProgressBar(ImGui_Context ctx, fraction, size_arg_w = -FLT_MIN, size_arg_h = 0.0, "overlay" = 0)`
Legacy EEL	`extension_api("ImGui_ProgressBar", ImGui_Context ctx, fraction, size_arg_w = -FLT_MIN, size_arg_h = 0.0, "overlay" = 0)`
Lua	`ImGui.ProgressBar(ImGui_Context ctx, number fraction, number size_arg_w = -FLT_MIN, number size_arg_h = 0.0, string overlay = nil)`
Python	`ImGui.ProgressBar(ImGui_Context ctx, float fraction, float size_arg_w = -FLT_MIN, float size_arg_h = 0.0, str overlay = None)`

Fraction < 0.0 displays an indeterminate progress bar animation since v0.9.1. The value must be animated along with time, for example -1.0 * ImGui.GetTime().

View source · v0.1+

Function: ValidatePtr

C++	`bool ImGui::ValidatePtr(void* pointer, const char* type)`
EEL	`bool ImGui_ValidatePtr(void pointer, "type")`
Legacy EEL	`bool extension_api("ImGui_ValidatePtr", void pointer, "type")`
Lua	`boolean retval = ImGui.ValidatePtr(userdata pointer, string type)`
Python	`bool retval = ImGui.ValidatePtr(void pointer, str type)`

Return whether the given pointer is a valid instance of one of the following types (indentation represents inheritance):

ImGui_Context*
ImGui_DrawList*
ImGui_DrawListSplitter*
ImGui_Font*
ImGui_Function*
ImGui_Image*
- ImGui_ImageSet*
ImGui_ListClipper*
ImGui_TextFilter*
ImGui_Viewport*

View source · v0.3+

Clipboard

Function: GetClipboardText

C++	`const char* ImGui::GetClipboardText(ImGui_Context* ctx)`
EEL	`const char* ImGui_GetClipboardText(ImGui_Context ctx)`
Legacy EEL	`const char* extension_api("ImGui_GetClipboardText", ImGui_Context ctx)`
Lua	`string retval = ImGui.GetClipboardText(ImGui_Context ctx)`
Python	`str retval = ImGui.GetClipboardText(ImGui_Context ctx)`

View source · v0.1+

Function: SetClipboardText

C++	`void ImGui::SetClipboardText(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_SetClipboardText(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_SetClipboardText", ImGui_Context ctx, "text")`
Lua	`ImGui.SetClipboardText(ImGui_Context ctx, string text)`
Python	`ImGui.SetClipboardText(ImGui_Context ctx, str text)`

See also the LogToClipboard function to capture GUI into clipboard, or easily output text data to the clipboard.

View source · v0.1+

Color Conversion

Function: ColorConvertDouble4ToU32

C++	`int ImGui::ColorConvertDouble4ToU32(double r, double g, double b, double a)`
EEL	`int ImGui_ColorConvertDouble4ToU32(r, g, b, a)`
Legacy EEL	`int extension_api("ImGui_ColorConvertDouble4ToU32", r, g, b, a)`
Lua	`integer retval = ImGui.ColorConvertDouble4ToU32(number r, number g, number b, number a)`
Python	`int retval = ImGui.ColorConvertDouble4ToU32(float r, float g, float b, float a)`

Pack 0..1 RGBA values into a 32-bit integer (0xRRGGBBAA).

View source · v0.7+

Function: ColorConvertHSVtoRGB

C++	`void ImGui::ColorConvertHSVtoRGB(double h, double s, double v, double* rOut, double* gOut, double* bOut)`
EEL	`ImGui_ColorConvertHSVtoRGB(h, s, v, &r, &g, &b)`
Legacy EEL	`extension_api("ImGui_ColorConvertHSVtoRGB", h, s, v, &r, &g, &b)`
Lua	`number r, number g, number b = ImGui.ColorConvertHSVtoRGB(number h, number s, number v)`
Python	`(float r, float g, float b) = ImGui.ColorConvertHSVtoRGB(float h, float s, float v)`

Convert HSV values (0..1) into RGB (0..1).

View source · v0.7+

Function: ColorConvertNative

C++	`int ImGui::ColorConvertNative(int rgb)`
EEL	`int ImGui_ColorConvertNative(int rgb)`
Legacy EEL	`int extension_api("ImGui_ColorConvertNative", int rgb)`
Lua	`integer retval = ImGui.ColorConvertNative(integer rgb)`
Python	`int retval = ImGui.ColorConvertNative(int rgb)`

Convert a native color coming from REAPER or 0xRRGGBB to native. This swaps the red and blue channels on Windows.

View source · v0.3+

Function: ColorConvertRGBtoHSV

C++	`void ImGui::ColorConvertRGBtoHSV(double r, double g, double b, double* hOut, double* sOut, double* vOut)`
EEL	`ImGui_ColorConvertRGBtoHSV(r, g, b, &h, &s, &v)`
Legacy EEL	`extension_api("ImGui_ColorConvertRGBtoHSV", r, g, b, &h, &s, &v)`
Lua	`number h, number s, number v = ImGui.ColorConvertRGBtoHSV(number r, number g, number b)`
Python	`(float h, float s, float v) = ImGui.ColorConvertRGBtoHSV(float r, float g, float b)`

Convert RGB values (0..1) into HSV (0..1).

View source · v0.7+

Function: ColorConvertU32ToDouble4

C++	`void ImGui::ColorConvertU32ToDouble4(int rgba, double* rOut, double* gOut, double* bOut, double* aOut)`
EEL	`ImGui_ColorConvertU32ToDouble4(int rgba, &r, &g, &b, &a)`
Legacy EEL	`extension_api("ImGui_ColorConvertU32ToDouble4", int rgba, &r, &g, &b, &a)`
Lua	`number r, number g, number b, number a = ImGui.ColorConvertU32ToDouble4(integer rgba)`
Python	`(float r, float g, float b, float a) = ImGui.ColorConvertU32ToDouble4(int rgba)`

Unpack a 32-bit integer (0xRRGGBBAA) into separate RGBA values (0..1).

View source · v0.7+

Conditions

Used for SetNextWindow*(), SetWindow*() and SetNextItem*() functions.

Constant: Cond_Always

C++	`int ImGui::Cond_Always`
EEL	`int ImGui_Cond_Always()`
Legacy EEL	`int extension_api("ImGui_Cond_Always")`
Lua	`integer ImGui.Cond_Always`
Python	`int retval = ImGui.Cond_Always()`

No condition (always set the variable).

View source · v0.1+

Constant: Cond_Appearing

C++	`int ImGui::Cond_Appearing`
EEL	`int ImGui_Cond_Appearing()`
Legacy EEL	`int extension_api("ImGui_Cond_Appearing")`
Lua	`integer ImGui.Cond_Appearing`
Python	`int retval = ImGui.Cond_Appearing()`

Set the variable if the object/window is appearing after being hidden/inactive (or the first time).

View source · v0.1+

Constant: Cond_FirstUseEver

C++	`int ImGui::Cond_FirstUseEver`
EEL	`int ImGui_Cond_FirstUseEver()`
Legacy EEL	`int extension_api("ImGui_Cond_FirstUseEver")`
Lua	`integer ImGui.Cond_FirstUseEver`
Python	`int retval = ImGui.Cond_FirstUseEver()`

Set the variable if the object/window has no persistently saved data (no entry in .ini file).

View source · v0.1+

Constant: Cond_Once

C++	`int ImGui::Cond_Once`
EEL	`int ImGui_Cond_Once()`
Legacy EEL	`int extension_api("ImGui_Cond_Once")`
Lua	`integer ImGui.Cond_Once`
Python	`int retval = ImGui.Cond_Once()`

Set the variable once per runtime session (only the first call will succeed).

View source · v0.1+

ID Stack/Scope

Read the FAQ for more details about how IDs are handled in dear imgui.

Those questions are answered and impacted by understanding of the ID stack system:
- "Q: Why is my widget not reacting when I click on it?"
- "Q: How can I have widgets with an empty label?"
- "Q: How can I have multiple widgets with the same label?"
Short version: ID are hashes of the entire ID stack. If you are creating widgets in a loop you most likely want to push a unique identifier (e.g. object pointer, loop index) to uniquely differentiate them.
You can also use the "Label##foobar" syntax within widget label to distinguish them from each others.
We use the "label"/"name" terminology to denote a string that will be displayed + used as an ID, whereas "str_id" denote a string that is only used as an ID and not normally displayed.

Function: PopID

C++	`void ImGui::PopID(ImGui_Context* ctx)`
EEL	`ImGui_PopID(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_PopID", ImGui_Context ctx)`
Lua	`ImGui.PopID(ImGui_Context ctx)`
Python	`ImGui.PopID(ImGui_Context ctx)`

Pop from the ID stack.

View source · v0.1+

Function: PushID

C++	`void ImGui::PushID(ImGui_Context* ctx, const char* str_id)`
EEL	`ImGui_PushID(ImGui_Context ctx, "str_id")`
Legacy EEL	`extension_api("ImGui_PushID", ImGui_Context ctx, "str_id")`
Lua	`ImGui.PushID(ImGui_Context ctx, string str_id)`
Python	`ImGui.PushID(ImGui_Context ctx, str str_id)`

Push string into the ID stack.

View source · v0.1+

Logging/Capture

All text output from the interface can be captured into tty/file/clipboard. By default, tree nodes are automatically opened during logging.

Function: LogFinish

C++	`void ImGui::LogFinish(ImGui_Context* ctx)`
EEL	`ImGui_LogFinish(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_LogFinish", ImGui_Context ctx)`
Lua	`ImGui.LogFinish(ImGui_Context ctx)`
Python	`ImGui.LogFinish(ImGui_Context ctx)`

Stop logging (close file, etc.)

View source · v0.1+

Function: LogText

C++	`void ImGui::LogText(ImGui_Context* ctx, const char* text)`
EEL	`ImGui_LogText(ImGui_Context ctx, "text")`
Legacy EEL	`extension_api("ImGui_LogText", ImGui_Context ctx, "text")`
Lua	`ImGui.LogText(ImGui_Context ctx, string text)`
Python	`ImGui.LogText(ImGui_Context ctx, str text)`

Pass text data straight to log (without being displayed)

View source · v0.1+

Function: LogToClipboard

C++	`void ImGui::LogToClipboard(ImGui_Context* ctx, int auto_open_depthInOptional = -1)`
EEL	`ImGui_LogToClipboard(ImGui_Context ctx, int auto_open_depth = -1)`
Legacy EEL	`extension_api("ImGui_LogToClipboard", ImGui_Context ctx, int auto_open_depth = -1)`
Lua	`ImGui.LogToClipboard(ImGui_Context ctx, integer auto_open_depth = -1)`
Python	`ImGui.LogToClipboard(ImGui_Context ctx, int auto_open_depth = -1)`

Start logging all text output from the interface to the OS clipboard. See also SetClipboardText.

View source · v0.1+

Function: LogToFile

C++	`void ImGui::LogToFile(ImGui_Context* ctx, int auto_open_depthInOptional = -1, const char* filenameInOptional = nullptr)`
EEL	`ImGui_LogToFile(ImGui_Context ctx, int auto_open_depth = -1, "filename" = 0)`
Legacy EEL	`extension_api("ImGui_LogToFile", ImGui_Context ctx, int auto_open_depth = -1, "filename" = 0)`
Lua	`ImGui.LogToFile(ImGui_Context ctx, integer auto_open_depth = -1, string filename = nil)`
Python	`ImGui.LogToFile(ImGui_Context ctx, int auto_open_depth = -1, str filename = None)`

Start logging all text output from the interface to a file. The data is saved to $resource_path/imgui_log.txt if filename is nil.

View source · v0.1+

Function: LogToTTY

C++	`void ImGui::LogToTTY(ImGui_Context* ctx, int auto_open_depthInOptional = -1)`
EEL	`ImGui_LogToTTY(ImGui_Context ctx, int auto_open_depth = -1)`
Legacy EEL	`extension_api("ImGui_LogToTTY", ImGui_Context ctx, int auto_open_depth = -1)`
Lua	`ImGui.LogToTTY(ImGui_Context ctx, integer auto_open_depth = -1)`
Python	`ImGui.LogToTTY(ImGui_Context ctx, int auto_open_depth = -1)`

Start logging all text output from the interface to the TTY (stdout).

View source · v0.1+

Viewport

Function: GetMainViewport

C++	`ImGui_Viewport* ImGui::GetMainViewport(ImGui_Context* ctx)`
EEL	`ImGui_Viewport* ImGui_GetMainViewport(ImGui_Context ctx)`
Legacy EEL	`ImGui_Viewport* extension_api("ImGui_GetMainViewport", ImGui_Context ctx)`
Lua	`ImGui_Viewport retval = ImGui.GetMainViewport(ImGui_Context ctx)`
Python	`ImGui_Viewport retval = ImGui.GetMainViewport(ImGui_Context ctx)`

Currently represents REAPER's main window (arrange view). WARNING: This may change or be removed in the future.

View source · v0.1+

Function: GetWindowViewport

C++	`ImGui_Viewport* ImGui::GetWindowViewport(ImGui_Context* ctx)`
EEL	`ImGui_Viewport* ImGui_GetWindowViewport(ImGui_Context ctx)`
Legacy EEL	`ImGui_Viewport* extension_api("ImGui_GetWindowViewport", ImGui_Context ctx)`
Lua	`ImGui_Viewport retval = ImGui.GetWindowViewport(ImGui_Context ctx)`
Python	`ImGui_Viewport retval = ImGui.GetWindowViewport(ImGui_Context ctx)`

Get viewport currently associated to the current window.

View source · v0.7+

Function: Viewport_GetCenter

C++	`void ImGui::Viewport_GetCenter(ImGui_Viewport* viewport, double* xOut, double* yOut)`
EEL	`ImGui_Viewport_GetCenter(ImGui_Viewport viewport, &x, &y)`
Legacy EEL	`extension_api("ImGui_Viewport_GetCenter", ImGui_Viewport viewport, &x, &y)`
Lua	`number x, number y = ImGui.Viewport_GetCenter(ImGui_Viewport viewport)`
Python	`(float x, float y) = ImGui.Viewport_GetCenter(ImGui_Viewport viewport)`

Center of the viewport.

View source · v0.1+

Function: Viewport_GetPos

C++	`void ImGui::Viewport_GetPos(ImGui_Viewport* viewport, double* xOut, double* yOut)`
EEL	`ImGui_Viewport_GetPos(ImGui_Viewport viewport, &x, &y)`
Legacy EEL	`extension_api("ImGui_Viewport_GetPos", ImGui_Viewport viewport, &x, &y)`
Lua	`number x, number y = ImGui.Viewport_GetPos(ImGui_Viewport viewport)`
Python	`(float x, float y) = ImGui.Viewport_GetPos(ImGui_Viewport viewport)`

Main Area: Position of the viewport

View source · v0.1+

Function: Viewport_GetSize

C++	`void ImGui::Viewport_GetSize(ImGui_Viewport* viewport, double* wOut, double* hOut)`
EEL	`ImGui_Viewport_GetSize(ImGui_Viewport viewport, &w, &h)`
Legacy EEL	`extension_api("ImGui_Viewport_GetSize", ImGui_Viewport viewport, &w, &h)`
Lua	`number w, number h = ImGui.Viewport_GetSize(ImGui_Viewport viewport)`
Python	`(float w, float h) = ImGui.Viewport_GetSize(ImGui_Viewport viewport)`

Main Area: Size of the viewport.

View source · v0.1+

Work Area

Viewport minus task bars, menu bars, status bars

Function: Viewport_GetWorkCenter

C++	`void ImGui::Viewport_GetWorkCenter(ImGui_Viewport* viewport, double* xOut, double* yOut)`
EEL	`ImGui_Viewport_GetWorkCenter(ImGui_Viewport viewport, &x, &y)`
Legacy EEL	`extension_api("ImGui_Viewport_GetWorkCenter", ImGui_Viewport viewport, &x, &y)`
Lua	`number x, number y = ImGui.Viewport_GetWorkCenter(ImGui_Viewport viewport)`
Python	`(float x, float y) = ImGui.Viewport_GetWorkCenter(ImGui_Viewport viewport)`

Center of the viewport's work area.

View source · v0.1+

Function: Viewport_GetWorkPos

C++	`void ImGui::Viewport_GetWorkPos(ImGui_Viewport* viewport, double* xOut, double* yOut)`
EEL	`ImGui_Viewport_GetWorkPos(ImGui_Viewport viewport, &x, &y)`
Legacy EEL	`extension_api("ImGui_Viewport_GetWorkPos", ImGui_Viewport viewport, &x, &y)`
Lua	`number x, number y = ImGui.Viewport_GetWorkPos(ImGui_Viewport viewport)`
Python	`(float x, float y) = ImGui.Viewport_GetWorkPos(ImGui_Viewport viewport)`

= Viewport_GetPos

View source · v0.1+

Function: Viewport_GetWorkSize

C++	`void ImGui::Viewport_GetWorkSize(ImGui_Viewport* viewport, double* wOut, double* hOut)`
EEL	`ImGui_Viewport_GetWorkSize(ImGui_Viewport viewport, &w, &h)`
Legacy EEL	`extension_api("ImGui_Viewport_GetWorkSize", ImGui_Viewport viewport, &w, &h)`
Lua	`number w, number h = ImGui.Viewport_GetWorkSize(ImGui_Viewport viewport)`
Python	`(float w, float h) = ImGui.Viewport_GetWorkSize(ImGui_Viewport viewport)`

<= Viewport_GetSize

View source · v0.1+

Window

Functions for creating and manipulating windows. Note that the bottom of the window stack always contains a window called "Debug".

Function: Begin

C++	`bool ImGui::Begin(ImGui_Context* ctx, const char* name, bool* p_openInOutOptional = nullptr, int flagsInOptional = WindowFlags_None)`
EEL	`bool ImGui_Begin(ImGui_Context ctx, "name", bool &p_open = 0, int flags = WindowFlags_None)`
Legacy EEL	`bool extension_api("ImGui_Begin", ImGui_Context ctx, "name", bool &p_open = 0, int flags = WindowFlags_None)`
Lua	`boolean retval, boolean p_open = ImGui.Begin(ImGui_Context ctx, string name, boolean p_open = nil, integer flags = WindowFlags_None)`
Python	`(bool retval, bool p_open) = ImGui.Begin(ImGui_Context ctx, str name, bool p_open = None, int flags = WindowFlags_None)`

Push window to the stack and start appending to it.

Passing true to 'p_open' shows a window-closing widget in the upper-right corner of the window, which clicking will set the boolean to false when returned.
You may append multiple times to the same window during the same frame by calling Begin()/End() pairs multiple times. Some information such as 'flags' or 'p_open' will only be considered by the first call to Begin().
Begin() return false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window.

View source · v0.5+

Function: End

C++	`void ImGui::End(ImGui_Context* ctx)`
EEL	`ImGui_End(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_End", ImGui_Context ctx)`
Lua	`ImGui.End(ImGui_Context ctx)`
Python	`ImGui.End(ImGui_Context ctx)`

Pop window from the stack. See Begin.

View source · v0.8+

Child Windows

Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child.

Function: BeginChild

C++	`bool ImGui::BeginChild(ImGui_Context* ctx, const char* str_id, double size_wInOptional = 0.0, double size_hInOptional = 0.0, int child_flagsInOptional = ChildFlags_None, int window_flagsInOptional = WindowFlags_None)`
EEL	`bool ImGui_BeginChild(ImGui_Context ctx, "str_id", size_w = 0.0, size_h = 0.0, int child_flags = ChildFlags_None, int window_flags = WindowFlags_None)`
Legacy EEL	`bool extension_api("ImGui_BeginChild", ImGui_Context ctx, "str_id", size_w = 0.0, size_h = 0.0, int child_flags = ChildFlags_None, int window_flags = WindowFlags_None)`
Lua	`boolean retval = ImGui.BeginChild(ImGui_Context ctx, string str_id, number size_w = 0.0, number size_h = 0.0, integer child_flags = ChildFlags_None, integer window_flags = WindowFlags_None)`
Python	`bool retval = ImGui.BeginChild(ImGui_Context ctx, str str_id, float size_w = 0.0, float size_h = 0.0, int child_flags = ChildFlags_None, int window_flags = WindowFlags_None)`

Manual sizing (each axis can use a different setting e.g. size_w=0 and size_h=400):

= 0.0: use remaining parent window size for this axis
> 0.0: use specified size for this axis
< 0.0: right/bottom-align to specified distance from available content boundaries

Specifying ChildFlags_AutoResizeX or ChildFlags_AutoResizeY makes the sizing automatic based on child contents.

Combining both ChildFlags_AutoResizeX and ChildFlags_AutoResizeY defeats purpose of a scrolling region and is NOT recommended.

Returns false to indicate the window is collapsed or fully clipped.

View source · v0.9+

Function: EndChild

C++	`void ImGui::EndChild(ImGui_Context* ctx)`
EEL	`ImGui_EndChild(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_EndChild", ImGui_Context ctx)`
Lua	`ImGui.EndChild(ImGui_Context ctx)`
Python	`ImGui.EndChild(ImGui_Context ctx)`

See BeginChild.

View source · v0.8+

Child Flags

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 ChildFlags_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.

Constant: ChildFlags_AlwaysAutoResize

C++	`int ImGui::ChildFlags_AlwaysAutoResize`
EEL	`int ImGui_ChildFlags_AlwaysAutoResize()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_AlwaysAutoResize")`
Lua	`integer ImGui.ChildFlags_AlwaysAutoResize`
Python	`int retval = ImGui.ChildFlags_AlwaysAutoResize()`

Combined with AutoResizeX/AutoResizeY. Always measure size even when child is hidden, always return true, always disable clipping optimization! NOT RECOMMENDED.

View source · v0.9+

Constant: ChildFlags_AlwaysUseWindowPadding

C++	`int ImGui::ChildFlags_AlwaysUseWindowPadding`
EEL	`int ImGui_ChildFlags_AlwaysUseWindowPadding()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_AlwaysUseWindowPadding")`
Lua	`integer ImGui.ChildFlags_AlwaysUseWindowPadding`
Python	`int retval = ImGui.ChildFlags_AlwaysUseWindowPadding()`

Pad with StyleVar_WindowPadding even if no border are drawn (no padding by default for non-bordered child windows because it makes more sense).

View source · v0.9+

Constant: ChildFlags_AutoResizeX

C++	`int ImGui::ChildFlags_AutoResizeX`
EEL	`int ImGui_ChildFlags_AutoResizeX()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_AutoResizeX")`
Lua	`integer ImGui.ChildFlags_AutoResizeX`
Python	`int retval = ImGui.ChildFlags_AutoResizeX()`

Enable auto-resizing width. Read notes above.

View source · v0.9+

Constant: ChildFlags_AutoResizeY

C++	`int ImGui::ChildFlags_AutoResizeY`
EEL	`int ImGui_ChildFlags_AutoResizeY()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_AutoResizeY")`
Lua	`integer ImGui.ChildFlags_AutoResizeY`
Python	`int retval = ImGui.ChildFlags_AutoResizeY()`

Enable auto-resizing height. Read notes above.

View source · v0.9+

Constant: ChildFlags_Border

C++	`int ImGui::ChildFlags_Border`
EEL	`int ImGui_ChildFlags_Border()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_Border")`
Lua	`integer ImGui.ChildFlags_Border`
Python	`int retval = ImGui.ChildFlags_Border()`

Show an outer border and enable WindowPadding.

View source · v0.9+

Constant: ChildFlags_FrameStyle

C++	`int ImGui::ChildFlags_FrameStyle`
EEL	`int ImGui_ChildFlags_FrameStyle()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_FrameStyle")`
Lua	`integer ImGui.ChildFlags_FrameStyle`
Python	`int retval = ImGui.ChildFlags_FrameStyle()`

Style the child window like a framed item: use Col_FrameBg, StyleVar_FrameRounding, StyleVar_FrameBorderSize, StyleVar_FramePadding instead of Col_ChildBg, StyleVar_ChildRounding, StyleVar_ChildBorderSize, StyleVar_WindowPadding.

View source · v0.9+

Constant: ChildFlags_NavFlattened

C++	`int ImGui::ChildFlags_NavFlattened`
EEL	`int ImGui_ChildFlags_NavFlattened()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_NavFlattened")`
Lua	`integer ImGui.ChildFlags_NavFlattened`
Python	`int retval = ImGui.ChildFlags_NavFlattened()`

Share focus scope, allow gamepad/keyboard navigation to cross over parent border to this child or between sibling child windows.

View source · v0.9.2+

Constant: ChildFlags_None

C++	`int ImGui::ChildFlags_None`
EEL	`int ImGui_ChildFlags_None()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_None")`
Lua	`integer ImGui.ChildFlags_None`
Python	`int retval = ImGui.ChildFlags_None()`

View source · v0.9+

Constant: ChildFlags_ResizeX

C++	`int ImGui::ChildFlags_ResizeX`
EEL	`int ImGui_ChildFlags_ResizeX()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_ResizeX")`
Lua	`integer ImGui.ChildFlags_ResizeX`
Python	`int retval = ImGui.ChildFlags_ResizeX()`

Allow resize from right border (layout direction). Enables .ini saving (unless WindowFlags_NoSavedSettings passed to window flags).

View source · v0.9+

Constant: ChildFlags_ResizeY

C++	`int ImGui::ChildFlags_ResizeY`
EEL	`int ImGui_ChildFlags_ResizeY()`
Legacy EEL	`int extension_api("ImGui_ChildFlags_ResizeY")`
Lua	`integer ImGui.ChildFlags_ResizeY`
Python	`int retval = ImGui.ChildFlags_ResizeY()`

Allow resize from bottom border (layout direction). Enables .ini saving (unless WindowFlags_NoSavedSettings passed to window flags).

View source · v0.9+

Content Region

Retrieve available space from a given point. GetContentRegionAvail() is frequently useful.

Function: GetContentRegionAvail

C++	`void ImGui::GetContentRegionAvail(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetContentRegionAvail(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetContentRegionAvail", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetContentRegionAvail(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetContentRegionAvail(ImGui_Context ctx)`

== GetContentRegionMax() - GetCursorPos()

View source · v0.1+

Function: GetContentRegionMax

C++	`void ImGui::GetContentRegionMax(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetContentRegionMax(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetContentRegionMax", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetContentRegionMax(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetContentRegionMax(ImGui_Context ctx)`

Current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates.

View source · v0.1+

Function: GetWindowContentRegionMax

C++	`void ImGui::GetWindowContentRegionMax(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetWindowContentRegionMax(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetWindowContentRegionMax", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetWindowContentRegionMax(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetWindowContentRegionMax(ImGui_Context ctx)`

Content boundaries max (roughly (0,0)+Size-Scroll) where Size can be overridden with SetNextWindowContentSize, in window coordinates.

View source · v0.1+

Function: GetWindowContentRegionMin

C++	`void ImGui::GetWindowContentRegionMin(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetWindowContentRegionMin(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetWindowContentRegionMin", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetWindowContentRegionMin(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetWindowContentRegionMin(ImGui_Context ctx)`

Content boundaries min (roughly (0,0)-Scroll), in window coordinates.

View source · v0.1+

Debug Windows

Function: ShowAboutWindow

C++	`void ImGui::ShowAboutWindow(ImGui_Context* ctx, bool* p_openInOutOptional = nullptr)`
EEL	`ImGui_ShowAboutWindow(ImGui_Context ctx, bool &p_open = 0)`
Legacy EEL	`extension_api("ImGui_ShowAboutWindow", ImGui_Context ctx, bool &p_open = 0)`
Lua	`boolean p_open = ImGui.ShowAboutWindow(ImGui_Context ctx, boolean p_open = nil)`
Python	`(bool p_open) = ImGui.ShowAboutWindow(ImGui_Context ctx, bool p_open = None)`

Create About window. Display ReaImGui version, Dear ImGui version, credits and build/system information.

View source · v0.5.4+

Function: ShowDebugLogWindow

C++	`void ImGui::ShowDebugLogWindow(ImGui_Context* ctx, bool* p_openInOutOptional = nullptr)`
EEL	`ImGui_ShowDebugLogWindow(ImGui_Context ctx, bool &p_open = 0)`
Legacy EEL	`extension_api("ImGui_ShowDebugLogWindow", ImGui_Context ctx, bool &p_open = 0)`
Lua	`boolean p_open = ImGui.ShowDebugLogWindow(ImGui_Context ctx, boolean p_open = nil)`
Python	`(bool p_open) = ImGui.ShowDebugLogWindow(ImGui_Context ctx, bool p_open = None)`

Create Debug Log window. display a simplified log of important dear imgui events.

View source · v0.7+

Function: ShowIDStackToolWindow

C++	`void ImGui::ShowIDStackToolWindow(ImGui_Context* ctx, bool* p_openInOutOptional = nullptr)`
EEL	`ImGui_ShowIDStackToolWindow(ImGui_Context ctx, bool &p_open = 0)`
Legacy EEL	`extension_api("ImGui_ShowIDStackToolWindow", ImGui_Context ctx, bool &p_open = 0)`
Lua	`boolean p_open = ImGui.ShowIDStackToolWindow(ImGui_Context ctx, boolean p_open = nil)`
Python	`(bool p_open) = ImGui.ShowIDStackToolWindow(ImGui_Context ctx, bool p_open = None)`

Create Stack Tool window. Hover items with mouse to query information about the source of their unique ID.

View source · v0.9+

Function: ShowMetricsWindow

C++	`void ImGui::ShowMetricsWindow(ImGui_Context* ctx, bool* p_openInOutOptional = nullptr)`
EEL	`ImGui_ShowMetricsWindow(ImGui_Context ctx, bool &p_open = 0)`
Legacy EEL	`extension_api("ImGui_ShowMetricsWindow", ImGui_Context ctx, bool &p_open = 0)`
Lua	`boolean p_open = ImGui.ShowMetricsWindow(ImGui_Context ctx, boolean p_open = nil)`
Python	`(bool p_open) = ImGui.ShowMetricsWindow(ImGui_Context ctx, bool p_open = None)`

Create Metrics/Debugger window. Display Dear ImGui internals: windows, draw commands, various internal state, etc.

View source · v0.1+

Docking

Dock windows into other windows or in REAPER dockers.

Dock IDs are:

0 = undocked
-1 to -16 = REAPER docker index
> 0 = Dear ImGui dockspace ID (when the user docked the window into another one).

Drag from window title bar or their tab to dock/undock. Hold SHIFT to disable docking. Drag from window menu button (upper-left button) to undock an entire node (all windows). DockingWithShift == true, you instead need to hold SHIFT to enable docking.

Function: GetWindowDockID

C++	`int ImGui::GetWindowDockID(ImGui_Context* ctx)`
EEL	`int ImGui_GetWindowDockID(ImGui_Context ctx)`
Legacy EEL	`int extension_api("ImGui_GetWindowDockID", ImGui_Context ctx)`
Lua	`integer retval = ImGui.GetWindowDockID(ImGui_Context ctx)`
Python	`int retval = ImGui.GetWindowDockID(ImGui_Context ctx)`

View source · v0.5+

Function: IsWindowDocked

C++	`bool ImGui::IsWindowDocked(ImGui_Context* ctx)`
EEL	`bool ImGui_IsWindowDocked(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsWindowDocked", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsWindowDocked(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsWindowDocked(ImGui_Context ctx)`

Is current window docked into another window or a REAPER docker?

View source · v0.5+

Function: SetNextWindowDockID

C++	`void ImGui::SetNextWindowDockID(ImGui_Context* ctx, int dock_id, int condInOptional = Cond_Always)`
EEL	`ImGui_SetNextWindowDockID(ImGui_Context ctx, int dock_id, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetNextWindowDockID", ImGui_Context ctx, int dock_id, int cond = Cond_Always)`
Lua	`ImGui.SetNextWindowDockID(ImGui_Context ctx, integer dock_id, integer cond = Cond_Always)`
Python	`ImGui.SetNextWindowDockID(ImGui_Context ctx, int dock_id, int cond = Cond_Always)`

View source · v0.5+

Flags

For Begin and BeginChild.

(Those are per-window flags. There are shared flags in SetConfigVar: ConfigVar_WindowsResizeFromEdges and ConfigVar_WindowsMoveFromTitleBarOnly)

Constant: WindowFlags_AlwaysAutoResize

C++	`int ImGui::WindowFlags_AlwaysAutoResize`
EEL	`int ImGui_WindowFlags_AlwaysAutoResize()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_AlwaysAutoResize")`
Lua	`integer ImGui.WindowFlags_AlwaysAutoResize`
Python	`int retval = ImGui.WindowFlags_AlwaysAutoResize()`

Resize every window to its content every frame.

View source · v0.1+

Constant: WindowFlags_AlwaysHorizontalScrollbar

C++	`int ImGui::WindowFlags_AlwaysHorizontalScrollbar`
EEL	`int ImGui_WindowFlags_AlwaysHorizontalScrollbar()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_AlwaysHorizontalScrollbar")`
Lua	`integer ImGui.WindowFlags_AlwaysHorizontalScrollbar`
Python	`int retval = ImGui.WindowFlags_AlwaysHorizontalScrollbar()`

Always show horizontal scrollbar (even if ContentSize.x < Size.x).

View source · v0.1+

Constant: WindowFlags_AlwaysVerticalScrollbar

C++	`int ImGui::WindowFlags_AlwaysVerticalScrollbar`
EEL	`int ImGui_WindowFlags_AlwaysVerticalScrollbar()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_AlwaysVerticalScrollbar")`
Lua	`integer ImGui.WindowFlags_AlwaysVerticalScrollbar`
Python	`int retval = ImGui.WindowFlags_AlwaysVerticalScrollbar()`

Always show vertical scrollbar (even if ContentSize.y < Size.y).

View source · v0.1+

Constant: WindowFlags_HorizontalScrollbar

C++	`int ImGui::WindowFlags_HorizontalScrollbar`
EEL	`int ImGui_WindowFlags_HorizontalScrollbar()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_HorizontalScrollbar")`
Lua	`integer ImGui.WindowFlags_HorizontalScrollbar`
Python	`int retval = ImGui.WindowFlags_HorizontalScrollbar()`

Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(width, 0.0) prior to calling Begin() to specify width. Read code in the demo's "Horizontal Scrolling" section.

View source · v0.1+

Constant: WindowFlags_MenuBar

C++	`int ImGui::WindowFlags_MenuBar`
EEL	`int ImGui_WindowFlags_MenuBar()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_MenuBar")`
Lua	`integer ImGui.WindowFlags_MenuBar`
Python	`int retval = ImGui.WindowFlags_MenuBar()`

Has a menu-bar.

View source · v0.1+

Constant: WindowFlags_NoBackground

C++	`int ImGui::WindowFlags_NoBackground`
EEL	`int ImGui_WindowFlags_NoBackground()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoBackground")`
Lua	`integer ImGui.WindowFlags_NoBackground`
Python	`int retval = ImGui.WindowFlags_NoBackground()`

Disable drawing background color (WindowBg, etc.) and outside border. Similar as using SetNextWindowBgAlpha(0.0).

View source · v0.1+

Constant: WindowFlags_NoCollapse

C++	`int ImGui::WindowFlags_NoCollapse`
EEL	`int ImGui_WindowFlags_NoCollapse()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoCollapse")`
Lua	`integer ImGui.WindowFlags_NoCollapse`
Python	`int retval = ImGui.WindowFlags_NoCollapse()`

Disable user collapsing window by double-clicking on it. Also referred to as Window Menu Button (e.g. within a docking node).

View source · v0.1+

Constant: WindowFlags_NoDecoration

C++	`int ImGui::WindowFlags_NoDecoration`
EEL	`int ImGui_WindowFlags_NoDecoration()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoDecoration")`
Lua	`integer ImGui.WindowFlags_NoDecoration`
Python	`int retval = ImGui.WindowFlags_NoDecoration()`

WindowFlags_NoTitleBar | WindowFlags_NoResize | WindowFlags_NoScrollbar | WindowFlags_NoCollapse

View source · v0.1+

Constant: WindowFlags_NoDocking

C++	`int ImGui::WindowFlags_NoDocking`
EEL	`int ImGui_WindowFlags_NoDocking()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoDocking")`
Lua	`integer ImGui.WindowFlags_NoDocking`
Python	`int retval = ImGui.WindowFlags_NoDocking()`

Disable docking of this window.

View source · v0.5+

Constant: WindowFlags_NoFocusOnAppearing

C++	`int ImGui::WindowFlags_NoFocusOnAppearing`
EEL	`int ImGui_WindowFlags_NoFocusOnAppearing()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoFocusOnAppearing")`
Lua	`integer ImGui.WindowFlags_NoFocusOnAppearing`
Python	`int retval = ImGui.WindowFlags_NoFocusOnAppearing()`

Disable taking focus when transitioning from hidden to visible state.

View source · v0.1+

Constant: WindowFlags_NoInputs

C++	`int ImGui::WindowFlags_NoInputs`
EEL	`int ImGui_WindowFlags_NoInputs()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoInputs")`
Lua	`integer ImGui.WindowFlags_NoInputs`
Python	`int retval = ImGui.WindowFlags_NoInputs()`

WindowFlags_NoMouseInputs | WindowFlags_NoNavInputs | WindowFlags_NoNavFocus

View source · v0.1+

Constant: WindowFlags_NoMouseInputs

C++	`int ImGui::WindowFlags_NoMouseInputs`
EEL	`int ImGui_WindowFlags_NoMouseInputs()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoMouseInputs")`
Lua	`integer ImGui.WindowFlags_NoMouseInputs`
Python	`int retval = ImGui.WindowFlags_NoMouseInputs()`

Disable catching mouse, hovering test with pass through.

View source · v0.1+

Constant: WindowFlags_NoMove

C++	`int ImGui::WindowFlags_NoMove`
EEL	`int ImGui_WindowFlags_NoMove()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoMove")`
Lua	`integer ImGui.WindowFlags_NoMove`
Python	`int retval = ImGui.WindowFlags_NoMove()`

Disable user moving the window.

View source · v0.1+

Constant: WindowFlags_NoNav

C++	`int ImGui::WindowFlags_NoNav`
EEL	`int ImGui_WindowFlags_NoNav()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoNav")`
Lua	`integer ImGui.WindowFlags_NoNav`
Python	`int retval = ImGui.WindowFlags_NoNav()`

WindowFlags_NoNavInputs | WindowFlags_NoNavFocus

View source · v0.1+

Constant: WindowFlags_NoNavFocus

C++	`int ImGui::WindowFlags_NoNavFocus`
EEL	`int ImGui_WindowFlags_NoNavFocus()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoNavFocus")`
Lua	`integer ImGui.WindowFlags_NoNavFocus`
Python	`int retval = ImGui.WindowFlags_NoNavFocus()`

No focusing toward this window with gamepad/keyboard navigation (e.g. skipped by CTRL+TAB).

View source · v0.1+

Constant: WindowFlags_NoNavInputs

C++	`int ImGui::WindowFlags_NoNavInputs`
EEL	`int ImGui_WindowFlags_NoNavInputs()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoNavInputs")`
Lua	`integer ImGui.WindowFlags_NoNavInputs`
Python	`int retval = ImGui.WindowFlags_NoNavInputs()`

No gamepad/keyboard navigation within the window.

View source · v0.1+

Constant: WindowFlags_NoResize

C++	`int ImGui::WindowFlags_NoResize`
EEL	`int ImGui_WindowFlags_NoResize()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoResize")`
Lua	`integer ImGui.WindowFlags_NoResize`
Python	`int retval = ImGui.WindowFlags_NoResize()`

Disable user resizing with the lower-right grip.

View source · v0.1+

Constant: WindowFlags_NoSavedSettings

C++	`int ImGui::WindowFlags_NoSavedSettings`
EEL	`int ImGui_WindowFlags_NoSavedSettings()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoSavedSettings")`
Lua	`integer ImGui.WindowFlags_NoSavedSettings`
Python	`int retval = ImGui.WindowFlags_NoSavedSettings()`

Never load/save settings in .ini file.

View source · v0.4+

Constant: WindowFlags_NoScrollWithMouse

C++	`int ImGui::WindowFlags_NoScrollWithMouse`
EEL	`int ImGui_WindowFlags_NoScrollWithMouse()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoScrollWithMouse")`
Lua	`integer ImGui.WindowFlags_NoScrollWithMouse`
Python	`int retval = ImGui.WindowFlags_NoScrollWithMouse()`

Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set.

View source · v0.1+

Constant: WindowFlags_NoScrollbar

C++	`int ImGui::WindowFlags_NoScrollbar`
EEL	`int ImGui_WindowFlags_NoScrollbar()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoScrollbar")`
Lua	`integer ImGui.WindowFlags_NoScrollbar`
Python	`int retval = ImGui.WindowFlags_NoScrollbar()`

Disable scrollbars (window can still scroll with mouse or programmatically).

View source · v0.1+

Constant: WindowFlags_NoTitleBar

C++	`int ImGui::WindowFlags_NoTitleBar`
EEL	`int ImGui_WindowFlags_NoTitleBar()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_NoTitleBar")`
Lua	`integer ImGui.WindowFlags_NoTitleBar`
Python	`int retval = ImGui.WindowFlags_NoTitleBar()`

Disable title-bar.

View source · v0.1+

Constant: WindowFlags_None

C++	`int ImGui::WindowFlags_None`
EEL	`int ImGui_WindowFlags_None()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_None")`
Lua	`integer ImGui.WindowFlags_None`
Python	`int retval = ImGui.WindowFlags_None()`

Default flag.

View source · v0.1+

Constant: WindowFlags_TopMost

C++	`int ImGui::WindowFlags_TopMost`
EEL	`int ImGui_WindowFlags_TopMost()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_TopMost")`
Lua	`integer ImGui.WindowFlags_TopMost`
Python	`int retval = ImGui.WindowFlags_TopMost()`

Show the window above all non-topmost windows.

View source · v0.5.5+

Constant: WindowFlags_UnsavedDocument

C++	`int ImGui::WindowFlags_UnsavedDocument`
EEL	`int ImGui_WindowFlags_UnsavedDocument()`
Legacy EEL	`int extension_api("ImGui_WindowFlags_UnsavedDocument")`
Lua	`integer ImGui.WindowFlags_UnsavedDocument`
Python	`int retval = ImGui.WindowFlags_UnsavedDocument()`

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.

View source · v0.1+

Properties

Prefer using SetNextWindow* functions (before Begin) rather that SetWindow* functions (after Begin).

'Current window' = the window we are appending into while inside a Begin()/End() block. 'Next window' = next window we will Begin() into.

Function: GetWindowDpiScale

C++	`double ImGui::GetWindowDpiScale(ImGui_Context* ctx)`
EEL	`double ImGui_GetWindowDpiScale(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetWindowDpiScale", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetWindowDpiScale(ImGui_Context ctx)`
Python	`float retval = ImGui.GetWindowDpiScale(ImGui_Context ctx)`

Get DPI scale currently associated to the current window's viewport (1.0 = 96 DPI).

View source · v0.7.2+

Function: GetWindowHeight

C++	`double ImGui::GetWindowHeight(ImGui_Context* ctx)`
EEL	`double ImGui_GetWindowHeight(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetWindowHeight", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetWindowHeight(ImGui_Context ctx)`
Python	`float retval = ImGui.GetWindowHeight(ImGui_Context ctx)`

Get current window height (shortcut for (GetWindowSize().h).

View source · v0.1+

Function: GetWindowPos

C++	`void ImGui::GetWindowPos(ImGui_Context* ctx, double* xOut, double* yOut)`
EEL	`ImGui_GetWindowPos(ImGui_Context ctx, &x, &y)`
Legacy EEL	`extension_api("ImGui_GetWindowPos", ImGui_Context ctx, &x, &y)`
Lua	`number x, number y = ImGui.GetWindowPos(ImGui_Context ctx)`
Python	`(float x, float y) = ImGui.GetWindowPos(ImGui_Context ctx)`

Get current window position in screen space (note: it is unlikely you need to use this. Consider using current layout pos instead, GetCursorScreenPos()).

View source · v0.1+

Function: GetWindowSize

C++	`void ImGui::GetWindowSize(ImGui_Context* ctx, double* wOut, double* hOut)`
EEL	`ImGui_GetWindowSize(ImGui_Context ctx, &w, &h)`
Legacy EEL	`extension_api("ImGui_GetWindowSize", ImGui_Context ctx, &w, &h)`
Lua	`number w, number h = ImGui.GetWindowSize(ImGui_Context ctx)`
Python	`(float w, float h) = ImGui.GetWindowSize(ImGui_Context ctx)`

Get current window size (note: it is unlikely you need to use this. Consider using GetCursorScreenPos() and e.g. GetContentRegionAvail() instead)

View source · v0.1+

Function: GetWindowWidth

C++	`double ImGui::GetWindowWidth(ImGui_Context* ctx)`
EEL	`double ImGui_GetWindowWidth(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetWindowWidth", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetWindowWidth(ImGui_Context ctx)`
Python	`float retval = ImGui.GetWindowWidth(ImGui_Context ctx)`

Get current window width (shortcut for (GetWindowSize().w).

View source · v0.1+

Function: IsWindowAppearing

C++	`bool ImGui::IsWindowAppearing(ImGui_Context* ctx)`
EEL	`bool ImGui_IsWindowAppearing(ImGui_Context ctx)`
Legacy EEL	`bool extension_api("ImGui_IsWindowAppearing", ImGui_Context ctx)`
Lua	`boolean retval = ImGui.IsWindowAppearing(ImGui_Context ctx)`
Python	`bool retval = ImGui.IsWindowAppearing(ImGui_Context ctx)`

Use after Begin/BeginPopup/BeginPopupModal to tell if a window just opened.

View source · v0.1+

Function: IsWindowFocused

C++	`bool ImGui::IsWindowFocused(ImGui_Context* ctx, int flagsInOptional = FocusedFlags_None)`
EEL	`bool ImGui_IsWindowFocused(ImGui_Context ctx, int flags = FocusedFlags_None)`
Legacy EEL	`bool extension_api("ImGui_IsWindowFocused", ImGui_Context ctx, int flags = FocusedFlags_None)`
Lua	`boolean retval = ImGui.IsWindowFocused(ImGui_Context ctx, integer flags = FocusedFlags_None)`
Python	`bool retval = ImGui.IsWindowFocused(ImGui_Context ctx, int flags = FocusedFlags_None)`

Is current window focused? or its root/child, depending on flags. See flags for options.

View source · v0.1+

Function: IsWindowHovered

C++	`bool ImGui::IsWindowHovered(ImGui_Context* ctx, int flagsInOptional = HoveredFlags_None)`
EEL	`bool ImGui_IsWindowHovered(ImGui_Context ctx, int flags = HoveredFlags_None)`
Legacy EEL	`bool extension_api("ImGui_IsWindowHovered", ImGui_Context ctx, int flags = HoveredFlags_None)`
Lua	`boolean retval = ImGui.IsWindowHovered(ImGui_Context ctx, integer flags = HoveredFlags_None)`
Python	`bool retval = ImGui.IsWindowHovered(ImGui_Context ctx, int flags = HoveredFlags_None)`

Is current window hovered and hoverable (e.g. not blocked by a popup/modal)? See HoveredFlags_* for options.

View source · v0.9+

Function: SetNextWindowBgAlpha

C++	`void ImGui::SetNextWindowBgAlpha(ImGui_Context* ctx, double alpha)`
EEL	`ImGui_SetNextWindowBgAlpha(ImGui_Context ctx, alpha)`
Legacy EEL	`extension_api("ImGui_SetNextWindowBgAlpha", ImGui_Context ctx, alpha)`
Lua	`ImGui.SetNextWindowBgAlpha(ImGui_Context ctx, number alpha)`
Python	`ImGui.SetNextWindowBgAlpha(ImGui_Context ctx, float alpha)`

Set next window background color alpha. Helper to easily override the Alpha component of Col_WindowBg/Col_ChildBg/Col_PopupBg. You may also use WindowFlags_NoBackground for a fully transparent window.

View source · v0.1+

Function: SetNextWindowCollapsed

C++	`void ImGui::SetNextWindowCollapsed(ImGui_Context* ctx, bool collapsed, int condInOptional = Cond_Always)`
EEL	`ImGui_SetNextWindowCollapsed(ImGui_Context ctx, bool collapsed, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetNextWindowCollapsed", ImGui_Context ctx, bool collapsed, int cond = Cond_Always)`
Lua	`ImGui.SetNextWindowCollapsed(ImGui_Context ctx, boolean collapsed, integer cond = Cond_Always)`
Python	`ImGui.SetNextWindowCollapsed(ImGui_Context ctx, bool collapsed, int cond = Cond_Always)`

Set next window collapsed state.

View source · v0.1+

Function: SetNextWindowContentSize

C++	`void ImGui::SetNextWindowContentSize(ImGui_Context* ctx, double size_w, double size_h)`
EEL	`ImGui_SetNextWindowContentSize(ImGui_Context ctx, size_w, size_h)`
Legacy EEL	`extension_api("ImGui_SetNextWindowContentSize", ImGui_Context ctx, size_w, size_h)`
Lua	`ImGui.SetNextWindowContentSize(ImGui_Context ctx, number size_w, number size_h)`
Python	`ImGui.SetNextWindowContentSize(ImGui_Context ctx, float size_w, float size_h)`

Set next window content size (~ scrollable client area, which enforce the range of scrollbars). Not including window decorations (title bar, menu bar, etc.) nor StyleVar_WindowPadding. set an axis to 0.0 to leave it automatic.

View source · v0.1+

Function: SetNextWindowFocus

C++	`void ImGui::SetNextWindowFocus(ImGui_Context* ctx)`
EEL	`ImGui_SetNextWindowFocus(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_SetNextWindowFocus", ImGui_Context ctx)`
Lua	`ImGui.SetNextWindowFocus(ImGui_Context ctx)`
Python	`ImGui.SetNextWindowFocus(ImGui_Context ctx)`

Set next window to be focused / top-most.

View source · v0.1+

Function: SetNextWindowPos

C++	`void ImGui::SetNextWindowPos(ImGui_Context* ctx, double pos_x, double pos_y, int condInOptional = Cond_Always, double pivot_xInOptional = 0.0, double pivot_yInOptional = 0.0)`
EEL	`ImGui_SetNextWindowPos(ImGui_Context ctx, pos_x, pos_y, int cond = Cond_Always, pivot_x = 0.0, pivot_y = 0.0)`
Legacy EEL	`extension_api("ImGui_SetNextWindowPos", ImGui_Context ctx, pos_x, pos_y, int cond = Cond_Always, pivot_x = 0.0, pivot_y = 0.0)`
Lua	`ImGui.SetNextWindowPos(ImGui_Context ctx, number pos_x, number pos_y, integer cond = Cond_Always, number pivot_x = 0.0, number pivot_y = 0.0)`
Python	`ImGui.SetNextWindowPos(ImGui_Context ctx, float pos_x, float pos_y, int cond = Cond_Always, float pivot_x = 0.0, float pivot_y = 0.0)`

Set next window position. Use pivot=(0.5,0.5) to center on given point, etc.

View source · v0.1+

Function: SetNextWindowScroll

C++	`void ImGui::SetNextWindowScroll(ImGui_Context* ctx, double scroll_x, double scroll_y)`
EEL	`ImGui_SetNextWindowScroll(ImGui_Context ctx, scroll_x, scroll_y)`
Legacy EEL	`extension_api("ImGui_SetNextWindowScroll", ImGui_Context ctx, scroll_x, scroll_y)`
Lua	`ImGui.SetNextWindowScroll(ImGui_Context ctx, number scroll_x, number scroll_y)`
Python	`ImGui.SetNextWindowScroll(ImGui_Context ctx, float scroll_x, float scroll_y)`

Set next window scrolling value (use < 0.0 to not affect a given axis).

View source · v0.1+

Function: SetNextWindowSize

C++	`void ImGui::SetNextWindowSize(ImGui_Context* ctx, double size_w, double size_h, int condInOptional = Cond_Always)`
EEL	`ImGui_SetNextWindowSize(ImGui_Context ctx, size_w, size_h, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetNextWindowSize", ImGui_Context ctx, size_w, size_h, int cond = Cond_Always)`
Lua	`ImGui.SetNextWindowSize(ImGui_Context ctx, number size_w, number size_h, integer cond = Cond_Always)`
Python	`ImGui.SetNextWindowSize(ImGui_Context ctx, float size_w, float size_h, int cond = Cond_Always)`

Set next window size. set axis to 0.0 to force an auto-fit on this axis.

View source · v0.1+

Function: SetNextWindowSizeConstraints

C++	`void ImGui::SetNextWindowSizeConstraints(ImGui_Context* ctx, double size_min_w, double size_min_h, double size_max_w, double size_max_h, ImGui_Function* custom_callbackInOptional = nullptr)`
EEL	`ImGui_SetNextWindowSizeConstraints(ImGui_Context ctx, size_min_w, size_min_h, size_max_w, size_max_h, ImGui_Function custom_callback = 0)`
Legacy EEL	`extension_api("ImGui_SetNextWindowSizeConstraints", ImGui_Context ctx, size_min_w, size_min_h, size_max_w, size_max_h, ImGui_Function custom_callback = 0)`
Lua	`ImGui.SetNextWindowSizeConstraints(ImGui_Context ctx, number size_min_w, number size_min_h, number size_max_w, number size_max_h, ImGui_Function custom_callback = nil)`
Python	`ImGui.SetNextWindowSizeConstraints(ImGui_Context ctx, float size_min_w, float size_min_h, float size_max_w, float size_max_h, ImGui_Function custom_callback = None)`

Set next window size limits. Use 0.0 or FLT_MAX (second return value of NumericLimits_Float) if you don't want limits.

Use -1 for both min and max of same axis to preserve current size (which itself is a constraint).

Use callback to apply non-trivial programmatic constraints.

View source · v0.8.5+

Function: SetWindowCollapsed

C++	`void ImGui::SetWindowCollapsed(ImGui_Context* ctx, bool collapsed, int condInOptional = Cond_Always)`
EEL	`ImGui_SetWindowCollapsed(ImGui_Context ctx, bool collapsed, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetWindowCollapsed", ImGui_Context ctx, bool collapsed, int cond = Cond_Always)`
Lua	`ImGui.SetWindowCollapsed(ImGui_Context ctx, boolean collapsed, integer cond = Cond_Always)`
Python	`ImGui.SetWindowCollapsed(ImGui_Context ctx, bool collapsed, int cond = Cond_Always)`

(Not recommended) Set current window collapsed state. Prefer using SetNextWindowCollapsed.

View source · v0.5+

Function: SetWindowCollapsedEx

C++	`void ImGui::SetWindowCollapsedEx(ImGui_Context* ctx, const char* name, bool collapsed, int condInOptional = Cond_Always)`
EEL	`ImGui_SetWindowCollapsedEx(ImGui_Context ctx, "name", bool collapsed, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetWindowCollapsedEx", ImGui_Context ctx, "name", bool collapsed, int cond = Cond_Always)`
Lua	`ImGui.SetWindowCollapsedEx(ImGui_Context ctx, string name, boolean collapsed, integer cond = Cond_Always)`
Python	`ImGui.SetWindowCollapsedEx(ImGui_Context ctx, str name, bool collapsed, int cond = Cond_Always)`

Set named window collapsed state.

View source · v0.5+

Function: SetWindowFocus

C++	`void ImGui::SetWindowFocus(ImGui_Context* ctx)`
EEL	`ImGui_SetWindowFocus(ImGui_Context ctx)`
Legacy EEL	`extension_api("ImGui_SetWindowFocus", ImGui_Context ctx)`
Lua	`ImGui.SetWindowFocus(ImGui_Context ctx)`
Python	`ImGui.SetWindowFocus(ImGui_Context ctx)`

(Not recommended) Set current window to be focused / top-most. Prefer using SetNextWindowFocus.

View source · v0.5+

Function: SetWindowFocusEx

C++	`void ImGui::SetWindowFocusEx(ImGui_Context* ctx, const char* name)`
EEL	`ImGui_SetWindowFocusEx(ImGui_Context ctx, "name")`
Legacy EEL	`extension_api("ImGui_SetWindowFocusEx", ImGui_Context ctx, "name")`
Lua	`ImGui.SetWindowFocusEx(ImGui_Context ctx, string name)`
Python	`ImGui.SetWindowFocusEx(ImGui_Context ctx, str name)`

Set named window to be focused / top-most. Use an empty name to remove focus.

View source · v0.5+

Function: SetWindowPos

C++	`void ImGui::SetWindowPos(ImGui_Context* ctx, double pos_x, double pos_y, int condInOptional = Cond_Always)`
EEL	`ImGui_SetWindowPos(ImGui_Context ctx, pos_x, pos_y, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetWindowPos", ImGui_Context ctx, pos_x, pos_y, int cond = Cond_Always)`
Lua	`ImGui.SetWindowPos(ImGui_Context ctx, number pos_x, number pos_y, integer cond = Cond_Always)`
Python	`ImGui.SetWindowPos(ImGui_Context ctx, float pos_x, float pos_y, int cond = Cond_Always)`

(Not recommended) Set current window position - call within Begin/End. Prefer using SetNextWindowPos, as this may incur tearing and minor side-effects.

View source · v0.5+

Function: SetWindowPosEx

C++	`void ImGui::SetWindowPosEx(ImGui_Context* ctx, const char* name, double pos_x, double pos_y, int condInOptional = Cond_Always)`
EEL	`ImGui_SetWindowPosEx(ImGui_Context ctx, "name", pos_x, pos_y, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetWindowPosEx", ImGui_Context ctx, "name", pos_x, pos_y, int cond = Cond_Always)`
Lua	`ImGui.SetWindowPosEx(ImGui_Context ctx, string name, number pos_x, number pos_y, integer cond = Cond_Always)`
Python	`ImGui.SetWindowPosEx(ImGui_Context ctx, str name, float pos_x, float pos_y, int cond = Cond_Always)`

Set named window position.

View source · v0.5+

Function: SetWindowSize

C++	`void ImGui::SetWindowSize(ImGui_Context* ctx, double size_w, double size_h, int condInOptional = Cond_Always)`
EEL	`ImGui_SetWindowSize(ImGui_Context ctx, size_w, size_h, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetWindowSize", ImGui_Context ctx, size_w, size_h, int cond = Cond_Always)`
Lua	`ImGui.SetWindowSize(ImGui_Context ctx, number size_w, number size_h, integer cond = Cond_Always)`
Python	`ImGui.SetWindowSize(ImGui_Context ctx, float size_w, float size_h, int cond = Cond_Always)`

(Not recommended) Set current window size - call within Begin/End. Set size_w and size_h to 0 to force an auto-fit. Prefer using SetNextWindowSize, as this may incur tearing and minor side-effects.

View source · v0.5+

Function: SetWindowSizeEx

C++	`void ImGui::SetWindowSizeEx(ImGui_Context* ctx, const char* name, double size_w, double size_h, int condInOptional = Cond_Always)`
EEL	`ImGui_SetWindowSizeEx(ImGui_Context ctx, "name", size_w, size_h, int cond = Cond_Always)`
Legacy EEL	`extension_api("ImGui_SetWindowSizeEx", ImGui_Context ctx, "name", size_w, size_h, int cond = Cond_Always)`
Lua	`ImGui.SetWindowSizeEx(ImGui_Context ctx, string name, number size_w, number size_h, integer cond = Cond_Always)`
Python	`ImGui.SetWindowSizeEx(ImGui_Context ctx, str name, float size_w, float size_h, int cond = Cond_Always)`

Set named window size. Set axis to 0.0 to force an auto-fit on this axis.

View source · v0.5+

Focused Flags

For IsWindowFocused.

Constant: FocusedFlags_AnyWindow

C++	`int ImGui::FocusedFlags_AnyWindow`
EEL	`int ImGui_FocusedFlags_AnyWindow()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_AnyWindow")`
Lua	`integer ImGui.FocusedFlags_AnyWindow`
Python	`int retval = ImGui.FocusedFlags_AnyWindow()`

Return true if any window is focused.

View source · v0.1+

Constant: FocusedFlags_ChildWindows

C++	`int ImGui::FocusedFlags_ChildWindows`
EEL	`int ImGui_FocusedFlags_ChildWindows()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_ChildWindows")`
Lua	`integer ImGui.FocusedFlags_ChildWindows`
Python	`int retval = ImGui.FocusedFlags_ChildWindows()`

Return true if any children of the window is focused.

View source · v0.1+

Constant: FocusedFlags_DockHierarchy

C++	`int ImGui::FocusedFlags_DockHierarchy`
EEL	`int ImGui_FocusedFlags_DockHierarchy()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_DockHierarchy")`
Lua	`integer ImGui.FocusedFlags_DockHierarchy`
Python	`int retval = ImGui.FocusedFlags_DockHierarchy()`

Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow).

View source · v0.5.10+

Constant: FocusedFlags_NoPopupHierarchy

C++	`int ImGui::FocusedFlags_NoPopupHierarchy`
EEL	`int ImGui_FocusedFlags_NoPopupHierarchy()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_NoPopupHierarchy")`
Lua	`integer ImGui.FocusedFlags_NoPopupHierarchy`
Python	`int retval = ImGui.FocusedFlags_NoPopupHierarchy()`

Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow).

View source · v0.5.10+

Constant: FocusedFlags_None

C++	`int ImGui::FocusedFlags_None`
EEL	`int ImGui_FocusedFlags_None()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_None")`
Lua	`integer ImGui.FocusedFlags_None`
Python	`int retval = ImGui.FocusedFlags_None()`

View source · v0.1+

Constant: FocusedFlags_RootAndChildWindows

C++	`int ImGui::FocusedFlags_RootAndChildWindows`
EEL	`int ImGui_FocusedFlags_RootAndChildWindows()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_RootAndChildWindows")`
Lua	`integer ImGui.FocusedFlags_RootAndChildWindows`
Python	`int retval = ImGui.FocusedFlags_RootAndChildWindows()`

FocusedFlags_RootWindow | FocusedFlags_ChildWindows

View source · v0.1+

Constant: FocusedFlags_RootWindow

C++	`int ImGui::FocusedFlags_RootWindow`
EEL	`int ImGui_FocusedFlags_RootWindow()`
Legacy EEL	`int extension_api("ImGui_FocusedFlags_RootWindow")`
Lua	`integer ImGui.FocusedFlags_RootWindow`
Python	`int retval = ImGui.FocusedFlags_RootWindow()`

Test from root window (top most parent of the current hierarchy).

View source · v0.1+

Size Callback

For SetNextWindowSizeConstraints.

Variable: CurrentSize

EEL	`double CurrentSize.x, CurrentSize.y`

Read-only. Current window size.

View source · v0.8.5+

Variable: DesiredSize

EEL	`double DesiredSize.x, DesiredSize.y`

Read-write. Desired size, based on user's mouse position. Write to this field to restrain resizing.

View source · v0.8.5+

Variable: Pos

EEL	`double Pos.x, Pos.y`

Read-only. Window position, for reference.

View source · v0.8.5+

Scrolling

Any change of Scroll will be applied at the beginning of next frame in the first call to Begin().

You may instead use SetNextWindowScroll() prior to calling Begin() to avoid this delay, as an alternative to using SetScrollX()/SetScrollY().

Function: GetScrollMaxX

C++	`double ImGui::GetScrollMaxX(ImGui_Context* ctx)`
EEL	`double ImGui_GetScrollMaxX(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetScrollMaxX", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetScrollMaxX(ImGui_Context ctx)`
Python	`float retval = ImGui.GetScrollMaxX(ImGui_Context ctx)`

Get maximum scrolling amount ~~ ContentSize.x - WindowSize.x - DecorationsSize.x

View source · v0.1+

Function: GetScrollMaxY

C++	`double ImGui::GetScrollMaxY(ImGui_Context* ctx)`
EEL	`double ImGui_GetScrollMaxY(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetScrollMaxY", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetScrollMaxY(ImGui_Context ctx)`
Python	`float retval = ImGui.GetScrollMaxY(ImGui_Context ctx)`

Get maximum scrolling amount ~~ ContentSize.y - WindowSize.y - DecorationsSize.y

View source · v0.1+

Function: GetScrollX

C++	`double ImGui::GetScrollX(ImGui_Context* ctx)`
EEL	`double ImGui_GetScrollX(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetScrollX", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetScrollX(ImGui_Context ctx)`
Python	`float retval = ImGui.GetScrollX(ImGui_Context ctx)`

Get scrolling amount [0 .. GetScrollMaxX()]

View source · v0.1+

Function: GetScrollY

C++	`double ImGui::GetScrollY(ImGui_Context* ctx)`
EEL	`double ImGui_GetScrollY(ImGui_Context ctx)`
Legacy EEL	`double extension_api("ImGui_GetScrollY", ImGui_Context ctx)`
Lua	`number retval = ImGui.GetScrollY(ImGui_Context ctx)`
Python	`float retval = ImGui.GetScrollY(ImGui_Context ctx)`

Get scrolling amount [0 .. GetScrollMaxY()]

View source · v0.1+

Function: SetScrollFromPosX

C++	`void ImGui::SetScrollFromPosX(ImGui_Context* ctx, double local_x, double center_x_ratioInOptional = 0.5)`
EEL	`ImGui_SetScrollFromPosX(ImGui_Context ctx, local_x, center_x_ratio = 0.5)`
Legacy EEL	`extension_api("ImGui_SetScrollFromPosX", ImGui_Context ctx, local_x, center_x_ratio = 0.5)`
Lua	`ImGui.SetScrollFromPosX(ImGui_Context ctx, number local_x, number center_x_ratio = 0.5)`
Python	`ImGui.SetScrollFromPosX(ImGui_Context ctx, float local_x, float center_x_ratio = 0.5)`

Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.

View source · v0.1+

Function: SetScrollFromPosY

C++	`void ImGui::SetScrollFromPosY(ImGui_Context* ctx, double local_y, double center_y_ratioInOptional = 0.5)`
EEL	`ImGui_SetScrollFromPosY(ImGui_Context ctx, local_y, center_y_ratio = 0.5)`
Legacy EEL	`extension_api("ImGui_SetScrollFromPosY", ImGui_Context ctx, local_y, center_y_ratio = 0.5)`
Lua	`ImGui.SetScrollFromPosY(ImGui_Context ctx, number local_y, number center_y_ratio = 0.5)`
Python	`ImGui.SetScrollFromPosY(ImGui_Context ctx, float local_y, float center_y_ratio = 0.5)`

Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.

View source · v0.1+

Function: SetScrollHereX

C++	`void ImGui::SetScrollHereX(ImGui_Context* ctx, double center_x_ratioInOptional = 0.5)`
EEL	`ImGui_SetScrollHereX(ImGui_Context ctx, center_x_ratio = 0.5)`
Legacy EEL	`extension_api("ImGui_SetScrollHereX", ImGui_Context ctx, center_x_ratio = 0.5)`
Lua	`ImGui.SetScrollHereX(ImGui_Context ctx, number center_x_ratio = 0.5)`
Python	`ImGui.SetScrollHereX(ImGui_Context ctx, float center_x_ratio = 0.5)`

Adjust scrolling amount to make current cursor position visible. center_x_ratio=0.0: left, 0.5: center, 1.0: right. When using to make a "default/current item" visible, consider using SetItemDefaultFocus instead.

View source · v0.1+

Function: SetScrollHereY

C++	`void ImGui::SetScrollHereY(ImGui_Context* ctx, double center_y_ratioInOptional = 0.5)`
EEL	`ImGui_SetScrollHereY(ImGui_Context ctx, center_y_ratio = 0.5)`
Legacy EEL	`extension_api("ImGui_SetScrollHereY", ImGui_Context ctx, center_y_ratio = 0.5)`
Lua	`ImGui.SetScrollHereY(ImGui_Context ctx, number center_y_ratio = 0.5)`
Python	`ImGui.SetScrollHereY(ImGui_Context ctx, float center_y_ratio = 0.5)`

Adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom. When using to make a "default/current item" visible, consider using SetItemDefaultFocus instead.

View source · v0.1+

Function: SetScrollX

C++	`void ImGui::SetScrollX(ImGui_Context* ctx, double scroll_x)`
EEL	`ImGui_SetScrollX(ImGui_Context ctx, scroll_x)`
Legacy EEL	`extension_api("ImGui_SetScrollX", ImGui_Context ctx, scroll_x)`
Lua	`ImGui.SetScrollX(ImGui_Context ctx, number scroll_x)`
Python	`ImGui.SetScrollX(ImGui_Context ctx, float scroll_x)`

Set scrolling amount [0 .. GetScrollMaxX()]

View source · v0.1+

Function: SetScrollY

C++	`void ImGui::SetScrollY(ImGui_Context* ctx, double scroll_y)`
EEL	`ImGui_SetScrollY(ImGui_Context ctx, scroll_y)`
Legacy EEL	`extension_api("ImGui_SetScrollY", ImGui_Context ctx, scroll_y)`
Lua	`ImGui.SetScrollY(ImGui_Context ctx, number scroll_y)`
Python	`ImGui.SetScrollY(ImGui_Context ctx, float scroll_y)`

Set scrolling amount [0 .. GetScrollMaxY()]

View source · v0.1+

EOF

ReaImGui Documentation

Table of Contents

Button

Cardinal Directions

Flags

Color Edit

Flags

User Options

Combo & List

Combo Box (Dropdown)

List Boxes

Selectables

Context

Flags

Options

Drag & Drop

Flags

Payload

Source

Drag & Slider

Drag Sliders

Flags

Regular Sliders

Draw List

Primitives

Splitter

Stateful Path

Font

Function

Image

Image Set

Item & Status

Dimensions

Focus & Activation

Hovered Flags

For IsItemHovered

Mouse Hovering Delays

For IsWindowHovered

Item/Widgets Utilities and Query Functions

Keyboard & Mouse

Keyboard

Named Keys

Keyboard

Modifiers

Mouse Buttons

Mouse

Mouse Cursor

Shortcuts

Flags

Routing policies

Layout

Clipping

Layout Cursor Positioning

List Clipper

Menu

Plot

Popup & Modal

Flags

For BeginPopupContext*

For IsPopupOpen

For OpenPopup* and BeginPopupContext*

Open+Begin Combined Helpers

Tooltips

Style

Colors

Variables

Tab Bar

Tab Item

Table

Background

Header & Columns

Column Flags

Input Configuration

Output Status

Sorting

Table Flags

Clipping

Decorations

Features

Miscellaneous