Overview
namespace ImGui {
// global variables
const ImGuiID IMGUI_VIEWPORT_DEFAULT_ID = 0x11111111;
// global functions
ImGuiIO& GetIO(ImGuiContext* ctx);
ImGuiPlatformIO& GetPlatformIO(ImGuiContext* ctx);
static void ItemHandleShortcut(ImGuiID id);
static int FindWindowFocusIndex(ImGuiWindow* window);
static void UpdateWindowInFocusOrderList(
ImGuiWindow* window,
bool just_created,
ImGuiWindowFlags new_flags
);
static void NavUpdate();
static void NavUpdateWindowing();
static void NavUpdateWindowingApplyFocus(ImGuiWindow* window);
static void NavUpdateWindowingOverlay();
static void NavUpdateCancelRequest();
static void NavUpdateCreateMoveRequest();
static void NavUpdateCreateTabbingRequest();
static float NavUpdatePageUpPageDown();
static void NavUpdateAnyRequestFlag();
static void NavUpdateCreateWrappingRequest();
static void NavEndFrame();
static bool NavScoreItem(
ImGuiNavItemData* result,
const ImRect& nav_bb
);
static void NavApplyItemToResult(ImGuiNavItemData* result);
static void NavProcessItem();
static void NavProcessItemForTabbingRequest(
ImGuiID id,
ImGuiItemFlags item_flags,
ImGuiNavMoveFlags move_flags
);
static ImGuiInputSource NavCalcPreferredRefPosSource(ImGuiWindowFlags window_type);
static ImVec2 NavCalcPreferredRefPos(ImGuiWindowFlags window_type);
static void NavSaveLastChildNavWindowIntoParent(ImGuiWindow* nav_window);
static ImGuiWindow* NavRestoreLastChildNavWindow(ImGuiWindow* window);
static void NavRestoreLayer(ImGuiNavLayer layer);
static void ErrorCheckNewFrameSanityChecks();
static void ErrorCheckEndFrameSanityChecks();
static void UpdateDebugToolItemPicker();
static void UpdateDebugToolItemPathQuery();
static void UpdateDebugToolFlashStyleColor();
static void UpdateKeyboardInputs();
static void UpdateMouseInputs();
static void UpdateMouseWheel();
static void UpdateKeyRoutingTable(ImGuiKeyRoutingTable* rt);
static void UpdateFontsNewFrame();
static void UpdateFontsEndFrame();
static void UpdateTexturesNewFrame();
static void UpdateTexturesEndFrame();
static void UpdateSettings();
static int UpdateWindowManualResize(
ImGuiWindow* window,
int* border_hovered,
int* border_held,
int resize_grip_count,
ImU32 resize_grip_col [4],
const ImRect& visibility_rect
);
static void RenderWindowOuterBorders(ImGuiWindow* window);
static void RenderWindowDecorations(
ImGuiWindow* window,
const ImRect& title_bar_rect,
bool title_bar_is_highlight,
bool handle_borders_and_resize_grips,
int resize_grip_count,
const ImU32 resize_grip_col [4],
float resize_grip_draw_size
);
static void RenderWindowTitleBarContents(
ImGuiWindow* window,
const ImRect& title_bar_rect,
const char* name,
bool* p_open
);
static void RenderDimmedBackgroundBehindWindow(
ImGuiWindow* window,
ImU32 col
);
static void RenderDimmedBackgrounds();
static void SetLastItemDataForWindow(
ImGuiWindow* window,
const ImRect& rect
);
static void SetLastItemDataForChildWindowItem(
ImGuiWindow* window,
const ImRect& rect
);
static ImGuiViewportP* AddUpdateViewport(
ImGuiWindow* window,
ImGuiID id,
const ImVec2& platform_pos,
const ImVec2& size,
ImGuiViewportFlags flags
);
static void DestroyViewport(ImGuiViewportP* viewport);
static void UpdateViewportsNewFrame();
static void UpdateViewportsEndFrame();
static void WindowSelectViewport(ImGuiWindow* window);
static void WindowSyncOwnedViewport(
ImGuiWindow* window,
ImGuiWindow* parent_window_in_stack
);
static bool UpdateTryMergeWindowIntoHostViewport(
ImGuiWindow* window,
ImGuiViewportP* host_viewport
);
static bool UpdateTryMergeWindowIntoHostViewports(ImGuiWindow* window);
static bool GetWindowAlwaysWantOwnViewport(ImGuiWindow* window);
static int FindPlatformMonitorForPos(const ImVec2& pos);
static int FindPlatformMonitorForRect(const ImRect& r);
static void UpdateViewportPlatformMonitor(ImGuiViewportP* viewport);
static ImGuiDockNode* DockContextAddNode(
ImGuiContext* ctx,
ImGuiID id
);
static void DockContextRemoveNode(
ImGuiContext* ctx,
ImGuiDockNode* node,
bool merge_sibling_into_parent_node
);
static void DockContextDeleteNode(
ImGuiContext* ctx,
ImGuiDockNode* node
);
static void DockContextQueueNotifyRemovedNode(
ImGuiContext* ctx,
ImGuiDockNode* node
);
static void DockContextProcessDock(
ImGuiContext* ctx,
ImGuiDockRequest* req
);
static void DockContextPruneUnusedSettingsNodes(ImGuiContext* ctx);
static ImGuiDockNode* DockContextBindNodeToWindow(
ImGuiContext* ctx,
ImGuiWindow* window
);
static void DockContextBuildNodesFromSettings(
ImGuiContext* ctx,
ImGuiDockNodeSettings* node_settings_array,
int node_settings_count
);
static void DockContextBuildAddWindowsToNodes(
ImGuiContext* ctx,
ImGuiID root_id
);
static void DockNodeAddWindow(
ImGuiDockNode* node,
ImGuiWindow* window,
bool add_to_tab_bar
);
static void DockNodeMoveWindows(
ImGuiDockNode* dst_node,
ImGuiDockNode* src_node
);
static void DockNodeMoveChildNodes(
ImGuiDockNode* dst_node,
ImGuiDockNode* src_node
);
static ImGuiWindow* DockNodeFindWindowByID(
ImGuiDockNode* node,
ImGuiID id
);
static void DockNodeApplyPosSizeToWindows(ImGuiDockNode* node);
static void DockNodeRemoveWindow(
ImGuiDockNode* node,
ImGuiWindow* window,
ImGuiID save_dock_id
);
static void DockNodeHideHostWindow(ImGuiDockNode* node);
static void DockNodeUpdate(ImGuiDockNode* node);
static void DockNodeUpdateForRootNode(ImGuiDockNode* node);
static void DockNodeUpdateFlagsAndCollapse(ImGuiDockNode* node);
static void DockNodeUpdateHasCentralNodeChild(ImGuiDockNode* node);
static void DockNodeUpdateTabBar(
ImGuiDockNode* node,
ImGuiWindow* host_window
);
static void DockNodeAddTabBar(ImGuiDockNode* node);
static void DockNodeRemoveTabBar(ImGuiDockNode* node);
static void DockNodeWindowMenuUpdate(
ImGuiDockNode* node,
ImGuiTabBar* tab_bar
);
static void DockNodeUpdateVisibleFlag(ImGuiDockNode* node);
static void DockNodeStartMouseMovingWindow(
ImGuiDockNode* node,
ImGuiWindow* window
);
static bool DockNodeIsDropAllowed(
ImGuiWindow* host_window,
ImGuiWindow* payload_window
);
static void DockNodePreviewDockSetup(
ImGuiWindow* host_window,
ImGuiDockNode* host_node,
ImGuiWindow* payload_window,
ImGuiDockNode* payload_node,
ImGuiDockPreviewData* preview_data,
bool is_explicit_target,
bool is_outer_docking
);
static void DockNodePreviewDockRender(
ImGuiWindow* host_window,
ImGuiDockNode* host_node,
ImGuiWindow* payload_window,
const ImGuiDockPreviewData* preview_data
);
static void DockNodeCalcTabBarLayout(
const ImGuiDockNode* node,
ImRect* out_title_rect,
ImRect* out_tab_bar_rect,
ImVec2* out_window_menu_button_pos,
ImVec2* out_close_button_pos
);
static void DockNodeCalcSplitRects(
ImVec2& pos_old,
ImVec2& size_old,
ImVec2& pos_new,
ImVec2& size_new,
ImGuiDir dir,
ImVec2 size_new_desired
);
static bool DockNodeCalcDropRectsAndTestMousePos(
const ImRect& parent,
ImGuiDir dir,
ImRect& out_draw,
bool outer_docking,
ImVec2* test_mouse_pos
);
static const char* DockNodeGetHostWindowTitle(
ImGuiDockNode* node,
char* buf,
int buf_size
);
static int DockNodeGetTabOrder(ImGuiWindow* window);
static void DockNodeTreeSplit(
ImGuiContext* ctx,
ImGuiDockNode* parent_node,
ImGuiAxis split_axis,
int split_first_child,
float split_ratio,
ImGuiDockNode* new_node
);
static void DockNodeTreeMerge(
ImGuiContext* ctx,
ImGuiDockNode* parent_node,
ImGuiDockNode* merge_lead_child
);
static void DockNodeTreeUpdatePosSize(
ImGuiDockNode* node,
ImVec2 pos,
ImVec2 size,
ImGuiDockNode* only_write_to_single_node = NULL
);
static void DockNodeTreeUpdateSplitter(ImGuiDockNode* node);
static ImGuiDockNode* DockNodeTreeFindVisibleNodeByPos(
ImGuiDockNode* node,
ImVec2 pos
);
static ImGuiDockNode* DockNodeTreeFindFallbackLeafNode(ImGuiDockNode* node);
static void DockSettingsRenameNodeReferences(
ImGuiID old_node_id,
ImGuiID new_node_id
);
static void DockSettingsRemoveNodeReferences(
ImGuiID* node_ids,
int node_ids_count
);
static ImGuiDockNodeSettings* DockSettingsFindNodeSettings(
ImGuiContext* ctx,
ImGuiID node_id
);
static void DockSettingsHandler_ClearAll(
ImGuiContext* ctx,
ImGuiSettingsHandler*
);
static void DockSettingsHandler_ApplyAll(
ImGuiContext* ctx,
ImGuiSettingsHandler*
);
static void* DockSettingsHandler_ReadOpen(
ImGuiContext*,
ImGuiSettingsHandler*,
const char* name
);
static void DockSettingsHandler_ReadLine(
ImGuiContext* ctx,
ImGuiSettingsHandler*,
void* entry,
const char* line
);
static void DockSettingsHandler_WriteAll(
ImGuiContext* imgui_ctx,
ImGuiSettingsHandler* handler,
ImGuiTextBuffer* buf
);
IMGUI_API ImGuiContext* CreateContext(ImFontAtlas* shared_font_atlas = NULL);
IMGUI_API void DestroyContext(ImGuiContext* ctx = NULL);
IMGUI_API ImGuiContext* GetCurrentContext();
IMGUI_API void SetCurrentContext(ImGuiContext* ctx);
IMGUI_API ImGuiIO& GetIO();
IMGUI_API ImGuiPlatformIO& GetPlatformIO();
IMGUI_API ImGuiStyle& GetStyle();
IMGUI_API void NewFrame();
IMGUI_API void EndFrame();
IMGUI_API void Render();
IMGUI_API ImDrawData* GetDrawData();
IMGUI_API void ShowDemoWindow(bool* p_open = NULL);
IMGUI_API void ShowMetricsWindow(bool* p_open = NULL);
IMGUI_API void ShowDebugLogWindow(bool* p_open = NULL);
IMGUI_API void ShowIDStackToolWindow(bool* p_open = NULL);
IMGUI_API void ShowAboutWindow(bool* p_open = NULL);
IMGUI_API void ShowStyleEditor(ImGuiStyle* ref = NULL);
IMGUI_API bool ShowStyleSelector(const char* label);
IMGUI_API void ShowFontSelector(const char* label);
IMGUI_API void ShowUserGuide();
IMGUI_API const char* GetVersion();
IMGUI_API void StyleColorsDark(ImGuiStyle* dst = NULL);
IMGUI_API void StyleColorsLight(ImGuiStyle* dst = NULL);
IMGUI_API void StyleColorsClassic(ImGuiStyle* dst = NULL);
IMGUI_API bool Begin(
const char* name,
bool* p_open = NULL,
ImGuiWindowFlags flags = 0
);
IMGUI_API void End();
IMGUI_API bool BeginChild(
const char* str_id,
const ImVec2& size = ImVec2(0, 0),
ImGuiChildFlags child_flags = 0,
ImGuiWindowFlags window_flags = 0
);
IMGUI_API bool BeginChild(
ImGuiID id,
const ImVec2& size = ImVec2(0, 0),
ImGuiChildFlags child_flags = 0,
ImGuiWindowFlags window_flags = 0
);
IMGUI_API void EndChild();
IMGUI_API bool IsWindowAppearing();
IMGUI_API bool IsWindowCollapsed();
IMGUI_API bool IsWindowFocused(ImGuiFocusedFlags flags = 0);
IMGUI_API bool IsWindowHovered(ImGuiHoveredFlags flags = 0);
IMGUI_API ImDrawList* GetWindowDrawList();
IMGUI_API float GetWindowDpiScale();
IMGUI_API ImVec2 GetWindowPos();
IMGUI_API ImVec2 GetWindowSize();
IMGUI_API float GetWindowWidth();
IMGUI_API float GetWindowHeight();
IMGUI_API ImGuiViewport* GetWindowViewport();
IMGUI_API void SetNextWindowPos(
const ImVec2& pos,
ImGuiCond cond = 0,
const ImVec2& pivot = ImVec2(0, 0)
);
IMGUI_API void SetNextWindowSize(
const ImVec2& size,
ImGuiCond cond = 0
);
IMGUI_API void SetNextWindowSizeConstraints(
const ImVec2& size_min,
const ImVec2& size_max,
ImGuiSizeCallback custom_callback = NULL,
void* custom_callback_data = NULL
);
IMGUI_API void SetNextWindowContentSize(const ImVec2& size);
IMGUI_API void SetNextWindowCollapsed(
bool collapsed,
ImGuiCond cond = 0
);
IMGUI_API void SetNextWindowFocus();
IMGUI_API void SetNextWindowScroll(const ImVec2& scroll);
IMGUI_API void SetNextWindowBgAlpha(float alpha);
IMGUI_API void SetNextWindowViewport(ImGuiID viewport_id);
IMGUI_API void SetWindowPos(
const ImVec2& pos,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowSize(
const ImVec2& size,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowCollapsed(
bool collapsed,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowFocus();
IMGUI_API void SetWindowPos(
const char* name,
const ImVec2& pos,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowSize(
const char* name,
const ImVec2& size,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowCollapsed(
const char* name,
bool collapsed,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowFocus(const char* name);
IMGUI_API float GetScrollX();
IMGUI_API float GetScrollY();
IMGUI_API void SetScrollX(float scroll_x);
IMGUI_API void SetScrollY(float scroll_y);
IMGUI_API float GetScrollMaxX();
IMGUI_API float GetScrollMaxY();
IMGUI_API void SetScrollHereX(float center_x_ratio = 0.5f);
IMGUI_API void SetScrollHereY(float center_y_ratio = 0.5f);
IMGUI_API void SetScrollFromPosX(
float local_x,
float center_x_ratio = 0.5f
);
IMGUI_API void SetScrollFromPosY(
float local_y,
float center_y_ratio = 0.5f
);
IMGUI_API void PushFont(
ImFont* font,
float font_size_base_unscaled
);
IMGUI_API void PopFont();
IMGUI_API ImFont* GetFont();
IMGUI_API float GetFontSize();
IMGUI_API ImFontBaked* GetFontBaked();
IMGUI_API void PushStyleColor(
ImGuiCol idx,
ImU32 col
);
IMGUI_API void PushStyleColor(
ImGuiCol idx,
const ImVec4& col
);
IMGUI_API void PopStyleColor(int count = 1);
IMGUI_API void PushStyleVar(
ImGuiStyleVar idx,
float val
);
IMGUI_API void PushStyleVar(
ImGuiStyleVar idx,
const ImVec2& val
);
IMGUI_API void PushStyleVarX(
ImGuiStyleVar idx,
float val_x
);
IMGUI_API void PushStyleVarY(
ImGuiStyleVar idx,
float val_y
);
IMGUI_API void PopStyleVar(int count = 1);
IMGUI_API void PushItemFlag(
ImGuiItemFlags option,
bool enabled
);
IMGUI_API void PopItemFlag();
IMGUI_API void PushItemWidth(float item_width);
IMGUI_API void PopItemWidth();
IMGUI_API void SetNextItemWidth(float item_width);
IMGUI_API float CalcItemWidth();
IMGUI_API void PushTextWrapPos(float wrap_local_pos_x = 0.0f);
IMGUI_API void PopTextWrapPos();
IMGUI_API ImVec2 GetFontTexUvWhitePixel();
IMGUI_API ImU32 GetColorU32(
ImGuiCol idx,
float alpha_mul = 1.0f
);
IMGUI_API ImU32 GetColorU32(const ImVec4& col);
IMGUI_API ImU32 GetColorU32(
ImU32 col,
float alpha_mul = 1.0f
);
IMGUI_API const ImVec4& GetStyleColorVec4(ImGuiCol idx);
IMGUI_API ImVec2 GetCursorScreenPos();
IMGUI_API void SetCursorScreenPos(const ImVec2& pos);
IMGUI_API ImVec2 GetContentRegionAvail();
IMGUI_API ImVec2 GetCursorPos();
IMGUI_API float GetCursorPosX();
IMGUI_API float GetCursorPosY();
IMGUI_API void SetCursorPos(const ImVec2& local_pos);
IMGUI_API void SetCursorPosX(float local_x);
IMGUI_API void SetCursorPosY(float local_y);
IMGUI_API ImVec2 GetCursorStartPos();
IMGUI_API void Separator();
IMGUI_API void SameLine(
float offset_from_start_x = 0.0f,
float spacing = -1.0f
);
IMGUI_API void NewLine();
IMGUI_API void Spacing();
IMGUI_API void Dummy(const ImVec2& size);
IMGUI_API void Indent(float indent_w = 0.0f);
IMGUI_API void Unindent(float indent_w = 0.0f);
IMGUI_API void BeginGroup();
IMGUI_API void EndGroup();
IMGUI_API void AlignTextToFramePadding();
IMGUI_API float GetTextLineHeight();
IMGUI_API float GetTextLineHeightWithSpacing();
IMGUI_API float GetFrameHeight();
IMGUI_API float GetFrameHeightWithSpacing();
IMGUI_API void PushID(const char* str_id);
IMGUI_API void PushID(
const char* str_id_begin,
const char* str_id_end
);
IMGUI_API void PushID(const void* ptr_id);
IMGUI_API void PushID(int int_id);
IMGUI_API void PopID();
IMGUI_API ImGuiID GetID(const char* str_id);
IMGUI_API ImGuiID GetID(
const char* str_id_begin,
const char* str_id_end
);
IMGUI_API ImGuiID GetID(const void* ptr_id);
IMGUI_API ImGuiID GetID(int int_id);
IMGUI_API void TextUnformatted(
const char* text,
const char* text_end = NULL
);
IMGUI_API void Text(
const char* fmt,
...
);
IMGUI_API void TextV(
const char* fmt,
va_list args
);
IMGUI_API void TextColored(
const ImVec4& col,
const char* fmt,
...
);
IMGUI_API void TextColoredV(
const ImVec4& col,
const char* fmt,
va_list args
);
IMGUI_API void TextDisabled(
const char* fmt,
...
);
IMGUI_API void TextDisabledV(
const char* fmt,
va_list args
);
IMGUI_API void TextWrapped(
const char* fmt,
...
);
IMGUI_API void TextWrappedV(
const char* fmt,
va_list args
);
IMGUI_API void LabelText(
const char* label,
const char* fmt,
...
);
IMGUI_API void LabelTextV(
const char* label,
const char* fmt,
va_list args
);
IMGUI_API void BulletText(
const char* fmt,
...
);
IMGUI_API void BulletTextV(
const char* fmt,
va_list args
);
IMGUI_API void SeparatorText(const char* label);
IMGUI_API bool Button(
const char* label,
const ImVec2& size = ImVec2(0, 0)
);
IMGUI_API bool SmallButton(const char* label);
IMGUI_API bool InvisibleButton(
const char* str_id,
const ImVec2& size,
ImGuiButtonFlags flags = 0
);
IMGUI_API bool ArrowButton(
const char* str_id,
ImGuiDir dir
);
IMGUI_API bool Checkbox(
const char* label,
bool* v
);
IMGUI_API bool CheckboxFlags(
const char* label,
int* flags,
int flags_value
);
IMGUI_API bool CheckboxFlags(
const char* label,
unsigned int* flags,
unsigned int flags_value
);
IMGUI_API bool RadioButton(
const char* label,
bool active
);
IMGUI_API bool RadioButton(
const char* label,
int* v,
int v_button
);
IMGUI_API void ProgressBar(
float fraction,
const ImVec2& size_arg = ImVec2(-FLT_MIN, 0),
const char* overlay = NULL
);
IMGUI_API void Bullet();
IMGUI_API bool TextLink(const char* label);
IMGUI_API bool TextLinkOpenURL(
const char* label,
const char* url = NULL
);
IMGUI_API void Image(
ImTextureRef tex_ref,
const ImVec2& image_size,
const ImVec2& uv0 = ImVec2(0, 0),
const ImVec2& uv1 = ImVec2(1, 1)
);
IMGUI_API void ImageWithBg(
ImTextureRef tex_ref,
const ImVec2& image_size,
const ImVec2& uv0 = ImVec2(0, 0),
const ImVec2& uv1 = ImVec2(1, 1),
const ImVec4& bg_col = ImVec4(0, 0, 0, 0),
const ImVec4& tint_col = ImVec4(1, 1, 1, 1)
);
IMGUI_API bool ImageButton(
const char* str_id,
ImTextureRef tex_ref,
const ImVec2& image_size,
const ImVec2& uv0 = ImVec2(0, 0),
const ImVec2& uv1 = ImVec2(1, 1),
const ImVec4& bg_col = ImVec4(0, 0, 0, 0),
const ImVec4& tint_col = ImVec4(1, 1, 1, 1)
);
IMGUI_API bool BeginCombo(
const char* label,
const char* preview_value,
ImGuiComboFlags flags = 0
);
IMGUI_API void EndCombo();
IMGUI_API bool Combo(
const char* label,
int* current_item,
const char*const items [],
int items_count,
int popup_max_height_in_items = -1
);
IMGUI_API bool Combo(
const char* label,
int* current_item,
const char* items_separated_by_zeros,
int popup_max_height_in_items = -1
);
IMGUI_API bool Combo(
const char* label,
int* current_item,
const char*(*)(void*user_data, int idx) getter,
void* user_data,
int items_count,
int popup_max_height_in_items = -1
);
IMGUI_API bool DragFloat(
const char* label,
float* v,
float v_speed = 1.0f,
float v_min = 0.0f,
float v_max = 0.0f,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragFloat2(
const char* label,
float v [2],
float v_speed = 1.0f,
float v_min = 0.0f,
float v_max = 0.0f,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragFloat3(
const char* label,
float v [3],
float v_speed = 1.0f,
float v_min = 0.0f,
float v_max = 0.0f,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragFloat4(
const char* label,
float v [4],
float v_speed = 1.0f,
float v_min = 0.0f,
float v_max = 0.0f,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragFloatRange2(
const char* label,
float* v_current_min,
float* v_current_max,
float v_speed = 1.0f,
float v_min = 0.0f,
float v_max = 0.0f,
const char* format = "%.3f",
const char* format_max = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragInt(
const char* label,
int* v,
float v_speed = 1.0f,
int v_min = 0,
int v_max = 0,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragInt2(
const char* label,
int v [2],
float v_speed = 1.0f,
int v_min = 0,
int v_max = 0,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragInt3(
const char* label,
int v [3],
float v_speed = 1.0f,
int v_min = 0,
int v_max = 0,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragInt4(
const char* label,
int v [4],
float v_speed = 1.0f,
int v_min = 0,
int v_max = 0,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragIntRange2(
const char* label,
int* v_current_min,
int* v_current_max,
float v_speed = 1.0f,
int v_min = 0,
int v_max = 0,
const char* format = "%d",
const char* format_max = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragScalar(
const char* label,
ImGuiDataType data_type,
void* p_data,
float v_speed = 1.0f,
const void* p_min = NULL,
const void* p_max = NULL,
const char* format = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool DragScalarN(
const char* label,
ImGuiDataType data_type,
void* p_data,
int components,
float v_speed = 1.0f,
const void* p_min = NULL,
const void* p_max = NULL,
const char* format = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderFloat(
const char* label,
float* v,
float v_min,
float v_max,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderFloat2(
const char* label,
float v [2],
float v_min,
float v_max,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderFloat3(
const char* label,
float v [3],
float v_min,
float v_max,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderFloat4(
const char* label,
float v [4],
float v_min,
float v_max,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderAngle(
const char* label,
float* v_rad,
float v_degrees_min = -360.0f,
float v_degrees_max = +360.0f,
const char* format = "%.0f deg",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderInt(
const char* label,
int* v,
int v_min,
int v_max,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderInt2(
const char* label,
int v [2],
int v_min,
int v_max,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderInt3(
const char* label,
int v [3],
int v_min,
int v_max,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderInt4(
const char* label,
int v [4],
int v_min,
int v_max,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderScalar(
const char* label,
ImGuiDataType data_type,
void* p_data,
const void* p_min,
const void* p_max,
const char* format = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool SliderScalarN(
const char* label,
ImGuiDataType data_type,
void* p_data,
int components,
const void* p_min,
const void* p_max,
const char* format = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool VSliderFloat(
const char* label,
const ImVec2& size,
float* v,
float v_min,
float v_max,
const char* format = "%.3f",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool VSliderInt(
const char* label,
const ImVec2& size,
int* v,
int v_min,
int v_max,
const char* format = "%d",
ImGuiSliderFlags flags = 0
);
IMGUI_API bool VSliderScalar(
const char* label,
const ImVec2& size,
ImGuiDataType data_type,
void* p_data,
const void* p_min,
const void* p_max,
const char* format = NULL,
ImGuiSliderFlags flags = 0
);
IMGUI_API bool InputText(
const char* label,
char* buf,
size_t buf_size,
ImGuiInputTextFlags flags = 0,
ImGuiInputTextCallback callback = NULL,
void* user_data = NULL
);
IMGUI_API bool InputTextMultiline(
const char* label,
char* buf,
size_t buf_size,
const ImVec2& size = ImVec2(0, 0),
ImGuiInputTextFlags flags = 0,
ImGuiInputTextCallback callback = NULL,
void* user_data = NULL
);
IMGUI_API bool InputTextWithHint(
const char* label,
const char* hint,
char* buf,
size_t buf_size,
ImGuiInputTextFlags flags = 0,
ImGuiInputTextCallback callback = NULL,
void* user_data = NULL
);
IMGUI_API bool InputFloat(
const char* label,
float* v,
float step = 0.0f,
float step_fast = 0.0f,
const char* format = "%.3f",
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputFloat2(
const char* label,
float v [2],
const char* format = "%.3f",
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputFloat3(
const char* label,
float v [3],
const char* format = "%.3f",
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputFloat4(
const char* label,
float v [4],
const char* format = "%.3f",
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputInt(
const char* label,
int* v,
int step = 1,
int step_fast = 100,
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputInt2(
const char* label,
int v [2],
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputInt3(
const char* label,
int v [3],
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputInt4(
const char* label,
int v [4],
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputDouble(
const char* label,
double* v,
double step = 0.0,
double step_fast = 0.0,
const char* format = "%.6f",
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputScalar(
const char* label,
ImGuiDataType data_type,
void* p_data,
const void* p_step = NULL,
const void* p_step_fast = NULL,
const char* format = NULL,
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool InputScalarN(
const char* label,
ImGuiDataType data_type,
void* p_data,
int components,
const void* p_step = NULL,
const void* p_step_fast = NULL,
const char* format = NULL,
ImGuiInputTextFlags flags = 0
);
IMGUI_API bool ColorEdit3(
const char* label,
float col [3],
ImGuiColorEditFlags flags = 0
);
IMGUI_API bool ColorEdit4(
const char* label,
float col [4],
ImGuiColorEditFlags flags = 0
);
IMGUI_API bool ColorPicker3(
const char* label,
float col [3],
ImGuiColorEditFlags flags = 0
);
IMGUI_API bool ColorPicker4(
const char* label,
float col [4],
ImGuiColorEditFlags flags = 0,
const float* ref_col = NULL
);
IMGUI_API bool ColorButton(
const char* desc_id,
const ImVec4& col,
ImGuiColorEditFlags flags = 0,
const ImVec2& size = ImVec2(0, 0)
);
IMGUI_API void SetColorEditOptions(ImGuiColorEditFlags flags);
IMGUI_API bool TreeNode(const char* label);
IMGUI_API bool TreeNode(
const char* str_id,
const char* fmt,
...
);
IMGUI_API bool TreeNode(
const void* ptr_id,
const char* fmt,
...
);
IMGUI_API bool TreeNodeV(
const char* str_id,
const char* fmt,
va_list args
);
IMGUI_API bool TreeNodeV(
const void* ptr_id,
const char* fmt,
va_list args
);
IMGUI_API bool TreeNodeEx(
const char* label,
ImGuiTreeNodeFlags flags = 0
);
IMGUI_API bool TreeNodeEx(
const char* str_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
...
);
IMGUI_API bool TreeNodeEx(
const void* ptr_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
...
);
IMGUI_API bool TreeNodeExV(
const char* str_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
va_list args
);
IMGUI_API bool TreeNodeExV(
const void* ptr_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
va_list args
);
IMGUI_API void TreePush(const char* str_id);
IMGUI_API void TreePush(const void* ptr_id);
IMGUI_API void TreePop();
IMGUI_API float GetTreeNodeToLabelSpacing();
IMGUI_API bool CollapsingHeader(
const char* label,
ImGuiTreeNodeFlags flags = 0
);
IMGUI_API bool CollapsingHeader(
const char* label,
bool* p_visible,
ImGuiTreeNodeFlags flags = 0
);
IMGUI_API void SetNextItemOpen(
bool is_open,
ImGuiCond cond = 0
);
IMGUI_API void SetNextItemStorageID(ImGuiID storage_id);
IMGUI_API bool TreeNodeGetOpen(ImGuiID storage_id);
IMGUI_API bool Selectable(
const char* label,
bool selected = false,
ImGuiSelectableFlags flags = 0,
const ImVec2& size = ImVec2(0, 0)
);
IMGUI_API bool Selectable(
const char* label,
bool* p_selected,
ImGuiSelectableFlags flags = 0,
const ImVec2& size = ImVec2(0, 0)
);
IMGUI_API ImGuiMultiSelectIO* BeginMultiSelect(
ImGuiMultiSelectFlags flags,
int selection_size = -1,
int items_count = -1
);
IMGUI_API ImGuiMultiSelectIO* EndMultiSelect();
IMGUI_API void SetNextItemSelectionUserData(ImGuiSelectionUserData selection_user_data);
IMGUI_API bool IsItemToggledSelection();
IMGUI_API bool BeginListBox(
const char* label,
const ImVec2& size = ImVec2(0, 0)
);
IMGUI_API void EndListBox();
IMGUI_API bool ListBox(
const char* label,
int* current_item,
const char*const items [],
int items_count,
int height_in_items = -1
);
IMGUI_API bool ListBox(
const char* label,
int* current_item,
const char*(*)(void*user_data, int idx) getter,
void* user_data,
int items_count,
int height_in_items = -1
);
IMGUI_API void PlotLines(
const char* label,
const float* values,
int values_count,
int values_offset = 0,
const char* overlay_text = NULL,
float scale_min = FLT_MAX,
float scale_max = FLT_MAX,
ImVec2 graph_size = ImVec2(0, 0),
int stride = sizeof(float)
);
IMGUI_API void PlotLines(
const char* label,
float(*)(void*data, int idx) values_getter,
void* data,
int values_count,
int values_offset = 0,
const char* overlay_text = NULL,
float scale_min = FLT_MAX,
float scale_max = FLT_MAX,
ImVec2 graph_size = ImVec2(0, 0)
);
IMGUI_API void PlotHistogram(
const char* label,
const float* values,
int values_count,
int values_offset = 0,
const char* overlay_text = NULL,
float scale_min = FLT_MAX,
float scale_max = FLT_MAX,
ImVec2 graph_size = ImVec2(0, 0),
int stride = sizeof(float)
);
IMGUI_API void PlotHistogram(
const char* label,
float(*)(void*data, int idx) values_getter,
void* data,
int values_count,
int values_offset = 0,
const char* overlay_text = NULL,
float scale_min = FLT_MAX,
float scale_max = FLT_MAX,
ImVec2 graph_size = ImVec2(0, 0)
);
IMGUI_API void Value(
const char* prefix,
bool b
);
IMGUI_API void Value(
const char* prefix,
int v
);
IMGUI_API void Value(
const char* prefix,
unsigned int v
);
IMGUI_API void Value(
const char* prefix,
float v,
const char* float_format = NULL
);
IMGUI_API bool BeginMenuBar();
IMGUI_API void EndMenuBar();
IMGUI_API bool BeginMainMenuBar();
IMGUI_API void EndMainMenuBar();
IMGUI_API bool BeginMenu(
const char* label,
bool enabled = true
);
IMGUI_API void EndMenu();
IMGUI_API bool MenuItem(
const char* label,
const char* shortcut = NULL,
bool selected = false,
bool enabled = true
);
IMGUI_API bool MenuItem(
const char* label,
const char* shortcut,
bool* p_selected,
bool enabled = true
);
IMGUI_API bool BeginTooltip();
IMGUI_API void EndTooltip();
IMGUI_API void SetTooltip(
const char* fmt,
...
);
IMGUI_API void SetTooltipV(
const char* fmt,
va_list args
);
IMGUI_API bool BeginItemTooltip();
IMGUI_API void SetItemTooltip(
const char* fmt,
...
);
IMGUI_API void SetItemTooltipV(
const char* fmt,
va_list args
);
IMGUI_API bool BeginPopup(
const char* str_id,
ImGuiWindowFlags flags = 0
);
IMGUI_API bool BeginPopupModal(
const char* name,
bool* p_open = NULL,
ImGuiWindowFlags flags = 0
);
IMGUI_API void EndPopup();
IMGUI_API void OpenPopup(
const char* str_id,
ImGuiPopupFlags popup_flags = 0
);
IMGUI_API void OpenPopup(
ImGuiID id,
ImGuiPopupFlags popup_flags = 0
);
IMGUI_API void OpenPopupOnItemClick(
const char* str_id = NULL,
ImGuiPopupFlags popup_flags = 0
);
IMGUI_API void CloseCurrentPopup();
IMGUI_API bool BeginPopupContextItem(
const char* str_id = NULL,
ImGuiPopupFlags popup_flags = 0
);
IMGUI_API bool BeginPopupContextWindow(
const char* str_id = NULL,
ImGuiPopupFlags popup_flags = 0
);
IMGUI_API bool BeginPopupContextVoid(
const char* str_id = NULL,
ImGuiPopupFlags popup_flags = 0
);
IMGUI_API bool IsPopupOpen(
const char* str_id,
ImGuiPopupFlags flags = 0
);
IMGUI_API bool BeginTable(
const char* str_id,
int columns,
ImGuiTableFlags flags = 0,
const ImVec2& outer_size = ImVec2(0.0f, 0.0f),
float inner_width = 0.0f
);
IMGUI_API void EndTable();
IMGUI_API void TableNextRow(
ImGuiTableRowFlags row_flags = 0,
float min_row_height = 0.0f
);
IMGUI_API bool TableNextColumn();
IMGUI_API bool TableSetColumnIndex(int column_n);
IMGUI_API void TableSetupColumn(
const char* label,
ImGuiTableColumnFlags flags = 0,
float init_width_or_weight = 0.0f,
ImGuiID user_id = 0
);
IMGUI_API void TableSetupScrollFreeze(
int cols,
int rows
);
IMGUI_API void TableHeader(const char* label);
IMGUI_API void TableHeadersRow();
IMGUI_API void TableAngledHeadersRow();
IMGUI_API ImGuiTableSortSpecs* TableGetSortSpecs();
IMGUI_API int TableGetColumnCount();
IMGUI_API int TableGetColumnIndex();
IMGUI_API int TableGetRowIndex();
IMGUI_API const char* TableGetColumnName(int column_n = -1);
IMGUI_API ImGuiTableColumnFlags TableGetColumnFlags(int column_n = -1);
IMGUI_API void TableSetColumnEnabled(
int column_n,
bool v
);
IMGUI_API int TableGetHoveredColumn();
IMGUI_API void TableSetBgColor(
ImGuiTableBgTarget target,
ImU32 color,
int column_n = -1
);
IMGUI_API void Columns(
int count = 1,
const char* id = NULL,
bool borders = true
);
IMGUI_API void NextColumn();
IMGUI_API int GetColumnIndex();
IMGUI_API float GetColumnWidth(int column_index = -1);
IMGUI_API void SetColumnWidth(
int column_index,
float width
);
IMGUI_API float GetColumnOffset(int column_index = -1);
IMGUI_API void SetColumnOffset(
int column_index,
float offset_x
);
IMGUI_API int GetColumnsCount();
IMGUI_API bool BeginTabBar(
const char* str_id,
ImGuiTabBarFlags flags = 0
);
IMGUI_API void EndTabBar();
IMGUI_API bool BeginTabItem(
const char* label,
bool* p_open = NULL,
ImGuiTabItemFlags flags = 0
);
IMGUI_API void EndTabItem();
IMGUI_API bool TabItemButton(
const char* label,
ImGuiTabItemFlags flags = 0
);
IMGUI_API void SetTabItemClosed(const char* tab_or_docked_window_label);
IMGUI_API ImGuiID DockSpace(
ImGuiID dockspace_id,
const ImVec2& size = ImVec2(0, 0),
ImGuiDockNodeFlags flags = 0,
const ImGuiWindowClass* window_class = NULL
);
IMGUI_API ImGuiID DockSpaceOverViewport(
ImGuiID dockspace_id = 0,
const ImGuiViewport* viewport = NULL,
ImGuiDockNodeFlags flags = 0,
const ImGuiWindowClass* window_class = NULL
);
IMGUI_API void SetNextWindowDockID(
ImGuiID dock_id,
ImGuiCond cond = 0
);
IMGUI_API void SetNextWindowClass(const ImGuiWindowClass* window_class);
IMGUI_API ImGuiID GetWindowDockID();
IMGUI_API bool IsWindowDocked();
IMGUI_API void LogToTTY(int auto_open_depth = -1);
IMGUI_API void LogToFile(
int auto_open_depth = -1,
const char* filename = NULL
);
IMGUI_API void LogToClipboard(int auto_open_depth = -1);
IMGUI_API void LogFinish();
IMGUI_API void LogButtons();
IMGUI_API void LogText(
const char* fmt,
...
);
IMGUI_API void LogTextV(
const char* fmt,
va_list args
);
IMGUI_API bool BeginDragDropSource(ImGuiDragDropFlags flags = 0);
IMGUI_API bool SetDragDropPayload(
const char* type,
const void* data,
size_t sz,
ImGuiCond cond = 0
);
IMGUI_API void EndDragDropSource();
IMGUI_API bool BeginDragDropTarget();
IMGUI_API const ImGuiPayload* AcceptDragDropPayload(
const char* type,
ImGuiDragDropFlags flags = 0
);
IMGUI_API void EndDragDropTarget();
IMGUI_API const ImGuiPayload* GetDragDropPayload();
IMGUI_API void BeginDisabled(bool disabled = true);
IMGUI_API void EndDisabled();
IMGUI_API void PushClipRect(
const ImVec2& clip_rect_min,
const ImVec2& clip_rect_max,
bool intersect_with_current_clip_rect
);
IMGUI_API void PopClipRect();
IMGUI_API void SetItemDefaultFocus();
IMGUI_API void SetKeyboardFocusHere(int offset = 0);
IMGUI_API void SetNavCursorVisible(bool visible);
IMGUI_API void SetNextItemAllowOverlap();
IMGUI_API bool IsItemHovered(ImGuiHoveredFlags flags = 0);
IMGUI_API bool IsItemActive();
IMGUI_API bool IsItemFocused();
IMGUI_API bool IsItemClicked(ImGuiMouseButton mouse_button = 0);
IMGUI_API bool IsItemVisible();
IMGUI_API bool IsItemEdited();
IMGUI_API bool IsItemActivated();
IMGUI_API bool IsItemDeactivated();
IMGUI_API bool IsItemDeactivatedAfterEdit();
IMGUI_API bool IsItemToggledOpen();
IMGUI_API bool IsAnyItemHovered();
IMGUI_API bool IsAnyItemActive();
IMGUI_API bool IsAnyItemFocused();
IMGUI_API ImGuiID GetItemID();
IMGUI_API ImVec2 GetItemRectMin();
IMGUI_API ImVec2 GetItemRectMax();
IMGUI_API ImVec2 GetItemRectSize();
IMGUI_API ImGuiItemFlags GetItemFlags();
IMGUI_API ImGuiViewport* GetMainViewport();
IMGUI_API ImDrawList* GetBackgroundDrawList(ImGuiViewport* viewport = NULL);
IMGUI_API ImDrawList* GetForegroundDrawList(ImGuiViewport* viewport = NULL);
IMGUI_API bool IsRectVisible(const ImVec2& size);
IMGUI_API bool IsRectVisible(
const ImVec2& rect_min,
const ImVec2& rect_max
);
IMGUI_API double GetTime();
IMGUI_API int GetFrameCount();
IMGUI_API ImDrawListSharedData* GetDrawListSharedData();
IMGUI_API const char* GetStyleColorName(ImGuiCol idx);
IMGUI_API void SetStateStorage(ImGuiStorage* storage);
IMGUI_API ImGuiStorage* GetStateStorage();
IMGUI_API ImVec2 CalcTextSize(
const char* text,
const char* text_end = NULL,
bool hide_text_after_double_hash = false,
float wrap_width = -1.0f
);
IMGUI_API ImVec4 ColorConvertU32ToFloat4(ImU32 in);
IMGUI_API ImU32 ColorConvertFloat4ToU32(const ImVec4& in);
IMGUI_API void ColorConvertRGBtoHSV(
float r,
float g,
float b,
float& out_h,
float& out_s,
float& out_v
);
IMGUI_API void ColorConvertHSVtoRGB(
float h,
float s,
float v,
float& out_r,
float& out_g,
float& out_b
);
IMGUI_API bool IsKeyDown(ImGuiKey key);
IMGUI_API bool IsKeyPressed(
ImGuiKey key,
bool repeat = true
);
IMGUI_API bool IsKeyReleased(ImGuiKey key);
IMGUI_API bool IsKeyChordPressed(ImGuiKeyChord key_chord);
IMGUI_API int GetKeyPressedAmount(
ImGuiKey key,
float repeat_delay,
float rate
);
IMGUI_API const char* GetKeyName(ImGuiKey key);
IMGUI_API void SetNextFrameWantCaptureKeyboard(bool want_capture_keyboard);
IMGUI_API bool Shortcut(
ImGuiKeyChord key_chord,
ImGuiInputFlags flags = 0
);
IMGUI_API void SetNextItemShortcut(
ImGuiKeyChord key_chord,
ImGuiInputFlags flags = 0
);
IMGUI_API void SetItemKeyOwner(ImGuiKey key);
IMGUI_API bool IsMouseDown(ImGuiMouseButton button);
IMGUI_API bool IsMouseClicked(
ImGuiMouseButton button,
bool repeat = false
);
IMGUI_API bool IsMouseReleased(ImGuiMouseButton button);
IMGUI_API bool IsMouseDoubleClicked(ImGuiMouseButton button);
IMGUI_API bool IsMouseReleasedWithDelay(
ImGuiMouseButton button,
float delay
);
IMGUI_API int GetMouseClickedCount(ImGuiMouseButton button);
IMGUI_API bool IsMouseHoveringRect(
const ImVec2& r_min,
const ImVec2& r_max,
bool clip = true
);
IMGUI_API bool IsMousePosValid(const ImVec2* mouse_pos = NULL);
IMGUI_API bool IsAnyMouseDown();
IMGUI_API ImVec2 GetMousePos();
IMGUI_API ImVec2 GetMousePosOnOpeningCurrentPopup();
IMGUI_API bool IsMouseDragging(
ImGuiMouseButton button,
float lock_threshold = -1.0f
);
IMGUI_API ImVec2 GetMouseDragDelta(
ImGuiMouseButton button = 0,
float lock_threshold = -1.0f
);
IMGUI_API void ResetMouseDragDelta(ImGuiMouseButton button = 0);
IMGUI_API ImGuiMouseCursor GetMouseCursor();
IMGUI_API void SetMouseCursor(ImGuiMouseCursor cursor_type);
IMGUI_API void SetNextFrameWantCaptureMouse(bool want_capture_mouse);
IMGUI_API const char* GetClipboardText();
IMGUI_API void SetClipboardText(const char* text);
IMGUI_API void LoadIniSettingsFromDisk(const char* ini_filename);
IMGUI_API void LoadIniSettingsFromMemory(
const char* ini_data,
size_t ini_size = 0
);
IMGUI_API void SaveIniSettingsToDisk(const char* ini_filename);
IMGUI_API const char* SaveIniSettingsToMemory(size_t* out_ini_size = NULL);
IMGUI_API void DebugTextEncoding(const char* text);
IMGUI_API void DebugFlashStyleColor(ImGuiCol idx);
IMGUI_API void DebugStartItemPicker();
IMGUI_API bool DebugCheckVersionAndDataLayout(
const char* version_str,
size_t sz_io,
size_t sz_style,
size_t sz_vec2,
size_t sz_vec4,
size_t sz_drawvert,
size_t sz_drawidx
);
IMGUI_API void DebugLog(
const char* fmt,
...
);
IMGUI_API void DebugLogV(
const char* fmt,
va_list args
);
IMGUI_API void SetAllocatorFunctions(
ImGuiMemAllocFunc alloc_func,
ImGuiMemFreeFunc free_func,
void* user_data = NULL
);
IMGUI_API void GetAllocatorFunctions(
ImGuiMemAllocFunc* p_alloc_func,
ImGuiMemFreeFunc* p_free_func,
void** p_user_data
);
IMGUI_API void* MemAlloc(size_t size);
IMGUI_API void MemFree(void* ptr);
IMGUI_API void UpdatePlatformWindows();
IMGUI_API void RenderPlatformWindowsDefault(
void* platform_render_arg = NULL,
void* renderer_render_arg = NULL
);
IMGUI_API void DestroyPlatformWindows();
IMGUI_API ImGuiViewport* FindViewportByID(ImGuiID viewport_id);
IMGUI_API ImGuiViewport* FindViewportByPlatformHandle(void* platform_handle);
void PushFont(ImFont* font);
IMGUI_API void SetWindowFontScale(float scale);
IMGUI_API void Image(
ImTextureRef tex_ref,
const ImVec2& image_size,
const ImVec2& uv0,
const ImVec2& uv1,
const ImVec4& tint_col,
const ImVec4& border_col
);
void PushButtonRepeat(bool repeat);
void PopButtonRepeat();
void PushTabStop(bool tab_stop);
void PopTabStop();
IMGUI_API ImVec2 GetContentRegionMax();
IMGUI_API ImVec2 GetWindowContentRegionMin();
IMGUI_API ImVec2 GetWindowContentRegionMax();
IMGUI_API void DemoMarker(
const char* file,
int line,
const char* section
);
IMGUI_API void ShowFontAtlas(ImFontAtlas* atlas);
IMGUI_API void TreeNodeSetOpen(
ImGuiID storage_id,
bool is_open
);
float GetScale();
ImGuiWindow* GetCurrentWindowRead();
ImGuiWindow* GetCurrentWindow();
IMGUI_API ImGuiWindow* FindWindowByID(ImGuiID id);
IMGUI_API ImGuiWindow* FindWindowByName(const char* name);
IMGUI_API void UpdateWindowParentAndRootLinks(
ImGuiWindow* window,
ImGuiWindowFlags flags,
ImGuiWindow* parent_window
);
IMGUI_API void UpdateWindowSkipRefresh(ImGuiWindow* window);
IMGUI_API ImVec2 CalcWindowNextAutoFitSize(ImGuiWindow* window);
IMGUI_API bool IsWindowChildOf(
ImGuiWindow* window,
ImGuiWindow* potential_parent,
bool popup_hierarchy,
bool dock_hierarchy
);
IMGUI_API bool IsWindowInBeginStack(ImGuiWindow* window);
IMGUI_API bool IsWindowWithinBeginStackOf(
ImGuiWindow* window,
ImGuiWindow* potential_parent
);
IMGUI_API bool IsWindowAbove(
ImGuiWindow* potential_above,
ImGuiWindow* potential_below
);
IMGUI_API bool IsWindowNavFocusable(ImGuiWindow* window);
IMGUI_API void SetWindowPos(
ImGuiWindow* window,
const ImVec2& pos,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowSize(
ImGuiWindow* window,
const ImVec2& size,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowCollapsed(
ImGuiWindow* window,
bool collapsed,
ImGuiCond cond = 0
);
IMGUI_API void SetWindowHitTestHole(
ImGuiWindow* window,
const ImVec2& pos,
const ImVec2& size
);
IMGUI_API void SetWindowHiddenAndSkipItemsForCurrentFrame(ImGuiWindow* window);
void SetWindowParentWindowForFocusRoute(
ImGuiWindow* window,
ImGuiWindow* parent_window
);
ImRect WindowRectAbsToRel(
ImGuiWindow* window,
const ImRect& r
);
ImRect WindowRectRelToAbs(
ImGuiWindow* window,
const ImRect& r
);
ImVec2 WindowPosAbsToRel(
ImGuiWindow* window,
const ImVec2& p
);
ImVec2 WindowPosRelToAbs(
ImGuiWindow* window,
const ImVec2& p
);
IMGUI_API void FocusWindow(
ImGuiWindow* window,
ImGuiFocusRequestFlags flags = 0
);
IMGUI_API void FocusTopMostWindowUnderOne(
ImGuiWindow* under_this_window,
ImGuiWindow* ignore_window,
ImGuiViewport* filter_viewport,
ImGuiFocusRequestFlags flags
);
IMGUI_API void BringWindowToFocusFront(ImGuiWindow* window);
IMGUI_API void BringWindowToDisplayFront(ImGuiWindow* window);
IMGUI_API void BringWindowToDisplayBack(ImGuiWindow* window);
IMGUI_API void BringWindowToDisplayBehind(
ImGuiWindow* window,
ImGuiWindow* above_window
);
IMGUI_API int FindWindowDisplayIndex(ImGuiWindow* window);
IMGUI_API ImGuiWindow* FindBottomMostVisibleWindowWithinBeginStack(ImGuiWindow* window);
IMGUI_API void SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags);
IMGUI_API void RegisterUserTexture(ImTextureData* tex);
IMGUI_API void UnregisterUserTexture(ImTextureData* tex);
IMGUI_API void RegisterFontAtlas(ImFontAtlas* atlas);
IMGUI_API void UnregisterFontAtlas(ImFontAtlas* atlas);
IMGUI_API void SetCurrentFont(
ImFont* font,
float font_size_before_scaling,
float font_size_after_scaling
);
IMGUI_API void UpdateCurrentFontSize(float restore_font_size_after_scaling);
IMGUI_API void SetFontRasterizerDensity(float rasterizer_density);
float GetFontRasterizerDensity();
float GetRoundedFontSize(float size);
IMGUI_API ImFont* GetDefaultFont();
IMGUI_API void PushPasswordFont();
IMGUI_API void PopPasswordFont();
ImDrawList* GetForegroundDrawList(ImGuiWindow* window);
IMGUI_API void AddDrawListToDrawDataEx(
ImDrawData* draw_data,
ImVector<ImDrawList*>* out_list,
ImDrawList* draw_list
);
IMGUI_API void Initialize();
IMGUI_API void Shutdown();
IMGUI_API void SetContextName(
ImGuiContext* ctx,
const char* name
);
IMGUI_API ImGuiID AddContextHook(
ImGuiContext* ctx,
const ImGuiContextHook* hook
);
IMGUI_API void RemoveContextHook(
ImGuiContext* ctx,
ImGuiID hook_to_remove
);
IMGUI_API void CallContextHooks(
ImGuiContext* ctx,
ImGuiContextHookType type
);
IMGUI_API void UpdateInputEvents(bool trickle_fast_inputs);
IMGUI_API void UpdateHoveredWindowAndCaptureFlags(const ImVec2& mouse_pos);
IMGUI_API void FindHoveredWindowEx(
const ImVec2& pos,
bool find_first_and_in_any_viewport,
ImGuiWindow** out_hovered_window,
ImGuiWindow** out_hovered_window_under_moving_window
);
IMGUI_API void StartMouseMovingWindow(ImGuiWindow* window);
IMGUI_API void StartMouseMovingWindowOrNode(
ImGuiWindow* window,
ImGuiDockNode* node,
bool undock
);
IMGUI_API void StopMouseMovingWindow();
IMGUI_API void UpdateMouseMovingWindowNewFrame();
IMGUI_API void UpdateMouseMovingWindowEndFrame();
IMGUI_API void TranslateWindowsInViewport(
ImGuiViewportP* viewport,
const ImVec2& old_pos,
const ImVec2& new_pos,
const ImVec2& old_size,
const ImVec2& new_size
);
IMGUI_API void ScaleWindowsInViewport(
ImGuiViewportP* viewport,
float scale
);
IMGUI_API void DestroyPlatformWindow(ImGuiViewportP* viewport);
IMGUI_API void SetWindowViewport(
ImGuiWindow* window,
ImGuiViewportP* viewport
);
IMGUI_API void SetCurrentViewport(
ImGuiWindow* window,
ImGuiViewportP* viewport
);
IMGUI_API const ImGuiPlatformMonitor* GetViewportPlatformMonitor(ImGuiViewport* viewport);
IMGUI_API ImGuiViewportP* FindHoveredViewportFromPlatformWindowStack(const ImVec2& mouse_platform_pos);
IMGUI_API void MarkIniSettingsDirty();
IMGUI_API void MarkIniSettingsDirty(ImGuiWindow* window);
IMGUI_API void ClearIniSettings();
IMGUI_API void AddSettingsHandler(const ImGuiSettingsHandler* handler);
IMGUI_API void RemoveSettingsHandler(const char* type_name);
IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
IMGUI_API ImGuiWindowSettings* CreateNewWindowSettings(const char* name);
IMGUI_API ImGuiWindowSettings* FindWindowSettingsByID(ImGuiID id);
IMGUI_API ImGuiWindowSettings* FindWindowSettingsByWindow(ImGuiWindow* window);
IMGUI_API void ClearWindowSettings(const char* name);
IMGUI_API void LocalizeRegisterEntries(
const ImGuiLocEntry* entries,
int count
);
const char* LocalizeGetMsg(ImGuiLocKey key);
IMGUI_API void SetScrollX(
ImGuiWindow* window,
float scroll_x
);
IMGUI_API void SetScrollY(
ImGuiWindow* window,
float scroll_y
);
IMGUI_API void SetScrollFromPosX(
ImGuiWindow* window,
float local_x,
float center_x_ratio
);
IMGUI_API void SetScrollFromPosY(
ImGuiWindow* window,
float local_y,
float center_y_ratio
);
IMGUI_API void ScrollToItem(ImGuiScrollFlags flags = 0);
IMGUI_API void ScrollToRect(
ImGuiWindow* window,
const ImRect& rect,
ImGuiScrollFlags flags = 0
);
IMGUI_API ImVec2 ScrollToRectEx(
ImGuiWindow* window,
const ImRect& rect,
ImGuiScrollFlags flags = 0
);
void ScrollToBringRectIntoView(
ImGuiWindow* window,
const ImRect& rect
);
ImGuiItemStatusFlags GetItemStatusFlags();
ImGuiID GetActiveID();
ImGuiID GetFocusID();
IMGUI_API void SetActiveID(
ImGuiID id,
ImGuiWindow* window
);
IMGUI_API void SetFocusID(
ImGuiID id,
ImGuiWindow* window
);
IMGUI_API void ClearActiveID();
IMGUI_API ImGuiID GetHoveredID();
IMGUI_API void SetHoveredID(ImGuiID id);
IMGUI_API void KeepAliveID(ImGuiID id);
IMGUI_API void MarkItemEdited(ImGuiID id);
IMGUI_API void PushOverrideID(ImGuiID id);
IMGUI_API ImGuiID GetIDWithSeed(
const char* str_id_begin,
const char* str_id_end,
ImGuiID seed
);
IMGUI_API ImGuiID GetIDWithSeed(
int n,
ImGuiID seed
);
IMGUI_API void ItemSize(
const ImVec2& size,
float text_baseline_y = -1.0f
);
void ItemSize(
const ImRect& bb,
float text_baseline_y = -1.0f
);
IMGUI_API bool ItemAdd(
const ImRect& bb,
ImGuiID id,
const ImRect* nav_bb = NULL,
ImGuiItemFlags extra_flags = 0
);
IMGUI_API bool ItemHoverable(
const ImRect& bb,
ImGuiID id,
ImGuiItemFlags item_flags
);
IMGUI_API bool IsWindowContentHoverable(
ImGuiWindow* window,
ImGuiHoveredFlags flags = 0
);
IMGUI_API bool IsClippedEx(
const ImRect& bb,
ImGuiID id
);
IMGUI_API void SetLastItemData(
ImGuiID item_id,
ImGuiItemFlags item_flags,
ImGuiItemStatusFlags status_flags,
const ImRect& item_rect
);
IMGUI_API ImVec2 CalcItemSize(
ImVec2 size,
float default_w,
float default_h
);
IMGUI_API float CalcWrapWidthForPos(
const ImVec2& pos,
float wrap_pos_x
);
IMGUI_API void PushMultiItemsWidths(
int components,
float width_full
);
IMGUI_API void ShrinkWidths(
ImGuiShrinkWidthItem* items,
int count,
float width_excess,
float width_min
);
IMGUI_API void CalcClipRectVisibleItemsY(
const ImRect& clip_rect,
const ImVec2& pos,
float items_height,
int* out_visible_start,
int* out_visible_end
);
IMGUI_API const ImGuiStyleVarInfo* GetStyleVarInfo(ImGuiStyleVar idx);
IMGUI_API void BeginDisabledOverrideReenable();
IMGUI_API void EndDisabledOverrideReenable();
IMGUI_API void LogBegin(
ImGuiLogFlags flags,
int auto_open_depth
);
IMGUI_API void LogToBuffer(int auto_open_depth = -1);
IMGUI_API void LogRenderedText(
const ImVec2* ref_pos,
const char* text,
const char* text_end = NULL
);
IMGUI_API void LogSetNextTextDecoration(
const char* prefix,
const char* suffix
);
IMGUI_API bool BeginChildEx(
const char* name,
ImGuiID id,
const ImVec2& size_arg,
ImGuiChildFlags child_flags,
ImGuiWindowFlags window_flags
);
IMGUI_API bool BeginPopupEx(
ImGuiID id,
ImGuiWindowFlags extra_window_flags
);
IMGUI_API bool BeginPopupMenuEx(
ImGuiID id,
const char* label,
ImGuiWindowFlags extra_window_flags
);
IMGUI_API void OpenPopupEx(
ImGuiID id,
ImGuiPopupFlags popup_flags = ImGuiPopupFlags_None
);
IMGUI_API void ClosePopupToLevel(
int remaining,
bool restore_focus_to_window_under_popup
);
IMGUI_API void ClosePopupsOverWindow(
ImGuiWindow* ref_window,
bool restore_focus_to_window_under_popup
);
IMGUI_API void ClosePopupsExceptModals();
IMGUI_API bool IsPopupOpen(
ImGuiID id,
ImGuiPopupFlags popup_flags
);
IMGUI_API ImRect GetPopupAllowedExtentRect(ImGuiWindow* window);
IMGUI_API ImGuiWindow* GetTopMostPopupModal();
IMGUI_API ImGuiWindow* GetTopMostAndVisiblePopupModal();
IMGUI_API ImGuiWindow* FindBlockingModal(ImGuiWindow* window);
IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow* window);
IMGUI_API ImVec2 FindBestWindowPosForPopupEx(
const ImVec2& ref_pos,
const ImVec2& size,
ImGuiDir* last_dir,
const ImRect& r_outer,
const ImRect& r_avoid,
ImGuiPopupPositionPolicy policy
);
IMGUI_API ImGuiMouseButton GetMouseButtonFromPopupFlags(ImGuiPopupFlags flags);
IMGUI_API bool BeginTooltipEx(
ImGuiTooltipFlags tooltip_flags,
ImGuiWindowFlags extra_window_flags
);
IMGUI_API bool BeginTooltipHidden();
IMGUI_API bool BeginViewportSideBar(
const char* name,
ImGuiViewport* viewport,
ImGuiDir dir,
float size,
ImGuiWindowFlags window_flags
);
IMGUI_API bool BeginMenuEx(
const char* label,
const char* icon,
bool enabled = true
);
IMGUI_API bool MenuItemEx(
const char* label,
const char* icon,
const char* shortcut = NULL,
bool selected = false,
bool enabled = true
);
IMGUI_API bool BeginComboPopup(
ImGuiID popup_id,
const ImRect& bb,
ImGuiComboFlags flags
);
IMGUI_API bool BeginComboPreview();
IMGUI_API void EndComboPreview();
IMGUI_API void NavInitWindow(
ImGuiWindow* window,
bool force_reinit
);
IMGUI_API void NavInitRequestApplyResult();
IMGUI_API bool NavMoveRequestButNoResultYet();
IMGUI_API void NavMoveRequestSubmit(
ImGuiDir move_dir,
ImGuiDir clip_dir,
ImGuiNavMoveFlags move_flags,
ImGuiScrollFlags scroll_flags
);
IMGUI_API void NavMoveRequestForward(
ImGuiDir move_dir,
ImGuiDir clip_dir,
ImGuiNavMoveFlags move_flags,
ImGuiScrollFlags scroll_flags
);
IMGUI_API void NavMoveRequestResolveWithLastItem(ImGuiNavItemData* result);
IMGUI_API void NavMoveRequestResolveWithPastTreeNode(
ImGuiNavItemData* result,
const ImGuiTreeNodeStackData* tree_node_data
);
IMGUI_API void NavMoveRequestCancel();
IMGUI_API void NavMoveRequestApplyResult();
IMGUI_API void NavMoveRequestTryWrapping(
ImGuiWindow* window,
ImGuiNavMoveFlags move_flags
);
IMGUI_API void NavHighlightActivated(ImGuiID id);
IMGUI_API void NavClearPreferredPosForAxis(ImGuiAxis axis);
IMGUI_API void SetNavCursorVisibleAfterMove();
IMGUI_API void NavUpdateCurrentWindowIsScrollPushableX();
IMGUI_API void SetNavWindow(ImGuiWindow* window);
IMGUI_API void SetNavID(
ImGuiID id,
ImGuiNavLayer nav_layer,
ImGuiID focus_scope_id,
const ImRect& rect_rel
);
IMGUI_API void SetNavFocusScope(ImGuiID focus_scope_id);
IMGUI_API void FocusItem();
IMGUI_API void ActivateItemByID(ImGuiID id);
bool IsNamedKey(ImGuiKey key);
bool IsNamedKeyOrMod(ImGuiKey key);
bool IsLegacyKey(ImGuiKey key);
bool IsKeyboardKey(ImGuiKey key);
bool IsGamepadKey(ImGuiKey key);
bool IsMouseKey(ImGuiKey key);
bool IsAliasKey(ImGuiKey key);
bool IsLRModKey(ImGuiKey key);
ImGuiKeyChord FixupKeyChord(ImGuiKeyChord key_chord);
ImGuiKey ConvertSingleModFlagToKey(ImGuiKey key);
IMGUI_API ImGuiKeyData* GetKeyData(
ImGuiContext* ctx,
ImGuiKey key
);
ImGuiKeyData* GetKeyData(ImGuiKey key);
IMGUI_API const char* GetKeyChordName(ImGuiKeyChord key_chord);
ImGuiKey MouseButtonToKey(ImGuiMouseButton button);
IMGUI_API bool IsMouseDragPastThreshold(
ImGuiMouseButton button,
float lock_threshold = -1.0f
);
IMGUI_API ImVec2 GetKeyMagnitude2d(
ImGuiKey key_left,
ImGuiKey key_right,
ImGuiKey key_up,
ImGuiKey key_down
);
IMGUI_API float GetNavTweakPressedAmount(ImGuiAxis axis);
IMGUI_API int CalcTypematicRepeatAmount(
float t0,
float t1,
float repeat_delay,
float repeat_rate
);
IMGUI_API void GetTypematicRepeatRate(
ImGuiInputFlags flags,
float* repeat_delay,
float* repeat_rate
);
IMGUI_API void TeleportMousePos(const ImVec2& pos);
IMGUI_API void SetActiveIdUsingAllKeyboardKeys();
bool IsActiveIdUsingNavDir(ImGuiDir dir);
IMGUI_API ImGuiID GetKeyOwner(ImGuiKey key);
IMGUI_API void SetKeyOwner(
ImGuiKey key,
ImGuiID owner_id,
ImGuiInputFlags flags = 0
);
IMGUI_API void SetKeyOwnersForKeyChord(
ImGuiKeyChord key,
ImGuiID owner_id,
ImGuiInputFlags flags = 0
);
IMGUI_API void SetItemKeyOwner(
ImGuiKey key,
ImGuiInputFlags flags
);
IMGUI_API bool TestKeyOwner(
ImGuiKey key,
ImGuiID owner_id
);
ImGuiKeyOwnerData* GetKeyOwnerData(
ImGuiContext* ctx,
ImGuiKey key
);
IMGUI_API bool IsKeyDown(
ImGuiKey key,
ImGuiID owner_id
);
IMGUI_API bool IsKeyPressed(
ImGuiKey key,
ImGuiInputFlags flags,
ImGuiID owner_id = 0
);
IMGUI_API bool IsKeyReleased(
ImGuiKey key,
ImGuiID owner_id
);
IMGUI_API bool IsKeyChordPressed(
ImGuiKeyChord key_chord,
ImGuiInputFlags flags,
ImGuiID owner_id = 0
);
IMGUI_API bool IsMouseDown(
ImGuiMouseButton button,
ImGuiID owner_id
);
IMGUI_API bool IsMouseClicked(
ImGuiMouseButton button,
ImGuiInputFlags flags,
ImGuiID owner_id = 0
);
IMGUI_API bool IsMouseReleased(
ImGuiMouseButton button,
ImGuiID owner_id
);
IMGUI_API bool IsMouseDoubleClicked(
ImGuiMouseButton button,
ImGuiID owner_id
);
IMGUI_API bool Shortcut(
ImGuiKeyChord key_chord,
ImGuiInputFlags flags,
ImGuiID owner_id
);
IMGUI_API bool SetShortcutRouting(
ImGuiKeyChord key_chord,
ImGuiInputFlags flags,
ImGuiID owner_id
);
IMGUI_API bool TestShortcutRouting(
ImGuiKeyChord key_chord,
ImGuiID owner_id
);
IMGUI_API ImGuiKeyRoutingData* GetShortcutRoutingData(ImGuiKeyChord key_chord);
IMGUI_API void DockContextInitialize(ImGuiContext* ctx);
IMGUI_API void DockContextShutdown(ImGuiContext* ctx);
IMGUI_API void DockContextClearNodes(
ImGuiContext* ctx,
ImGuiID root_id,
bool clear_settings_refs
);
IMGUI_API void DockContextRebuildNodes(ImGuiContext* ctx);
IMGUI_API void DockContextNewFrameUpdateUndocking(ImGuiContext* ctx);
IMGUI_API void DockContextNewFrameUpdateDocking(ImGuiContext* ctx);
IMGUI_API void DockContextEndFrame(ImGuiContext* ctx);
IMGUI_API ImGuiID DockContextGenNodeID(ImGuiContext* ctx);
IMGUI_API void DockContextQueueDock(
ImGuiContext* ctx,
ImGuiWindow* target,
ImGuiDockNode* target_node,
ImGuiWindow* payload,
ImGuiDir split_dir,
float split_ratio,
bool split_outer
);
IMGUI_API void DockContextQueueUndockWindow(
ImGuiContext* ctx,
ImGuiWindow* window
);
IMGUI_API void DockContextQueueUndockNode(
ImGuiContext* ctx,
ImGuiDockNode* node
);
IMGUI_API void DockContextProcessUndockWindow(
ImGuiContext* ctx,
ImGuiWindow* window,
bool clear_persistent_docking_ref = true
);
IMGUI_API void DockContextProcessUndockNode(
ImGuiContext* ctx,
ImGuiDockNode* node
);
IMGUI_API bool DockContextCalcDropPosForDocking(
ImGuiWindow* target,
ImGuiDockNode* target_node,
ImGuiWindow* payload_window,
ImGuiDockNode* payload_node,
ImGuiDir split_dir,
bool split_outer,
ImVec2* out_pos
);
IMGUI_API ImGuiDockNode* DockContextFindNodeByID(
ImGuiContext* ctx,
ImGuiID id
);
IMGUI_API void DockNodeWindowMenuHandler_Default(
ImGuiContext* ctx,
ImGuiDockNode* node,
ImGuiTabBar* tab_bar
);
IMGUI_API bool DockNodeBeginAmendTabBar(ImGuiDockNode* node);
IMGUI_API void DockNodeEndAmendTabBar();
ImGuiDockNode* DockNodeGetRootNode(ImGuiDockNode* node);
bool DockNodeIsInHierarchyOf(
ImGuiDockNode* node,
ImGuiDockNode* parent
);
int DockNodeGetDepth(const ImGuiDockNode* node);
ImGuiID DockNodeGetWindowMenuButtonId(const ImGuiDockNode* node);
ImGuiDockNode* GetWindowDockNode();
IMGUI_API bool GetWindowAlwaysWantOwnTabBar(ImGuiWindow* window);
IMGUI_API void BeginDocked(
ImGuiWindow* window,
bool* p_open
);
IMGUI_API void BeginDockableDragDropSource(ImGuiWindow* window);
IMGUI_API void BeginDockableDragDropTarget(ImGuiWindow* window);
IMGUI_API void SetWindowDock(
ImGuiWindow* window,
ImGuiID dock_id,
ImGuiCond cond
);
IMGUI_API void DockBuilderDockWindow(
const char* window_name,
ImGuiID node_id
);
IMGUI_API ImGuiDockNode* DockBuilderGetNode(ImGuiID node_id);
ImGuiDockNode* DockBuilderGetCentralNode(ImGuiID node_id);
IMGUI_API ImGuiID DockBuilderAddNode(
ImGuiID node_id = 0,
ImGuiDockNodeFlags flags = 0
);
IMGUI_API void DockBuilderRemoveNode(ImGuiID node_id);
IMGUI_API void DockBuilderRemoveNodeDockedWindows(
ImGuiID node_id,
bool clear_settings_refs = true
);
IMGUI_API void DockBuilderRemoveNodeChildNodes(ImGuiID node_id);
IMGUI_API void DockBuilderSetNodePos(
ImGuiID node_id,
ImVec2 pos
);
IMGUI_API void DockBuilderSetNodeSize(
ImGuiID node_id,
ImVec2 size
);
IMGUI_API ImGuiID DockBuilderSplitNode(
ImGuiID node_id,
ImGuiDir split_dir,
float size_ratio_for_node_at_dir,
ImGuiID* out_id_at_dir,
ImGuiID* out_id_at_opposite_dir
);
IMGUI_API void DockBuilderCopyDockSpace(
ImGuiID src_dockspace_id,
ImGuiID dst_dockspace_id,
ImVector<const char*>* in_window_remap_pairs
);
IMGUI_API void DockBuilderCopyNode(
ImGuiID src_node_id,
ImGuiID dst_node_id,
ImVector<ImGuiID>* out_node_remap_pairs
);
IMGUI_API void DockBuilderCopyWindowSettings(
const char* src_name,
const char* dst_name
);
IMGUI_API void DockBuilderFinish(ImGuiID node_id);
IMGUI_API void PushFocusScope(ImGuiID id);
IMGUI_API void PopFocusScope();
ImGuiID GetCurrentFocusScope();
IMGUI_API bool IsDragDropActive();
IMGUI_API bool BeginDragDropTargetCustom(
const ImRect& bb,
ImGuiID id
);
IMGUI_API bool BeginDragDropTargetViewport(
ImGuiViewport* viewport,
const ImRect* p_bb = NULL
);
IMGUI_API void ClearDragDrop();
IMGUI_API bool IsDragDropPayloadBeingAccepted();
IMGUI_API void RenderDragDropTargetRectForItem(const ImRect& bb);
IMGUI_API void RenderDragDropTargetRectEx(
ImDrawList* draw_list,
const ImRect& bb
);
IMGUI_API ImGuiTypingSelectRequest* GetTypingSelectRequest(ImGuiTypingSelectFlags flags = ImGuiTypingSelectFlags_None);
IMGUI_API int TypingSelectFindMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char*(*)(void*, int) get_item_name_func,
void* user_data,
int nav_item_idx
);
IMGUI_API int TypingSelectFindNextSingleCharMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char*(*)(void*, int) get_item_name_func,
void* user_data,
int nav_item_idx
);
IMGUI_API int TypingSelectFindBestLeadingMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char*(*)(void*, int) get_item_name_func,
void* user_data
);
IMGUI_API bool BeginBoxSelect(
const ImRect& scope_rect,
ImGuiWindow* window,
ImGuiID box_select_id,
ImGuiMultiSelectFlags ms_flags
);
IMGUI_API void EndBoxSelect(
const ImRect& scope_rect,
ImGuiMultiSelectFlags ms_flags
);
IMGUI_API void MultiSelectItemHeader(
ImGuiID id,
bool* p_selected,
ImGuiButtonFlags* p_button_flags
);
IMGUI_API void MultiSelectItemFooter(
ImGuiID id,
bool* p_selected,
bool* p_pressed
);
IMGUI_API void MultiSelectAddSetAll(
ImGuiMultiSelectTempData* ms,
bool selected
);
IMGUI_API void MultiSelectAddSetRange(
ImGuiMultiSelectTempData* ms,
bool selected,
int range_dir,
ImGuiSelectionUserData first_item,
ImGuiSelectionUserData last_item
);
ImGuiBoxSelectState* GetBoxSelectState(ImGuiID id);
ImGuiMultiSelectState* GetMultiSelectState(ImGuiID id);
IMGUI_API void SetWindowClipRectBeforeSetChannel(
ImGuiWindow* window,
const ImRect& clip_rect
);
IMGUI_API void BeginColumns(
const char* str_id,
int count,
ImGuiOldColumnFlags flags = 0
);
IMGUI_API void EndColumns();
IMGUI_API void PushColumnClipRect(int column_index);
IMGUI_API void PushColumnsBackground();
IMGUI_API void PopColumnsBackground();
IMGUI_API ImGuiID GetColumnsID(
const char* str_id,
int count
);
IMGUI_API ImGuiOldColumns* FindOrCreateColumns(
ImGuiWindow* window,
ImGuiID id
);
IMGUI_API float GetColumnOffsetFromNorm(
const ImGuiOldColumns* columns,
float offset_norm
);
IMGUI_API float GetColumnNormFromOffset(
const ImGuiOldColumns* columns,
float offset
);
IMGUI_API void TableOpenContextMenu(int column_n = -1);
IMGUI_API void TableSetColumnWidth(
int column_n,
float width
);
IMGUI_API void TableSetColumnSortDirection(
int column_n,
ImGuiSortDirection sort_direction,
bool append_to_sort_specs
);
IMGUI_API int TableGetHoveredRow();
IMGUI_API float TableGetHeaderRowHeight();
IMGUI_API float TableGetHeaderAngledMaxLabelWidth();
IMGUI_API void TablePushBackgroundChannel();
IMGUI_API void TablePopBackgroundChannel();
IMGUI_API void TablePushColumnChannel(int column_n);
IMGUI_API void TablePopColumnChannel();
IMGUI_API void TableAngledHeadersRowEx(
ImGuiID row_id,
float angle,
float max_label_width,
const ImGuiTableHeaderData* data,
int data_count
);
ImGuiTable* GetCurrentTable();
IMGUI_API ImGuiTable* TableFindByID(ImGuiID id);
IMGUI_API bool BeginTableEx(
const char* name,
ImGuiID id,
int columns_count,
ImGuiTableFlags flags = 0,
const ImVec2& outer_size = ImVec2(0, 0),
float inner_width = 0.0f
);
IMGUI_API void TableBeginInitMemory(
ImGuiTable* table,
int columns_count
);
IMGUI_API void TableBeginApplyRequests(ImGuiTable* table);
IMGUI_API void TableSetupDrawChannels(ImGuiTable* table);
IMGUI_API void TableUpdateLayout(ImGuiTable* table);
IMGUI_API void TableUpdateBorders(ImGuiTable* table);
IMGUI_API void TableUpdateColumnsWeightFromWidth(ImGuiTable* table);
IMGUI_API void TableDrawBorders(ImGuiTable* table);
IMGUI_API void TableDrawDefaultContextMenu(
ImGuiTable* table,
ImGuiTableFlags flags_for_section_to_display
);
IMGUI_API bool TableBeginContextMenuPopup(ImGuiTable* table);
IMGUI_API void TableMergeDrawChannels(ImGuiTable* table);
ImGuiTableInstanceData* TableGetInstanceData(
ImGuiTable* table,
int instance_no
);
ImGuiID TableGetInstanceID(
ImGuiTable* table,
int instance_no
);
IMGUI_API void TableFixDisplayOrder(ImGuiTable* table);
IMGUI_API void TableSortSpecsSanitize(ImGuiTable* table);
IMGUI_API void TableSortSpecsBuild(ImGuiTable* table);
IMGUI_API ImGuiSortDirection TableGetColumnNextSortDirection(ImGuiTableColumn* column);
IMGUI_API void TableFixColumnSortDirection(
ImGuiTable* table,
ImGuiTableColumn* column
);
IMGUI_API float TableGetColumnWidthAuto(
ImGuiTable* table,
ImGuiTableColumn* column
);
IMGUI_API void TableBeginRow(ImGuiTable* table);
IMGUI_API void TableEndRow(ImGuiTable* table);
IMGUI_API void TableBeginCell(
ImGuiTable* table,
int column_n
);
IMGUI_API void TableEndCell(ImGuiTable* table);
IMGUI_API ImRect TableGetCellBgRect(
const ImGuiTable* table,
int column_n
);
IMGUI_API const char* TableGetColumnName(
const ImGuiTable* table,
int column_n
);
IMGUI_API ImGuiID TableGetColumnResizeID(
ImGuiTable* table,
int column_n,
int instance_no = 0
);
IMGUI_API float TableCalcMaxColumnWidth(
const ImGuiTable* table,
int column_n
);
IMGUI_API void TableSetColumnWidthAutoSingle(
ImGuiTable* table,
int column_n
);
IMGUI_API void TableSetColumnWidthAutoAll(ImGuiTable* table);
IMGUI_API void TableSetColumnDisplayOrder(
ImGuiTable* table,
int column_n,
int dst_order
);
IMGUI_API void TableRemove(ImGuiTable* table);
IMGUI_API void TableGcCompactTransientBuffers(ImGuiTable* table);
IMGUI_API void TableGcCompactTransientBuffers(ImGuiTableTempData* table);
IMGUI_API void TableGcCompactSettings();
IMGUI_API void TableLoadSettings(ImGuiTable* table);
IMGUI_API void TableSaveSettings(ImGuiTable* table);
IMGUI_API void TableResetSettings(ImGuiTable* table);
IMGUI_API ImGuiTableSettings* TableGetBoundSettings(ImGuiTable* table);
IMGUI_API void TableSettingsAddSettingsHandler();
IMGUI_API ImGuiTableSettings* TableSettingsCreate(
ImGuiID id,
int columns_count
);
IMGUI_API ImGuiTableSettings* TableSettingsFindByID(ImGuiID id);
ImGuiTabBar* GetCurrentTabBar();
IMGUI_API ImGuiTabBar* TabBarFindByID(ImGuiID id);
IMGUI_API void TabBarRemove(ImGuiTabBar* tab_bar);
IMGUI_API bool BeginTabBarEx(
ImGuiTabBar* tab_bar,
const ImRect& bb,
ImGuiTabBarFlags flags
);
IMGUI_API ImGuiTabItem* TabBarFindTabByID(
ImGuiTabBar* tab_bar,
ImGuiID tab_id
);
IMGUI_API ImGuiTabItem* TabBarFindTabByOrder(
ImGuiTabBar* tab_bar,
int order
);
IMGUI_API ImGuiTabItem* TabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar);
IMGUI_API ImGuiTabItem* TabBarGetCurrentTab(ImGuiTabBar* tab_bar);
int TabBarGetTabOrder(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab
);
IMGUI_API const char* TabBarGetTabName(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab
);
IMGUI_API void TabBarAddTab(
ImGuiTabBar* tab_bar,
ImGuiTabItemFlags tab_flags,
ImGuiWindow* window
);
IMGUI_API void TabBarRemoveTab(
ImGuiTabBar* tab_bar,
ImGuiID tab_id
);
IMGUI_API void TabBarCloseTab(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab
);
IMGUI_API void TabBarQueueFocus(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab
);
IMGUI_API void TabBarQueueFocus(
ImGuiTabBar* tab_bar,
const char* tab_name
);
IMGUI_API void TabBarQueueReorder(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab,
int offset
);
IMGUI_API void TabBarQueueReorderFromMousePos(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab,
ImVec2 mouse_pos
);
IMGUI_API bool TabBarProcessReorder(ImGuiTabBar* tab_bar);
IMGUI_API bool TabItemEx(
ImGuiTabBar* tab_bar,
const char* label,
bool* p_open,
ImGuiTabItemFlags flags,
ImGuiWindow* docked_window
);
IMGUI_API void TabItemSpacing(
const char* str_id,
ImGuiTabItemFlags flags,
float width
);
IMGUI_API ImVec2 TabItemCalcSize(
const char* label,
bool has_close_button_or_unsaved_marker
);
IMGUI_API ImVec2 TabItemCalcSize(ImGuiWindow* window);
IMGUI_API void TabItemBackground(
ImDrawList* draw_list,
const ImRect& bb,
ImGuiTabItemFlags flags,
ImU32 col
);
IMGUI_API void TabItemLabelAndCloseButton(
ImDrawList* draw_list,
const ImRect& bb,
ImGuiTabItemFlags flags,
ImVec2 frame_padding,
const char* label,
ImGuiID tab_id,
ImGuiID close_button_id,
bool is_contents_visible,
bool* out_just_closed,
bool* out_text_clipped
);
IMGUI_API void RenderText(
ImVec2 pos,
const char* text,
const char* text_end = NULL,
bool hide_text_after_hash = true
);
IMGUI_API void RenderTextWrapped(
ImVec2 pos,
const char* text,
const char* text_end,
float wrap_width
);
IMGUI_API void RenderTextClipped(
const ImVec2& pos_min,
const ImVec2& pos_max,
const char* text,
const char* text_end,
const ImVec2* text_size_if_known,
const ImVec2& align = ImVec2(0, 0),
const ImRect* clip_rect = NULL
);
IMGUI_API void RenderTextClippedEx(
ImDrawList* draw_list,
const ImVec2& pos_min,
const ImVec2& pos_max,
const char* text,
const char* text_end,
const ImVec2* text_size_if_known,
const ImVec2& align = ImVec2(0, 0),
const ImRect* clip_rect = NULL
);
IMGUI_API void RenderTextEllipsis(
ImDrawList* draw_list,
const ImVec2& pos_min,
const ImVec2& pos_max,
float ellipsis_max_x,
const char* text,
const char* text_end,
const ImVec2* text_size_if_known
);
IMGUI_API void RenderFrame(
ImVec2 p_min,
ImVec2 p_max,
ImU32 fill_col,
bool borders = true,
float rounding = 0.0f
);
IMGUI_API void RenderFrameBorder(
ImVec2 p_min,
ImVec2 p_max,
float rounding = 0.0f
);
IMGUI_API void RenderColorComponentMarker(
const ImRect& bb,
ImU32 col,
float rounding
);
IMGUI_API void RenderColorRectWithAlphaCheckerboard(
ImDrawList* draw_list,
ImVec2 p_min,
ImVec2 p_max,
ImU32 fill_col,
float grid_step,
ImVec2 grid_off,
float rounding = 0.0f,
ImDrawFlags flags = 0
);
IMGUI_API void RenderNavCursor(
const ImRect& bb,
ImGuiID id,
ImGuiNavRenderCursorFlags flags = ImGuiNavRenderCursorFlags_None
);
void RenderNavHighlight(
const ImRect& bb,
ImGuiID id,
ImGuiNavRenderCursorFlags flags = ImGuiNavRenderCursorFlags_None
);
IMGUI_API const char* FindRenderedTextEnd(
const char* text,
const char* text_end = NULL
);
IMGUI_API void RenderMouseCursor(
ImVec2 pos,
float scale,
ImGuiMouseCursor mouse_cursor,
ImU32 col_fill,
ImU32 col_border,
ImU32 col_shadow
);
IMGUI_API void RenderArrow(
ImDrawList* draw_list,
ImVec2 pos,
ImU32 col,
ImGuiDir dir,
float scale = 1.0f
);
IMGUI_API void RenderBullet(
ImDrawList* draw_list,
ImVec2 pos,
ImU32 col
);
IMGUI_API void RenderCheckMark(
ImDrawList* draw_list,
ImVec2 pos,
ImU32 col,
float sz
);
IMGUI_API void RenderArrowPointingAt(
ImDrawList* draw_list,
ImVec2 pos,
ImVec2 half_sz,
ImGuiDir direction,
ImU32 col
);
IMGUI_API void RenderArrowDockMenu(
ImDrawList* draw_list,
ImVec2 p_min,
float sz,
ImU32 col
);
IMGUI_API void RenderRectFilledInRangeH(
ImDrawList* draw_list,
const ImRect& rect,
ImU32 col,
float fill_x0,
float fill_x1,
float rounding
);
IMGUI_API void RenderRectFilledWithHole(
ImDrawList* draw_list,
const ImRect& outer,
const ImRect& inner,
ImU32 col,
float rounding
);
IMGUI_API ImDrawFlags CalcRoundingFlagsForRectInRect(
const ImRect& r_in,
const ImRect& r_outer,
float threshold
);
IMGUI_API void TextEx(
const char* text,
const char* text_end = NULL,
ImGuiTextFlags flags = 0
);
IMGUI_API void TextAligned(
float align_x,
float size_x,
const char* fmt,
...
);
IMGUI_API void TextAlignedV(
float align_x,
float size_x,
const char* fmt,
va_list args
);
IMGUI_API bool ButtonEx(
const char* label,
const ImVec2& size_arg = ImVec2(0, 0),
ImGuiButtonFlags flags = 0
);
IMGUI_API bool ArrowButtonEx(
const char* str_id,
ImGuiDir dir,
ImVec2 size_arg,
ImGuiButtonFlags flags = 0
);
IMGUI_API bool ImageButtonEx(
ImGuiID id,
ImTextureRef tex_ref,
const ImVec2& image_size,
const ImVec2& uv0,
const ImVec2& uv1,
const ImVec4& bg_col,
const ImVec4& tint_col,
ImGuiButtonFlags flags = 0
);
IMGUI_API void SeparatorEx(
ImGuiSeparatorFlags flags,
float thickness = 1.0f
);
IMGUI_API void SeparatorTextEx(
ImGuiID id,
const char* label,
const char* label_end,
float extra_width
);
IMGUI_API bool CheckboxFlags(
const char* label,
ImS64* flags,
ImS64 flags_value
);
IMGUI_API bool CheckboxFlags(
const char* label,
ImU64* flags,
ImU64 flags_value
);
IMGUI_API bool CloseButton(
ImGuiID id,
const ImVec2& pos
);
IMGUI_API bool CollapseButton(
ImGuiID id,
const ImVec2& pos,
ImGuiDockNode* dock_node
);
IMGUI_API void Scrollbar(ImGuiAxis axis);
IMGUI_API bool ScrollbarEx(
const ImRect& bb,
ImGuiID id,
ImGuiAxis axis,
ImS64* p_scroll_v,
ImS64 avail_v,
ImS64 contents_v,
ImDrawFlags draw_rounding_flags = 0
);
IMGUI_API ImRect GetWindowScrollbarRect(
ImGuiWindow* window,
ImGuiAxis axis
);
IMGUI_API ImGuiID GetWindowScrollbarID(
ImGuiWindow* window,
ImGuiAxis axis
);
IMGUI_API ImGuiID GetWindowResizeCornerID(
ImGuiWindow* window,
int n
);
IMGUI_API ImGuiID GetWindowResizeBorderID(
ImGuiWindow* window,
ImGuiDir dir
);
IMGUI_API bool ButtonBehavior(
const ImRect& bb,
ImGuiID id,
bool* out_hovered,
bool* out_held,
ImGuiButtonFlags flags = 0
);
IMGUI_API bool DragBehavior(
ImGuiID id,
ImGuiDataType data_type,
void* p_v,
float v_speed,
const void* p_min,
const void* p_max,
const char* format,
ImGuiSliderFlags flags
);
IMGUI_API bool SliderBehavior(
const ImRect& bb,
ImGuiID id,
ImGuiDataType data_type,
void* p_v,
const void* p_min,
const void* p_max,
const char* format,
ImGuiSliderFlags flags,
ImRect* out_grab_bb
);
IMGUI_API bool SplitterBehavior(
const ImRect& bb,
ImGuiID id,
ImGuiAxis axis,
float* size1,
float* size2,
float min_size1,
float min_size2,
float hover_extend = 0.0f,
float hover_visibility_delay = 0.0f,
ImU32 bg_col = 0
);
IMGUI_API bool TreeNodeBehavior(
ImGuiID id,
ImGuiTreeNodeFlags flags,
const char* label,
const char* label_end = NULL
);
IMGUI_API void TreeNodeDrawLineToChildNode(const ImVec2& target_pos);
IMGUI_API void TreeNodeDrawLineToTreePop(const ImGuiTreeNodeStackData* data);
IMGUI_API void TreePushOverrideID(ImGuiID id);
IMGUI_API bool TreeNodeUpdateNextOpen(
ImGuiID storage_id,
ImGuiTreeNodeFlags flags
);
template <typename T, typename SIGNED_T, typename FLOAT_T>
IMGUI_API float ScaleRatioFromValueT(
ImGuiDataType data_type,
T v,
T v_min,
T v_max,
bool is_logarithmic,
float logarithmic_zero_epsilon,
float zero_deadzone_size
);
template <typename T, typename SIGNED_T, typename FLOAT_T>
IMGUI_API T ScaleValueFromRatioT(
ImGuiDataType data_type,
float t,
T v_min,
T v_max,
bool is_logarithmic,
float logarithmic_zero_epsilon,
float zero_deadzone_size
);
template <typename T, typename SIGNED_T, typename FLOAT_T>
IMGUI_API bool DragBehaviorT(
ImGuiDataType data_type,
T* v,
float v_speed,
T v_min,
T v_max,
const char* format,
ImGuiSliderFlags flags
);
template <typename T, typename SIGNED_T, typename FLOAT_T>
IMGUI_API bool SliderBehaviorT(
const ImRect& bb,
ImGuiID id,
ImGuiDataType data_type,
T* v,
T v_min,
T v_max,
const char* format,
ImGuiSliderFlags flags,
ImRect* out_grab_bb
);
template <typename T>
IMGUI_API T RoundScalarWithFormatT(
const char* format,
ImGuiDataType data_type,
T v
);
template <typename T>
IMGUI_API bool CheckboxFlagsT(
const char* label,
T* flags,
T flags_value
);
IMGUI_API const ImGuiDataTypeInfo* DataTypeGetInfo(ImGuiDataType data_type);
IMGUI_API int DataTypeFormatString(
char* buf,
int buf_size,
ImGuiDataType data_type,
const void* p_data,
const char* format
);
IMGUI_API void DataTypeApplyOp(
ImGuiDataType data_type,
int op,
void* output,
const void* arg_1,
const void* arg_2
);
IMGUI_API bool DataTypeApplyFromText(
const char* buf,
ImGuiDataType data_type,
void* p_data,
const char* format,
void* p_data_when_empty = NULL
);
IMGUI_API int DataTypeCompare(
ImGuiDataType data_type,
const void* arg_1,
const void* arg_2
);
IMGUI_API bool DataTypeClamp(
ImGuiDataType data_type,
void* p_data,
const void* p_min,
const void* p_max
);
IMGUI_API bool DataTypeIsZero(
ImGuiDataType data_type,
const void* p_data
);
IMGUI_API bool InputTextEx(
const char* label,
const char* hint,
char* buf,
int buf_size,
const ImVec2& size_arg,
ImGuiInputTextFlags flags,
ImGuiInputTextCallback callback = NULL,
void* user_data = NULL
);
IMGUI_API void InputTextDeactivateHook(ImGuiID id);
IMGUI_API bool TempInputText(
const ImRect& bb,
ImGuiID id,
const char* label,
char* buf,
int buf_size,
ImGuiInputTextFlags flags
);
IMGUI_API bool TempInputScalar(
const ImRect& bb,
ImGuiID id,
const char* label,
ImGuiDataType data_type,
void* p_data,
const char* format,
const void* p_clamp_min = NULL,
const void* p_clamp_max = NULL
);
bool TempInputIsActive(ImGuiID id);
ImGuiInputTextState* GetInputTextState(ImGuiID id);
IMGUI_API void SetNextItemRefVal(
ImGuiDataType data_type,
void* p_data
);
bool IsItemActiveAsInputText();
IMGUI_API void ColorTooltip(
const char* text,
const float* col,
ImGuiColorEditFlags flags
);
IMGUI_API void ColorEditOptionsPopup(
const float* col,
ImGuiColorEditFlags flags
);
IMGUI_API void ColorPickerOptionsPopup(
const float* ref_col,
ImGuiColorEditFlags flags
);
void SetNextItemColorMarker(ImU32 col);
IMGUI_API int PlotEx(
ImGuiPlotType plot_type,
const char* label,
float(*)(void*data, int idx) values_getter,
void* data,
int values_count,
int values_offset,
const char* overlay_text,
float scale_min,
float scale_max,
const ImVec2& size_arg
);
IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(
ImDrawList* draw_list,
int vert_start_idx,
int vert_end_idx,
ImVec2 gradient_p0,
ImVec2 gradient_p1,
ImU32 col0,
ImU32 col1
);
IMGUI_API void ShadeVertsLinearUV(
ImDrawList* draw_list,
int vert_start_idx,
int vert_end_idx,
const ImVec2& a,
const ImVec2& b,
const ImVec2& uv_a,
const ImVec2& uv_b,
bool clamp
);
IMGUI_API void ShadeVertsTransformPos(
ImDrawList* draw_list,
int vert_start_idx,
int vert_end_idx,
const ImVec2& pivot_in,
float cos_a,
float sin_a,
const ImVec2& pivot_out
);
IMGUI_API void GcCompactTransientMiscBuffers();
IMGUI_API void GcCompactTransientWindowBuffers(ImGuiWindow* window);
IMGUI_API void GcAwakeTransientWindowBuffers(ImGuiWindow* window);
IMGUI_API bool ErrorLog(const char* msg);
IMGUI_API void ErrorRecoveryStoreState(ImGuiErrorRecoveryState* state_out);
IMGUI_API void ErrorRecoveryTryToRecoverState(const ImGuiErrorRecoveryState* state_in);
IMGUI_API void ErrorRecoveryTryToRecoverWindowState(const ImGuiErrorRecoveryState* state_in);
IMGUI_API void ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
IMGUI_API void ErrorCheckEndFrameFinalizeErrorTooltip();
IMGUI_API bool BeginErrorTooltip();
IMGUI_API void EndErrorTooltip();
IMGUI_API void DebugAllocHook(
ImGuiDebugAllocInfo* info,
int frame_count,
void* ptr,
size_t size
);
IMGUI_API void DebugDrawCursorPos(ImU32 col = IM_COL32(255, 0, 0, 255));
IMGUI_API void DebugDrawLineExtents(ImU32 col = IM_COL32(255, 0, 0, 255));
IMGUI_API void DebugDrawItemRect(ImU32 col = IM_COL32(255, 0, 0, 255));
IMGUI_API void DebugTextUnformattedWithLocateItem(
const char* line_begin,
const char* line_end
);
IMGUI_API void DebugLocateItem(ImGuiID target_id);
IMGUI_API void DebugLocateItemOnHover(ImGuiID target_id);
IMGUI_API void DebugLocateItemResolveWithLastItem();
IMGUI_API void DebugBreakClearData();
IMGUI_API bool DebugBreakButton(
const char* label,
const char* description_of_location
);
IMGUI_API void DebugBreakButtonTooltip(
bool keyboard_only,
const char* description_of_location
);
IMGUI_API ImU64 DebugTextureIDToU64(ImTextureID tex_id);
IMGUI_API void DebugHookIdInfo(
ImGuiID id,
ImGuiDataType data_type,
const void* data_id,
const void* data_id_end
);
IMGUI_API void DebugNodeColumns(ImGuiOldColumns* columns);
IMGUI_API void DebugNodeDockNode(
ImGuiDockNode* node,
const char* label
);
IMGUI_API void DebugNodeDrawList(
ImGuiWindow* window,
ImGuiViewportP* viewport,
const ImDrawList* draw_list,
const char* label
);
IMGUI_API void DebugNodeDrawCmdShowMeshAndBoundingBox(
ImDrawList* out_draw_list,
const ImDrawList* draw_list,
const ImDrawCmd* draw_cmd,
bool show_mesh,
bool show_aabb
);
IMGUI_API void DebugNodeFont(ImFont* font);
IMGUI_API void DebugNodeFontGlyphesForSrcMask(
ImFont* font,
ImFontBaked* baked,
int src_mask
);
IMGUI_API void DebugNodeFontGlyph(
ImFont* font,
const ImFontGlyph* glyph
);
IMGUI_API void DebugNodeTexture(
ImTextureData* tex,
int int_id,
const ImFontAtlasRect* highlight_rect = NULL
);
IMGUI_API void DebugNodeStorage(
ImGuiStorage* storage,
const char* label
);
IMGUI_API void DebugNodeTabBar(
ImGuiTabBar* tab_bar,
const char* label
);
IMGUI_API void DebugNodeTable(ImGuiTable* table);
IMGUI_API void DebugNodeTableSettings(ImGuiTableSettings* settings);
IMGUI_API void DebugNodeInputTextState(ImGuiInputTextState* state);
IMGUI_API void DebugNodeTypingSelectState(ImGuiTypingSelectState* state);
IMGUI_API void DebugNodeMultiSelectState(ImGuiMultiSelectState* state);
IMGUI_API void DebugNodeWindow(
ImGuiWindow* window,
const char* label
);
IMGUI_API void DebugNodeWindowSettings(ImGuiWindowSettings* settings);
IMGUI_API void DebugNodeWindowsList(
ImVector<ImGuiWindow*>* windows,
const char* label
);
IMGUI_API void DebugNodeWindowsListByBeginStackParent(
ImGuiWindow** windows,
int windows_size,
ImGuiWindow* parent_in_begin_stack
);
IMGUI_API void DebugNodeViewport(ImGuiViewportP* viewport);
IMGUI_API void DebugNodePlatformMonitor(
ImGuiPlatformMonitor* monitor,
const char* label,
int idx
);
IMGUI_API void DebugRenderKeyboardPreview(ImDrawList* draw_list);
IMGUI_API void DebugRenderViewportThumbnail(
ImDrawList* draw_list,
ImGuiViewportP* viewport,
const ImRect& bb
);
static void TabBarLayout(ImGuiTabBar* tab_bar);
static ImU32 TabBarCalcTabID(
ImGuiTabBar* tab_bar,
const char* label,
ImGuiWindow* docked_window
);
static float TabBarCalcMaxTabWidth();
static float TabBarScrollClamp(
ImGuiTabBar* tab_bar,
float scrolling
);
static void TabBarScrollToTab(
ImGuiTabBar* tab_bar,
ImGuiID tab_id,
ImGuiTabBarSection* sections
);
static ImGuiTabItem* TabBarScrollingButtons(ImGuiTabBar* tab_bar);
static ImGuiTabItem* TabBarTabListPopupButton(ImGuiTabBar* tab_bar);
IMGUI_API bool InputText(
const char* label,
std::string* str,
ImGuiInputTextFlags flags = 0,
ImGuiInputTextCallback callback = nullptr,
void* user_data = nullptr
);
IMGUI_API bool InputTextMultiline(
const char* label,
std::string* str,
const ImVec2& size = ImVec2(0, 0),
ImGuiInputTextFlags flags = 0,
ImGuiInputTextCallback callback = nullptr,
void* user_data = nullptr
);
IMGUI_API bool InputTextWithHint(
const char* label,
const char* hint,
std::string* str,
ImGuiInputTextFlags flags = 0,
ImGuiInputTextCallback callback = nullptr,
void* user_data = nullptr
);
} // namespace ImGui