struct ImGui::ImGuiIO

• ImGui::ImGuiIO
• Struct
• Value
• Object

Overview

struct ImGuiIO

Included Modules

• ImGui::ClassType(LibImGui::ImGuiIO)

Defined in:

obj.cr

Constructors

• .new : ImGuiIO

  ImGuiIO::ImGuiIO()

Instance Method Summary

• #add_focus_event(focused : Bool) : Void

  Queue a gain/loss of focus for the application (generally based on OS/platform focus of your window)

• #add_input_character(c : UInt32) : Void

  Queue a new character input

• #add_input_character_utf16(c : ImWchar16) : Void

  Queue a new character input from a UTF-16 character, it can be a surrogate

• #add_input_characters_utf8(str : String) : Void

  Queue a new characters input from a UTF-8 string

• #add_key_analog_event(key : ImGuiKey, down : Bool, v : Float32) : Void

  Queue a new key down/up event for analog values (e.g.

• #add_key_event(key : ImGuiKey, down : Bool) : Void

  Queue a new key down/up event.

• #add_mouse_button_event(button : Int32, down : Bool) : Void

  Queue a mouse button change

• #add_mouse_pos_event(x : Float32, y : Float32) : Void

  Queue a mouse position update.

• #add_mouse_source_event(source : ImGuiMouseSource) : Void

  Queue a mouse source change (Mouse/TouchScreen/Pen)

• #add_mouse_wheel_event(wheel_x : Float32, wheel_y : Float32) : Void

  Queue a mouse wheel update.

• #app_accepting_events : Bool

  Only modify via SetAppAcceptingEvents()

• #app_accepting_events=(app_accepting_events : Bool)
• #app_focus_lost : Bool

  Only modify via AddFocusEvent()

• #app_focus_lost=(app_focus_lost : Bool)
• #backend_flags : ImGuiBackendFlags

  = 0 See ImGuiBackendFlags_ enum.

• #backend_flags=(backend_flags : ImGuiBackendFlags)
• #backend_language_user_data : Pointer(Void)

  = NULL User data for non C++ programming language backend

• #backend_language_user_data=(backend_language_user_data : Pointer(Void))
• #backend_platform_name : String | Nil

  = NULL

• #backend_platform_name=(backend_platform_name : String | Nil)
• #backend_platform_user_data : Pointer(Void)

  = NULL User data for platform backend

• #backend_platform_user_data=(backend_platform_user_data : Pointer(Void))
• #backend_renderer_name : String | Nil

  = NULL

• #backend_renderer_name=(backend_renderer_name : String | Nil)
• #backend_renderer_user_data : Pointer(Void)

  = NULL User data for renderer backend

• #backend_renderer_user_data=(backend_renderer_user_data : Pointer(Void))
• #backend_using_legacy_key_arrays : Int8

  -1: unknown, 0: using AddKeyEvent(), 1: using legacy io.KeysDown[]

• #backend_using_legacy_key_arrays=(backend_using_legacy_key_arrays : Int8)
• #backend_using_legacy_nav_input_array : Bool

  0: using AddKeyAnalogEvent(), 1: writing to legacy io.NavInputs[] directly

• #backend_using_legacy_nav_input_array=(backend_using_legacy_nav_input_array : Bool)
• #clear_events_queue : Void

  Clear all incoming events.

• #clear_input_keys : Void

  Clear current keyboard/mouse/gamepad state + current frame text input buffer.

• #clipboard_user_data : Pointer(Void)
• #clipboard_user_data=(clipboard_user_data : Pointer(Void))
• #config_debug_begin_return_value_loop : Bool

  = false Some calls to Begin()/BeginChild() will return false.

• #config_debug_begin_return_value_loop=(config_debug_begin_return_value_loop : Bool)
• #config_debug_begin_return_value_once : Bool

  = false First-time calls to Begin()/BeginChild() will return false.

• #config_debug_begin_return_value_once=(config_debug_begin_return_value_once : Bool)
• #config_debug_ignore_focus_loss : Bool

  = false Ignore io.AddFocusEvent(false), consequently not calling io.ClearInputKeys() in input processing.

• #config_debug_ignore_focus_loss=(config_debug_ignore_focus_loss : Bool)
• #config_debug_ini_settings : Bool

  = false Save .ini data with extra comments (particularly helpful for Docking, but makes saving slower)

• #config_debug_ini_settings=(config_debug_ini_settings : Bool)
• #config_drag_click_to_input_text : Bool

  = false [BETA] Enable turning DragXXX widgets into text input with a simple mouse click-release (without moving).

• #config_drag_click_to_input_text=(config_drag_click_to_input_text : Bool)
• #config_flags : ImGuiConfigFlags

  = 0 See ImGuiConfigFlags_ enum.

• #config_flags=(config_flags : ImGuiConfigFlags)
• #config_input_text_cursor_blink : Bool

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

• #config_input_text_cursor_blink=(config_input_text_cursor_blink : Bool)
• #config_input_text_enter_keep_active : Bool

  = false [BETA] Pressing Enter will keep item active and select contents (single-line only).

• #config_input_text_enter_keep_active=(config_input_text_enter_keep_active : Bool)
• #config_input_trickle_event_queue : Bool

  = true Enable input queue trickling: some types of events submitted during the same frame (e.g.

• #config_input_trickle_event_queue=(config_input_trickle_event_queue : Bool)
• #config_mac_osx_behaviors : Bool

  = defined(APPLE) 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.

• #config_mac_osx_behaviors=(config_mac_osx_behaviors : Bool)
• #config_memory_compact_timer : Float32

  = 60.0f Timer (in seconds) to free transient windows/tables memory buffers when unused.

• #config_memory_compact_timer=(config_memory_compact_timer : Float32)
• #config_windows_move_from_title_bar_only : Bool

  = false Enable allowing to move windows only when clicking on their title bar.

• #config_windows_move_from_title_bar_only=(config_windows_move_from_title_bar_only : Bool)
• #config_windows_resize_from_edges : Bool

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

• #config_windows_resize_from_edges=(config_windows_resize_from_edges : Bool)
• #ctx : ImGuiContext | Nil

  Parent UI context (needs to be set explicitly by parent).

• #ctx=(ctx : ImGuiContext | Nil)
• #delta_time : Float32

  = 1.0f/60.0f Time elapsed since last frame, in seconds.

• #delta_time=(delta_time : Float32)
• #display_framebuffer_scale : ImVec2

  = (1, 1) For retina display or other situations where window coordinates are different from framebuffer coordinates.

• #display_framebuffer_scale=(display_framebuffer_scale : ImVec2)
• #display_size : ImVec2

  Main display size, in pixels (generally == GetMainViewport()->Size).

• #display_size=(display_size : ImVec2)
• #font_allow_user_scaling : Bool

  = false Allow user scaling text of individual window with CTRL+Wheel.

• #font_allow_user_scaling=(font_allow_user_scaling : Bool)
• #font_default : ImFont

  = NULL Font to use on NewFrame().

• #font_default=(font_default : ImFont)
• #font_global_scale : Float32

  = 1.0f Global scale all fonts

• #font_global_scale=(font_global_scale : Float32)
• #fonts : ImFontAtlas

  Font atlas: load, rasterize and pack one or more fonts into a single texture.

• #fonts=(fonts : ImFontAtlas)
• #framerate : Float32

  Estimate of application framerate (rolling average over 60 frames, based on io.DeltaTime), in frame per second.

• #framerate=(framerate : Float32)
• #get_clipboard_text_fn : Pointer(Void) -> String
• #get_clipboard_text_fn=(get_clipboard_text_fn : Pointer(Void) -> String)
• #ini_filename : String | Nil

  = "imgui.ini" Path to .ini file (important: default "imgui.ini" is relative to current working dir!).

• #ini_filename=(ini_filename : String | Nil)
• #ini_saving_rate : Float32

  = 5.0f Minimum time between saving positions/sizes to .ini file, in seconds.

• #ini_saving_rate=(ini_saving_rate : Float32)
• #input_queue_characters : ImVector(ImWchar)

  Queue of characters input (obtained by platform backend).

• #input_queue_characters=(input_queue_characters : ImVector(ImWchar))
• #input_queue_surrogate : ImWchar16

  For AddInputCharacterUTF16()

• #input_queue_surrogate=(input_queue_surrogate : ImWchar16)
• #key_alt : Bool

  Keyboard modifier down: Alt

• #key_alt=(key_alt : Bool)
• #key_ctrl : Bool

  Keyboard modifier down: Control

• #key_ctrl=(key_ctrl : Bool)
• #key_map : Slice(Int32)

  [LEGACY] Input: map of indices into the KeysDown[512] entries array which represent your "native" keyboard state.

• #key_map=(key_map : Slice(Int32))
• #key_mods : ImGuiKeyChord

  Key mods flags (any of ImGuiMod_Ctrl/ImGuiMod_Shift/ImGuiMod_Alt/ImGuiMod_Super flags, same as io.KeyCtrl/KeyShift/KeyAlt/KeySuper but merged into flags.

• #key_mods=(key_mods : ImGuiKeyChord)
• #key_repeat_delay : Float32

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

• #key_repeat_delay=(key_repeat_delay : Float32)
• #key_repeat_rate : Float32

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

• #key_repeat_rate=(key_repeat_rate : Float32)
• #key_shift : Bool

  Keyboard modifier down: Shift

• #key_shift=(key_shift : Bool)
• #key_super : Bool

  Keyboard modifier down: Cmd/Super/Windows

• #key_super=(key_super : Bool)
• #keys_data : Slice(ImGuiKeyData)

  Key state for all known keys.

• #keys_data=(keys_data : Slice(ImGuiKeyData))
• #keys_down : Slice(Bool)

  [LEGACY] Input: Keyboard keys that are pressed (ideally left in the "native" order your engine has access to keyboard keys, so you can use your own defines/enums for keys).

• #keys_down=(keys_down : Slice(Bool))
• #log_filename : String | Nil

  = "imgui_log.txt"// Path to .log file (default parameter to ImGui::LogToFile when no file is specified).

• #log_filename=(log_filename : String | Nil)
• #metrics_active_allocations : Int32

  Number of active allocations, updated by MemAlloc/MemFree based on current context.

• #metrics_active_allocations=(metrics_active_allocations : Int32)
• #metrics_active_windows : Int32

  Number of active windows

• #metrics_active_windows=(metrics_active_windows : Int32)
• #metrics_render_indices : Int32

  Indices output during last call to Render() = number of triangles * 3

• #metrics_render_indices=(metrics_render_indices : Int32)
• #metrics_render_vertices : Int32

  Vertices output during last call to Render()

• #metrics_render_vertices=(metrics_render_vertices : Int32)
• #metrics_render_windows : Int32

  Number of visible windows

• #metrics_render_windows=(metrics_render_windows : Int32)
• #mouse_clicked : Slice(Bool)

  Mouse button went from !Down to Down (same as MouseClickedCount[x] != 0)

• #mouse_clicked=(mouse_clicked : Slice(Bool))
• #mouse_clicked_count : Slice(UInt16)

  == 0 (not clicked), == 1 (same as MouseClicked[]), == 2 (double-clicked), == 3 (triple-clicked) etc.

• #mouse_clicked_count=(mouse_clicked_count : Slice(UInt16))
• #mouse_clicked_last_count : Slice(UInt16)

  Count successive number of clicks.

• #mouse_clicked_last_count=(mouse_clicked_last_count : Slice(UInt16))
• #mouse_clicked_pos : Slice(ImVec2)

  Position at time of clicking

• #mouse_clicked_pos=(mouse_clicked_pos : Slice(ImVec2))
• #mouse_clicked_time : Slice(Float64)

  Time of last click (used to figure out double-click)

• #mouse_clicked_time=(mouse_clicked_time : Slice(Float64))
• #mouse_delta : ImVec2

  Mouse delta.

• #mouse_delta=(mouse_delta : ImVec2)
• #mouse_double_click_max_dist : Float32

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

• #mouse_double_click_max_dist=(mouse_double_click_max_dist : Float32)
• #mouse_double_click_time : Float32

  = 0.30f Time for a double-click, in seconds.

• #mouse_double_click_time=(mouse_double_click_time : Float32)
• #mouse_double_clicked : Slice(Bool)

  Has mouse button been double-clicked? (same as MouseClickedCount[x] == 2)

• #mouse_double_clicked=(mouse_double_clicked : Slice(Bool))
• #mouse_down : Slice(Bool)

  Mouse buttons: 0=left, 1=right, 2=middle + extras (ImGuiMouseButton_COUNT == 5).

• #mouse_down=(mouse_down : Slice(Bool))
• #mouse_down_duration : Slice(Float32)

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

• #mouse_down_duration=(mouse_down_duration : Slice(Float32))
• #mouse_down_duration_prev : Slice(Float32)

  Previous time the mouse button has been down

• #mouse_down_duration_prev=(mouse_down_duration_prev : Slice(Float32))
• #mouse_down_owned : Slice(Bool)

  Track if button was clicked inside a dear imgui window or over void blocked by a popup.

• #mouse_down_owned=(mouse_down_owned : Slice(Bool))
• #mouse_down_owned_unless_popup_close : Slice(Bool)

  Track if button was clicked inside a dear imgui window.

• #mouse_down_owned_unless_popup_close=(mouse_down_owned_unless_popup_close : Slice(Bool))
• #mouse_drag_max_distance_sqr : Slice(Float32)

  Squared maximum distance of how much mouse has traveled from the clicking point (used for moving thresholds)

• #mouse_drag_max_distance_sqr=(mouse_drag_max_distance_sqr : Slice(Float32))
• #mouse_drag_threshold : Float32

  = 6.0f Distance threshold before considering we are dragging.

• #mouse_drag_threshold=(mouse_drag_threshold : Float32)
• #mouse_draw_cursor : Bool

  = false Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor).

• #mouse_draw_cursor=(mouse_draw_cursor : Bool)
• #mouse_pos : ImVec2

  Mouse position, in pixels.

• #mouse_pos=(mouse_pos : ImVec2)
• #mouse_pos_prev : ImVec2

  Previous mouse position (note that MouseDelta is not necessary == MousePos-MousePosPrev, in case either position is invalid)

• #mouse_pos_prev=(mouse_pos_prev : ImVec2)
• #mouse_released : Slice(Bool)

  Mouse button went from Down to !Down

• #mouse_released=(mouse_released : Slice(Bool))
• #mouse_source : ImGuiMouseSource

  Mouse actual input peripheral (Mouse/TouchScreen/Pen).

• #mouse_source=(mouse_source : ImGuiMouseSource)
• #mouse_wheel : Float32

  Mouse wheel Vertical: 1 unit scrolls about 5 lines text.

• #mouse_wheel=(mouse_wheel : Float32)
• #mouse_wheel_h : Float32

  Mouse wheel Horizontal.

• #mouse_wheel_h=(mouse_wheel_h : Float32)
• #mouse_wheel_request_axis_swap : Bool

  On a non-Mac system, holding SHIFT requests WheelY to perform the equivalent of a WheelX event.

• #mouse_wheel_request_axis_swap=(mouse_wheel_request_axis_swap : Bool)
• #nav_active : Bool

  Keyboard/Gamepad navigation is currently allowed (will handle ImGuiKey_NavXXX events) = a window is focused and it doesn't use the ImGuiWindowFlags_NoNavInputs flag.

• #nav_active=(nav_active : Bool)
• #nav_inputs : Slice(Float32)

  [LEGACY] Since 1.88, NavInputs[] was removed.

• #nav_inputs=(nav_inputs : Slice(Float32))
• #nav_visible : Bool

  Keyboard/Gamepad navigation is visible and allowed (will handle ImGuiKey_NavXXX events).

• #nav_visible=(nav_visible : Bool)
• #pen_pressure : Float32

  Touch/Pen pressure (0.0f to 1.0f, should be >0.0f only when MouseDown[0] == true).

• #pen_pressure=(pen_pressure : Float32)
• #platform_locale_decimal_point : ImWchar

  '.' [Experimental] Configure decimal point e.g.

• #platform_locale_decimal_point=(platform_locale_decimal_point : ImWchar)
• #set_app_accepting_events(accepting_events : Bool) : Void

  Set master flag for accepting key/mouse/text events (default to true).

• #set_clipboard_text_fn : Pointer(Void), String -> Void
• #set_clipboard_text_fn=(set_clipboard_text_fn : Pointer(Void), String -> Void)
• #set_key_event_native_data(key : ImGuiKey, native_keycode : Int32, native_scancode : Int32, native_legacy_index : Int32 = -1) : Void

  [Optional] Specify index for legacy <1.87 IsKeyXXX() functions with native indices + specify native keycode, scancode.

• #set_platform_ime_data_fn : ImGuiViewport, ImGuiPlatformImeData -> Void
• #set_platform_ime_data_fn=(set_platform_ime_data_fn : ImGuiViewport, ImGuiPlatformImeData -> Void)
• #to_unsafe : Pointer(T)
• #user_data : Pointer(Void)

  = NULL Store your own data.

• #user_data=(user_data : Pointer(Void))
• #want_capture_keyboard : Bool

  Set when Dear ImGui will use keyboard inputs, in this case do not dispatch them to your main game/application (either way, always pass keyboard inputs to imgui).

• #want_capture_keyboard=(want_capture_keyboard : Bool)
• #want_capture_mouse : Bool

  Set when Dear ImGui will use mouse inputs, in this case do not dispatch them to your main game/application (either way, always pass on mouse inputs to imgui).

• #want_capture_mouse=(want_capture_mouse : Bool)
• #want_capture_mouse_unless_popup_close : Bool

  Alternative to WantCaptureMouse: (WantCaptureMouse == true && WantCaptureMouseUnlessPopupClose == false) when a click over void is expected to close a popup.

• #want_capture_mouse_unless_popup_close=(want_capture_mouse_unless_popup_close : Bool)
• #want_save_ini_settings : Bool

  When manual .ini load/save is active (io.IniFilename == NULL), this will be set to notify your application that you can call SaveIniSettingsToMemory() and save yourself.

• #want_save_ini_settings=(want_save_ini_settings : Bool)
• #want_set_mouse_pos : Bool

  MousePos has been altered, backend should reposition mouse on next frame.

• #want_set_mouse_pos=(want_set_mouse_pos : Bool)
• #want_text_input : Bool

  Mobile/console: when set, you may display an on-screen keyboard.

• #want_text_input=(want_text_input : Bool)

Constructor Detail

Instance Method Detail