Functions
static void	NavUpdate ()

static void	NavUpdateWindowing ()

static void	NavUpdateWindowingOverlay ()

static void	NavUpdateMoveResult ()

static void	NavUpdateInitResult ()

static float	NavUpdatePageUpPageDown ()

static void	NavUpdateAnyRequestFlag ()

static void	NavEndFrame ()

static bool	NavScoreItem (ImGuiNavItemData *result, ImRect cand)

static void	NavApplyItemToResult (ImGuiNavItemData result, ImGuiWindow window, ImGuiID id, const ImRect &nav_bb_rel)

static void	NavProcessItem (ImGuiWindow *window, const ImRect &nav_bb, ImGuiID id)

static ImVec2	NavCalcPreferredRefPos ()

static void	NavSaveLastChildNavWindowIntoParent (ImGuiWindow *nav_window)

static ImGuiWindow *	NavRestoreLastChildNavWindow (ImGuiWindow *window)

static void	NavRestoreLayer (ImGuiNavLayer layer)

static int	FindWindowFocusIndex (ImGuiWindow *window)

static void	ErrorCheckNewFrameSanityChecks ()

static void	ErrorCheckEndFrameSanityChecks ()

static void	UpdateSettings ()

static void	UpdateMouseInputs ()

static void	UpdateMouseWheel ()

static void	UpdateTabFocus ()

static void	UpdateDebugToolItemPicker ()

static bool	UpdateWindowManualResize (ImGuiWindow window, const ImVec2 &size_auto_fit, 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, 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	UpdateViewportsNewFrame ()

void	ShowFontAtlas (ImFontAtlas *atlas)

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 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	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), bool border=false, ImGuiWindowFlags flags=0)

IMGUI_API bool	BeginChild (ImGuiID id, const ImVec2 &size=ImVec2(0, 0), bool border=false, ImGuiWindowFlags 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 ImVec2	GetWindowPos ()

IMGUI_API ImVec2	GetWindowSize ()

IMGUI_API float	GetWindowWidth ()

IMGUI_API float	GetWindowHeight ()

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	SetNextWindowBgAlpha (float alpha)

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	SetWindowFontScale (float scale)

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 ImVec2	GetContentRegionAvail ()

IMGUI_API ImVec2	GetContentRegionMax ()

IMGUI_API ImVec2	GetWindowContentRegionMin ()

IMGUI_API ImVec2	GetWindowContentRegionMax ()

IMGUI_API float	GetWindowContentRegionWidth ()

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)

IMGUI_API void	PopFont ()

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	PopStyleVar (int count=1)

IMGUI_API void	PushAllowKeyboardFocus (bool allow_keyboard_focus)

IMGUI_API void	PopAllowKeyboardFocus ()

IMGUI_API void	PushButtonRepeat (bool repeat)

IMGUI_API void	PopButtonRepeat ()

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 ImFont *	GetFont ()

IMGUI_API float	GetFontSize ()

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)

IMGUI_API const ImVec4 &	GetStyleColorVec4 (ImGuiCol idx)

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 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 ImVec2	GetCursorScreenPos ()

IMGUI_API void	SetCursorScreenPos (const ImVec2 &pos)

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 void	TextUnformatted (const char text, const char text_end=NULL)

IMGUI_API void	Text (const char *fmt,...) IM_FMTARGS(1)

IMGUI_API void	TextV (const char *fmt, va_list args) IM_FMTLIST(1)

IMGUI_API void	TextColored (const ImVec4 &col, const char *fmt,...) IM_FMTARGS(2)

IMGUI_API void	TextColoredV (const ImVec4 &col, const char *fmt, va_list args) IM_FMTLIST(2)

IMGUI_API void	TextDisabled (const char *fmt,...) IM_FMTARGS(1)

IMGUI_API void	TextDisabledV (const char *fmt, va_list args) IM_FMTLIST(1)

IMGUI_API void	TextWrapped (const char *fmt,...) IM_FMTARGS(1)

IMGUI_API void	TextWrappedV (const char *fmt, va_list args) IM_FMTLIST(1)

IMGUI_API void	LabelText (const char label, const char fmt,...) IM_FMTARGS(2)

IMGUI_API void	LabelTextV (const char label, const char fmt, va_list args) IM_FMTLIST(2)

IMGUI_API void	BulletText (const char *fmt,...) IM_FMTARGS(1)

IMGUI_API void	BulletTextV (const char *fmt, va_list args) IM_FMTLIST(1)

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 void	Image (ImTextureID user_texture_id, const ImVec2 &size, const ImVec2 &uv0=ImVec2(0, 0), const ImVec2 &uv1=ImVec2(1, 1), const ImVec4 &tint_col=ImVec4(1, 1, 1, 1), const ImVec4 &border_col=ImVec4(0, 0, 0, 0))

IMGUI_API bool	ImageButton (ImTextureID user_texture_id, const ImVec2 &size, const ImVec2 &uv0=ImVec2(0, 0), const ImVec2 &uv1=ImVec2(1, 1), int frame_padding=-1, const ImVec4 &bg_col=ImVec4(0, 0, 0, 0), const ImVec4 &tint_col=ImVec4(1, 1, 1, 1))

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	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, bool(items_getter)(void data, int idx, const char *out_text), void 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, const char current_label=NULL, const char *original_label=NULL)

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, const char current_label=NULL, const char original_label=NULL)

IMGUI_API bool	ColorButton (const char *desc_id, const ImVec4 &col, ImGuiColorEditFlags flags=0, 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,...) IM_FMTARGS(2)

IMGUI_API bool	TreeNode (const void ptr_id, const char fmt,...) IM_FMTARGS(2)

IMGUI_API bool	TreeNodeV (const char str_id, const char fmt, va_list args) IM_FMTLIST(2)

IMGUI_API bool	TreeNodeV (const void ptr_id, const char fmt, va_list args) IM_FMTLIST(2)

IMGUI_API bool	TreeNodeEx (const char *label, ImGuiTreeNodeFlags flags=0)

IMGUI_API bool	TreeNodeEx (const char str_id, ImGuiTreeNodeFlags flags, const char fmt,...) IM_FMTARGS(3)

IMGUI_API bool	TreeNodeEx (const void ptr_id, ImGuiTreeNodeFlags flags, const char fmt,...) IM_FMTARGS(3)

IMGUI_API bool	TreeNodeExV (const char str_id, ImGuiTreeNodeFlags flags, const char fmt, va_list args) IM_FMTLIST(3)

IMGUI_API bool	TreeNodeExV (const void ptr_id, ImGuiTreeNodeFlags flags, const char fmt, va_list args) IM_FMTLIST(3)

IMGUI_API void	TreePush (const char *str_id)

IMGUI_API void	TreePush (const void *ptr_id=NULL)

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 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 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, bool(items_getter)(void data, int idx, const char *out_text), void 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(values_getter)(void data, int idx), 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(values_getter)(void data, int idx), 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 void	BeginTooltip ()

IMGUI_API void	EndTooltip ()

IMGUI_API void	SetTooltip (const char *fmt,...) IM_FMTARGS(1)

IMGUI_API void	SetTooltipV (const char *fmt, va_list args) IM_FMTLIST(1)

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=1)

IMGUI_API void	CloseCurrentPopup ()

IMGUI_API bool	BeginPopupContextItem (const char *str_id=NULL, ImGuiPopupFlags popup_flags=1)

IMGUI_API bool	BeginPopupContextWindow (const char *str_id=NULL, ImGuiPopupFlags popup_flags=1)

IMGUI_API bool	BeginPopupContextVoid (const char *str_id=NULL, ImGuiPopupFlags popup_flags=1)

IMGUI_API bool	IsPopupOpen (const char *str_id, ImGuiPopupFlags flags=0)

IMGUI_API bool	BeginTable (const char *str_id, int column, 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	TableHeadersRow ()

IMGUI_API void	TableHeader (const char *label)

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 void	TableSetBgColor (ImGuiTableBgTarget target, ImU32 color, int column_n=-1)

IMGUI_API void	Columns (int count=1, const char *id=NULL, bool border=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 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,...) IM_FMTARGS(1)

IMGUI_API void	LogTextV (const char *fmt, va_list args) IM_FMTLIST(1)

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	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 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 ImVec2	GetItemRectMin ()

IMGUI_API ImVec2	GetItemRectMax ()

IMGUI_API ImVec2	GetItemRectSize ()

IMGUI_API void	SetItemAllowOverlap ()

IMGUI_API ImGuiViewport *	GetMainViewport ()

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 ImDrawList *	GetBackgroundDrawList ()

IMGUI_API ImDrawList *	GetForegroundDrawList ()

IMGUI_API ImDrawListSharedData *	GetDrawListSharedData ()

IMGUI_API const char *	GetStyleColorName (ImGuiCol idx)

IMGUI_API void	SetStateStorage (ImGuiStorage *storage)

IMGUI_API ImGuiStorage *	GetStateStorage ()

IMGUI_API void	CalcListClipping (int items_count, float items_height, int out_items_display_start, int out_items_display_end)

IMGUI_API bool	BeginChildFrame (ImGuiID id, const ImVec2 &size, ImGuiWindowFlags flags=0)

IMGUI_API void	EndChildFrame ()

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 int	GetKeyIndex (ImGuiKey imgui_key)

IMGUI_API bool	IsKeyDown (int user_key_index)

IMGUI_API bool	IsKeyPressed (int user_key_index, bool repeat=true)

IMGUI_API bool	IsKeyReleased (int user_key_index)

IMGUI_API int	GetKeyPressedAmount (int key_index, float repeat_delay, float rate)

IMGUI_API void	CaptureKeyboardFromApp (bool want_capture_keyboard_value=true)

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	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	CaptureMouseFromApp (bool want_capture_mouse_value=true)

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 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	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 bool	ListBoxHeader (const char *label, int items_count, int height_in_items=-1)

static bool	ListBoxHeader (const char *label, const ImVec2 &size=ImVec2(0, 0))

static void	ListBoxFooter ()

static void	OpenPopupContextItem (const char *str_id=NULL, ImGuiMouseButton mb=1)

IMGUI_API bool	DragScalar (const char label, ImGuiDataType data_type, void p_data, float v_speed, const void p_min, const void p_max, const char *format, float power)

IMGUI_API bool	DragScalarN (const char label, ImGuiDataType data_type, void p_data, int components, float v_speed, const void p_min, const void p_max, const char *format, float power)

static bool	DragFloat (const char label, float v, float v_speed, float v_min, float v_max, const char *format, float power)

static bool	DragFloat2 (const char label, float v[2], float v_speed, float v_min, float v_max, const char format, float power)

static bool	DragFloat3 (const char label, float v[3], float v_speed, float v_min, float v_max, const char format, float power)

static bool	DragFloat4 (const char label, float v[4], float v_speed, float v_min, float v_max, const char format, float power)

IMGUI_API bool	SliderScalar (const char label, ImGuiDataType data_type, void p_data, const void p_min, const void p_max, const char *format, float power)

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, float power)

static bool	SliderFloat (const char label, float v, float v_min, float v_max, const char *format, float power)

static bool	SliderFloat2 (const char label, float v[2], float v_min, float v_max, const char format, float power)

static bool	SliderFloat3 (const char label, float v[3], float v_min, float v_max, const char format, float power)

static bool	SliderFloat4 (const char label, float v[4], float v_min, float v_max, const char format, float power)

static bool	BeginPopupContextWindow (const char *str_id, ImGuiMouseButton mb, bool over_items)

static void	TreeAdvanceToLabelPos ()

static void	SetNextTreeNodeOpen (bool open, ImGuiCond cond=0)

static float	GetContentRegionAvailWidth ()

static ImDrawList *	GetOverlayDrawList ()

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 ImVec2	CalcWindowNextAutoFitSize (ImGuiWindow *window)

IMGUI_API bool	IsWindowChildOf (ImGuiWindow window, ImGuiWindow potential_parent)

IMGUI_API bool	IsWindowAbove (ImGuiWindow potential_above, ImGuiWindow potential_below)

IMGUI_API bool	IsWindowNavFocusable (ImGuiWindow *window)

IMGUI_API ImRect	GetWindowAllowedExtentRect (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	FocusWindow (ImGuiWindow *window)

IMGUI_API void	FocusTopMostWindowUnderOne (ImGuiWindow under_this_window, ImGuiWindow ignore_window)

IMGUI_API void	BringWindowToFocusFront (ImGuiWindow *window)

IMGUI_API void	BringWindowToDisplayFront (ImGuiWindow *window)

IMGUI_API void	BringWindowToDisplayBack (ImGuiWindow *window)

IMGUI_API void	SetCurrentFont (ImFont *font)

ImFont *	GetDefaultFont ()

ImDrawList *	GetForegroundDrawList (ImGuiWindow *window)

IMGUI_API ImDrawList *	GetBackgroundDrawList (ImGuiViewport *viewport)

IMGUI_API ImDrawList *	GetForegroundDrawList (ImGuiViewport *viewport)

IMGUI_API void	Initialize (ImGuiContext *context)

IMGUI_API void	Shutdown (ImGuiContext *context)

IMGUI_API void	UpdateHoveredWindowAndCaptureFlags ()

IMGUI_API void	StartMouseMovingWindow (ImGuiWindow *window)

IMGUI_API void	UpdateMouseMovingWindowNewFrame ()

IMGUI_API void	UpdateMouseMovingWindowEndFrame ()

IMGUI_API ImGuiID	AddContextHook (ImGuiContext context, const ImGuiContextHook hook)

IMGUI_API void	RemoveContextHook (ImGuiContext *context, ImGuiID hook_to_remove)

IMGUI_API void	CallContextHooks (ImGuiContext *context, ImGuiContextHookType type)

IMGUI_API void	MarkIniSettingsDirty ()

IMGUI_API void	MarkIniSettingsDirty (ImGuiWindow *window)

IMGUI_API void	ClearIniSettings ()

IMGUI_API ImGuiWindowSettings *	CreateNewWindowSettings (const char *name)

IMGUI_API ImGuiWindowSettings *	FindWindowSettings (ImGuiID id)

IMGUI_API ImGuiWindowSettings *	FindOrCreateWindowSettings (const char *name)

IMGUI_API ImGuiSettingsHandler *	FindSettingsHandler (const char *type_name)

IMGUI_API void	SetNextWindowScroll (const ImVec2 &scroll)

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 ImVec2	ScrollToBringRectIntoView (ImGuiWindow *window, const ImRect &item_rect)

ImGuiID	GetItemID ()

ImGuiItemStatusFlags	GetItemStatusFlags ()

ImGuiID	GetActiveID ()

ImGuiID	GetFocusID ()

ImGuiItemFlags	GetItemFlags ()

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 void	ItemSize (const ImVec2 &size, float text_baseline_y=-1.0f)

IMGUI_API 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, ImGuiItemAddFlags flags=0)

IMGUI_API bool	ItemHoverable (const ImRect &bb, ImGuiID id)

IMGUI_API void	ItemFocusable (ImGuiWindow *window, ImGuiID id)

IMGUI_API bool	IsClippedEx (const ImRect &bb, ImGuiID id, bool clip_even_when_logged)

IMGUI_API void	SetLastItemData (ImGuiWindow *window, ImGuiID item_id, 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	PushItemFlag (ImGuiItemFlags option, bool enabled)

IMGUI_API void	PopItemFlag ()

IMGUI_API bool	IsItemToggledSelection ()

IMGUI_API ImVec2	GetContentRegionMaxAbs ()

IMGUI_API void	ShrinkWidths (ImGuiShrinkWidthItem *items, int count, float width_excess)

bool	FocusableItemRegister (ImGuiWindow *window, ImGuiID id)

void	FocusableItemUnregister (ImGuiWindow *window)

IMGUI_API void	LogBegin (ImGuiLogType type, 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, bool border, ImGuiWindowFlags 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 bool	IsPopupOpen (ImGuiID id, ImGuiPopupFlags popup_flags)

IMGUI_API bool	BeginPopupEx (ImGuiID id, ImGuiWindowFlags extra_flags)

IMGUI_API void	BeginTooltipEx (ImGuiWindowFlags extra_flags, ImGuiTooltipFlags tooltip_flags)

IMGUI_API ImGuiWindow *	GetTopMostPopupModal ()

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 bool	BeginViewportSideBar (const char name, ImGuiViewport viewport, ImGuiDir dir, float size, ImGuiWindowFlags window_flags)

IMGUI_API void	NavInitWindow (ImGuiWindow *window, bool force_reinit)

IMGUI_API bool	NavMoveRequestButNoResultYet ()

IMGUI_API void	NavMoveRequestCancel ()

IMGUI_API void	NavMoveRequestForward (ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect &bb_rel, ImGuiNavMoveFlags move_flags)

IMGUI_API void	NavMoveRequestTryWrapping (ImGuiWindow *window, ImGuiNavMoveFlags move_flags)

IMGUI_API float	GetNavInputAmount (ImGuiNavInput n, ImGuiInputReadMode mode)

IMGUI_API ImVec2	GetNavInputAmount2d (ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor=0.0f, float fast_factor=0.0f)

IMGUI_API int	CalcTypematicRepeatAmount (float t0, float t1, float repeat_delay, float repeat_rate)

IMGUI_API void	ActivateItem (ImGuiID id)

IMGUI_API void	SetNavID (ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, const ImRect &rect_rel)

IMGUI_API void	PushFocusScope (ImGuiID id)

IMGUI_API void	PopFocusScope ()

ImGuiID	GetFocusedFocusScope ()

ImGuiID	GetFocusScope ()

IMGUI_API void	SetItemUsingMouseWheel ()

bool	IsActiveIdUsingNavDir (ImGuiDir dir)

bool	IsActiveIdUsingNavInput (ImGuiNavInput input)

bool	IsActiveIdUsingKey (ImGuiKey key)

IMGUI_API bool	IsMouseDragPastThreshold (ImGuiMouseButton button, float lock_threshold=-1.0f)

bool	IsKeyPressedMap (ImGuiKey key, bool repeat=true)

bool	IsNavInputDown (ImGuiNavInput n)

bool	IsNavInputTest (ImGuiNavInput n, ImGuiInputReadMode rm)

IMGUI_API ImGuiKeyModFlags	GetMergedKeyModFlags ()

IMGUI_API bool	BeginDragDropTargetCustom (const ImRect &bb, ImGuiID id)

IMGUI_API void	ClearDragDrop ()

IMGUI_API bool	IsDragDropPayloadBeingAccepted ()

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	TableGetHoveredColumn ()

IMGUI_API float	TableGetHeaderRowHeight ()

IMGUI_API void	TablePushBackgroundChannel ()

IMGUI_API void	TablePopBackgroundChannel ()

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	TableDrawContextMenu (ImGuiTable *table)

IMGUI_API void	TableMergeDrawChannels (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 (const ImGuiTable *table, int column_n, int instance_no=0)

IMGUI_API float	TableGetMaxColumnWidth (const ImGuiTable *table, int column_n)

IMGUI_API void	TableSetColumnWidthAutoSingle (ImGuiTable *table, int column_n)

IMGUI_API void	TableSetColumnWidthAutoAll (ImGuiTable *table)

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	TableSettingsInstallHandler (ImGuiContext *context)

IMGUI_API ImGuiTableSettings *	TableSettingsCreate (ImGuiID id, int columns_count)

IMGUI_API ImGuiTableSettings *	TableSettingsFindByID (ImGuiID id)

IMGUI_API bool	BeginTabBarEx (ImGuiTabBar *tab_bar, const ImRect &bb, ImGuiTabBarFlags flags)

IMGUI_API ImGuiTabItem *	TabBarFindTabByID (ImGuiTabBar *tab_bar, ImGuiID tab_id)

IMGUI_API void	TabBarRemoveTab (ImGuiTabBar *tab_bar, ImGuiID tab_id)

IMGUI_API void	TabBarCloseTab (ImGuiTabBar tab_bar, ImGuiTabItem tab)

IMGUI_API void	TabBarQueueReorder (ImGuiTabBar tab_bar, const ImGuiTabItem tab, int offset)

IMGUI_API void	TabBarQueueReorderFromMousePos (ImGuiTabBar tab_bar, const 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)

IMGUI_API ImVec2	TabItemCalcSize (const char *label, bool has_close_button)

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 clip_max_x, 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 border=true, float rounding=0.0f)

IMGUI_API void	RenderFrameBorder (ImVec2 p_min, ImVec2 p_max, float rounding=0.0f)

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	RenderNavHighlight (const ImRect &bb, ImGuiID id, ImGuiNavHighlightFlags flags=ImGuiNavHighlightFlags_TypeDefault)

IMGUI_API const char *	FindRenderedTextEnd (const char text, const char text_end=NULL)

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	RenderMouseCursor (ImDrawList *draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow)

IMGUI_API void	RenderArrowPointingAt (ImDrawList *draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col)

IMGUI_API void	RenderRectFilledRangeH (ImDrawList *draw_list, const ImRect &rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding)

IMGUI_API void	RenderRectFilledWithHole (ImDrawList *draw_list, ImRect outer, ImRect inner, ImU32 col, float rounding)

void	RenderArrow (ImVec2 pos, ImGuiDir dir, float scale=1.0f)

void	RenderBullet (ImVec2 pos)

IMGUI_API void	TextEx (const char text, const char text_end=NULL, ImGuiTextFlags flags=0)

IMGUI_API bool	ButtonEx (const char *label, const ImVec2 &size_arg=ImVec2(0, 0), ImGuiButtonFlags flags=0)

IMGUI_API bool	CloseButton (ImGuiID id, const ImVec2 &pos)

IMGUI_API bool	CollapseButton (ImGuiID id, const ImVec2 &pos)

IMGUI_API bool	ArrowButtonEx (const char *str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags=0)

IMGUI_API void	Scrollbar (ImGuiAxis axis)

IMGUI_API bool	ScrollbarEx (const ImRect &bb, ImGuiID id, ImGuiAxis axis, float *p_scroll_v, float avail_v, float contents_v, ImDrawFlags flags)

IMGUI_API bool	ImageButtonEx (ImGuiID id, ImTextureID texture_id, const ImVec2 &size, const ImVec2 &uv0, const ImVec2 &uv1, const ImVec2 &padding, const ImVec4 &bg_col, const ImVec4 &tint_col)

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 void	SeparatorEx (ImGuiSeparatorFlags flags)

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	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)

IMGUI_API bool	TreeNodeBehavior (ImGuiID id, ImGuiTreeNodeFlags flags, const char label, const char label_end=NULL)

IMGUI_API bool	TreeNodeBehaviorIsOpen (ImGuiID id, ImGuiTreeNodeFlags flags=0)

IMGUI_API void	TreePushOverrideID (ImGuiID id)

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 , typename SIGNED_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	DataTypeApplyOpFromText (const char buf, const char initial_value_buf, ImGuiDataType data_type, void p_data, const char format)

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	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 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	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)

IMGUI_API int	PlotEx (ImGuiPlotType plot_type, const char label, float(values_getter)(void data, int idx), void data, int values_count, int values_offset, const char *overlay_text, float scale_min, float scale_max, ImVec2 frame_size)

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	GcCompactTransientMiscBuffers ()

IMGUI_API void	GcCompactTransientWindowBuffers (ImGuiWindow *window)

IMGUI_API void	GcAwakeTransientWindowBuffers (ImGuiWindow *window)

IMGUI_API void	ErrorCheckEndFrameRecover (ImGuiErrorLogCallback log_callback, void *user_data=NULL)

void	DebugDrawItemRect (ImU32 col=IM_COL32(255, 0, 0, 255))

void	DebugStartItemPicker ()

IMGUI_API void	DebugNodeColumns (ImGuiOldColumns *columns)

IMGUI_API void	DebugNodeDrawList (ImGuiWindow window, 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	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	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	DebugNodeViewport (ImGuiViewportP *viewport)

IMGUI_API void	DebugRenderViewportThumbnail (ImDrawList draw_list, ImGuiViewportP viewport, const ImRect &bb)

IMGUI_API bool	InputText (const char label, std::string str, ImGuiInputTextFlags flags=0, ImGuiInputTextCallback callback=NULL, void *user_data=NULL)

IMGUI_API bool	InputTextMultiline (const char label, std::string str, 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, std::string str, ImGuiInputTextFlags flags=0, ImGuiInputTextCallback callback=NULL, void user_data=NULL)

static void	TabBarLayout (ImGuiTabBar *tab_bar)

static ImU32	TabBarCalcTabID (ImGuiTabBar tab_bar, const char label)

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)

bool	Combo (const char label, int idx, std::vector< std::string > &values)

bool	Combo (const char label, int idx, std::function< const char *(int)> getter, int items_count)

bool	ListBox (const char label, int idx, std::vector< std::string > &values)

bool	InputText (const char label, std::string &str, ImGuiInputTextFlags flags=0, ImGuiTextEditCallback callback=NULL, void user_data=NULL)

Variables
const char	ColorMarkerHovered = 0x1

const char	ColorMarkerStart = 0x2

const char	ColorMarkerEnd = 0x3

const wchar_t	PrintIconMarker = 0x4

const wchar_t	PrinterIconMarker = 0x5

const wchar_t	PrinterSlaIconMarker = 0x6

const wchar_t	FilamentIconMarker = 0x7

const wchar_t	MaterialIconMarker = 0x8

const wchar_t	CloseNotifButton = 0xB

const wchar_t	CloseNotifHoverButton = 0xC

const wchar_t	MinimalizeButton = 0xE

const wchar_t	MinimalizeHoverButton = 0xF

const wchar_t	WarningMarker = 0x10

const wchar_t	ErrorMarker = 0x11

const wchar_t	EjectButton = 0x12

const wchar_t	EjectHoverButton = 0x13

const wchar_t	CancelButton = 0x14

const wchar_t	CancelHoverButton = 0x15

const wchar_t	RevertButton = 0x16

const wchar_t	RightArrowButton = 0x18

const wchar_t	RightArrowHoverButton = 0x19

const wchar_t	PreferencesButton = 0x1A

const wchar_t	PreferencesHoverButton = 0x1B

const wchar_t	PlugMarker = 0x1C

const wchar_t	DowelMarker = 0x1D

const wchar_t	DocumentationButton = 0x2600

const wchar_t	DocumentationHoverButton = 0x2601

const wchar_t	ClippyMarker = 0x2602

const wchar_t	InfoMarker = 0x2603

const wchar_t	SliderFloatEditBtnIcon = 0x2604

const wchar_t	SliderFloatEditBtnPressedIcon = 0x2605

const wchar_t	ClipboardBtnIcon = 0x2606

const wchar_t	PlayButton = 0x2618

const wchar_t	PlayHoverButton = 0x2619

const wchar_t	PauseButton = 0x261A

const wchar_t	PauseHoverButton = 0x261B

const wchar_t	OpenButton = 0x261C

const wchar_t	OpenHoverButton = 0x261D

const wchar_t	SlaViewOriginal = 0x261E

const wchar_t	SlaViewProcessed = 0x261F

const wchar_t	LegendTravel = 0x2701

const wchar_t	LegendWipe = 0x2702

const wchar_t	LegendRetract = 0x2703

const wchar_t	LegendDeretract = 0x2704

const wchar_t	LegendSeams = 0x2705

const wchar_t	LegendToolChanges = 0x2706

const wchar_t	LegendColorChanges = 0x2707

const wchar_t	LegendPausePrints = 0x2708

const wchar_t	LegendCustomGCodes = 0x2709

const wchar_t	LegendCOG = 0x2710

const wchar_t	LegendShells = 0x2711

const wchar_t	LegendToolMarker = 0x2712

const wchar_t	WarningMarkerSmall = 0x2713

const wchar_t	ExpandBtn = 0x2714

const wchar_t	InfoMarkerSmall = 0x2716

const wchar_t	CollapseBtn = 0x2715

static auto	vector_getter

Function Documentation

◆ AcceptDragDropPayload()

const ImGuiPayload * ImGui::AcceptDragDropPayload	(	const char *	type,
		ImGuiDragDropFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiPayload& payload = g.DragDropPayload;
    IM_ASSERT(g.DragDropActive);                        // Not called between BeginDragDropTarget() and EndDragDropTarget() ?
    IM_ASSERT(payload.DataFrameCount != -1);            // Forgot to call EndDragDropTarget() ?
    if (type != NULL && !payload.IsDataType(type))
        return NULL;
 
    // Accept smallest drag target bounding box, this allows us to nest drag targets conveniently without ordering constraints.
    // NB: We currently accept NULL id as target. However, overlapping targets requires a unique ID to function!
    const bool was_accepted_previously = (g.DragDropAcceptIdPrev == g.DragDropTargetId);
    ImRect r = g.DragDropTargetRect;
    float r_surface = r.GetWidth() * r.GetHeight();
    if (r_surface <= g.DragDropAcceptIdCurrRectSurface)
    {
        g.DragDropAcceptFlags = flags;
        g.DragDropAcceptIdCurr = g.DragDropTargetId;
        g.DragDropAcceptIdCurrRectSurface = r_surface;
    }
 
    // Render default drop visuals
    payload.Preview = was_accepted_previously;
    flags |= (g.DragDropSourceFlags & ImGuiDragDropFlags_AcceptNoDrawDefaultRect); // Source can also inhibit the preview (useful for external sources that lives for 1 frame)
    if (!(flags & ImGuiDragDropFlags_AcceptNoDrawDefaultRect) && payload.Preview)
    {
        // FIXME-DRAGDROP: Settle on a proper default visuals for drop target.
        r.Expand(3.5f);
        bool push_clip_rect = !window->ClipRect.Contains(r);
        if (push_clip_rect) window->DrawList->PushClipRect(r.Min - ImVec2(1, 1), r.Max + ImVec2(1, 1));
        window->DrawList->AddRect(r.Min, r.Max, GetColorU32(ImGuiCol_DragDropTarget), 0.0f, 0, 2.0f);
        if (push_clip_rect) window->DrawList->PopClipRect();
    }
 
    g.DragDropAcceptFrameCount = g.FrameCount;
    payload.Delivery = was_accepted_previously && !IsMouseDown(g.DragDropMouseButton); // For extern drag sources affecting os window focus, it's easier to just test !IsMouseDown() instead of IsMouseReleased()
    if (!payload.Delivery && !(flags & ImGuiDragDropFlags_AcceptBeforeDelivery))
        return NULL;
 
    return &payload;
}

Referenced by ColorEdit4(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ActivateItem()

void ImGui::ActivateItem ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    g.NavNextActivateId = id;
}

References GImGui, and ImGuiContext::NavNextActivateId.

◆ AddContextHook()

ImGuiID ImGui::AddContextHook	(	ImGuiContext *	context,
		const ImGuiContextHook *	hook
	)

{
    ImGuiContext& g = *ctx;
    IM_ASSERT(hook->Callback != NULL && hook->HookId == 0 && hook->Type != ImGuiContextHookType_PendingRemoval_);
    g.Hooks.push_back(*hook);
    g.Hooks.back().HookId = ++g.HookIdNext;
    return g.HookIdNext;
}

References ImVector< T >::back(), ImGuiContextHook::Callback, ImGuiContextHook::HookId, ImGuiContext::HookIdNext, ImGuiContext::Hooks, IM_ASSERT, ImGuiContextHookType_PendingRemoval_, ImVector< T >::push_back(), and ImGuiContextHook::Type.

Here is the call graph for this function:

◆ AlignTextToFramePadding()

void ImGui::AlignTextToFramePadding ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    window->DC.CurrLineSize.y = ImMax(window->DC.CurrLineSize.y, g.FontSize + g.Style.FramePadding.y * 2);
    window->DC.CurrLineTextBaseOffset = ImMax(window->DC.CurrLineTextBaseOffset, g.Style.FramePadding.y);
}

References ImGuiWindowTempData::CurrLineSize, ImGuiWindowTempData::CurrLineTextBaseOffset, ImGuiWindow::DC, ImGuiContext::FontSize, ImGuiStyle::FramePadding, GetCurrentWindow(), GImGui, ImMax(), ImGuiWindow::SkipItems, ImGuiContext::Style, and ImVec2::y.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ArrowButton()

bool ImGui::ArrowButton	(	const char *	str_id,
		ImGuiDir	dir
	)

{
    float sz = GetFrameHeight();
    return ArrowButtonEx(str_id, dir, ImVec2(sz, sz), ImGuiButtonFlags_None);
}

References ArrowButtonEx(), GetFrameHeight(), and ImGuiButtonFlags_None.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ArrowButtonEx()

bool ImGui::ArrowButtonEx	(	const char *	str_id,
		ImGuiDir	dir,
		ImVec2	size_arg,
		ImGuiButtonFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiID id = window->GetID(str_id);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    const float default_size = GetFrameHeight();
    ItemSize(size, (size.y >= default_size) ? g.Style.FramePadding.y : -1.0f);
    if (!ItemAdd(bb, id))
        return false;
 
    if (g.CurrentItemFlags & ImGuiItemFlags_ButtonRepeat)
        flags |= ImGuiButtonFlags_Repeat;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
 
    // Render
    const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
    const ImU32 text_col = GetColorU32(ImGuiCol_Text);
    RenderNavHighlight(bb, id);
    RenderFrame(bb.Min, bb.Max, bg_col, true, g.Style.FrameRounding);
    RenderArrow(window->DrawList, bb.Min + ImVec2(ImMax(0.0f, (size.x - g.FontSize) * 0.5f), ImMax(0.0f, (size.y - g.FontSize) * 0.5f)), text_col, dir);
 
    return pressed;
}

References ButtonBehavior(), ImGuiContext::CurrentItemFlags, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImGuiStyle::FrameRounding, GetColorU32(), GetCurrentWindow(), GetFrameHeight(), ImGuiWindow::GetID(), GImGui, ImGuiButtonFlags_Repeat, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_Text, ImGuiItemFlags_ButtonRepeat, ImMax(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, RenderArrow(), RenderFrame(), RenderNavHighlight(), ImGuiWindow::SkipItems, ImGuiContext::Style, and ImVec2::y.

Referenced by ArrowButton(), and TabBarScrollingButtons().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Begin()

bool ImGui::Begin	(	const char *	name,
		bool *	p_open = `NULL`,
		ImGuiWindowFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    IM_ASSERT(name != NULL && name[0] != '\0');     // Window name required
    IM_ASSERT(g.WithinFrameScope);                  // Forgot to call ImGui::NewFrame()
    IM_ASSERT(g.FrameCountEnded != g.FrameCount);   // Called ImGui::Render() or ImGui::EndFrame() and haven't called ImGui::NewFrame() again yet
 
    // Find or create
    ImGuiWindow* window = FindWindowByName(name);
    const bool window_just_created = (window == NULL);
    if (window_just_created)
        window = CreateNewWindow(name, flags);
 
    // Automatically disable manual moving/resizing when NoInputs is set
    if ((flags & ImGuiWindowFlags_NoInputs) == ImGuiWindowFlags_NoInputs)
        flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize;
 
    if (flags & ImGuiWindowFlags_NavFlattened)
        IM_ASSERT(flags & ImGuiWindowFlags_ChildWindow);
 
    const int current_frame = g.FrameCount;
    const bool first_begin_of_the_frame = (window->LastFrameActive != current_frame);
    window->IsFallbackWindow = (g.CurrentWindowStack.Size == 0 && g.WithinFrameScopeWithImplicitWindow);
 
    // Update the Appearing flag
    bool window_just_activated_by_user = (window->LastFrameActive < current_frame - 1);   // Not using !WasActive because the implicit "Debug" window would always toggle off->on
    if (flags & ImGuiWindowFlags_Popup)
    {
        ImGuiPopupData& popup_ref = g.OpenPopupStack[g.BeginPopupStack.Size];
        window_just_activated_by_user |= (window->PopupId != popup_ref.PopupId); // We recycle popups so treat window as activated if popup id changed
        window_just_activated_by_user |= (window != popup_ref.Window);
    }
    window->Appearing = window_just_activated_by_user;
    if (window->Appearing)
        SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, true);
 
    // Update Flags, LastFrameActive, BeginOrderXXX fields
    if (first_begin_of_the_frame)
    {
        window->Flags = (ImGuiWindowFlags)flags;
        window->LastFrameActive = current_frame;
        window->LastTimeActive = (float)g.Time;
        window->BeginOrderWithinParent = 0;
        window->BeginOrderWithinContext = (short)(g.WindowsActiveCount++);
    }
    else
    {
        flags = window->Flags;
    }
 
    // Parent window is latched only on the first call to Begin() of the frame, so further append-calls can be done from a different window stack
    ImGuiWindow* parent_window_in_stack = g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back();
    ImGuiWindow* parent_window = first_begin_of_the_frame ? ((flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)) ? parent_window_in_stack : NULL) : window->ParentWindow;
    IM_ASSERT(parent_window != NULL || !(flags & ImGuiWindowFlags_ChildWindow));
 
    // We allow window memory to be compacted so recreate the base stack when needed.
    if (window->IDStack.Size == 0)
        window->IDStack.push_back(window->ID);
 
    // Add to stack
    // We intentionally set g.CurrentWindow to NULL to prevent usage until when the viewport is set, then will call SetCurrentWindow()
    g.CurrentWindowStack.push_back(window);
    g.CurrentWindow = window;
    window->DC.StackSizesOnBegin.SetToCurrentState();
    g.CurrentWindow = NULL;
 
    if (flags & ImGuiWindowFlags_Popup)
    {
        ImGuiPopupData& popup_ref = g.OpenPopupStack[g.BeginPopupStack.Size];
        popup_ref.Window = window;
        g.BeginPopupStack.push_back(popup_ref);
        window->PopupId = popup_ref.PopupId;
    }
 
    // Update ->RootWindow and others pointers (before any possible call to FocusWindow)
    if (first_begin_of_the_frame)
        UpdateWindowParentAndRootLinks(window, flags, parent_window);
 
    // Process SetNextWindow***() calls
    // (FIXME: Consider splitting the HasXXX flags into X/Y components
    bool window_pos_set_by_api = false;
    bool window_size_x_set_by_api = false, window_size_y_set_by_api = false;
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos)
    {
        window_pos_set_by_api = (window->SetWindowPosAllowFlags & g.NextWindowData.PosCond) != 0;
        if (window_pos_set_by_api && ImLengthSqr(g.NextWindowData.PosPivotVal) > 0.00001f)
        {
            // May be processed on the next frame if this is our first frame and we are measuring size
            // FIXME: Look into removing the branch so everything can go through this same code path for consistency.
            window->SetWindowPosVal = g.NextWindowData.PosVal;
            window->SetWindowPosPivot = g.NextWindowData.PosPivotVal;
            window->SetWindowPosAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);
        }
        else
        {
            SetWindowPos(window, g.NextWindowData.PosVal, g.NextWindowData.PosCond);
        }
    }
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize)
    {
        window_size_x_set_by_api = (window->SetWindowSizeAllowFlags & g.NextWindowData.SizeCond) != 0 && (g.NextWindowData.SizeVal.x > 0.0f);
        window_size_y_set_by_api = (window->SetWindowSizeAllowFlags & g.NextWindowData.SizeCond) != 0 && (g.NextWindowData.SizeVal.y > 0.0f);
        SetWindowSize(window, g.NextWindowData.SizeVal, g.NextWindowData.SizeCond);
    }
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasScroll)
    {
        if (g.NextWindowData.ScrollVal.x >= 0.0f)
        {
            window->ScrollTarget.x = g.NextWindowData.ScrollVal.x;
            window->ScrollTargetCenterRatio.x = 0.0f;
        }
        if (g.NextWindowData.ScrollVal.y >= 0.0f)
        {
            window->ScrollTarget.y = g.NextWindowData.ScrollVal.y;
            window->ScrollTargetCenterRatio.y = 0.0f;
        }
    }
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasContentSize)
        window->ContentSizeExplicit = g.NextWindowData.ContentSizeVal;
    else if (first_begin_of_the_frame)
        window->ContentSizeExplicit = ImVec2(0.0f, 0.0f);
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasCollapsed)
        SetWindowCollapsed(window, g.NextWindowData.CollapsedVal, g.NextWindowData.CollapsedCond);
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasFocus)
        FocusWindow(window);
    if (window->Appearing)
        SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, false);
 
    // When reusing window again multiple times a frame, just append content (don't need to setup again)
    if (first_begin_of_the_frame)
    {
        // Initialize
        const bool window_is_child_tooltip = (flags & ImGuiWindowFlags_ChildWindow) && (flags & ImGuiWindowFlags_Tooltip); // FIXME-WIP: Undocumented behavior of Child+Tooltip for pinned tooltip (#1345)
        window->Active = true;
        window->HasCloseButton = (p_open != NULL);
        window->ClipRect = ImVec4(-FLT_MAX, -FLT_MAX, +FLT_MAX, +FLT_MAX);
        window->IDStack.resize(1);
        window->DrawList->_ResetForNewFrame();
        window->DC.CurrentTableIdx = -1;
 
        // Restore buffer capacity when woken from a compacted state, to avoid
        if (window->MemoryCompacted)
            GcAwakeTransientWindowBuffers(window);
 
        // Update stored window name when it changes (which can _only_ happen with the "###" operator, so the ID would stay unchanged).
        // The title bar always display the 'name' parameter, so we only update the string storage if it needs to be visible to the end-user elsewhere.
        bool window_title_visible_elsewhere = false;
        if (g.NavWindowingListWindow != NULL && (window->Flags & ImGuiWindowFlags_NoNavFocus) == 0)   // Window titles visible when using CTRL+TAB
            window_title_visible_elsewhere = true;
        if (window_title_visible_elsewhere && !window_just_created && strcmp(name, window->Name) != 0)
        {
            size_t buf_len = (size_t)window->NameBufLen;
            window->Name = ImStrdupcpy(window->Name, &buf_len, name);
            window->NameBufLen = (int)buf_len;
        }
 
        // UPDATE CONTENTS SIZE, UPDATE HIDDEN STATUS
 
        // Update contents size from last frame for auto-fitting (or use explicit size)
        const bool window_just_appearing_after_hidden_for_resize = (window->HiddenFramesCannotSkipItems > 0);
        CalcWindowContentSizes(window, &window->ContentSize, &window->ContentSizeIdeal);
        if (window->HiddenFramesCanSkipItems > 0)
            window->HiddenFramesCanSkipItems--;
        if (window->HiddenFramesCannotSkipItems > 0)
            window->HiddenFramesCannotSkipItems--;
        if (window->HiddenFramesForRenderOnly > 0)
            window->HiddenFramesForRenderOnly--;
 
        // Hide new windows for one frame until they calculate their size
        if (window_just_created && (!window_size_x_set_by_api || !window_size_y_set_by_api))
            window->HiddenFramesCannotSkipItems = 1;
 
        // Hide popup/tooltip window when re-opening while we measure size (because we recycle the windows)
        // We reset Size/ContentSize for reappearing popups/tooltips early in this function, so further code won't be tempted to use the old size.
        if (window_just_activated_by_user && (flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)) != 0)
        {
            window->HiddenFramesCannotSkipItems = 1;
            if (flags & ImGuiWindowFlags_AlwaysAutoResize)
            {
                if (!window_size_x_set_by_api)
                    window->Size.x = window->SizeFull.x = 0.f;
                if (!window_size_y_set_by_api)
                    window->Size.y = window->SizeFull.y = 0.f;
                window->ContentSize = window->ContentSizeIdeal = ImVec2(0.f, 0.f);
            }
        }
 
        // SELECT VIEWPORT
        // FIXME-VIEWPORT: In the docking/viewport branch, this is the point where we select the current viewport (which may affect the style)
        SetCurrentWindow(window);
 
        // LOCK BORDER SIZE AND PADDING FOR THE FRAME (so that altering them doesn't cause inconsistencies)
 
        if (flags & ImGuiWindowFlags_ChildWindow)
            window->WindowBorderSize = style.ChildBorderSize;
        else
            window->WindowBorderSize = ((flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)) && !(flags & ImGuiWindowFlags_Modal)) ? style.PopupBorderSize : style.WindowBorderSize;
        window->WindowPadding = style.WindowPadding;
        if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & (ImGuiWindowFlags_AlwaysUseWindowPadding | ImGuiWindowFlags_Popup)) && window->WindowBorderSize == 0.0f)
            window->WindowPadding = ImVec2(0.0f, (flags & ImGuiWindowFlags_MenuBar) ? style.WindowPadding.y : 0.0f);
 
        // Lock menu offset so size calculation can use it as menu-bar windows need a minimum size.
        window->DC.MenuBarOffset.x = ImMax(ImMax(window->WindowPadding.x, style.ItemSpacing.x), g.NextWindowData.MenuBarOffsetMinVal.x);
        window->DC.MenuBarOffset.y = g.NextWindowData.MenuBarOffsetMinVal.y;
 
        // Collapse window by double-clicking on title bar
        // At this point we don't have a clipping rectangle setup yet, so we can use the title bar area for hit detection and drawing
        if (!(flags & ImGuiWindowFlags_NoTitleBar) && !(flags & ImGuiWindowFlags_NoCollapse))
        {
            // We don't use a regular button+id to test for double-click on title bar (mostly due to legacy reason, could be fixed), so verify that we don't have items over the title bar.
            ImRect title_bar_rect = window->TitleBarRect();
            if (g.HoveredWindow == window && g.HoveredId == 0 && g.HoveredIdPreviousFrame == 0 && IsMouseHoveringRect(title_bar_rect.Min, title_bar_rect.Max) && g.IO.MouseDoubleClicked[0])
                window->WantCollapseToggle = true;
            if (window->WantCollapseToggle)
            {
                window->Collapsed = !window->Collapsed;
                MarkIniSettingsDirty(window);
            }
        }
        else
        {
            window->Collapsed = false;
        }
        window->WantCollapseToggle = false;
 
        // SIZE
 
        // Calculate auto-fit size, handle automatic resize
        const ImVec2 size_auto_fit = CalcWindowAutoFitSize(window, window->ContentSizeIdeal);
        bool use_current_size_for_scrollbar_x = window_just_created;
        bool use_current_size_for_scrollbar_y = window_just_created;
        if ((flags & ImGuiWindowFlags_AlwaysAutoResize) && !window->Collapsed)
        {
            // Using SetNextWindowSize() overrides ImGuiWindowFlags_AlwaysAutoResize, so it can be used on tooltips/popups, etc.
            if (!window_size_x_set_by_api)
            {
                window->SizeFull.x = size_auto_fit.x;
                use_current_size_for_scrollbar_x = true;
            }
            if (!window_size_y_set_by_api)
            {
                window->SizeFull.y = size_auto_fit.y;
                use_current_size_for_scrollbar_y = true;
            }
        }
        else if (window->AutoFitFramesX > 0 || window->AutoFitFramesY > 0)
        {
            // Auto-fit may only grow window during the first few frames
            // We still process initial auto-fit on collapsed windows to get a window width, but otherwise don't honor ImGuiWindowFlags_AlwaysAutoResize when collapsed.
            if (!window_size_x_set_by_api && window->AutoFitFramesX > 0)
            {
                window->SizeFull.x = window->AutoFitOnlyGrows ? ImMax(window->SizeFull.x, size_auto_fit.x) : size_auto_fit.x;
                use_current_size_for_scrollbar_x = true;
            }
            if (!window_size_y_set_by_api && window->AutoFitFramesY > 0)
            {
                window->SizeFull.y = window->AutoFitOnlyGrows ? ImMax(window->SizeFull.y, size_auto_fit.y) : size_auto_fit.y;
                use_current_size_for_scrollbar_y = true;
            }
            if (!window->Collapsed)
                MarkIniSettingsDirty(window);
        }
 
        // Apply minimum/maximum window size constraints and final size
        window->SizeFull = CalcWindowSizeAfterConstraint(window, window->SizeFull);
        window->Size = window->Collapsed && !(flags & ImGuiWindowFlags_ChildWindow) ? window->TitleBarRect().GetSize() : window->SizeFull;
 
        // Decoration size
        const float decoration_up_height = window->TitleBarHeight() + window->MenuBarHeight();
 
        // POSITION
 
        // Popup latch its initial position, will position itself when it appears next frame
        if (window_just_activated_by_user)
        {
            window->AutoPosLastDirection = ImGuiDir_None;
            if ((flags & ImGuiWindowFlags_Popup) != 0 && !(flags & ImGuiWindowFlags_Modal) && !window_pos_set_by_api) // FIXME: BeginPopup() could use SetNextWindowPos()
                window->Pos = g.BeginPopupStack.back().OpenPopupPos;
        }
 
        // Position child window
        if (flags & ImGuiWindowFlags_ChildWindow)
        {
            IM_ASSERT(parent_window && parent_window->Active);
            window->BeginOrderWithinParent = (short)parent_window->DC.ChildWindows.Size;
            parent_window->DC.ChildWindows.push_back(window);
            if (!(flags & ImGuiWindowFlags_Popup) && !window_pos_set_by_api && !window_is_child_tooltip)
                window->Pos = parent_window->DC.CursorPos;
        }
 
        const bool window_pos_with_pivot = (window->SetWindowPosVal.x != FLT_MAX && window->HiddenFramesCannotSkipItems == 0);
        if (window_pos_with_pivot)
            SetWindowPos(window, window->SetWindowPosVal - window->Size * window->SetWindowPosPivot, 0); // Position given a pivot (e.g. for centering)
        else if ((flags & ImGuiWindowFlags_ChildMenu) != 0)
            window->Pos = FindBestWindowPosForPopup(window);
        else if ((flags & ImGuiWindowFlags_Popup) != 0 && !window_pos_set_by_api && window_just_appearing_after_hidden_for_resize)
            window->Pos = FindBestWindowPosForPopup(window);
        else if ((flags & ImGuiWindowFlags_Tooltip) != 0 && !window_pos_set_by_api && !window_is_child_tooltip)
            window->Pos = FindBestWindowPosForPopup(window);
 
        // Calculate the range of allowed position for that window (to be movable and visible past safe area padding)
        // When clamping to stay visible, we will enforce that window->Pos stays inside of visibility_rect.
        ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)GetMainViewport();
        ImRect viewport_rect(viewport->GetMainRect());
        ImRect viewport_work_rect(viewport->GetWorkRect());
        ImVec2 visibility_padding = ImMax(style.DisplayWindowPadding, style.DisplaySafeAreaPadding);
        ImRect visibility_rect(viewport_work_rect.Min + visibility_padding, viewport_work_rect.Max - visibility_padding);
 
        // Clamp position/size so window stays visible within its viewport or monitor
        // Ignore zero-sized display explicitly to avoid losing positions if a window manager reports zero-sized window when initializing or minimizing.
        if (!window_pos_set_by_api && !(flags & ImGuiWindowFlags_ChildWindow) && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0)
            if (viewport_rect.GetWidth() > 0.0f && viewport_rect.GetHeight() > 0.0f)
                ClampWindowRect(window, visibility_rect);
        window->Pos = ImFloor(window->Pos);
 
        // Lock window rounding for the frame (so that altering them doesn't cause inconsistencies)
        // Large values tend to lead to variety of artifacts and are not recommended.
        window->WindowRounding = (flags & ImGuiWindowFlags_ChildWindow) ? style.ChildRounding : ((flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiWindowFlags_Modal)) ? style.PopupRounding : style.WindowRounding;
 
        // For windows with title bar or menu bar, we clamp to FrameHeight(FontSize + FramePadding.y * 2.0f) to completely hide artifacts.
        //if ((window->Flags & ImGuiWindowFlags_MenuBar) || !(window->Flags & ImGuiWindowFlags_NoTitleBar))
        //    window->WindowRounding = ImMin(window->WindowRounding, g.FontSize + style.FramePadding.y * 2.0f);
 
        // Apply window focus (new and reactivated windows are moved to front)
        bool want_focus = false;
        if (window_just_activated_by_user && !(flags & ImGuiWindowFlags_NoFocusOnAppearing))
        {
            if (flags & ImGuiWindowFlags_Popup)
                want_focus = true;
            else if ((flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Tooltip)) == 0)
                want_focus = true;
        }
 
        // Handle manual resize: Resize Grips, Borders, Gamepad
        int border_held = -1;
        ImU32 resize_grip_col[4] = {};
        const int resize_grip_count = g.IO.ConfigWindowsResizeFromEdges ? 2 : 1; // Allow resize from lower-left if we have the mouse cursor feedback for it.
        const float resize_grip_draw_size = IM_FLOOR(ImMax(g.FontSize * 1.10f, window->WindowRounding + 1.0f + g.FontSize * 0.2f));
        if (!window->Collapsed)
            if (UpdateWindowManualResize(window, size_auto_fit, &border_held, resize_grip_count, &resize_grip_col[0], visibility_rect))
                use_current_size_for_scrollbar_x = use_current_size_for_scrollbar_y = true;
        window->ResizeBorderHeld = (signed char)border_held;
 
        // SCROLLBAR VISIBILITY
 
        // Update scrollbar visibility (based on the Size that was effective during last frame or the auto-resized Size).
        if (!window->Collapsed)
        {
            // When reading the current size we need to read it after size constraints have been applied.
            // When we use InnerRect here we are intentionally reading last frame size, same for ScrollbarSizes values before we set them again.
            ImVec2 avail_size_from_current_frame = ImVec2(window->SizeFull.x, window->SizeFull.y - decoration_up_height);
            ImVec2 avail_size_from_last_frame = window->InnerRect.GetSize() + window->ScrollbarSizes;
            ImVec2 needed_size_from_last_frame = window_just_created ? ImVec2(0, 0) : window->ContentSize + window->WindowPadding * 2.0f;
            float size_x_for_scrollbars = use_current_size_for_scrollbar_x ? avail_size_from_current_frame.x : avail_size_from_last_frame.x;
            float size_y_for_scrollbars = use_current_size_for_scrollbar_y ? avail_size_from_current_frame.y : avail_size_from_last_frame.y;
            //bool scrollbar_y_from_last_frame = window->ScrollbarY; // FIXME: May want to use that in the ScrollbarX expression? How many pros vs cons?
            window->ScrollbarY = (flags & ImGuiWindowFlags_AlwaysVerticalScrollbar) || ((needed_size_from_last_frame.y > size_y_for_scrollbars) && !(flags & ImGuiWindowFlags_NoScrollbar));
            window->ScrollbarX = (flags & ImGuiWindowFlags_AlwaysHorizontalScrollbar) || ((needed_size_from_last_frame.x > size_x_for_scrollbars - (window->ScrollbarY ? style.ScrollbarSize : 0.0f)) && !(flags & ImGuiWindowFlags_NoScrollbar) && (flags & ImGuiWindowFlags_HorizontalScrollbar));
            if (window->ScrollbarX && !window->ScrollbarY)
                window->ScrollbarY = (needed_size_from_last_frame.y > size_y_for_scrollbars) && !(flags & ImGuiWindowFlags_NoScrollbar);
            window->ScrollbarSizes = ImVec2(window->ScrollbarY ? style.ScrollbarSize : 0.0f, window->ScrollbarX ? style.ScrollbarSize : 0.0f);
        }
 
        // UPDATE RECTANGLES (1- THOSE NOT AFFECTED BY SCROLLING)
        // Update various regions. Variables they depends on should be set above in this function.
        // We set this up after processing the resize grip so that our rectangles doesn't lag by a frame.
 
        // Outer rectangle
        // Not affected by window border size. Used by:
        // - FindHoveredWindow() (w/ extra padding when border resize is enabled)
        // - Begin() initial clipping rect for drawing window background and borders.
        // - Begin() clipping whole child
        const ImRect host_rect = ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup) && !window_is_child_tooltip) ? parent_window->ClipRect : viewport_rect;
        const ImRect outer_rect = window->Rect();
        const ImRect title_bar_rect = window->TitleBarRect();
        window->OuterRectClipped = outer_rect;
        window->OuterRectClipped.ClipWith(host_rect);
 
        // Inner rectangle
        // Not affected by window border size. Used by:
        // - InnerClipRect
        // - ScrollToBringRectIntoView()
        // - NavUpdatePageUpPageDown()
        // - Scrollbar()
        window->InnerRect.Min.x = window->Pos.x;
        window->InnerRect.Min.y = window->Pos.y + decoration_up_height;
        window->InnerRect.Max.x = window->Pos.x + window->Size.x - window->ScrollbarSizes.x;
        window->InnerRect.Max.y = window->Pos.y + window->Size.y - window->ScrollbarSizes.y;
 
        // Inner clipping rectangle.
        // Will extend a little bit outside the normal work region.
        // This is to allow e.g. Selectable or CollapsingHeader or some separators to cover that space.
        // Force round operator last to ensure that e.g. (int)(max.x-min.x) in user's render code produce correct result.
        // Note that if our window is collapsed we will end up with an inverted (~null) clipping rectangle which is the correct behavior.
        // Affected by window/frame border size. Used by:
        // - Begin() initial clip rect
        float top_border_size = (((flags & ImGuiWindowFlags_MenuBar) || !(flags & ImGuiWindowFlags_NoTitleBar)) ? style.FrameBorderSize : window->WindowBorderSize);
        window->InnerClipRect.Min.x = ImFloor(0.5f + window->InnerRect.Min.x + ImMax(ImFloor(window->WindowPadding.x * 0.5f), window->WindowBorderSize));
        window->InnerClipRect.Min.y = ImFloor(0.5f + window->InnerRect.Min.y + top_border_size);
        window->InnerClipRect.Max.x = ImFloor(0.5f + window->InnerRect.Max.x - ImMax(ImFloor(window->WindowPadding.x * 0.5f), window->WindowBorderSize));
        window->InnerClipRect.Max.y = ImFloor(0.5f + window->InnerRect.Max.y - window->WindowBorderSize);
        window->InnerClipRect.ClipWithFull(host_rect);
 
        // Default item width. Make it proportional to window size if window manually resizes
        if (window->Size.x > 0.0f && !(flags & ImGuiWindowFlags_Tooltip) && !(flags & ImGuiWindowFlags_AlwaysAutoResize))
            window->ItemWidthDefault = ImFloor(window->Size.x * 0.65f);
        else
            window->ItemWidthDefault = ImFloor(g.FontSize * 16.0f);
 
        // SCROLLING
 
        // Lock down maximum scrolling
        // The value of ScrollMax are ahead from ScrollbarX/ScrollbarY which is intentionally using InnerRect from previous rect in order to accommodate
        // for right/bottom aligned items without creating a scrollbar.
        window->ScrollMax.x = ImMax(0.0f, window->ContentSize.x + window->WindowPadding.x * 2.0f - window->InnerRect.GetWidth());
        window->ScrollMax.y = ImMax(0.0f, window->ContentSize.y + window->WindowPadding.y * 2.0f - window->InnerRect.GetHeight());
 
        // Apply scrolling
        window->Scroll = CalcNextScrollFromScrollTargetAndClamp(window);
        window->ScrollTarget = ImVec2(FLT_MAX, FLT_MAX);
 
        // DRAWING
 
        // Setup draw list and outer clipping rectangle
        IM_ASSERT(window->DrawList->CmdBuffer.Size == 1 && window->DrawList->CmdBuffer[0].ElemCount == 0);
        window->DrawList->PushTextureID(g.Font->ContainerAtlas->TexID);
        PushClipRect(host_rect.Min, host_rect.Max, false);
 
        // Draw modal window background (darkens what is behind them, all viewports)
        const bool dim_bg_for_modal = (flags & ImGuiWindowFlags_Modal) && window == GetTopMostPopupModal() && window->HiddenFramesCannotSkipItems <= 0;
        const bool dim_bg_for_window_list = g.NavWindowingTargetAnim && (window == g.NavWindowingTargetAnim->RootWindow);
        if (dim_bg_for_modal || dim_bg_for_window_list)
        {
            const ImU32 dim_bg_col = GetColorU32(dim_bg_for_modal ? ImGuiCol_ModalWindowDimBg : ImGuiCol_NavWindowingDimBg, g.DimBgRatio);
            window->DrawList->AddRectFilled(viewport_rect.Min, viewport_rect.Max, dim_bg_col);
        }
 
        // Draw navigation selection/windowing rectangle background
        if (dim_bg_for_window_list && window == g.NavWindowingTargetAnim)
        {
            ImRect bb = window->Rect();
            bb.Expand(g.FontSize);
            if (!bb.Contains(viewport_rect)) // Avoid drawing if the window covers all the viewport anyway
                window->DrawList->AddRectFilled(bb.Min, bb.Max, GetColorU32(ImGuiCol_NavWindowingHighlight, g.NavWindowingHighlightAlpha * 0.25f), g.Style.WindowRounding);
        }
 
        // Since 1.71, child window can render their decoration (bg color, border, scrollbars, etc.) within their parent to save a draw call.
        // When using overlapping child windows, this will break the assumption that child z-order is mapped to submission order.
        // We disable this when the parent window has zero vertices, which is a common pattern leading to laying out multiple overlapping child.
        // We also disabled this when we have dimming overlay behind this specific one child.
        // FIXME: More code may rely on explicit sorting of overlapping child window and would need to disable this somehow. Please get in contact if you are affected.
        {
            bool render_decorations_in_parent = false;
            if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup) && !window_is_child_tooltip)
                if (window->DrawList->CmdBuffer.back().ElemCount == 0 && parent_window->DrawList->VtxBuffer.Size > 0)
                    render_decorations_in_parent = true;
            if (render_decorations_in_parent)
                window->DrawList = parent_window->DrawList;
 
            // Handle title bar, scrollbar, resize grips and resize borders
            const ImGuiWindow* window_to_highlight = g.NavWindowingTarget ? g.NavWindowingTarget : g.NavWindow;
            const bool title_bar_is_highlight = want_focus || (window_to_highlight && window->RootWindowForTitleBarHighlight == window_to_highlight->RootWindowForTitleBarHighlight);
            RenderWindowDecorations(window, title_bar_rect, title_bar_is_highlight, resize_grip_count, resize_grip_col, resize_grip_draw_size);
 
            if (render_decorations_in_parent)
                window->DrawList = &window->DrawListInst;
        }
 
        // Draw navigation selection/windowing rectangle border
        if (g.NavWindowingTargetAnim == window)
        {
            float rounding = ImMax(window->WindowRounding, g.Style.WindowRounding);
            ImRect bb = window->Rect();
            bb.Expand(g.FontSize);
            if (bb.Contains(viewport_rect)) // If a window fits the entire viewport, adjust its highlight inward
            {
                bb.Expand(-g.FontSize - 1.0f);
                rounding = window->WindowRounding;
            }
            window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(ImGuiCol_NavWindowingHighlight, g.NavWindowingHighlightAlpha), rounding, 0, 3.0f);
        }
 
        // UPDATE RECTANGLES (2- THOSE AFFECTED BY SCROLLING)
 
        // Work rectangle.
        // Affected by window padding and border size. Used by:
        // - Columns() for right-most edge
        // - TreeNode(), CollapsingHeader() for right-most edge
        // - BeginTabBar() for right-most edge
        const bool allow_scrollbar_x = !(flags & ImGuiWindowFlags_NoScrollbar) && (flags & ImGuiWindowFlags_HorizontalScrollbar);
        const bool allow_scrollbar_y = !(flags & ImGuiWindowFlags_NoScrollbar);
        const float work_rect_size_x = (window->ContentSizeExplicit.x != 0.0f ? window->ContentSizeExplicit.x : ImMax(allow_scrollbar_x ? window->ContentSize.x : 0.0f, window->Size.x - window->WindowPadding.x * 2.0f - window->ScrollbarSizes.x));
        const float work_rect_size_y = (window->ContentSizeExplicit.y != 0.0f ? window->ContentSizeExplicit.y : ImMax(allow_scrollbar_y ? window->ContentSize.y : 0.0f, window->Size.y - window->WindowPadding.y * 2.0f - decoration_up_height - window->ScrollbarSizes.y));
        window->WorkRect.Min.x = ImFloor(window->InnerRect.Min.x - window->Scroll.x + ImMax(window->WindowPadding.x, window->WindowBorderSize));
        window->WorkRect.Min.y = ImFloor(window->InnerRect.Min.y - window->Scroll.y + ImMax(window->WindowPadding.y, window->WindowBorderSize));
        window->WorkRect.Max.x = window->WorkRect.Min.x + work_rect_size_x;
        window->WorkRect.Max.y = window->WorkRect.Min.y + work_rect_size_y;
        window->ParentWorkRect = window->WorkRect;
 
        // [LEGACY] Content Region
        // FIXME-OBSOLETE: window->ContentRegionRect.Max is currently very misleading / partly faulty, but some BeginChild() patterns relies on it.
        // Used by:
        // - Mouse wheel scrolling + many other things
        window->ContentRegionRect.Min.x = window->Pos.x - window->Scroll.x + window->WindowPadding.x;
        window->ContentRegionRect.Min.y = window->Pos.y - window->Scroll.y + window->WindowPadding.y + decoration_up_height;
        window->ContentRegionRect.Max.x = window->ContentRegionRect.Min.x + (window->ContentSizeExplicit.x != 0.0f ? window->ContentSizeExplicit.x : (window->Size.x - window->WindowPadding.x * 2.0f - window->ScrollbarSizes.x));
        window->ContentRegionRect.Max.y = window->ContentRegionRect.Min.y + (window->ContentSizeExplicit.y != 0.0f ? window->ContentSizeExplicit.y : (window->Size.y - window->WindowPadding.y * 2.0f - decoration_up_height - window->ScrollbarSizes.y));
 
        // Setup drawing context
        // (NB: That term "drawing context / DC" lost its meaning a long time ago. Initially was meant to hold transient data only. Nowadays difference between window-> and window->DC-> is dubious.)
        window->DC.Indent.x = 0.0f + window->WindowPadding.x - window->Scroll.x;
        window->DC.GroupOffset.x = 0.0f;
        window->DC.ColumnsOffset.x = 0.0f;
        window->DC.CursorStartPos = window->Pos + ImVec2(window->DC.Indent.x + window->DC.ColumnsOffset.x, decoration_up_height + window->WindowPadding.y - window->Scroll.y);
        window->DC.CursorPos = window->DC.CursorStartPos;
        window->DC.CursorPosPrevLine = window->DC.CursorPos;
        window->DC.CursorMaxPos = window->DC.CursorStartPos;
        window->DC.IdealMaxPos = window->DC.CursorStartPos;
        window->DC.CurrLineSize = window->DC.PrevLineSize = ImVec2(0.0f, 0.0f);
        window->DC.CurrLineTextBaseOffset = window->DC.PrevLineTextBaseOffset = 0.0f;
 
        window->DC.NavLayerCurrent = ImGuiNavLayer_Main;
        window->DC.NavLayersActiveMask = window->DC.NavLayersActiveMaskNext;
        window->DC.NavLayersActiveMaskNext = 0x00;
        window->DC.NavHideHighlightOneFrame = false;
        window->DC.NavHasScroll = (window->ScrollMax.y > 0.0f);
 
        window->DC.MenuBarAppending = false;
        window->DC.MenuColumns.Update(3, style.ItemSpacing.x, window_just_activated_by_user);
        window->DC.TreeDepth = 0;
        window->DC.TreeJumpToParentOnPopMask = 0x00;
        window->DC.ChildWindows.resize(0);
        window->DC.StateStorage = &window->StateStorage;
        window->DC.CurrentColumns = NULL;
        window->DC.LayoutType = ImGuiLayoutType_Vertical;
        window->DC.ParentLayoutType = parent_window ? parent_window->DC.LayoutType : ImGuiLayoutType_Vertical;
        window->DC.FocusCounterRegular = window->DC.FocusCounterTabStop = -1;
 
        window->DC.ItemWidth = window->ItemWidthDefault;
        window->DC.TextWrapPos = -1.0f; // disabled
        window->DC.ItemWidthStack.resize(0);
        window->DC.TextWrapPosStack.resize(0);
 
        if (window->AutoFitFramesX > 0)
            window->AutoFitFramesX--;
        if (window->AutoFitFramesY > 0)
            window->AutoFitFramesY--;
 
        // Apply focus (we need to call FocusWindow() AFTER setting DC.CursorStartPos so our initial navigation reference rectangle can start around there)
        if (want_focus)
        {
            FocusWindow(window);
            NavInitWindow(window, false); // <-- this is in the way for us to be able to defer and sort reappearing FocusWindow() calls
        }
 
        // Title bar
        if (!(flags & ImGuiWindowFlags_NoTitleBar))
            RenderWindowTitleBarContents(window, ImRect(title_bar_rect.Min.x + window->WindowBorderSize, title_bar_rect.Min.y, title_bar_rect.Max.x - window->WindowBorderSize, title_bar_rect.Max.y), name, p_open);
 
        // Clear hit test shape every frame
        window->HitTestHoleSize.x = window->HitTestHoleSize.y = 0;
 
        // Pressing CTRL+C while holding on a window copy its content to the clipboard
        // This works but 1. doesn't handle multiple Begin/End pairs, 2. recursing into another Begin/End pair - so we need to work that out and add better logging scope.
        // Maybe we can support CTRL+C on every element?
        /*
        //if (g.NavWindow == window && g.ActiveId == 0)
        if (g.ActiveId == window->MoveId)
            if (g.IO.KeyCtrl && IsKeyPressedMap(ImGuiKey_C))
                LogToClipboard();
        */
 
        // We fill last item data based on Title Bar/Tab, in order for IsItemHovered() and IsItemActive() to be usable after Begin().
        // This is useful to allow creating context menus on title bar only, etc.
        SetLastItemData(window, window->MoveId, IsMouseHoveringRect(title_bar_rect.Min, title_bar_rect.Max, false) ? ImGuiItemStatusFlags_HoveredRect : 0, title_bar_rect);
 
#ifdef IMGUI_ENABLE_TEST_ENGINE
        if (!(window->Flags & ImGuiWindowFlags_NoTitleBar))
            IMGUI_TEST_ENGINE_ITEM_ADD(window->DC.LastItemRect, window->DC.LastItemId);
#endif
    }
    else
    {
        // Append
        SetCurrentWindow(window);
    }
 
    // Pull/inherit current state
    g.CurrentItemFlags = g.ItemFlagsStack.back(); // Inherit from shared stack
    window->DC.NavFocusScopeIdCurrent = (flags & ImGuiWindowFlags_ChildWindow) ? parent_window->DC.NavFocusScopeIdCurrent : 0; // Inherit from parent only // -V595
 
    PushClipRect(window->InnerClipRect.Min, window->InnerClipRect.Max, true);
 
    // Clear 'accessed' flag last thing (After PushClipRect which will set the flag. We want the flag to stay false when the default "Debug" window is unused)
    window->WriteAccessed = false;
    window->BeginCount++;
    g.NextWindowData.ClearFlags();
 
    // Update visibility
    if (first_begin_of_the_frame)
    {
        if (flags & ImGuiWindowFlags_ChildWindow)
        {
            // Child window can be out of sight and have "negative" clip windows.
            // Mark them as collapsed so commands are skipped earlier (we can't manually collapse them because they have no title bar).
            IM_ASSERT((flags & ImGuiWindowFlags_NoTitleBar) != 0);
            if (!(flags & ImGuiWindowFlags_AlwaysAutoResize) && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0) // FIXME: Doesn't make sense for ChildWindow??
                if (!g.LogEnabled)
                    if (window->OuterRectClipped.Min.x >= window->OuterRectClipped.Max.x || window->OuterRectClipped.Min.y >= window->OuterRectClipped.Max.y)
                        window->HiddenFramesCanSkipItems = 1;
 
            // Hide along with parent or if parent is collapsed
            if (parent_window && (parent_window->Collapsed || parent_window->HiddenFramesCanSkipItems > 0))
                window->HiddenFramesCanSkipItems = 1;
            if (parent_window && (parent_window->Collapsed || parent_window->HiddenFramesCannotSkipItems > 0))
                window->HiddenFramesCannotSkipItems = 1;
        }
 
        // Don't render if style alpha is 0.0 at the time of Begin(). This is arbitrary and inconsistent but has been there for a long while (may remove at some point)
        if (style.Alpha <= 0.0f)
            window->HiddenFramesCanSkipItems = 1;
 
        // Update the Hidden flag
        window->Hidden = (window->HiddenFramesCanSkipItems > 0) || (window->HiddenFramesCannotSkipItems > 0) || (window->HiddenFramesForRenderOnly > 0);
 
        // Disable inputs for requested number of frames
        if (window->DisableInputsFrames > 0)
        {
            window->DisableInputsFrames--;
            window->Flags |= ImGuiWindowFlags_NoInputs;
        }
 
        // Update the SkipItems flag, used to early out of all items functions (no layout required)
        bool skip_items = false;
        if (window->Collapsed || !window->Active || window->Hidden)
            if (window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0 && window->HiddenFramesCannotSkipItems <= 0)
                skip_items = true;
        window->SkipItems = skip_items;
    }
 
    return !window->SkipItems;
}

Referenced by Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::begin(), BeginChildEx(), BeginCombo(), BeginPopupEx(), BeginPopupModal(), BeginTooltipEx(), BeginViewportSideBar(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), NavUpdateWindowingOverlay(), NewFrame(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), ShowAboutWindow(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppAutoResize(), ShowExampleAppConstrainedResize(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppFullscreen(), ShowExampleAppLayout(), ShowExampleAppLog(), ShowExampleAppLongText(), ShowExampleAppPropertyEditor(), ShowExampleAppSimpleOverlay(), ShowExampleAppWindowTitles(), and ShowMetricsWindow().

Here is the caller graph for this function:

◆ BeginChild() [1/2]

bool ImGui::BeginChild	(	const char *	str_id,
		const ImVec2 &	size = `ImVec2(0, 0)`,
		bool	border = `false`,
		ImGuiWindowFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    return BeginChildEx(str_id, window->GetID(str_id), size_arg, border, extra_flags);
}

References BeginChildEx(), GetCurrentWindow(), and ImGuiWindow::GetID().

Referenced by BeginChildFrame(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppLayout(), ShowExampleAppLongText(), ShowExampleMenuFile(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginChild() [2/2]

bool ImGui::BeginChild	(	ImGuiID	id,
		const ImVec2 &	size = `ImVec2(0, 0)`,
		bool	border = `false`,
		ImGuiWindowFlags	flags = `0`
	)

{
    IM_ASSERT(id != 0);
    return BeginChildEx(NULL, id, size_arg, border, extra_flags);
}

References BeginChildEx(), and IM_ASSERT.

Here is the call graph for this function:

◆ BeginChildEx()

bool ImGui::BeginChildEx	(	const char *	name,
		ImGuiID	id,
		const ImVec2 &	size_arg,
		bool	border,
		ImGuiWindowFlags	flags
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* parent_window = g.CurrentWindow;
 
    flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_ChildWindow;
    flags |= (parent_window->Flags & ImGuiWindowFlags_NoMove);  // Inherit the NoMove flag
 
    // Size
    const ImVec2 content_avail = GetContentRegionAvail();
    ImVec2 size = ImFloor(size_arg);
    const int auto_fit_axises = ((size.x == 0.0f) ? (1 << ImGuiAxis_X) : 0x00) | ((size.y == 0.0f) ? (1 << ImGuiAxis_Y) : 0x00);
    if (size.x <= 0.0f)
        size.x = ImMax(content_avail.x + size.x, 4.0f); // Arbitrary minimum child size (0.0f causing too much issues)
    if (size.y <= 0.0f)
        size.y = ImMax(content_avail.y + size.y, 4.0f);
    SetNextWindowSize(size);
 
    // Build up name. If you need to append to a same child from multiple location in the ID stack, use BeginChild(ImGuiID id) with a stable value.
    if (name)
        ImFormatString(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), "%s/%s_%08X", parent_window->Name, name, id);
    else
        ImFormatString(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), "%s/%08X", parent_window->Name, id);
 
    const float backup_border_size = g.Style.ChildBorderSize;
    if (!border)
        g.Style.ChildBorderSize = 0.0f;
    bool ret = Begin(g.TempBuffer, NULL, flags);
    g.Style.ChildBorderSize = backup_border_size;
 
    ImGuiWindow* child_window = g.CurrentWindow;
    child_window->ChildId = id;
    child_window->AutoFitChildAxises = (ImS8)auto_fit_axises;
 
    // Set the cursor to handle case where the user called SetNextWindowPos()+BeginChild() manually.
    // While this is not really documented/defined, it seems that the expected thing to do.
    if (child_window->BeginCount == 1)
        parent_window->DC.CursorPos = child_window->Pos;
 
    // Process navigation-in immediately so NavInit can run on first frame
    if (g.NavActivateId == id && !(flags & ImGuiWindowFlags_NavFlattened) && (child_window->DC.NavLayersActiveMask != 0 || child_window->DC.NavHasScroll))
    {
        FocusWindow(child_window);
        NavInitWindow(child_window, false);
        SetActiveID(id + 1, child_window); // Steal ActiveId with another arbitrary id so that key-press won't activate child item
        g.ActiveIdSource = ImGuiInputSource_Nav;
    }
    return ret;
}

References ImGuiContext::ActiveIdSource, ImGuiWindow::AutoFitChildAxises, Begin(), ImGuiWindow::BeginCount, ImGuiStyle::ChildBorderSize, ImGuiWindow::ChildId, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::Flags, FocusWindow(), GetContentRegionAvail(), GImGui, IM_ARRAYSIZE, ImFloor(), ImFormatString(), ImGuiAxis_X, ImGuiAxis_Y, ImGuiInputSource_Nav, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NavFlattened, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_NoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, ImMax(), ImGuiWindow::Name, ImGuiContext::NavActivateId, ImGuiWindowTempData::NavHasScroll, NavInitWindow(), ImGuiWindowTempData::NavLayersActiveMask, ImGuiWindow::Pos, SetActiveID(), SetNextWindowSize(), ImGuiContext::Style, ImGuiContext::TempBuffer, ImVec2::x, and ImVec2::y.

Referenced by BeginChild(), BeginChild(), BeginTableEx(), and InputTextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginChildFrame()

bool ImGui::BeginChildFrame	(	ImGuiID	id,
		const ImVec2 &	size,
		ImGuiWindowFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);
    PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
    PushStyleVar(ImGuiStyleVar_ChildBorderSize, style.FrameBorderSize);
    PushStyleVar(ImGuiStyleVar_WindowPadding, style.FramePadding);
    bool ret = BeginChild(id, size, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysUseWindowPadding | extra_flags);
    PopStyleVar(3);
    PopStyleColor();
    return ret;
}

References BeginChild(), GImGui, ImGuiCol_ChildBg, ImGuiCol_FrameBg, ImGuiStyleVar_ChildBorderSize, ImGuiStyleVar_ChildRounding, ImGuiStyleVar_WindowPadding, ImGuiWindowFlags_AlwaysUseWindowPadding, ImGuiWindowFlags_NoMove, PopStyleColor(), PopStyleVar(), PushStyleColor(), PushStyleVar(), ImGuiContext::Style, and style.

Referenced by BeginListBox(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowAboutWindow(), and ShowExampleAppDocuments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginColumns()

void ImGui::BeginColumns	(	const char *	str_id,
		int	count,
		ImGuiOldColumnFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
 
    IM_ASSERT(columns_count >= 1);
    IM_ASSERT(window->DC.CurrentColumns == NULL);   // Nested columns are currently not supported
 
    // Acquire storage for the columns set
    ImGuiID id = GetColumnsID(str_id, columns_count);
    ImGuiOldColumns* columns = FindOrCreateColumns(window, id);
    IM_ASSERT(columns->ID == id);
    columns->Current = 0;
    columns->Count = columns_count;
    columns->Flags = flags;
    window->DC.CurrentColumns = columns;
 
    columns->HostCursorPosY = window->DC.CursorPos.y;
    columns->HostCursorMaxPosX = window->DC.CursorMaxPos.x;
    columns->HostInitialClipRect = window->ClipRect;
    columns->HostBackupParentWorkRect = window->ParentWorkRect;
    window->ParentWorkRect = window->WorkRect;
 
    // Set state for first column
    // We aim so that the right-most column will have the same clipping width as other after being clipped by parent ClipRect
    const float column_padding = g.Style.ItemSpacing.x;
    const float half_clip_extend_x = ImFloor(ImMax(window->WindowPadding.x * 0.5f, window->WindowBorderSize));
    const float max_1 = window->WorkRect.Max.x + column_padding - ImMax(column_padding - window->WindowPadding.x, 0.0f);
    const float max_2 = window->WorkRect.Max.x + half_clip_extend_x;
    columns->OffMinX = window->DC.Indent.x - column_padding + ImMax(column_padding - window->WindowPadding.x, 0.0f);
    columns->OffMaxX = ImMax(ImMin(max_1, max_2) - window->Pos.x, columns->OffMinX + 1.0f);
    columns->LineMinY = columns->LineMaxY = window->DC.CursorPos.y;
 
    // Clear data if columns count changed
    if (columns->Columns.Size != 0 && columns->Columns.Size != columns_count + 1)
        columns->Columns.resize(0);
 
    // Initialize default widths
    columns->IsFirstFrame = (columns->Columns.Size == 0);
    if (columns->Columns.Size == 0)
    {
        columns->Columns.reserve(columns_count + 1);
        for (int n = 0; n < columns_count + 1; n++)
        {
            ImGuiOldColumnData column;
            column.OffsetNorm = n / (float)columns_count;
            columns->Columns.push_back(column);
        }
    }
 
    for (int n = 0; n < columns_count; n++)
    {
        // Compute clipping rectangle
        ImGuiOldColumnData* column = &columns->Columns[n];
        float clip_x1 = IM_ROUND(window->Pos.x + GetColumnOffset(n));
        float clip_x2 = IM_ROUND(window->Pos.x + GetColumnOffset(n + 1) - 1.0f);
        column->ClipRect = ImRect(clip_x1, -FLT_MAX, clip_x2, +FLT_MAX);
        column->ClipRect.ClipWithFull(window->ClipRect);
    }
 
    if (columns->Count > 1)
    {
        columns->Splitter.Split(window->DrawList, 1 + columns->Count);
        columns->Splitter.SetCurrentChannel(window->DrawList, 1);
        PushColumnClipRect(0);
    }
 
    // We don't generally store Indent.x inside ColumnsOffset because it may be manipulated by the user.
    float offset_0 = GetColumnOffset(columns->Current);
    float offset_1 = GetColumnOffset(columns->Current + 1);
    float width = offset_1 - offset_0;
    PushItemWidth(width * 0.65f);
    window->DC.ColumnsOffset.x = ImMax(column_padding - window->WindowPadding.x, 0.0f);
    window->DC.CursorPos.x = IM_FLOOR(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
    window->WorkRect.Max.x = window->Pos.x + offset_1 - column_padding;
}

References ImGuiOldColumnData::ClipRect, ImGuiWindow::ClipRect, ImRect::ClipWithFull(), ImGuiOldColumns::Columns, ImGuiWindowTempData::ColumnsOffset, ImGuiOldColumns::Count, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, FindOrCreateColumns(), ImGuiOldColumns::Flags, GetColumnOffset(), GetColumnsID(), GetCurrentWindow(), GImGui, ImGuiOldColumns::HostBackupParentWorkRect, ImGuiOldColumns::HostCursorMaxPosX, ImGuiOldColumns::HostCursorPosY, ImGuiOldColumns::HostInitialClipRect, ImGuiOldColumns::ID, IM_ASSERT, IM_FLOOR, IM_ROUND, ImFloor(), ImMax(), ImMin(), ImGuiWindowTempData::Indent, ImGuiOldColumns::IsFirstFrame, ImGuiStyle::ItemSpacing, ImGuiOldColumns::LineMaxY, ImGuiOldColumns::LineMinY, ImRect::Max, ImGuiOldColumns::OffMaxX, ImGuiOldColumns::OffMinX, ImGuiOldColumnData::OffsetNorm, ImGuiWindow::ParentWorkRect, ImGuiWindow::Pos, ImVector< T >::push_back(), PushColumnClipRect(), PushItemWidth(), ImVector< T >::reserve(), ImVector< T >::resize(), ImDrawListSplitter::SetCurrentChannel(), ImVector< T >::Size, ImDrawListSplitter::Split(), ImGuiOldColumns::Splitter, ImGuiContext::Style, ImGuiWindow::WindowBorderSize, ImGuiWindow::WindowPadding, ImGuiWindow::WorkRect, ImVec2::x, ImVec1::x, and ImVec2::y.

Referenced by Columns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginCombo()

bool ImGui::BeginCombo	(	const char *	label,
		const char *	preview_value,
		ImGuiComboFlags	flags = `0`
	)

{
    // Always consume the SetNextWindowSizeConstraint() call in our early return paths
    ImGuiContext& g = *GImGui;
    bool has_window_size_constraint = (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint) != 0;
    g.NextWindowData.Flags &= ~ImGuiNextWindowDataFlags_HasSizeConstraint;
 
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    IM_ASSERT((flags & (ImGuiComboFlags_NoArrowButton | ImGuiComboFlags_NoPreview)) != (ImGuiComboFlags_NoArrowButton | ImGuiComboFlags_NoPreview)); // Can't use both flags together
 
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
 
    const float arrow_size = (flags & ImGuiComboFlags_NoArrowButton) ? 0.0f : GetFrameHeight();
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
    const float expected_w = CalcItemWidth();
    const float w = (flags & ImGuiComboFlags_NoPreview) ? arrow_size : expected_w;
    const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y * 2.0f));
    const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, id, &frame_bb))
        return false;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(frame_bb, id, &hovered, &held);
 
    const ImGuiID popup_id = ImHashStr("##ComboPopup", 0, id);
    bool popup_open = IsPopupOpen(popup_id, ImGuiPopupFlags_None);
 
    const ImU32 frame_col = GetColorU32(hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
    const float value_x2 = ImMax(frame_bb.Min.x, frame_bb.Max.x - arrow_size);
    RenderNavHighlight(frame_bb, id);
    if (!(flags & ImGuiComboFlags_NoPreview))
        window->DrawList->AddRectFilled(frame_bb.Min, ImVec2(value_x2, frame_bb.Max.y), frame_col, style.FrameRounding, (flags & ImGuiComboFlags_NoArrowButton) ? ImDrawFlags_RoundCornersAll : ImDrawFlags_RoundCornersLeft);
    if (!(flags & ImGuiComboFlags_NoArrowButton))
    {
        ImU32 bg_col = GetColorU32((popup_open || hovered) ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
        ImU32 text_col = GetColorU32(ImGuiCol_Text);
        window->DrawList->AddRectFilled(ImVec2(value_x2, frame_bb.Min.y), frame_bb.Max, bg_col, style.FrameRounding, (w <= arrow_size) ? ImDrawFlags_RoundCornersAll : ImDrawFlags_RoundCornersRight);
        if (value_x2 + arrow_size - style.FramePadding.x <= frame_bb.Max.x)
            RenderArrow(window->DrawList, ImVec2(value_x2 + style.FramePadding.y, frame_bb.Min.y + style.FramePadding.y), text_col, ImGuiDir_Down, 1.0f);
    }
    RenderFrameBorder(frame_bb.Min, frame_bb.Max, style.FrameRounding);
    if (preview_value != NULL && !(flags & ImGuiComboFlags_NoPreview))
    {
        ImVec2 preview_pos = frame_bb.Min + style.FramePadding;
        if (g.LogEnabled)
            LogSetNextTextDecoration("{", "}");
        RenderTextClipped(preview_pos, ImVec2(value_x2, frame_bb.Max.y), preview_value, NULL, NULL, ImVec2(0.0f, 0.0f));
    }
    if (label_size.x > 0)
        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
    if ((pressed || g.NavActivateId == id) && !popup_open)
    {
        if (window->DC.NavLayerCurrent == 0)
            window->NavLastIds[0] = id;
        OpenPopupEx(popup_id, ImGuiPopupFlags_None);
        popup_open = true;
    }
 
    if (!popup_open)
        return false;
 
    if (has_window_size_constraint)
    {
        g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSizeConstraint;
        g.NextWindowData.SizeConstraintRect.Min.x = ImMax(g.NextWindowData.SizeConstraintRect.Min.x, w);
    }
    else
    {
        if ((flags & ImGuiComboFlags_HeightMask_) == 0)
            flags |= ImGuiComboFlags_HeightRegular;
        IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiComboFlags_HeightMask_));    // Only one
        int popup_max_height_in_items = -1;
        if (flags & ImGuiComboFlags_HeightRegular)     popup_max_height_in_items = 8;
        else if (flags & ImGuiComboFlags_HeightSmall)  popup_max_height_in_items = 4;
        else if (flags & ImGuiComboFlags_HeightLarge)  popup_max_height_in_items = 20;
        SetNextWindowSizeConstraints(ImVec2(w, 0.0f), ImVec2(FLT_MAX, CalcMaxPopupHeightFromItemCount(popup_max_height_in_items)));
    }
 
    char name[16];
    ImFormatString(name, IM_ARRAYSIZE(name), "##Combo_%02d", g.BeginPopupStack.Size); // Recycle windows based on depth
 
    // Position the window given a custom constraint (peak into expected window size so we can position it)
    // This might be easier to express with an hypothetical SetNextWindowPosConstraints() function.
    if (ImGuiWindow* popup_window = FindWindowByName(name))
        if (popup_window->WasActive)
        {
            // Always override 'AutoPosLastDirection' to not leave a chance for a past value to affect us.
            ImVec2 size_expected = CalcWindowNextAutoFitSize(popup_window);
            if (flags & ImGuiComboFlags_PopupAlignLeft)
                popup_window->AutoPosLastDirection = ImGuiDir_Left; // "Below, Toward Left"
            else
                popup_window->AutoPosLastDirection = ImGuiDir_Down; // "Below, Toward Right (default)"
            ImRect r_outer = GetWindowAllowedExtentRect(popup_window);
            ImVec2 pos = FindBestWindowPosForPopupEx(frame_bb.GetBL(), size_expected, &popup_window->AutoPosLastDirection, r_outer, frame_bb, ImGuiPopupPositionPolicy_ComboBox);
            SetNextWindowPos(pos);
        }
 
    // We don't use BeginPopupEx() solely because we have a custom name string, which we could make an argument to BeginPopupEx()
    ImGuiWindowFlags window_flags = ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_Popup | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoMove;
 
    // Horizontally align ourselves with the framed text
    PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(style.FramePadding.x, style.WindowPadding.y));
    bool ret = Begin(name, NULL, window_flags);
    PopStyleVar();
    if (!ret)
    {
        EndPopup();
        IM_ASSERT(0);   // This should never happen as we tested for IsPopupOpen() above
        return false;
    }
    return true;
}

References ImDrawList::AddRectFilled(), Begin(), ImGuiContext::BeginPopupStack, ButtonBehavior(), CalcItemWidth(), CalcMaxPopupHeightFromItemCount(), CalcTextSize(), CalcWindowNextAutoFitSize(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, EndPopup(), FindBestWindowPosForPopupEx(), FindWindowByName(), ImGuiNextWindowData::Flags, ImRect::GetBL(), GetColorU32(), GetCurrentWindow(), GetFrameHeight(), ImGuiWindow::GetID(), GetWindowAllowedExtentRect(), GImGui, IM_ARRAYSIZE, IM_ASSERT, ImDrawFlags_RoundCornersAll, ImDrawFlags_RoundCornersLeft, ImDrawFlags_RoundCornersRight, ImFormatString(), ImGuiCol_Button, ImGuiCol_ButtonHovered, ImGuiCol_FrameBg, ImGuiCol_FrameBgHovered, ImGuiCol_Text, ImGuiComboFlags_HeightLarge, ImGuiComboFlags_HeightMask_, ImGuiComboFlags_HeightRegular, ImGuiComboFlags_HeightSmall, ImGuiComboFlags_NoArrowButton, ImGuiComboFlags_NoPreview, ImGuiComboFlags_PopupAlignLeft, ImGuiDir_Down, ImGuiDir_Left, ImGuiNextWindowDataFlags_HasSizeConstraint, ImGuiPopupFlags_None, ImGuiPopupPositionPolicy_ComboBox, ImGuiStyleVar_WindowPadding, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_NoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, ImGuiWindowFlags_Popup, ImHashStr(), ImIsPowerOfTwo(), ImMax(), IsPopupOpen(), ItemAdd(), ItemSize(), ImGuiContext::LogEnabled, LogSetNextTextDecoration(), ImRect::Max, ImRect::Min, ImGuiContext::NavActivateId, ImGuiWindow::NavLastIds, ImGuiWindowTempData::NavLayerCurrent, ImGuiContext::NextWindowData, OpenPopupEx(), PopStyleVar(), PushStyleVar(), RenderArrow(), RenderFrameBorder(), RenderNavHighlight(), RenderText(), RenderTextClipped(), SetNextWindowPos(), SetNextWindowSizeConstraints(), ImVector< T >::Size, ImGuiNextWindowData::SizeConstraintRect, ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::ImGuiWrapper::combo(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), EditTableSizingFlags(), Slic3r::GUI::render_extruders_combo(), ShowDemoWindowWidgets(), ShowFontSelector(), and TabBarTabListPopupButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginDragDropSource()

bool ImGui::BeginDragDropSource ( ImGuiDragDropFlags flags = 0 )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    // FIXME-DRAGDROP: While in the common-most "drag from non-zero active id" case we can tell the mouse button,
    // in both SourceExtern and id==0 cases we may requires something else (explicit flags or some heuristic).
    ImGuiMouseButton mouse_button = ImGuiMouseButton_Left;
 
    bool source_drag_active = false;
    ImGuiID source_id = 0;
    ImGuiID source_parent_id = 0;
    if (!(flags & ImGuiDragDropFlags_SourceExtern))
    {
        source_id = window->DC.LastItemId;
        if (source_id != 0)
        {
            // Common path: items with ID
            if (g.ActiveId != source_id)
                return false;
            if (g.ActiveIdMouseButton != -1)
                mouse_button = g.ActiveIdMouseButton;
            if (g.IO.MouseDown[mouse_button] == false)
                return false;
            g.ActiveIdAllowOverlap = false;
        }
        else
        {
            // Uncommon path: items without ID
            if (g.IO.MouseDown[mouse_button] == false)
                return false;
 
            // If you want to use BeginDragDropSource() on an item with no unique identifier for interaction, such as Text() or Image(), you need to:
            // A) Read the explanation below, B) Use the ImGuiDragDropFlags_SourceAllowNullID flag, C) Swallow your programmer pride.
            if (!(flags & ImGuiDragDropFlags_SourceAllowNullID))
            {
                IM_ASSERT(0);
                return false;
            }
 
            // Early out
            if ((window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect) == 0 && (g.ActiveId == 0 || g.ActiveIdWindow != window))
                return false;
 
            // Magic fallback (=somehow reprehensible) to handle items with no assigned ID, e.g. Text(), Image()
            // We build a throwaway ID based on current ID stack + relative AABB of items in window.
            // THE IDENTIFIER WON'T SURVIVE ANY REPOSITIONING OF THE WIDGET, so if your widget moves your dragging operation will be canceled.
            // We don't need to maintain/call ClearActiveID() as releasing the button will early out this function and trigger !ActiveIdIsAlive.
            source_id = window->DC.LastItemId = window->GetIDFromRectangle(window->DC.LastItemRect);
            bool is_hovered = ItemHoverable(window->DC.LastItemRect, source_id);
            if (is_hovered && g.IO.MouseClicked[mouse_button])
            {
                SetActiveID(source_id, window);
                FocusWindow(window);
            }
            if (g.ActiveId == source_id) // Allow the underlying widget to display/return hovered during the mouse release frame, else we would get a flicker.
                g.ActiveIdAllowOverlap = is_hovered;
        }
        if (g.ActiveId != source_id)
            return false;
        source_parent_id = window->IDStack.back();
        source_drag_active = IsMouseDragging(mouse_button);
 
        // Disable navigation and key inputs while dragging
        g.ActiveIdUsingNavDirMask = ~(ImU32)0;
        g.ActiveIdUsingNavInputMask = ~(ImU32)0;
        g.ActiveIdUsingKeyInputMask = ~(ImU64)0;
    }
    else
    {
        window = NULL;
        source_id = ImHashStr("#SourceExtern");
        source_drag_active = true;
    }
 
    if (source_drag_active)
    {
        if (!g.DragDropActive)
        {
            IM_ASSERT(source_id != 0);
            ClearDragDrop();
            ImGuiPayload& payload = g.DragDropPayload;
            payload.SourceId = source_id;
            payload.SourceParentId = source_parent_id;
            g.DragDropActive = true;
            g.DragDropSourceFlags = flags;
            g.DragDropMouseButton = mouse_button;
            if (payload.SourceId == g.ActiveId)
                g.ActiveIdNoClearOnFocusLoss = true;
        }
        g.DragDropSourceFrameCount = g.FrameCount;
        g.DragDropWithinSource = true;
 
        if (!(flags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
        {
            // Target can request the Source to not display its tooltip (we use a dedicated flag to make this request explicit)
            // We unfortunately can't just modify the source flags and skip the call to BeginTooltip, as caller may be emitting contents.
            BeginTooltip();
            if (g.DragDropAcceptIdPrev && (g.DragDropAcceptFlags & ImGuiDragDropFlags_AcceptNoPreviewTooltip))
            {
                ImGuiWindow* tooltip_window = g.CurrentWindow;
                tooltip_window->SkipItems = true;
                tooltip_window->HiddenFramesCanSkipItems = 1;
            }
        }
 
        if (!(flags & ImGuiDragDropFlags_SourceNoDisableHover) && !(flags & ImGuiDragDropFlags_SourceExtern))
            window->DC.LastItemStatusFlags &= ~ImGuiItemStatusFlags_HoveredRect;
 
        return true;
    }
    return false;
}

Referenced by ColorButton(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginDragDropTarget()

bool ImGui::BeginDragDropTarget ( )

{
    ImGuiContext& g = *GImGui;
    if (!g.DragDropActive)
        return false;
 
    ImGuiWindow* window = g.CurrentWindow;
    if (!(window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect))
        return false;
    ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
    if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
        return false;
 
    const ImRect& display_rect = (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect) ? window->DC.LastItemDisplayRect : window->DC.LastItemRect;
    ImGuiID id = window->DC.LastItemId;
    if (id == 0)
        id = window->GetIDFromRectangle(display_rect);
    if (g.DragDropPayload.SourceId == id)
        return false;
 
    IM_ASSERT(g.DragDropWithinTarget == false);
    g.DragDropTargetRect = display_rect;
    g.DragDropTargetId = id;
    g.DragDropWithinTarget = true;
    return true;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiContext::DragDropActive, ImGuiContext::DragDropPayload, ImGuiContext::DragDropTargetId, ImGuiContext::DragDropTargetRect, ImGuiContext::DragDropWithinTarget, ImGuiWindow::GetIDFromRectangle(), GImGui, ImGuiContext::HoveredWindowUnderMovingWindow, IM_ASSERT, ImGuiItemStatusFlags_HasDisplayRect, ImGuiItemStatusFlags_HoveredRect, ImGuiWindowTempData::LastItemDisplayRect, ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemRect, ImGuiWindowTempData::LastItemStatusFlags, ImGuiWindow::RootWindow, and ImGuiPayload::SourceId.

Referenced by ColorEdit4(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginDragDropTargetCustom()

bool ImGui::BeginDragDropTargetCustom	(	const ImRect &	bb,
		ImGuiID	id
	)

{
    ImGuiContext& g = *GImGui;
    if (!g.DragDropActive)
        return false;
 
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
    if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
        return false;
    IM_ASSERT(id != 0);
    if (!IsMouseHoveringRect(bb.Min, bb.Max) || (id == g.DragDropPayload.SourceId))
        return false;
    if (window->SkipItems)
        return false;
 
    IM_ASSERT(g.DragDropWithinTarget == false);
    g.DragDropTargetRect = bb;
    g.DragDropTargetId = id;
    g.DragDropWithinTarget = true;
    return true;
}

References ImGuiContext::CurrentWindow, ImGuiContext::DragDropActive, ImGuiContext::DragDropPayload, ImGuiContext::DragDropTargetId, ImGuiContext::DragDropTargetRect, ImGuiContext::DragDropWithinTarget, GImGui, ImGuiContext::HoveredWindowUnderMovingWindow, IM_ASSERT, IsMouseHoveringRect(), ImRect::Max, ImRect::Min, ImGuiWindow::RootWindow, ImGuiWindow::SkipItems, and ImGuiPayload::SourceId.

Here is the call graph for this function:

◆ BeginGroup()

void ImGui::BeginGroup ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    g.GroupStack.resize(g.GroupStack.Size + 1);
    ImGuiGroupData& group_data = g.GroupStack.back();
    group_data.WindowID = window->ID;
    group_data.BackupCursorPos = window->DC.CursorPos;
    group_data.BackupCursorMaxPos = window->DC.CursorMaxPos;
    group_data.BackupIndent = window->DC.Indent;
    group_data.BackupGroupOffset = window->DC.GroupOffset;
    group_data.BackupCurrLineSize = window->DC.CurrLineSize;
    group_data.BackupCurrLineTextBaseOffset = window->DC.CurrLineTextBaseOffset;
    group_data.BackupActiveIdIsAlive = g.ActiveIdIsAlive;
    group_data.BackupHoveredIdIsAlive = g.HoveredId != 0;
    group_data.BackupActiveIdPreviousFrameIsAlive = g.ActiveIdPreviousFrameIsAlive;
    group_data.EmitItem = true;
 
    window->DC.GroupOffset.x = window->DC.CursorPos.x - window->Pos.x - window->DC.ColumnsOffset.x;
    window->DC.Indent = window->DC.GroupOffset;
    window->DC.CursorMaxPos = window->DC.CursorPos;
    window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
    if (g.LogEnabled)
        g.LogLinePosY = -FLT_MAX; // To enforce a carriage return
}

References ImGuiContext::ActiveIdIsAlive, ImGuiContext::ActiveIdPreviousFrameIsAlive, ImVector< T >::back(), ImGuiGroupData::BackupActiveIdIsAlive, ImGuiGroupData::BackupActiveIdPreviousFrameIsAlive, ImGuiGroupData::BackupCurrLineSize, ImGuiGroupData::BackupCurrLineTextBaseOffset, ImGuiGroupData::BackupCursorMaxPos, ImGuiGroupData::BackupCursorPos, ImGuiGroupData::BackupGroupOffset, ImGuiGroupData::BackupHoveredIdIsAlive, ImGuiGroupData::BackupIndent, ImGuiWindowTempData::ColumnsOffset, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CurrLineSize, ImGuiWindowTempData::CurrLineTextBaseOffset, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiGroupData::EmitItem, GImGui, ImGuiWindowTempData::GroupOffset, ImGuiContext::GroupStack, ImGuiContext::HoveredId, ImGuiWindow::ID, ImGuiWindowTempData::Indent, ImGuiContext::LogEnabled, ImGuiContext::LogLinePosY, ImGuiWindow::Pos, ImVector< T >::resize(), ImVector< T >::Size, ImGuiGroupData::WindowID, ImVec2::x, and ImVec1::x.

Referenced by BeginListBox(), BeginMenuBar(), ColorEdit4(), ColorPicker4(), DragFloatRange2(), DragIntRange2(), DragScalarN(), InputScalar(), InputScalarN(), InputTextEx(), Slic3r::GUI::render_extruders_combo(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppLayout(), ShowStyleEditor(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginListBox()

bool ImGui::BeginListBox	(	const char *	label,
		const ImVec2 &	size = `ImVec2(0, 0)`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = GetID(label);
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    // Size default to hold ~7.25 items.
    // Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar.
    ImVec2 size = ImFloor(CalcItemSize(size_arg, CalcItemWidth(), GetTextLineHeightWithSpacing() * 7.25f + style.FramePadding.y * 2.0f));
    ImVec2 frame_size = ImVec2(size.x, ImMax(size.y, label_size.y));
    ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);
    ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
    g.NextItemData.ClearFlags();
 
    if (!IsRectVisible(bb.Min, bb.Max))
    {
        ItemSize(bb.GetSize(), style.FramePadding.y);
        ItemAdd(bb, 0, &frame_bb);
        return false;
    }
 
    // FIXME-OPT: We could omit the BeginGroup() if label_size.x but would need to omit the EndGroup() as well.
    BeginGroup();
    if (label_size.x > 0.0f)
    {
        ImVec2 label_pos = ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y);
        RenderText(label_pos, label);
        window->DC.CursorMaxPos = ImMax(window->DC.CursorMaxPos, label_pos + label_size);
    }
 
    BeginChildFrame(id, frame_bb.GetSize());
    return true;
}

References BeginChildFrame(), BeginGroup(), CalcItemSize(), CalcItemWidth(), CalcTextSize(), ImGuiNextItemData::ClearFlags(), ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), GetID(), ImRect::GetSize(), GetTextLineHeightWithSpacing(), GImGui, ImFloor(), ImMax(), IsRectVisible(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, ImGuiContext::NextItemData, RenderText(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by ListBoxHeader(), ListBoxHeader(), ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginMainMenuBar()

bool ImGui::BeginMainMenuBar ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)GetMainViewport();
 
    // For the main menu bar, which cannot be moved, we honor g.Style.DisplaySafeAreaPadding to ensure text can be visible on a TV set.
    // FIXME: This could be generalized as an opt-in way to clamp window->DC.CursorStartPos to avoid SafeArea?
    // FIXME: Consider removing support for safe area down the line... it's messy. Nowadays consoles have support for TV calibration in OS settings.
    g.NextWindowData.MenuBarOffsetMinVal = ImVec2(g.Style.DisplaySafeAreaPadding.x, ImMax(g.Style.DisplaySafeAreaPadding.y - g.Style.FramePadding.y, 0.0f));
    ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_MenuBar;
    float height = GetFrameHeight();
    bool is_open = BeginViewportSideBar("##MainMenuBar", viewport, ImGuiDir_Up, height, window_flags);
    g.NextWindowData.MenuBarOffsetMinVal = ImVec2(0.0f, 0.0f);
 
    if (is_open)
        BeginMenuBar();
    else
        End();
    return is_open;
}

References BeginMenuBar(), BeginViewportSideBar(), ImGuiStyle::DisplaySafeAreaPadding, End(), ImGuiStyle::FramePadding, GetFrameHeight(), GetMainViewport(), GImGui, ImGuiDir_Up, ImGuiWindowFlags_MenuBar, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoScrollbar, ImMax(), ImGuiNextWindowData::MenuBarOffsetMinVal, ImGuiContext::NextWindowData, ImGuiContext::Style, ImVec2::x, and ImVec2::y.

Referenced by ShowExampleAppMainMenuBar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginMenu()

bool ImGui::BeginMenu	(	const char *	label,
		bool	enabled = `true`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    bool menu_is_open = IsPopupOpen(id, ImGuiPopupFlags_None);
 
    // Sub-menus are ChildWindow so that mouse can be hovering across them (otherwise top-most popup menu would steal focus and not allow hovering on parent menu)
    ImGuiWindowFlags flags = ImGuiWindowFlags_ChildMenu | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNavFocus;
    if (window->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu))
        flags |= ImGuiWindowFlags_ChildWindow;
 
    // If a menu with same the ID was already submitted, we will append to it, matching the behavior of Begin().
    // We are relying on a O(N) search - so O(N log N) over the frame - which seems like the most efficient for the expected small amount of BeginMenu() calls per frame.
    // If somehow this is ever becoming a problem we can switch to use e.g. ImGuiStorage mapping key to last frame used.
    if (g.MenusIdSubmittedThisFrame.contains(id))
    {
        if (menu_is_open)
            menu_is_open = BeginPopupEx(id, flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
        else
            g.NextWindowData.ClearFlags();          // we behave like Begin() and need to consume those values
        return menu_is_open;
    }
 
    // Tag menu as used. Next time BeginMenu() with same ID is called it will append to existing menu
    g.MenusIdSubmittedThisFrame.push_back(id);
 
    ImVec2 label_size = CalcTextSize(label, NULL, true);
    bool pressed;
    bool menuset_is_open = !(window->Flags & ImGuiWindowFlags_Popup) && (g.OpenPopupStack.Size > g.BeginPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].OpenParentId == window->IDStack.back());
    ImGuiWindow* backed_nav_window = g.NavWindow;
    if (menuset_is_open)
        g.NavWindow = window;  // Odd hack to allow hovering across menus of a same menu-set (otherwise we wouldn't be able to hover parent)
 
    // The reference position stored in popup_pos will be used by Begin() to find a suitable position for the child menu,
    // However the final position is going to be different! It is chosen by FindBestWindowPosForPopup().
    // e.g. Menus tend to overlap each other horizontally to amplify relative Z-ordering.
    ImVec2 popup_pos, pos = window->DC.CursorPos;
    if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)
    {
        // Menu inside an horizontal menu bar
        // Selectable extend their highlight by half ItemSpacing in each direction.
        // For ChildMenu, the popup position will be overwritten by the call to FindBestWindowPosForPopup() in Begin()
        popup_pos = ImVec2(pos.x - 1.0f - IM_FLOOR(style.ItemSpacing.x * 0.5f), pos.y - style.FramePadding.y + window->MenuBarHeight());
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * 0.5f);
        PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x * 2.0f, style.ItemSpacing.y));
        float w = label_size.x;
        pressed = Selectable(label, menu_is_open, ImGuiSelectableFlags_NoHoldingActiveID | ImGuiSelectableFlags_SelectOnClick | ImGuiSelectableFlags_DontClosePopups | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(w, 0.0f));
        PopStyleVar();
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * (-1.0f + 0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().
    }
    else
    {
        // Menu inside a menu
        // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.
        //  Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.
        popup_pos = ImVec2(pos.x, pos.y - style.WindowPadding.y);
        float min_w = window->DC.MenuColumns.DeclColumns(label_size.x, 0.0f, IM_FLOOR(g.FontSize * 1.20f)); // Feedback to next frame
        float extra_w = ImMax(0.0f, GetContentRegionAvail().x - min_w);
        pressed = Selectable(label, menu_is_open, ImGuiSelectableFlags_NoHoldingActiveID | ImGuiSelectableFlags_SelectOnClick | ImGuiSelectableFlags_DontClosePopups | ImGuiSelectableFlags_SpanAvailWidth | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(min_w, 0.0f));
        ImU32 text_col = GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled);
        RenderArrow(window->DrawList, pos + ImVec2(window->DC.MenuColumns.Pos[2] + extra_w + g.FontSize * 0.30f, 0.0f), text_col, ImGuiDir_Right);
    }
 
    const bool hovered = enabled && ItemHoverable(window->DC.LastItemRect, id);
    if (menuset_is_open)
        g.NavWindow = backed_nav_window;
 
    bool want_open = false;
    bool want_close = false;
    if (window->DC.LayoutType == ImGuiLayoutType_Vertical) // (window->Flags & (ImGuiWindowFlags_Popup|ImGuiWindowFlags_ChildMenu))
    {
        // Close menu when not hovering it anymore unless we are moving roughly in the direction of the menu
        // Implement http://bjk5.com/post/44698559168/breaking-down-amazons-mega-dropdown to avoid using timers, so menus feels more reactive.
        bool moving_toward_other_child_menu = false;
 
        ImGuiWindow* child_menu_window = (g.BeginPopupStack.Size < g.OpenPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].SourceWindow == window) ? g.OpenPopupStack[g.BeginPopupStack.Size].Window : NULL;
        if (g.HoveredWindow == window && child_menu_window != NULL && !(window->Flags & ImGuiWindowFlags_MenuBar))
        {
            // FIXME-DPI: Values should be derived from a master "scale" factor.
            ImRect next_window_rect = child_menu_window->Rect();
            ImVec2 ta = g.IO.MousePos - g.IO.MouseDelta;
            ImVec2 tb = (window->Pos.x < child_menu_window->Pos.x) ? next_window_rect.GetTL() : next_window_rect.GetTR();
            ImVec2 tc = (window->Pos.x < child_menu_window->Pos.x) ? next_window_rect.GetBL() : next_window_rect.GetBR();
            float extra = ImClamp(ImFabs(ta.x - tb.x) * 0.30f, 5.0f, 30.0f);    // add a bit of extra slack.
            ta.x += (window->Pos.x < child_menu_window->Pos.x) ? -0.5f : +0.5f; // to avoid numerical issues
            tb.y = ta.y + ImMax((tb.y - extra) - ta.y, -100.0f);                // triangle is maximum 200 high to limit the slope and the bias toward large sub-menus // FIXME: Multiply by fb_scale?
            tc.y = ta.y + ImMin((tc.y + extra) - ta.y, +100.0f);
            moving_toward_other_child_menu = ImTriangleContainsPoint(ta, tb, tc, g.IO.MousePos);
            //GetForegroundDrawList()->AddTriangleFilled(ta, tb, tc, moving_within_opened_triangle ? IM_COL32(0,128,0,128) : IM_COL32(128,0,0,128)); // [DEBUG]
        }
        if (menu_is_open && !hovered && g.HoveredWindow == window && g.HoveredIdPreviousFrame != 0 && g.HoveredIdPreviousFrame != id && !moving_toward_other_child_menu)
            want_close = true;
 
        if (!menu_is_open && hovered && pressed) // Click to open
            want_open = true;
        else if (!menu_is_open && hovered && !moving_toward_other_child_menu) // Hover to open
            want_open = true;
 
        if (g.NavActivateId == id)
        {
            want_close = menu_is_open;
            want_open = !menu_is_open;
        }
        if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Right) // Nav-Right to open
        {
            want_open = true;
            NavMoveRequestCancel();
        }
    }
    else
    {
        // Menu bar
        if (menu_is_open && pressed && menuset_is_open) // Click an open menu again to close it
        {
            want_close = true;
            want_open = menu_is_open = false;
        }
        else if (pressed || (hovered && menuset_is_open && !menu_is_open)) // First click to open, then hover to open others
        {
            want_open = true;
        }
        else if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Down) // Nav-Down to open
        {
            want_open = true;
            NavMoveRequestCancel();
        }
    }
 
    if (!enabled) // explicitly close if an open menu becomes disabled, facilitate users code a lot in pattern such as 'if (BeginMenu("options", has_object)) { ..use object.. }'
        want_close = true;
    if (want_close && IsPopupOpen(id, ImGuiPopupFlags_None))
        ClosePopupToLevel(g.BeginPopupStack.Size, true);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags | ImGuiItemStatusFlags_Openable | (menu_is_open ? ImGuiItemStatusFlags_Opened : 0));
 
    if (!menu_is_open && want_open && g.OpenPopupStack.Size > g.BeginPopupStack.Size)
    {
        // Don't recycle same menu level in the same frame, first close the other menu and yield for a frame.
        OpenPopup(label);
        return false;
    }
 
    menu_is_open |= want_open;
    if (want_open)
        OpenPopup(label);
 
    if (menu_is_open)
    {
        SetNextWindowPos(popup_pos, ImGuiCond_Always); // Note: this is super misleading! The value will serve as reference for FindBestWindowPosForPopup(), not actual pos.
        menu_is_open = BeginPopupEx(id, flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
    }
    else
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
    }
 
    return menu_is_open;
}

References ImVector< T >::back(), BeginPopupEx(), ImGuiContext::BeginPopupStack, CalcTextSize(), ImGuiNextWindowData::ClearFlags(), ClosePopupToLevel(), ImVector< T >::contains(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiMenuColumns::DeclColumns(), ImGuiWindow::DrawList, ImGuiWindow::Flags, ImGuiContext::FontSize, ImRect::GetBL(), ImRect::GetBR(), GetColorU32(), GetContentRegionAvail(), GetCurrentWindow(), ImGuiWindow::GetID(), ImRect::GetTL(), ImRect::GetTR(), GImGui, ImGuiContext::HoveredIdPreviousFrame, ImGuiContext::HoveredWindow, ImGuiWindow::IDStack, IM_FLOOR, ImClamp(), ImFabs, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiCond_Always, ImGuiDir_Down, ImGuiDir_Right, ImGuiLayoutType_Horizontal, ImGuiLayoutType_Vertical, ImGuiPopupFlags_None, ImGuiSelectableFlags_Disabled, ImGuiSelectableFlags_DontClosePopups, ImGuiSelectableFlags_NoHoldingActiveID, ImGuiSelectableFlags_SelectOnClick, ImGuiSelectableFlags_SpanAvailWidth, ImGuiStyleVar_ItemSpacing, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_MenuBar, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_NoNavFocus, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, ImGuiWindowFlags_Popup, ImMax(), ImMin(), ImTriangleContainsPoint(), ImGuiContext::IO, IsPopupOpen(), ItemHoverable(), ImGuiWindowTempData::LastItemRect, ImGuiWindowTempData::LastItemStatusFlags, ImGuiWindowTempData::LayoutType, ImGuiWindow::MenuBarHeight(), ImGuiWindowTempData::MenuColumns, ImGuiContext::MenusIdSubmittedThisFrame, ImGuiIO::MouseDelta, ImGuiIO::MousePos, ImGuiContext::NavActivateId, ImGuiContext::NavId, ImGuiContext::NavMoveDir, ImGuiContext::NavMoveRequest, NavMoveRequestCancel(), ImGuiContext::NavWindow, ImGuiContext::NextWindowData, OpenPopup(), ImGuiContext::OpenPopupStack, PopStyleVar(), ImGuiMenuColumns::Pos, ImGuiWindow::Pos, ImVector< T >::push_back(), PushStyleVar(), ImGuiWindow::Rect(), RenderArrow(), Selectable(), SetNextWindowPos(), ImVector< T >::Size, ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowExampleAppDocuments(), ShowExampleAppLayout(), ShowExampleAppMainMenuBar(), and ShowExampleMenuFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginMenuBar()

bool ImGui::BeginMenuBar ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
    if (!(window->Flags & ImGuiWindowFlags_MenuBar))
        return false;
 
    IM_ASSERT(!window->DC.MenuBarAppending);
    BeginGroup(); // Backup position on layer 0 // FIXME: Misleading to use a group for that backup/restore
    PushID("##menubar");
 
    // We don't clip with current window clipping rectangle as it is already set to the area below. However we clip with window full rect.
    // We remove 1 worth of rounding to Max.x to that text in long menus and small windows don't tend to display over the lower-right rounded area, which looks particularly glitchy.
    ImRect bar_rect = window->MenuBarRect();
    ImRect clip_rect(IM_ROUND(bar_rect.Min.x + window->WindowBorderSize), IM_ROUND(bar_rect.Min.y + window->WindowBorderSize), IM_ROUND(ImMax(bar_rect.Min.x, bar_rect.Max.x - ImMax(window->WindowRounding, window->WindowBorderSize))), IM_ROUND(bar_rect.Max.y));
    clip_rect.ClipWith(window->OuterRectClipped);
    PushClipRect(clip_rect.Min, clip_rect.Max, false);
 
    // We overwrite CursorMaxPos because BeginGroup sets it to CursorPos (essentially the .EmitItem hack in EndMenuBar() would need something analogous here, maybe a BeginGroupEx() with flags).
    window->DC.CursorPos = window->DC.CursorMaxPos = ImVec2(bar_rect.Min.x + window->DC.MenuBarOffset.x, bar_rect.Min.y + window->DC.MenuBarOffset.y);
    window->DC.LayoutType = ImGuiLayoutType_Horizontal;
    window->DC.NavLayerCurrent = ImGuiNavLayer_Menu;
    window->DC.MenuBarAppending = true;
    AlignTextToFramePadding();
    return true;
}

References AlignTextToFramePadding(), BeginGroup(), ImRect::ClipWith(), ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::Flags, GetCurrentWindow(), IM_ASSERT, IM_ROUND, ImGuiLayoutType_Horizontal, ImGuiNavLayer_Menu, ImGuiWindowFlags_MenuBar, ImMax(), ImGuiWindowTempData::LayoutType, ImRect::Max, ImGuiWindowTempData::MenuBarAppending, ImGuiWindowTempData::MenuBarOffset, ImGuiWindow::MenuBarRect(), ImRect::Min, ImGuiWindowTempData::NavLayerCurrent, ImGuiWindow::OuterRectClipped, PushClipRect(), PushID(), ImGuiWindow::SkipItems, ImGuiWindow::WindowBorderSize, ImGuiWindow::WindowRounding, ImVec2::x, and ImVec2::y.

Referenced by BeginMainMenuBar(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowExampleAppDocuments(), and ShowExampleAppLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginPopup()

bool ImGui::BeginPopup	(	const char *	str_id,
		ImGuiWindowFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    if (g.OpenPopupStack.Size <= g.BeginPopupStack.Size) // Early out for performance
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }
    flags |= ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings;
    return BeginPopupEx(g.CurrentWindow->GetID(str_id), flags);
}

References BeginPopupEx(), ImGuiContext::BeginPopupStack, ImGuiNextWindowData::ClearFlags(), ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), GImGui, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, ImGuiContext::NextWindowData, ImGuiContext::OpenPopupStack, and ImVector< T >::Size.

Referenced by ColorEdit4(), ColorEditOptionsPopup(), ColorPickerOptionsPopup(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginPopupContextItem()

bool ImGui::BeginPopupContextItem	(	const char *	str_id = `NULL`,
		ImGuiPopupFlags	popup_flags = `1`
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (window->SkipItems)
        return false;
    ImGuiID id = str_id ? window->GetID(str_id) : window->DC.LastItemId; // If user hasn't passed an ID, we can use the LastItemID. Using LastItemID as a Popup ID won't conflict!
    IM_ASSERT(id != 0);                                                  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a Text() item)
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
        OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

References BeginPopupEx(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiWindow::GetID(), GImGui, IM_ASSERT, ImGuiHoveredFlags_AllowWhenBlockedByPopup, ImGuiPopupFlags_MouseButtonMask_, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, IsItemHovered(), IsMouseReleased(), ImGuiWindowTempData::LastItemId, OpenPopupEx(), and ImGuiWindow::SkipItems.

Referenced by MyDocument::DisplayContextMenu(), ExampleAppConsole::Draw(), ShowDemoWindowPopups(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginPopupContextVoid()

bool ImGui::BeginPopupContextVoid	(	const char *	str_id = `NULL`,
		ImGuiPopupFlags	popup_flags = `1`
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (!str_id)
        str_id = "void_context";
    ImGuiID id = window->GetID(str_id);
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && !IsWindowHovered(ImGuiHoveredFlags_AnyWindow))
        if (GetTopMostPopupModal() == NULL)
            OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

References BeginPopupEx(), ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), GetTopMostPopupModal(), GImGui, ImGuiHoveredFlags_AnyWindow, ImGuiPopupFlags_MouseButtonMask_, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, IsMouseReleased(), IsWindowHovered(), and OpenPopupEx().

Here is the call graph for this function:

◆ BeginPopupContextWindow() [1/2]

static bool ImGui::BeginPopupContextWindow	(	const char *	str_id,
		ImGuiMouseButton	mb,
		bool	over_items
	)

inlinestatic

2806{ return BeginPopupContextWindow(str_id, mb | (over_items ? 0 : ImGuiPopupFlags_NoOpenOverItems)); }

ImGuiPopupFlags_NoOpenOverItems

@ ImGuiPopupFlags_NoOpenOverItems

Definition imgui.h:1022

ImGui::BeginPopupContextWindow

IMGUI_API bool BeginPopupContextWindow(const char *str_id=NULL, ImGuiPopupFlags popup_flags=1)

Definition imgui.cpp:8419

References BeginPopupContextWindow(), and ImGuiPopupFlags_NoOpenOverItems.

Here is the call graph for this function:

◆ BeginPopupContextWindow() [2/2]

bool ImGui::BeginPopupContextWindow	(	const char *	str_id = `NULL`,
		ImGuiPopupFlags	popup_flags = `1`
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (!str_id)
        str_id = "window_context";
    ImGuiID id = window->GetID(str_id);
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
        if (!(popup_flags & ImGuiPopupFlags_NoOpenOverItems) || !IsAnyItemHovered())
            OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

References BeginPopupEx(), ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), GImGui, ImGuiHoveredFlags_AllowWhenBlockedByPopup, ImGuiPopupFlags_MouseButtonMask_, ImGuiPopupFlags_NoOpenOverItems, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, IsAnyItemHovered(), IsMouseReleased(), IsWindowHovered(), and OpenPopupEx().

Referenced by BeginPopupContextWindow(), ExampleAppConsole::Draw(), and ShowExampleAppSimpleOverlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginPopupEx()

bool ImGui::BeginPopupEx	(	ImGuiID	id,
		ImGuiWindowFlags	extra_flags
	)

{
    ImGuiContext& g = *GImGui;
    if (!IsPopupOpen(id, ImGuiPopupFlags_None))
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }
 
    char name[20];
    if (flags & ImGuiWindowFlags_ChildMenu)
        ImFormatString(name, IM_ARRAYSIZE(name), "##Menu_%02d", g.BeginPopupStack.Size); // Recycle windows based on depth
    else
        ImFormatString(name, IM_ARRAYSIZE(name), "##Popup_%08x", id); // Not recycling, so we can close/open during the same frame
 
    flags |= ImGuiWindowFlags_Popup;
    bool is_open = Begin(name, NULL, flags);
    if (!is_open) // NB: Begin can return false when the popup is completely clipped (e.g. zero size display)
        EndPopup();
 
    return is_open;
}

References Begin(), ImGuiContext::BeginPopupStack, ImGuiNextWindowData::ClearFlags(), EndPopup(), GImGui, IM_ARRAYSIZE, ImFormatString(), ImGuiPopupFlags_None, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_Popup, IsPopupOpen(), ImGuiContext::NextWindowData, and ImVector< T >::Size.

Referenced by BeginMenu(), BeginPopup(), BeginPopupContextItem(), BeginPopupContextVoid(), BeginPopupContextWindow(), and TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginPopupModal()

bool ImGui::BeginPopupModal	(	const char *	name,
		bool *	p_open = `NULL`,
		ImGuiWindowFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(name);
    if (!IsPopupOpen(id, ImGuiPopupFlags_None))
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }
 
    // Center modal windows by default for increased visibility
    // (this won't really last as settings will kick in, and is mostly for backward compatibility. user may do the same themselves)
    // FIXME: Should test for (PosCond & window->SetWindowPosAllowFlags) with the upcoming window.
    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)
    {
        const ImGuiViewport* viewport = GetMainViewport();
        SetNextWindowPos(viewport->GetCenter(), ImGuiCond_FirstUseEver, ImVec2(0.5f, 0.5f));
    }
 
    flags |= ImGuiWindowFlags_Popup | ImGuiWindowFlags_Modal | ImGuiWindowFlags_NoCollapse;
    const bool is_open = Begin(name, p_open, flags);
    if (!is_open || (p_open && !*p_open)) // NB: is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
    {
        EndPopup();
        if (is_open)
            ClosePopupToLevel(g.BeginPopupStack.Size, true);
        return false;
    }
    return is_open;
}

References Begin(), ImGuiContext::BeginPopupStack, ImGuiNextWindowData::ClearFlags(), ClosePopupToLevel(), ImGuiContext::CurrentWindow, EndPopup(), ImGuiNextWindowData::Flags, ImGuiViewport::GetCenter(), ImGuiWindow::GetID(), GetMainViewport(), GImGui, ImGuiCond_FirstUseEver, ImGuiNextWindowDataFlags_HasPos, ImGuiPopupFlags_None, ImGuiWindowFlags_Modal, ImGuiWindowFlags_NoCollapse, ImGuiWindowFlags_Popup, IsPopupOpen(), ImGuiContext::NextWindowData, SetNextWindowPos(), and ImVector< T >::Size.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_style_add_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_button(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), ShowDemoWindowPopups(), and ShowExampleAppDocuments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTabBar()

bool ImGui::BeginTabBar	(	const char *	str_id,
		ImGuiTabBarFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    ImGuiID id = window->GetID(str_id);
    ImGuiTabBar* tab_bar = g.TabBars.GetOrAddByKey(id);
    ImRect tab_bar_bb = ImRect(window->DC.CursorPos.x, window->DC.CursorPos.y, window->WorkRect.Max.x, window->DC.CursorPos.y + g.FontSize + g.Style.FramePadding.y * 2);
    tab_bar->ID = id;
    return BeginTabBarEx(tab_bar, tab_bar_bb, flags | ImGuiTabBarFlags_IsFocused);
}

References BeginTabBarEx(), ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImGuiWindow::GetID(), ImPool< T >::GetOrAddByKey(), GImGui, ImGuiTabBar::ID, ImGuiTabBarFlags_IsFocused, ImRect::Max, ImGuiWindow::SkipItems, ImGuiContext::Style, ImGuiContext::TabBars, ImGuiWindow::WorkRect, ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppLayout(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTabBarEx()

bool ImGui::BeginTabBarEx	(	ImGuiTabBar *	tab_bar,
		const ImRect &	bb,
		ImGuiTabBarFlags	flags
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    if ((flags & ImGuiTabBarFlags_DockNode) == 0)
        PushOverrideID(tab_bar->ID);
 
    // Add to stack
    g.CurrentTabBarStack.push_back(GetTabBarRefFromTabBar(tab_bar));
    g.CurrentTabBar = tab_bar;
 
    // Append with multiple BeginTabBar()/EndTabBar() pairs.
    tab_bar->BackupCursorPos = window->DC.CursorPos;
    if (tab_bar->CurrFrameVisible == g.FrameCount)
    {
        window->DC.CursorPos = ImVec2(tab_bar->BarRect.Min.x, tab_bar->BarRect.Max.y + tab_bar->ItemSpacingY);
        tab_bar->BeginCount++;
        return true;
    }
 
    // Ensure correct ordering when toggling ImGuiTabBarFlags_Reorderable flag, or when a new tab was added while being not reorderable
    if ((flags & ImGuiTabBarFlags_Reorderable) != (tab_bar->Flags & ImGuiTabBarFlags_Reorderable) || (tab_bar->TabsAddedNew && !(flags & ImGuiTabBarFlags_Reorderable)))
        if (tab_bar->Tabs.Size > 1)
            ImQsort(tab_bar->Tabs.Data, tab_bar->Tabs.Size, sizeof(ImGuiTabItem), TabItemComparerByBeginOrder);
    tab_bar->TabsAddedNew = false;
 
    // Flags
    if ((flags & ImGuiTabBarFlags_FittingPolicyMask_) == 0)
        flags |= ImGuiTabBarFlags_FittingPolicyDefault_;
 
    tab_bar->Flags = flags;
    tab_bar->BarRect = tab_bar_bb;
    tab_bar->WantLayout = true; // Layout will be done on the first call to ItemTab()
    tab_bar->PrevFrameVisible = tab_bar->CurrFrameVisible;
    tab_bar->CurrFrameVisible = g.FrameCount;
    tab_bar->PrevTabsContentsHeight = tab_bar->CurrTabsContentsHeight;
    tab_bar->CurrTabsContentsHeight = 0.0f;
    tab_bar->ItemSpacingY = g.Style.ItemSpacing.y;
    tab_bar->FramePadding = g.Style.FramePadding;
    tab_bar->TabsActiveCount = 0;
    tab_bar->BeginCount = 1;
 
    // Set cursor pos in a way which only be used in the off-chance the user erroneously submits item before BeginTabItem(): items will overlap
    window->DC.CursorPos = ImVec2(tab_bar->BarRect.Min.x, tab_bar->BarRect.Max.y + tab_bar->ItemSpacingY);
 
    // Draw separator
    const ImU32 col = GetColorU32((flags & ImGuiTabBarFlags_IsFocused) ? ImGuiCol_TabActive : ImGuiCol_TabUnfocusedActive);
    const float y = tab_bar->BarRect.Max.y - 1.0f;
    {
        const float separator_min_x = tab_bar->BarRect.Min.x - IM_FLOOR(window->WindowPadding.x * 0.5f);
        const float separator_max_x = tab_bar->BarRect.Max.x + IM_FLOOR(window->WindowPadding.x * 0.5f);
        window->DrawList->AddLine(ImVec2(separator_min_x, y), ImVec2(separator_max_x, y), col, 1.0f);
    }
    return true;
}

References ImDrawList::AddLine(), ImGuiTabBar::BackupCursorPos, ImGuiTabBar::BarRect, ImGuiTabBar::BeginCount, col(), ImGuiContext::CurrentTabBar, ImGuiContext::CurrentTabBarStack, ImGuiContext::CurrentWindow, ImGuiTabBar::CurrFrameVisible, ImGuiTabBar::CurrTabsContentsHeight, ImGuiWindowTempData::CursorPos, ImVector< T >::Data, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiTabBar::Flags, ImGuiContext::FrameCount, ImGuiStyle::FramePadding, ImGuiTabBar::FramePadding, GetColorU32(), GetTabBarRefFromTabBar(), GImGui, ImGuiTabBar::ID, IM_FLOOR, ImGuiCol_TabActive, ImGuiCol_TabUnfocusedActive, ImGuiTabBarFlags_DockNode, ImGuiTabBarFlags_FittingPolicyDefault_, ImGuiTabBarFlags_FittingPolicyMask_, ImGuiTabBarFlags_IsFocused, ImGuiTabBarFlags_Reorderable, ImQsort, ImGuiStyle::ItemSpacing, ImGuiTabBar::ItemSpacingY, ImRect::Max, ImRect::Min, ImGuiTabBar::PrevFrameVisible, ImGuiTabBar::PrevTabsContentsHeight, ImVector< T >::push_back(), PushOverrideID(), ImVector< T >::Size, ImGuiWindow::SkipItems, ImGuiContext::Style, TabItemComparerByBeginOrder(), ImGuiTabBar::Tabs, ImGuiTabBar::TabsActiveCount, ImGuiTabBar::TabsAddedNew, ImGuiTabBar::WantLayout, ImGuiWindow::WindowPadding, ImVec2::x, and ImVec2::y.

Referenced by BeginTabBar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTabItem()

bool ImGui::BeginTabItem	(	const char *	label,
		bool *	p_open = `NULL`,
		ImGuiTabItemFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    ImGuiTabBar* tab_bar = g.CurrentTabBar;
    if (tab_bar == NULL)
    {
        IM_ASSERT_USER_ERROR(tab_bar, "Needs to be called between BeginTabBar() and EndTabBar()!");
        return false;
    }
    IM_ASSERT(!(flags & ImGuiTabItemFlags_Button)); // BeginTabItem() Can't be used with button flags, use TabItemButton() instead!
 
    bool ret = TabItemEx(tab_bar, label, p_open, flags);
    if (ret && !(flags & ImGuiTabItemFlags_NoPushId))
    {
        ImGuiTabItem* tab = &tab_bar->Tabs[tab_bar->LastTabItemIdx];
        PushOverrideID(tab->ID); // We already hashed 'label' so push into the ID stack directly instead of doing another hash through PushID(label)
    }
    return ret;
}

References ImGuiContext::CurrentTabBar, ImGuiContext::CurrentWindow, GImGui, ImGuiTabItem::ID, IM_ASSERT, IM_ASSERT_USER_ERROR, ImGuiTabItemFlags_Button, ImGuiTabItemFlags_NoPushId, ImGuiTabBar::LastTabItemIdx, PushOverrideID(), ImGuiWindow::SkipItems, TabItemEx(), and ImGuiTabBar::Tabs.

Referenced by ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppLayout(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTable()

bool ImGui::BeginTable	(	const char *	str_id,
		int	column,
		ImGuiTableFlags	flags = `0`,
		const ImVec2 &	outer_size = `ImVec2(0.0f, 0.0f)`,
		float	inner_width = `0.0f`
	)

{
    ImGuiID id = GetID(str_id);
    return BeginTableEx(str_id, id, columns_count, flags, outer_size, inner_width);
}

References BeginTableEx(), and GetID().

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppPropertyEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTableEx()

bool ImGui::BeginTableEx	(	const char *	name,
		ImGuiID	id,
		int	columns_count,
		ImGuiTableFlags	flags = `0`,
		const ImVec2 &	outer_size = `ImVec2(0, 0)`,
		float	inner_width = `0.0f`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* outer_window = GetCurrentWindow();
    if (outer_window->SkipItems) // Consistent with other tables + beneficial side effect that assert on miscalling EndTable() will be more visible.
        return false;
 
    // Sanity checks
    IM_ASSERT(columns_count > 0 && columns_count <= IMGUI_TABLE_MAX_COLUMNS && "Only 1..64 columns allowed!");
    if (flags & ImGuiTableFlags_ScrollX)
        IM_ASSERT(inner_width >= 0.0f);
 
    // If an outer size is specified ahead we will be able to early out when not visible. Exact clipping rules may evolve.
    const bool use_child_window = (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) != 0;
    const ImVec2 avail_size = GetContentRegionAvail();
    ImVec2 actual_outer_size = CalcItemSize(outer_size, ImMax(avail_size.x, 1.0f), use_child_window ? ImMax(avail_size.y, 1.0f) : 0.0f);
    ImRect outer_rect(outer_window->DC.CursorPos, outer_window->DC.CursorPos + actual_outer_size);
    if (use_child_window && IsClippedEx(outer_rect, 0, false))
    {
        ItemSize(outer_rect);
        return false;
    }
 
    // Acquire storage for the table
    ImGuiTable* table = g.Tables.GetOrAddByKey(id);
    const int instance_no = (table->LastFrameActive != g.FrameCount) ? 0 : table->InstanceCurrent + 1;
    const ImGuiID instance_id = id + instance_no;
    const ImGuiTableFlags table_last_flags = table->Flags;
    if (instance_no > 0)
        IM_ASSERT(table->ColumnsCount == columns_count && "BeginTable(): Cannot change columns count mid-frame while preserving same ID");
 
    // Acquire temporary buffers
    const int table_idx = g.Tables.GetIndex(table);
    g.CurrentTableStackIdx++;
    if (g.CurrentTableStackIdx + 1 > g.TablesTempDataStack.Size)
        g.TablesTempDataStack.resize(g.CurrentTableStackIdx + 1, ImGuiTableTempData());
    ImGuiTableTempData* temp_data = table->TempData = &g.TablesTempDataStack[g.CurrentTableStackIdx];
    temp_data->TableIndex = table_idx;
    table->DrawSplitter = &table->TempData->DrawSplitter;
    table->DrawSplitter->Clear();
 
    // Fix flags
    table->IsDefaultSizingPolicy = (flags & ImGuiTableFlags_SizingMask_) == 0;
    flags = TableFixFlags(flags, outer_window);
 
    // Initialize
    table->ID = id;
    table->Flags = flags;
    table->InstanceCurrent = (ImS16)instance_no;
    table->LastFrameActive = g.FrameCount;
    table->OuterWindow = table->InnerWindow = outer_window;
    table->ColumnsCount = columns_count;
    table->IsLayoutLocked = false;
    table->InnerWidth = inner_width;
    temp_data->UserOuterSize = outer_size;
 
    // When not using a child window, WorkRect.Max will grow as we append contents.
    if (use_child_window)
    {
        // Ensure no vertical scrollbar appears if we only want horizontal one, to make flag consistent
        // (we have no other way to disable vertical scrollbar of a window while keeping the horizontal one showing)
        ImVec2 override_content_size(FLT_MAX, FLT_MAX);
        if ((flags & ImGuiTableFlags_ScrollX) && !(flags & ImGuiTableFlags_ScrollY))
            override_content_size.y = FLT_MIN;
 
        // Ensure specified width (when not specified, Stretched columns will act as if the width == OuterWidth and
        // never lead to any scrolling). We don't handle inner_width < 0.0f, we could potentially use it to right-align
        // based on the right side of the child window work rect, which would require knowing ahead if we are going to
        // have decoration taking horizontal spaces (typically a vertical scrollbar).
        if ((flags & ImGuiTableFlags_ScrollX) && inner_width > 0.0f)
            override_content_size.x = inner_width;
 
        if (override_content_size.x != FLT_MAX || override_content_size.y != FLT_MAX)
            SetNextWindowContentSize(ImVec2(override_content_size.x != FLT_MAX ? override_content_size.x : 0.0f, override_content_size.y != FLT_MAX ? override_content_size.y : 0.0f));
 
        // Reset scroll if we are reactivating it
        if ((table_last_flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) == 0)
            SetNextWindowScroll(ImVec2(0.0f, 0.0f));
 
        // Create scrolling region (without border and zero window padding)
        ImGuiWindowFlags child_flags = (flags & ImGuiTableFlags_ScrollX) ? ImGuiWindowFlags_HorizontalScrollbar : ImGuiWindowFlags_None;
        BeginChildEx(name, instance_id, outer_rect.GetSize(), false, child_flags);
        table->InnerWindow = g.CurrentWindow;
        table->WorkRect = table->InnerWindow->WorkRect;
        table->OuterRect = table->InnerWindow->Rect();
        table->InnerRect = table->InnerWindow->InnerRect;
        IM_ASSERT(table->InnerWindow->WindowPadding.x == 0.0f && table->InnerWindow->WindowPadding.y == 0.0f && table->InnerWindow->WindowBorderSize == 0.0f);
    }
    else
    {
        // For non-scrolling tables, WorkRect == OuterRect == InnerRect.
        // But at this point we do NOT have a correct value for .Max.y (unless a height has been explicitly passed in). It will only be updated in EndTable().
        table->WorkRect = table->OuterRect = table->InnerRect = outer_rect;
    }
 
    // Push a standardized ID for both child-using and not-child-using tables
    PushOverrideID(instance_id);
 
    // Backup a copy of host window members we will modify
    ImGuiWindow* inner_window = table->InnerWindow;
    table->HostIndentX = inner_window->DC.Indent.x;
    table->HostClipRect = inner_window->ClipRect;
    table->HostSkipItems = inner_window->SkipItems;
    temp_data->HostBackupWorkRect = inner_window->WorkRect;
    temp_data->HostBackupParentWorkRect = inner_window->ParentWorkRect;
    temp_data->HostBackupColumnsOffset = outer_window->DC.ColumnsOffset;
    temp_data->HostBackupPrevLineSize = inner_window->DC.PrevLineSize;
    temp_data->HostBackupCurrLineSize = inner_window->DC.CurrLineSize;
    temp_data->HostBackupCursorMaxPos = inner_window->DC.CursorMaxPos;
    temp_data->HostBackupItemWidth = outer_window->DC.ItemWidth;
    temp_data->HostBackupItemWidthStackSize = outer_window->DC.ItemWidthStack.Size;
    inner_window->DC.PrevLineSize = inner_window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
 
    // Padding and Spacing
    // - None               ........Content..... Pad .....Content........
    // - PadOuter           | Pad ..Content..... Pad .....Content.. Pad |
    // - PadInner           ........Content.. Pad | Pad ..Content........
    // - PadOuter+PadInner  | Pad ..Content.. Pad | Pad ..Content.. Pad |
    const bool pad_outer_x = (flags & ImGuiTableFlags_NoPadOuterX) ? false : (flags & ImGuiTableFlags_PadOuterX) ? true : (flags & ImGuiTableFlags_BordersOuterV) != 0;
    const bool pad_inner_x = (flags & ImGuiTableFlags_NoPadInnerX) ? false : true;
    const float inner_spacing_for_border = (flags & ImGuiTableFlags_BordersInnerV) ? TABLE_BORDER_SIZE : 0.0f;
    const float inner_spacing_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) == 0) ? g.Style.CellPadding.x : 0.0f;
    const float inner_padding_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) != 0) ? g.Style.CellPadding.x : 0.0f;
    table->CellSpacingX1 = inner_spacing_explicit + inner_spacing_for_border;
    table->CellSpacingX2 = inner_spacing_explicit;
    table->CellPaddingX = inner_padding_explicit;
    table->CellPaddingY = g.Style.CellPadding.y;
 
    const float outer_padding_for_border = (flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
    const float outer_padding_explicit = pad_outer_x ? g.Style.CellPadding.x : 0.0f;
    table->OuterPaddingX = (outer_padding_for_border + outer_padding_explicit) - table->CellPaddingX;
 
    table->CurrentColumn = -1;
    table->CurrentRow = -1;
    table->RowBgColorCounter = 0;
    table->LastRowFlags = ImGuiTableRowFlags_None;
    table->InnerClipRect = (inner_window == outer_window) ? table->WorkRect : inner_window->ClipRect;
    table->InnerClipRect.ClipWith(table->WorkRect);     // We need this to honor inner_width
    table->InnerClipRect.ClipWithFull(table->HostClipRect);
    table->InnerClipRect.Max.y = (flags & ImGuiTableFlags_NoHostExtendY) ? ImMin(table->InnerClipRect.Max.y, inner_window->WorkRect.Max.y) : inner_window->ClipRect.Max.y;
 
    table->RowPosY1 = table->RowPosY2 = table->WorkRect.Min.y; // This is needed somehow
    table->RowTextBaseline = 0.0f; // This will be cleared again by TableBeginRow()
    table->FreezeRowsRequest = table->FreezeRowsCount = 0; // This will be setup by TableSetupScrollFreeze(), if any
    table->FreezeColumnsRequest = table->FreezeColumnsCount = 0;
    table->IsUnfrozenRows = true;
    table->DeclColumnsCount = 0;
 
    // Using opaque colors facilitate overlapping elements of the grid
    table->BorderColorStrong = GetColorU32(ImGuiCol_TableBorderStrong);
    table->BorderColorLight = GetColorU32(ImGuiCol_TableBorderLight);
 
    // Make table current
    g.CurrentTable = table;
    outer_window->DC.CurrentTableIdx = table_idx;
    if (inner_window != outer_window) // So EndChild() within the inner window can restore the table properly.
        inner_window->DC.CurrentTableIdx = table_idx;
 
    if ((table_last_flags & ImGuiTableFlags_Reorderable) && (flags & ImGuiTableFlags_Reorderable) == 0)
        table->IsResetDisplayOrderRequest = true;
 
    // Mark as used
    if (table_idx >= g.TablesLastTimeActive.Size)
        g.TablesLastTimeActive.resize(table_idx + 1, -1.0f);
    g.TablesLastTimeActive[table_idx] = (float)g.Time;
    temp_data->LastTimeActive = (float)g.Time;
    table->MemoryCompacted = false;
 
    // Setup memory buffer (clear data if columns count changed)
    ImGuiTableColumn* old_columns_to_preserve = NULL;
    void* old_columns_raw_data = NULL;
    const int old_columns_count = table->Columns.size();
    if (old_columns_count != 0 && old_columns_count != columns_count)
    {
        // Attempt to preserve width on column count change (#4046)
        old_columns_to_preserve = table->Columns.Data;
        old_columns_raw_data = table->RawData;
        table->RawData = NULL;
    }
    if (table->RawData == NULL)
    {
        TableBeginInitMemory(table, columns_count);
        table->IsInitializing = table->IsSettingsRequestLoad = true;
    }
    if (table->IsResetAllRequest)
        TableResetSettings(table);
    if (table->IsInitializing)
    {
        // Initialize
        table->SettingsOffset = -1;
        table->IsSortSpecsDirty = true;
        table->InstanceInteracted = -1;
        table->ContextPopupColumn = -1;
        table->ReorderColumn = table->ResizedColumn = table->LastResizedColumn = -1;
        table->AutoFitSingleColumn = -1;
        table->HoveredColumnBody = table->HoveredColumnBorder = -1;
        for (int n = 0; n < columns_count; n++)
        {
            ImGuiTableColumn* column = &table->Columns[n];
            if (old_columns_to_preserve && n < old_columns_count)
            {
                // FIXME: We don't attempt to preserve column order in this path.
                *column = old_columns_to_preserve[n];
            }
            else
            {
                float width_auto = column->WidthAuto;
                *column = ImGuiTableColumn();
                column->WidthAuto = width_auto;
                column->IsPreserveWidthAuto = true; // Preserve WidthAuto when reinitializing a live table: not technically necessary but remove a visible flicker
                column->IsEnabled = column->IsEnabledNextFrame = true;
            }
            column->DisplayOrder = table->DisplayOrderToIndex[n] = (ImGuiTableColumnIdx)n;
        }
    }
    if (old_columns_raw_data)
        IM_FREE(old_columns_raw_data);
 
    // Load settings
    if (table->IsSettingsRequestLoad)
        TableLoadSettings(table);
 
    // Handle DPI/font resize
    // This is designed to facilitate DPI changes with the assumption that e.g. style.CellPadding has been scaled as well.
    // It will also react to changing fonts with mixed results. It doesn't need to be perfect but merely provide a decent transition.
    // FIXME-DPI: Provide consistent standards for reference size. Perhaps using g.CurrentDpiScale would be more self explanatory.
    // This is will lead us to non-rounded WidthRequest in columns, which should work but is a poorly tested path.
    const float new_ref_scale_unit = g.FontSize; // g.Font->GetCharAdvance('A') ?
    if (table->RefScale != 0.0f && table->RefScale != new_ref_scale_unit)
    {
        const float scale_factor = new_ref_scale_unit / table->RefScale;
        //IMGUI_DEBUG_LOG("[table] %08X RefScaleUnit %.3f -> %.3f, scaling width by %.3f\n", table->ID, table->RefScaleUnit, new_ref_scale_unit, scale_factor);
        for (int n = 0; n < columns_count; n++)
            table->Columns[n].WidthRequest = table->Columns[n].WidthRequest * scale_factor;
    }
    table->RefScale = new_ref_scale_unit;
 
    // Disable output until user calls TableNextRow() or TableNextColumn() leading to the TableUpdateLayout() call..
    // This is not strictly necessary but will reduce cases were "out of table" output will be misleading to the user.
    // Because we cannot safely assert in EndTable() when no rows have been created, this seems like our best option.
    inner_window->SkipItems = true;
 
    // Clear names
    // At this point the ->NameOffset field of each column will be invalid until TableUpdateLayout() or the first call to TableSetupColumn()
    if (table->ColumnsNames.Buf.Size > 0)
        table->ColumnsNames.Buf.resize(0);
 
    // Apply queued resizing/reordering/hiding requests
    TableBeginApplyRequests(table);
 
    return true;
}

Referenced by BeginTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTooltip()

void ImGui::BeginTooltip ( )

{
    BeginTooltipEx(ImGuiWindowFlags_None, ImGuiTooltipFlags_None);
}

References BeginTooltipEx(), ImGuiTooltipFlags_None, and ImGuiWindowFlags_None.

Referenced by BeginDragDropSource(), EditTableSizingFlags(), HelpMarker(), MetricsHelpMarker(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::HintNotification::render_documentation_button(), Slic3r::GUI::NotificationManager::ExportFinishedNotification::render_eject_button(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay(), Slic3r::GUI::NotificationManager::HintNotification::render_preferences_button(), Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button(), ShowDemoWindowWidgets(), ShowFont(), ShowStyleEditor(), Slic3r::GUI::ImGuiWrapper::tooltip(), and UpdateDebugToolItemPicker().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginTooltipEx()

void ImGui::BeginTooltipEx	(	ImGuiWindowFlags	extra_flags,
		ImGuiTooltipFlags	tooltip_flags
	)

{
    ImGuiContext& g = *GImGui;
 
    if (g.DragDropWithinSource || g.DragDropWithinTarget)
    {
        // The default tooltip position is a little offset to give space to see the context menu (it's also clamped within the current viewport/monitor)
        // In the context of a dragging tooltip we try to reduce that offset and we enforce following the cursor.
        // Whatever we do we want to call SetNextWindowPos() to enforce a tooltip position and disable clipping the tooltip without our display area, like regular tooltip do.
        //ImVec2 tooltip_pos = g.IO.MousePos - g.ActiveIdClickOffset - g.Style.WindowPadding;
        ImVec2 tooltip_pos = g.IO.MousePos + ImVec2(16 * g.Style.MouseCursorScale, 8 * g.Style.MouseCursorScale);
        SetNextWindowPos(tooltip_pos);
        SetNextWindowBgAlpha(g.Style.Colors[ImGuiCol_PopupBg].w * 0.60f);
        //PushStyleVar(ImGuiStyleVar_Alpha, g.Style.Alpha * 0.60f); // This would be nice but e.g ColorButton with checkboard has issue with transparent colors :(
        tooltip_flags |= ImGuiTooltipFlags_OverridePreviousTooltip;
    }
 
    char window_name[16];
    ImFormatString(window_name, IM_ARRAYSIZE(window_name), "##Tooltip_%02d", g.TooltipOverrideCount);
    if (tooltip_flags & ImGuiTooltipFlags_OverridePreviousTooltip)
        if (ImGuiWindow* window = FindWindowByName(window_name))
            if (window->Active)
            {
                // Hide previous tooltip from being displayed. We can't easily "reset" the content of a window so we create a new one.
                window->Hidden = true;
                window->HiddenFramesCanSkipItems = 1; // FIXME: This may not be necessary?
                ImFormatString(window_name, IM_ARRAYSIZE(window_name), "##Tooltip_%02d", ++g.TooltipOverrideCount);
            }
    ImGuiWindowFlags flags = ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_AlwaysAutoResize;
    Begin(window_name, NULL, flags | extra_flags);
}

References Begin(), ImGuiStyle::Colors, ImGuiContext::DragDropWithinSource, ImGuiContext::DragDropWithinTarget, FindWindowByName(), GImGui, IM_ARRAYSIZE, ImFormatString(), ImGuiCol_PopupBg, ImGuiTooltipFlags_OverridePreviousTooltip, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoInputs, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_NoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, ImGuiWindowFlags_Tooltip, ImGuiContext::IO, ImGuiStyle::MouseCursorScale, ImGuiIO::MousePos, SetNextWindowBgAlpha(), SetNextWindowPos(), ImGuiContext::Style, ImGuiContext::TooltipOverrideCount, and ImVec4::w.

Referenced by BeginTooltip(), ColorTooltip(), and SetTooltipV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginViewportSideBar()

bool ImGui::BeginViewportSideBar	(	const char *	name,
		ImGuiViewport *	viewport,
		ImGuiDir	dir,
		float	size,
		ImGuiWindowFlags	window_flags
	)

{
    IM_ASSERT(dir != ImGuiDir_None);
 
    ImGuiWindow* bar_window = FindWindowByName(name);
    if (bar_window == NULL || bar_window->BeginCount == 0)
    {
        // Calculate and set window size/position
        ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)(viewport_p ? viewport_p : GetMainViewport());
        ImRect avail_rect = viewport->GetBuildWorkRect();
        ImGuiAxis axis = (dir == ImGuiDir_Up || dir == ImGuiDir_Down) ? ImGuiAxis_Y : ImGuiAxis_X;
        ImVec2 pos = avail_rect.Min;
        if (dir == ImGuiDir_Right || dir == ImGuiDir_Down)
            pos[axis] = avail_rect.Max[axis] - axis_size;
        ImVec2 size = avail_rect.GetSize();
        size[axis] = axis_size;
        SetNextWindowPos(pos);
        SetNextWindowSize(size);
 
        // Report our size into work area (for next frame) using actual window size
        if (dir == ImGuiDir_Up || dir == ImGuiDir_Left)
            viewport->BuildWorkOffsetMin[axis] += axis_size;
        else if (dir == ImGuiDir_Down || dir == ImGuiDir_Right)
            viewport->BuildWorkOffsetMax[axis] -= axis_size;
    }
 
    window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
    PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
    PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0)); // Lift normal size constraint
    bool is_open = Begin(name, NULL, window_flags);
    PopStyleVar(2);
 
    return is_open;
}

References Begin(), ImGuiWindow::BeginCount, ImGuiViewportP::BuildWorkOffsetMax, ImGuiViewportP::BuildWorkOffsetMin, FindWindowByName(), ImGuiViewportP::GetBuildWorkRect(), GetMainViewport(), ImRect::GetSize(), IM_ASSERT, ImGuiAxis_X, ImGuiAxis_Y, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_None, ImGuiDir_Right, ImGuiDir_Up, ImGuiStyleVar_WindowMinSize, ImGuiStyleVar_WindowRounding, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_NoResize, ImGuiWindowFlags_NoTitleBar, ImRect::Max, ImRect::Min, PopStyleVar(), PushStyleVar(), SetNextWindowPos(), and SetNextWindowSize().

Referenced by BeginMainMenuBar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BringWindowToDisplayBack()

void ImGui::BringWindowToDisplayBack ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
    if (g.Windows[0] == window)
        return;
    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i] == window)
        {
            memmove(&g.Windows[1], &g.Windows[0], (size_t)i * sizeof(ImGuiWindow*));
            g.Windows[0] = window;
            break;
        }
}

References GImGui, ImVector< T >::Size, and ImGuiContext::Windows.

◆ BringWindowToDisplayFront()

void ImGui::BringWindowToDisplayFront ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* current_front_window = g.Windows.back();
    if (current_front_window == window || current_front_window->RootWindow == window) // Cheap early out (could be better)
        return;
    for (int i = g.Windows.Size - 2; i >= 0; i--) // We can ignore the top-most window
        if (g.Windows[i] == window)
        {
            memmove(&g.Windows[i], &g.Windows[i + 1], (size_t)(g.Windows.Size - i - 1) * sizeof(ImGuiWindow*));
            g.Windows[g.Windows.Size - 1] = window;
            break;
        }
}

References ImVector< T >::back(), GImGui, ImGuiWindow::RootWindow, ImVector< T >::Size, and ImGuiContext::Windows.

Referenced by FocusWindow(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), and Slic3r::GUI::GLGizmoMeasure::render_dimensioning().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BringWindowToFocusFront()

void ImGui::BringWindowToFocusFront ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(window == window->RootWindow);
 
    const int cur_order = window->FocusOrder;
    IM_ASSERT(g.WindowsFocusOrder[cur_order] == window);
    if (g.WindowsFocusOrder.back() == window)
        return;
 
    const int new_order = g.WindowsFocusOrder.Size - 1;
    for (int n = cur_order; n < new_order; n++)
    {
        g.WindowsFocusOrder[n] = g.WindowsFocusOrder[n + 1];
        g.WindowsFocusOrder[n]->FocusOrder--;
        IM_ASSERT(g.WindowsFocusOrder[n]->FocusOrder == n);
    }
    g.WindowsFocusOrder[new_order] = window;
    window->FocusOrder = (short)new_order;
}

References ImVector< T >::back(), ImGuiWindow::FocusOrder, GImGui, IM_ASSERT, ImGuiWindow::RootWindow, ImVector< T >::Size, and ImGuiContext::WindowsFocusOrder.

Referenced by FocusWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bullet()

void ImGui::Bullet ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const float line_height = ImMax(ImMin(window->DC.CurrLineSize.y, g.FontSize + g.Style.FramePadding.y * 2), g.FontSize);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(g.FontSize, line_height));
    ItemSize(bb);
    if (!ItemAdd(bb, 0))
    {
        SameLine(0, style.FramePadding.x * 2);
        return;
    }
 
    // Render and stay on same line
    ImU32 text_col = GetColorU32(ImGuiCol_Text);
    RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, line_height * 0.5f), text_col);
    SameLine(0, style.FramePadding.x * 2.0f);
}

References ImGuiWindowTempData::CurrLineSize, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiContext::FontSize, ImGuiStyle::FramePadding, GetColorU32(), GetCurrentWindow(), GImGui, ImGuiCol_Text, ImMax(), ImMin(), ItemAdd(), ItemSize(), ImRect::Min, RenderBullet(), SameLine(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, and ImVec2::y.

Referenced by DebugNodeTable(), ShowDemoWindowMisc(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BulletText()

void ImGui::BulletText	(	const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    BulletTextV(fmt, args);
    va_end(args);
}

References BulletTextV().

Referenced by DebugNodeColumns(), DebugNodeDrawList(), DebugNodeStorage(), DebugNodeTable(), DebugNodeTableSettings(), DebugNodeViewport(), DebugNodeWindow(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowWidgets(), ShowFont(), ShowMetricsWindow(), and ShowUserGuide().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BulletTextV()

void ImGui::BulletTextV	(	const char *	fmt,
		va_list	args
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
 
    const char* text_begin = g.TempBuffer;
    const char* text_end = text_begin + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    const ImVec2 label_size = CalcTextSize(text_begin, text_end, false);
    const ImVec2 total_size = ImVec2(g.FontSize + (label_size.x > 0.0f ? (label_size.x + style.FramePadding.x * 2) : 0.0f), label_size.y);  // Empty text doesn't add padding
    ImVec2 pos = window->DC.CursorPos;
    pos.y += window->DC.CurrLineTextBaseOffset;
    ItemSize(total_size, 0.0f);
    const ImRect bb(pos, pos + total_size);
    if (!ItemAdd(bb, 0))
        return;
 
    // Render
    ImU32 text_col = GetColorU32(ImGuiCol_Text);
    RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, g.FontSize * 0.5f), text_col);
    RenderText(bb.Min + ImVec2(g.FontSize + style.FramePadding.x * 2, 0.0f), text_begin, text_end, false);
}

References CalcTextSize(), ImGuiWindowTempData::CurrLineTextBaseOffset, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiContext::FontSize, GetColorU32(), GetCurrentWindow(), GImGui, IM_ARRAYSIZE, ImFormatStringV(), ImGuiCol_Text, ItemAdd(), ItemSize(), ImRect::Min, RenderBullet(), RenderText(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImGuiContext::TempBuffer, ImVec2::x, and ImVec2::y.

Referenced by BulletText().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Button()

bool ImGui::Button	(	const char *	label,
		const ImVec2 &	size = `ImVec2(0, 0)`
	)

{
    return ButtonEx(label, size_arg, ImGuiButtonFlags_None);
}

References ButtonEx(), and ImGuiButtonFlags_None.

Referenced by Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::button(), ColorEditOptionsPopup(), MyDocument::DisplayContents(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_font_list_line(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), Slic3r::GUI::GLGizmoEmboss::draw_window(), LogButtons(), Slic3r::GUI::GLGizmoCut3D::render_reset_button(), ShowAboutWindow(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppConstrainedResize(), ShowExampleAppDocuments(), ShowExampleAppFullscreen(), ShowExampleAppLayout(), ShowExampleAppLongText(), ShowMetricsWindow(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ButtonBehavior()

bool ImGui::ButtonBehavior	(	const ImRect &	bb,
		ImGuiID	id,
		bool *	out_hovered,
		bool *	out_held,
		ImGuiButtonFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
 
    if (flags & ImGuiButtonFlags_Disabled)
    {
        if (out_hovered) *out_hovered = false;
        if (out_held) *out_held = false;
        if (g.ActiveId == id) ClearActiveID();
        return false;
    }
 
    // Default only reacts to left mouse button
    if ((flags & ImGuiButtonFlags_MouseButtonMask_) == 0)
        flags |= ImGuiButtonFlags_MouseButtonDefault_;
 
    // Default behavior requires click + release inside bounding box
    if ((flags & ImGuiButtonFlags_PressedOnMask_) == 0)
        flags |= ImGuiButtonFlags_PressedOnDefault_;
 
    ImGuiWindow* backup_hovered_window = g.HoveredWindow;
    const bool flatten_hovered_children = (flags & ImGuiButtonFlags_FlattenChildren) && g.HoveredWindow && g.HoveredWindow->RootWindow == window;
    if (flatten_hovered_children)
        g.HoveredWindow = window;
 
#ifdef IMGUI_ENABLE_TEST_ENGINE
    if (id != 0 && window->DC.LastItemId != id)
        IMGUI_TEST_ENGINE_ITEM_ADD(bb, id);
#endif
 
    bool pressed = false;
    bool hovered = ItemHoverable(bb, id);
 
    // Drag source doesn't report as hovered
    if (hovered && g.DragDropActive && g.DragDropPayload.SourceId == id && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoDisableHover))
        hovered = false;
 
    // Special mode for Drag and Drop where holding button pressed for a long time while dragging another item triggers the button
    if (g.DragDropActive && (flags & ImGuiButtonFlags_PressedOnDragDropHold) && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoHoldToOpenOthers))
        if (IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))
        {
            hovered = true;
            SetHoveredID(id);
            if (CalcTypematicRepeatAmount(g.HoveredIdTimer + 0.0001f - g.IO.DeltaTime, g.HoveredIdTimer + 0.0001f, DRAGDROP_HOLD_TO_OPEN_TIMER, 0.00f))
            {
                pressed = true;
                g.DragDropHoldJustPressedId = id;
                FocusWindow(window);
            }
        }
 
    if (flatten_hovered_children)
        g.HoveredWindow = backup_hovered_window;
 
    // AllowOverlap mode (rarely used) requires previous frame HoveredId to be null or to match. This allows using patterns where a later submitted widget overlaps a previous one.
    if (hovered && (flags & ImGuiButtonFlags_AllowItemOverlap) && (g.HoveredIdPreviousFrame != id && g.HoveredIdPreviousFrame != 0))
        hovered = false;
 
    // Mouse handling
    if (hovered)
    {
        if (!(flags & ImGuiButtonFlags_NoKeyModifiers) || (!g.IO.KeyCtrl && !g.IO.KeyShift && !g.IO.KeyAlt))
        {
            // Poll buttons
            int mouse_button_clicked = -1;
            int mouse_button_released = -1;
            if ((flags & ImGuiButtonFlags_MouseButtonLeft) && g.IO.MouseClicked[0])         { mouse_button_clicked = 0; }
            else if ((flags & ImGuiButtonFlags_MouseButtonRight) && g.IO.MouseClicked[1])   { mouse_button_clicked = 1; }
            else if ((flags & ImGuiButtonFlags_MouseButtonMiddle) && g.IO.MouseClicked[2])  { mouse_button_clicked = 2; }
            if ((flags & ImGuiButtonFlags_MouseButtonLeft) && g.IO.MouseReleased[0])        { mouse_button_released = 0; }
            else if ((flags & ImGuiButtonFlags_MouseButtonRight) && g.IO.MouseReleased[1])  { mouse_button_released = 1; }
            else if ((flags & ImGuiButtonFlags_MouseButtonMiddle) && g.IO.MouseReleased[2]) { mouse_button_released = 2; }
 
            if (mouse_button_clicked != -1 && g.ActiveId != id)
            {
                if (flags & (ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere))
                {
                    SetActiveID(id, window);
                    g.ActiveIdMouseButton = mouse_button_clicked;
                    if (!(flags & ImGuiButtonFlags_NoNavFocus))
                        SetFocusID(id, window);
                    FocusWindow(window);
                }
                if ((flags & ImGuiButtonFlags_PressedOnClick) || ((flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseDoubleClicked[mouse_button_clicked]))
                {
                    pressed = true;
                    if (flags & ImGuiButtonFlags_NoHoldingActiveId)
                        ClearActiveID();
                    else
                        SetActiveID(id, window); // Hold on ID
                    g.ActiveIdMouseButton = mouse_button_clicked;
                    FocusWindow(window);
                }
            }
            if ((flags & ImGuiButtonFlags_PressedOnRelease) && mouse_button_released != -1)
            {
                // Repeat mode trumps on release behavior
                const bool has_repeated_at_least_once = (flags & ImGuiButtonFlags_Repeat) && g.IO.MouseDownDurationPrev[mouse_button_released] >= g.IO.KeyRepeatDelay;
                if (!has_repeated_at_least_once)
                    pressed = true;
                ClearActiveID();
            }
 
            // 'Repeat' mode acts when held regardless of _PressedOn flags (see table above).
            // Relies on repeat logic of IsMouseClicked() but we may as well do it ourselves if we end up exposing finer RepeatDelay/RepeatRate settings.
            if (g.ActiveId == id && (flags & ImGuiButtonFlags_Repeat))
                if (g.IO.MouseDownDuration[g.ActiveIdMouseButton] > 0.0f && IsMouseClicked(g.ActiveIdMouseButton, true))
                    pressed = true;
        }
 
        if (pressed)
            g.NavDisableHighlight = true;
    }
 
    // Gamepad/Keyboard navigation
    // We report navigated item as hovered but we don't set g.HoveredId to not interfere with mouse.
    if (g.NavId == id && !g.NavDisableHighlight && g.NavDisableMouseHover && (g.ActiveId == 0 || g.ActiveId == id || g.ActiveId == window->MoveId))
        if (!(flags & ImGuiButtonFlags_NoHoveredOnFocus))
            hovered = true;
    if (g.NavActivateDownId == id)
    {
        bool nav_activated_by_code = (g.NavActivateId == id);
        bool nav_activated_by_inputs = IsNavInputTest(ImGuiNavInput_Activate, (flags & ImGuiButtonFlags_Repeat) ? ImGuiInputReadMode_Repeat : ImGuiInputReadMode_Pressed);
        if (nav_activated_by_code || nav_activated_by_inputs)
            pressed = true;
        if (nav_activated_by_code || nav_activated_by_inputs || g.ActiveId == id)
        {
            // Set active id so it can be queried by user via IsItemActive(), equivalent of holding the mouse button.
            g.NavActivateId = id; // This is so SetActiveId assign a Nav source
            SetActiveID(id, window);
            if ((nav_activated_by_code || nav_activated_by_inputs) && !(flags & ImGuiButtonFlags_NoNavFocus))
                SetFocusID(id, window);
        }
    }
 
    // Process while held
    bool held = false;
    if (g.ActiveId == id)
    {
        if (g.ActiveIdSource == ImGuiInputSource_Mouse)
        {
            if (g.ActiveIdIsJustActivated)
                g.ActiveIdClickOffset = g.IO.MousePos - bb.Min;
 
            const int mouse_button = g.ActiveIdMouseButton;
            IM_ASSERT(mouse_button >= 0 && mouse_button < ImGuiMouseButton_COUNT);
            if (g.IO.MouseDown[mouse_button])
            {
                held = true;
            }
            else
            {
                bool release_in = hovered && (flags & ImGuiButtonFlags_PressedOnClickRelease) != 0;
                bool release_anywhere = (flags & ImGuiButtonFlags_PressedOnClickReleaseAnywhere) != 0;
                if ((release_in || release_anywhere) && !g.DragDropActive)
                {
                    // Report as pressed when releasing the mouse (this is the most common path)
                    bool is_double_click_release = (flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseDownWasDoubleClick[mouse_button];
                    bool is_repeating_already = (flags & ImGuiButtonFlags_Repeat) && g.IO.MouseDownDurationPrev[mouse_button] >= g.IO.KeyRepeatDelay; // Repeat mode trumps <on release>
                    if (!is_double_click_release && !is_repeating_already)
                        pressed = true;
                }
                ClearActiveID();
            }
            if (!(flags & ImGuiButtonFlags_NoNavFocus))
                g.NavDisableHighlight = true;
        }
        else if (g.ActiveIdSource == ImGuiInputSource_Nav)
        {
            // When activated using Nav, we hold on the ActiveID until activation button is released
            if (g.NavActivateDownId != id)
                ClearActiveID();
        }
        if (pressed)
            g.ActiveIdHasBeenPressedBefore = true;
    }
 
    if (out_hovered) *out_hovered = hovered;
    if (out_held) *out_held = held;
 
    return pressed;
}

Referenced by ArrowButtonEx(), BeginCombo(), ButtonEx(), Checkbox(), CloseButton(), CollapseButton(), ColorButton(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), EndColumns(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), InvisibleButton(), RadioButton(), ScrollbarEx(), Slic3r::GUI::selectable(), Selectable(), SplitterBehavior(), TabItemEx(), TableHeader(), TableUpdateBorders(), TreeNodeBehavior(), and UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ButtonEx()

bool ImGui::ButtonEx	(	const char *	label,
		const ImVec2 &	size_arg = `ImVec2(0, 0)`,
		ImGuiButtonFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    ImVec2 pos = window->DC.CursorPos;
    if ((flags & ImGuiButtonFlags_AlignTextBaseLine) && style.FramePadding.y < window->DC.CurrLineTextBaseOffset) // Try to vertically align buttons that are smaller/have no padding so that text baseline matches (bit hacky, since it shouldn't be a flag)
        pos.y += window->DC.CurrLineTextBaseOffset - style.FramePadding.y;
    ImVec2 size = CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);
 
    const ImRect bb(pos, pos + size);
    ItemSize(size, style.FramePadding.y);
    if (!ItemAdd(bb, id))
        return false;
 
    if (g.CurrentItemFlags & ImGuiItemFlags_ButtonRepeat)
        flags |= ImGuiButtonFlags_Repeat;
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
 
    // Render
    const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
    RenderNavHighlight(bb, id);
    RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
 
    if (g.LogEnabled)
        LogSetNextTextDecoration("[", "]");
    RenderTextClipped(bb.Min + style.FramePadding, bb.Max - style.FramePadding, label, NULL, &label_size, style.ButtonTextAlign, &bb);
 
    // Automatically close popups
    //if (pressed && !(flags & ImGuiButtonFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))
    //    CloseCurrentPopup();
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    return pressed;
}

References ButtonBehavior(), CalcItemSize(), CalcTextSize(), col(), ImGuiContext::CurrentItemFlags, ImGuiWindowTempData::CurrLineTextBaseOffset, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetColorU32(), GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiButtonFlags_AlignTextBaseLine, ImGuiButtonFlags_Repeat, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiItemFlags_ButtonRepeat, ItemAdd(), ItemSize(), ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::LogEnabled, LogSetNextTextDecoration(), ImRect::Max, ImRect::Min, RenderFrame(), RenderNavHighlight(), RenderTextClipped(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by Button(), InputScalar(), and SmallButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcItemSize()

ImVec2 ImGui::CalcItemSize	(	ImVec2	size,
		float	default_w,
		float	default_h
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
 
    ImVec2 region_max;
    if (size.x < 0.0f || size.y < 0.0f)
        region_max = GetContentRegionMaxAbs();
 
    if (size.x == 0.0f)
        size.x = default_w;
    else if (size.x < 0.0f)
        size.x = ImMax(4.0f, region_max.x - window->DC.CursorPos.x + size.x);
 
    if (size.y == 0.0f)
        size.y = default_h;
    else if (size.y < 0.0f)
        size.y = ImMax(4.0f, region_max.y - window->DC.CursorPos.y + size.y);
 
    return size;
}

References ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetContentRegionMaxAbs(), GImGui, ImMax(), ImVec2::x, and ImVec2::y.

Referenced by BeginListBox(), BeginTableEx(), ButtonEx(), Slic3r::GUI::ImGuiWrapper::calc_button_size(), InputTextEx(), InvisibleButton(), ProgressBar(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcItemWidth()

float ImGui::CalcItemWidth ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float w;
    if (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasWidth)
        w = g.NextItemData.Width;
    else
        w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        float region_max_x = GetContentRegionMaxAbs().x;
        w = ImMax(1.0f, region_max_x - window->DC.CursorPos.x + w);
    }
    w = IM_FLOOR(w);
    return w;
}

References ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiNextItemData::Flags, GetContentRegionMaxAbs(), GImGui, IM_FLOOR, ImGuiNextItemDataFlags_HasWidth, ImMax(), ImGuiWindowTempData::ItemWidth, ImGuiContext::NextItemData, ImGuiNextItemData::Width, and ImVec2::x.

Referenced by BeginCombo(), BeginListBox(), ColorEdit4(), ColorPicker4(), DragFloatRange2(), DragIntRange2(), DragScalar(), DragScalarN(), InputScalar(), InputScalarN(), InputTextEx(), LabelTextV(), PlotEx(), ProgressBar(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowExampleAppCustomRendering(), SliderScalar(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcListClipping()

void ImGui::CalcListClipping	(	int	items_count,
		float	items_height,
		int *	out_items_display_start,
		int *	out_items_display_end
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (g.LogEnabled)
    {
        // If logging is active, do not perform any clipping
        *out_items_display_start = 0;
        *out_items_display_end = items_count;
        return;
    }
    if (GetSkipItemForListClipping())
    {
        *out_items_display_start = *out_items_display_end = 0;
        return;
    }
 
    // We create the union of the ClipRect and the NavScoringRect which at worst should be 1 page away from ClipRect
    ImRect unclipped_rect = window->ClipRect;
    if (g.NavMoveRequest)
        unclipped_rect.Add(g.NavScoringRect);
    if (g.NavJustMovedToId && window->NavLastIds[0] == g.NavJustMovedToId)
        unclipped_rect.Add(ImRect(window->Pos + window->NavRectRel[0].Min, window->Pos + window->NavRectRel[0].Max));
 
    const ImVec2 pos = window->DC.CursorPos;
    int start = (int)((unclipped_rect.Min.y - pos.y) / items_height);
    int end = (int)((unclipped_rect.Max.y - pos.y) / items_height);
 
    // When performing a navigation request, ensure we have one item extra in the direction we are moving to
    if (g.NavMoveRequest && g.NavMoveClipDir == ImGuiDir_Up)
        start--;
    if (g.NavMoveRequest && g.NavMoveClipDir == ImGuiDir_Down)
        end++;
 
    start = ImClamp(start, 0, items_count);
    end = ImClamp(end + 1, start, items_count);
    *out_items_display_start = start;
    *out_items_display_end = end;
}

References ImRect::Add(), ImGuiWindow::ClipRect, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetSkipItemForListClipping(), GImGui, ImClamp(), ImGuiDir_Down, ImGuiDir_Up, ImGuiContext::LogEnabled, ImRect::Max, ImRect::Min, ImGuiContext::NavJustMovedToId, ImGuiWindow::NavLastIds, ImGuiContext::NavMoveClipDir, ImGuiContext::NavMoveRequest, ImGuiWindow::NavRectRel, ImGuiContext::NavScoringRect, ImGuiWindow::Pos, and ImVec2::y.

Referenced by ImGuiListClipper::Step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcTextSize()

ImVec2 ImGui::CalcTextSize	(	const char *	text,
		const char *	text_end = `NULL`,
		bool	hide_text_after_double_hash = `false`,
		float	wrap_width = `-1.0f`
	)

{
    ImGuiContext& g = *GImGui;
 
    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindRenderedTextEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;
 
    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    if (text == text_display_end)
        return ImVec2(0.0f, font_size);
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);
 
    // Round
    // FIXME: This has been here since Dec 2015 (7b0bf230) but down the line we want this out.
    // FIXME: Investigate using ceilf or e.g.
    // - https://git.musl-libc.org/cgit/musl/tree/src/math/ceilf.c
    // - https://embarkstudios.github.io/rust-gpu/api/src/libm/math/ceilf.rs.html
    text_size.x = IM_FLOOR(text_size.x + 0.99999f);
 
    return text_size;
}

References ImFont::CalcTextSizeA(), FindRenderedTextEnd(), ImGuiContext::Font, ImGuiContext::FontSize, GImGui, IM_FLOOR, and ImVec2::x.

Here is the call graph for this function:

◆ CalcTypematicRepeatAmount()

int ImGui::CalcTypematicRepeatAmount	(	float	t0,
		float	t1,
		float	repeat_delay,
		float	repeat_rate
	)

{
    if (t1 == 0.0f)
        return 1;
    if (t0 >= t1)
        return 0;
    if (repeat_rate <= 0.0f)
        return (t0 < repeat_delay) && (t1 >= repeat_delay);
    const int count_t0 = (t0 < repeat_delay) ? -1 : (int)((t0 - repeat_delay) / repeat_rate);
    const int count_t1 = (t1 < repeat_delay) ? -1 : (int)((t1 - repeat_delay) / repeat_rate);
    const int count = count_t1 - count_t0;
    return count;
}

Referenced by ButtonBehavior(), GetKeyPressedAmount(), GetNavInputAmount(), and IsMouseClicked().

Here is the caller graph for this function:

◆ CalcWindowNextAutoFitSize()

ImVec2 ImGui::CalcWindowNextAutoFitSize ( ImGuiWindow * window )

{
    ImVec2 size_contents_current;
    ImVec2 size_contents_ideal;
    CalcWindowContentSizes(window, &size_contents_current, &size_contents_ideal);
    ImVec2 size_auto_fit = CalcWindowAutoFitSize(window, size_contents_ideal);
    ImVec2 size_final = CalcWindowSizeAfterConstraint(window, size_auto_fit);
    return size_final;
}

References CalcWindowAutoFitSize(), CalcWindowContentSizes(), and CalcWindowSizeAfterConstraint().

Referenced by BeginCombo(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), and Slic3r::GUI::GCodeViewer::render_legend().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcWrapWidthForPos()

float ImGui::CalcWrapWidthForPos	(	const ImVec2 &	pos,
		float	wrap_pos_x
	)

{
    if (wrap_pos_x < 0.0f)
        return 0.0f;
 
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (wrap_pos_x == 0.0f)
    {
        // We could decide to setup a default wrapping max point for auto-resizing windows,
        // or have auto-wrap (with unspecified wrapping pos) behave as a ContentSize extending function?
        //if (window->Hidden && (window->Flags & ImGuiWindowFlags_AlwaysAutoResize))
        //    wrap_pos_x = ImMax(window->WorkRect.Min.x + g.FontSize * 10.0f, window->WorkRect.Max.x);
        //else
        wrap_pos_x = window->WorkRect.Max.x;
    }
    else if (wrap_pos_x > 0.0f)
    {
        wrap_pos_x += window->Pos.x - window->Scroll.x; // wrap_pos_x is provided is window local space
    }
 
    return ImMax(wrap_pos_x - pos.x, 1.0f);
}

References ImGuiContext::CurrentWindow, GImGui, ImMax(), ImRect::Max, ImGuiWindow::Pos, ImGuiWindow::Scroll, ImGuiWindow::WorkRect, and ImVec2::x.

Referenced by TextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallContextHooks()

void ImGui::CallContextHooks	(	ImGuiContext *	context,
		ImGuiContextHookType	type
	)

{
    ImGuiContext& g = *ctx;
    for (int n = 0; n < g.Hooks.Size; n++)
        if (g.Hooks[n].Type == hook_type)
            g.Hooks[n].Callback(&g, &g.Hooks[n]);
}

References ImGuiContext::Hooks, and ImVector< T >::Size.

Referenced by EndFrame(), NewFrame(), Render(), and Shutdown().

Here is the caller graph for this function:

◆ CaptureKeyboardFromApp()

void ImGui::CaptureKeyboardFromApp ( bool want_capture_keyboard_value = true )

{
    GImGui->WantCaptureKeyboardNextFrame = capture ? 1 : 0;
}

References GImGui, and ImGuiContext::WantCaptureKeyboardNextFrame.

Referenced by ShowDemoWindowMisc().

Here is the caller graph for this function:

◆ CaptureMouseFromApp()

void ImGui::CaptureMouseFromApp ( bool want_capture_mouse_value = true )

{
    GImGui->WantCaptureMouseNextFrame = capture ? 1 : 0;
}

References GImGui, and ImGuiContext::WantCaptureMouseNextFrame.

◆ Checkbox()

bool ImGui::Checkbox	(	const char *	label,
		bool *	v
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    const float square_sz = GetFrameHeight();
    const ImVec2 pos = window->DC.CursorPos;
    const ImRect total_bb(pos, pos + ImVec2(square_sz + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), label_size.y + style.FramePadding.y * 2.0f));
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, id))
    {
        IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));
        return false;
    }
 
    bool hovered, held;
    bool pressed = ButtonBehavior(total_bb, id, &hovered, &held);
    if (pressed)
    {
        *v = !(*v);
        MarkItemEdited(id);
    }
 
    const ImRect check_bb(pos, pos + ImVec2(square_sz, square_sz));
    RenderNavHighlight(total_bb, id);
    RenderFrame(check_bb.Min, check_bb.Max, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), true, style.FrameRounding);
    ImU32 check_col = GetColorU32(ImGuiCol_CheckMark);
    bool mixed_value = (g.CurrentItemFlags & ImGuiItemFlags_MixedValue) != 0;
    if (mixed_value)
    {
        // Undocumented tristate/mixed/indeterminate checkbox (#2644)
        // This may seem awkwardly designed because the aim is to make ImGuiItemFlags_MixedValue supported by all widgets (not just checkbox)
        ImVec2 pad(ImMax(1.0f, IM_FLOOR(square_sz / 3.6f)), ImMax(1.0f, IM_FLOOR(square_sz / 3.6f)));
        window->DrawList->AddRectFilled(check_bb.Min + pad, check_bb.Max - pad, check_col, style.FrameRounding);
    }
    else if (*v)
    {
        const float pad = ImMax(1.0f, IM_FLOOR(square_sz / 6.0f));
        RenderCheckMark(window->DrawList, check_bb.Min + ImVec2(pad, pad), check_col, square_sz - pad * 2.0f);
    }
 
    ImVec2 label_pos = ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y);
    if (g.LogEnabled)
        LogRenderedText(&label_pos, mixed_value ? "[~]" : *v ? "[x]" : "[ ]");
    if (label_size.x > 0.0f)
        RenderText(label_pos, label);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));
    return pressed;
}

References ImDrawList::AddRectFilled(), ButtonBehavior(), CalcTextSize(), ImGuiContext::CurrentItemFlags, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, GetColorU32(), GetCurrentWindow(), GetFrameHeight(), ImGuiWindow::GetID(), GImGui, IM_FLOOR, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiCol_CheckMark, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiItemFlags_MixedValue, ImMax(), ItemAdd(), ItemSize(), ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::LogEnabled, LogRenderedText(), MarkItemEdited(), ImRect::Max, ImRect::Min, RenderCheckMark(), RenderFrame(), RenderNavHighlight(), RenderText(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::ImGuiWrapper::checkbox(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), Slic3r::GUI::GLGizmoEmboss::draw_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::rev_checkbox(), ShowAboutWindow(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppConstrainedResize(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppFullscreen(), ShowExampleMenuFile(), ShowMetricsWindow(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckboxFlags() [1/4]

bool ImGui::CheckboxFlags	(	const char *	label,
		ImS64 *	flags,
		ImS64	flags_value
	)

{
    return CheckboxFlagsT(label, flags, flags_value);
}

References CheckboxFlagsT().

Here is the call graph for this function:

◆ CheckboxFlags() [2/4]

bool ImGui::CheckboxFlags	(	const char *	label,
		ImU64 *	flags,
		ImU64	flags_value
	)

{
    return CheckboxFlagsT(label, flags, flags_value);
}

References CheckboxFlagsT().

Here is the call graph for this function:

◆ CheckboxFlags() [3/4]

bool ImGui::CheckboxFlags	(	const char *	label,
		int *	flags,
		int	flags_value
	)

{
    return CheckboxFlagsT(label, flags, flags_value);
}

References CheckboxFlagsT().

Referenced by ColorPickerOptionsPopup(), EditTableColumnsFlags(), ShowDemoWindow(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppFullscreen(), and ShowTableColumnsStatusFlags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckboxFlags() [4/4]

bool ImGui::CheckboxFlags	(	const char *	label,
		unsigned int *	flags,
		unsigned int	flags_value
	)

{
    return CheckboxFlagsT(label, flags, flags_value);
}

References CheckboxFlagsT().

Here is the call graph for this function:

◆ CheckboxFlagsT()

template<typename T >

IMGUI_API bool ImGui::CheckboxFlagsT	(	const char *	label,
		T *	flags,
		T	flags_value
	)

Referenced by CheckboxFlags(), CheckboxFlags(), CheckboxFlags(), and CheckboxFlags().

Here is the caller graph for this function:

◆ ClearActiveID()

void ImGui::ClearActiveID ( )

{
    SetActiveID(0, NULL); // g.ActiveId = 0;
}

References SetActiveID().

Referenced by ButtonBehavior(), DragBehavior(), FocusWindow(), InputTextEx(), ItemFocusable(), Slic3r::GUI::ImGuiWrapper::left_inputs(), NavUpdate(), NavUpdateMoveResult(), NavUpdateWindowing(), NewFrame(), Slic3r::GUI::ImGuiWrapper::slider_float(), TableUpdateBorders(), TempInputText(), UpdateMouseMovingWindowNewFrame(), and UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearDragDrop()

void ImGui::ClearDragDrop ( )

{
    ImGuiContext& g = *GImGui;
    g.DragDropActive = false;
    g.DragDropPayload.Clear();
    g.DragDropAcceptFlags = ImGuiDragDropFlags_None;
    g.DragDropAcceptIdCurr = g.DragDropAcceptIdPrev = 0;
    g.DragDropAcceptIdCurrRectSurface = FLT_MAX;
    g.DragDropAcceptFrameCount = -1;
 
    g.DragDropPayloadBufHeap.clear();
    memset(&g.DragDropPayloadBufLocal, 0, sizeof(g.DragDropPayloadBufLocal));
}

References ImVector< T >::clear(), ImGuiPayload::Clear(), ImGuiContext::DragDropAcceptFlags, ImGuiContext::DragDropAcceptFrameCount, ImGuiContext::DragDropAcceptIdCurr, ImGuiContext::DragDropAcceptIdCurrRectSurface, ImGuiContext::DragDropAcceptIdPrev, ImGuiContext::DragDropActive, ImGuiContext::DragDropPayload, ImGuiContext::DragDropPayloadBufHeap, ImGuiContext::DragDropPayloadBufLocal, GImGui, and ImGuiDragDropFlags_None.

Referenced by BeginDragDropSource(), EndDragDropSource(), and EndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearIniSettings()

void ImGui::ClearIniSettings ( )

{
    ImGuiContext& g = *GImGui;
    g.SettingsIniData.clear();
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].ClearAllFn)
            g.SettingsHandlers[handler_n].ClearAllFn(&g, &g.SettingsHandlers[handler_n]);
}

References ImGuiTextBuffer::clear(), GImGui, ImGuiContext::SettingsHandlers, ImGuiContext::SettingsIniData, and ImVector< T >::Size.

Referenced by ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CloseButton()

bool ImGui::CloseButton	(	ImGuiID	id,
		const ImVec2 &	pos
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    // Tweak 1: Shrink hit-testing area if button covers an abnormally large proportion of the visible region. That's in order to facilitate moving the window away. (#3825)
    // This may better be applied as a general hit-rect reduction mechanism for all widgets to ensure the area to move window is always accessible?
    const ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize) + g.Style.FramePadding * 2.0f);
    ImRect bb_interact = bb;
    const float area_to_visible_ratio = window->OuterRectClipped.GetArea() / bb.GetArea();
    if (area_to_visible_ratio < 1.5f)
        bb_interact.Expand(ImFloor(bb_interact.GetSize() * -0.25f));
 
    // Tweak 2: We intentionally allow interaction when clipped so that a mechanical Alt,Right,Activate sequence can always close a window.
    // (this isn't the regular behavior of buttons, but it doesn't affect the user much because navigation tends to keep items visible).
    bool is_clipped = !ItemAdd(bb_interact, id);
 
    bool hovered, held;
    bool pressed = ButtonBehavior(bb_interact, id, &hovered, &held);
    if (is_clipped)
        return pressed;
 
    // Render
    // FIXME: Clarify this mess
    ImU32 col = GetColorU32(held ? ImGuiCol_ButtonActive : ImGuiCol_ButtonHovered);
    ImVec2 center = bb.GetCenter();
    if (hovered)
        window->DrawList->AddCircleFilled(center, ImMax(2.0f, g.FontSize * 0.5f + 1.0f), col, 12);
 
    float cross_extent = g.FontSize * 0.5f * 0.7071f - 1.0f;
    ImU32 cross_col = GetColorU32(ImGuiCol_Text);
    center -= ImVec2(0.5f, 0.5f);
    window->DrawList->AddLine(center + ImVec2(+cross_extent, +cross_extent), center + ImVec2(-cross_extent, -cross_extent), cross_col, 1.0f);
    window->DrawList->AddLine(center + ImVec2(+cross_extent, -cross_extent), center + ImVec2(-cross_extent, +cross_extent), cross_col, 1.0f);
 
    return pressed;
}

References ImDrawList::AddCircleFilled(), ImDrawList::AddLine(), ButtonBehavior(), col(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImRect::Expand(), ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImRect::GetArea(), ImRect::GetCenter(), GetColorU32(), ImRect::GetSize(), GImGui, ImFloor(), ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_Text, ImMax(), ItemAdd(), ImGuiWindow::OuterRectClipped, and ImGuiContext::Style.

Referenced by CollapsingHeader(), RenderWindowTitleBarContents(), and TabItemLabelAndCloseButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CloseCurrentPopup()

void ImGui::CloseCurrentPopup ( )

{
    ImGuiContext& g = *GImGui;
    int popup_idx = g.BeginPopupStack.Size - 1;
    if (popup_idx < 0 || popup_idx >= g.OpenPopupStack.Size || g.BeginPopupStack[popup_idx].PopupId != g.OpenPopupStack[popup_idx].PopupId)
        return;
 
    // Closing a menu closes its top-most parent popup (unless a modal)
    while (popup_idx > 0)
    {
        ImGuiWindow* popup_window = g.OpenPopupStack[popup_idx].Window;
        ImGuiWindow* parent_popup_window = g.OpenPopupStack[popup_idx - 1].Window;
        bool close_parent = false;
        if (popup_window && (popup_window->Flags & ImGuiWindowFlags_ChildMenu))
            if (parent_popup_window == NULL || !(parent_popup_window->Flags & ImGuiWindowFlags_Modal))
                close_parent = true;
        if (!close_parent)
            break;
        popup_idx--;
    }
    IMGUI_DEBUG_LOG_POPUP("CloseCurrentPopup %d -> %d\n", g.BeginPopupStack.Size - 1, popup_idx);
    ClosePopupToLevel(popup_idx, true);
 
    // A common pattern is to close a popup when selecting a menu item/selectable that will open another window.
    // To improve this usage pattern, we avoid nav highlight for a single frame in the parent window.
    // Similarly, we could avoid mouse hover highlight in this window but it is less visually problematic.
    if (ImGuiWindow* window = g.NavWindow)
        window->DC.NavHideHighlightOneFrame = true;
}

References ImGuiContext::BeginPopupStack, ClosePopupToLevel(), ImGuiWindow::Flags, GImGui, IMGUI_DEBUG_LOG_POPUP, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_Modal, ImGuiContext::NavWindow, ImGuiContext::OpenPopupStack, and ImVector< T >::Size.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::selectable(), Selectable(), ShowDemoWindowPopups(), ShowDemoWindowTables(), and ShowExampleAppDocuments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClosePopupsOverWindow()

void ImGui::ClosePopupsOverWindow	(	ImGuiWindow *	ref_window,
		bool	restore_focus_to_window_under_popup
	)

{
    ImGuiContext& g = *GImGui;
    if (g.OpenPopupStack.Size == 0)
        return;
 
    // Don't close our own child popup windows.
    int popup_count_to_keep = 0;
    if (ref_window)
    {
        // Find the highest popup which is a descendant of the reference window (generally reference window = NavWindow)
        for (; popup_count_to_keep < g.OpenPopupStack.Size; popup_count_to_keep++)
        {
            ImGuiPopupData& popup = g.OpenPopupStack[popup_count_to_keep];
            if (!popup.Window)
                continue;
            IM_ASSERT((popup.Window->Flags & ImGuiWindowFlags_Popup) != 0);
            if (popup.Window->Flags & ImGuiWindowFlags_ChildWindow)
                continue;
 
            // Trim the stack unless the popup is a direct parent of the reference window (the reference window is often the NavWindow)
            // - With this stack of window, clicking/focusing Popup1 will close Popup2 and Popup3:
            //     Window -> Popup1 -> Popup2 -> Popup3
            // - Each popups may contain child windows, which is why we compare ->RootWindow!
            //     Window -> Popup1 -> Popup1_Child -> Popup2 -> Popup2_Child
            bool ref_window_is_descendent_of_popup = false;
            for (int n = popup_count_to_keep; n < g.OpenPopupStack.Size; n++)
                if (ImGuiWindow* popup_window = g.OpenPopupStack[n].Window)
                    if (popup_window->RootWindow == ref_window->RootWindow)
                    {
                        ref_window_is_descendent_of_popup = true;
                        break;
                    }
            if (!ref_window_is_descendent_of_popup)
                break;
        }
    }
    if (popup_count_to_keep < g.OpenPopupStack.Size) // This test is not required but it allows to set a convenient breakpoint on the statement below
    {
        IMGUI_DEBUG_LOG_POPUP("ClosePopupsOverWindow(\"%s\") -> ClosePopupToLevel(%d)\n", ref_window->Name, popup_count_to_keep);
        ClosePopupToLevel(popup_count_to_keep, restore_focus_to_window_under_popup);
    }
}

References ClosePopupToLevel(), ImGuiWindow::Flags, GImGui, IM_ASSERT, IMGUI_DEBUG_LOG_POPUP, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_Popup, ImGuiWindow::Name, ImGuiContext::OpenPopupStack, ImGuiWindow::RootWindow, ImVector< T >::Size, and ImGuiPopupData::Window.

Referenced by FocusWindow(), NavUpdateWindowing(), NewFrame(), and UpdateMouseMovingWindowEndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClosePopupToLevel()

void ImGui::ClosePopupToLevel	(	int	remaining,
		bool	restore_focus_to_window_under_popup
	)

{
    ImGuiContext& g = *GImGui;
    IMGUI_DEBUG_LOG_POPUP("ClosePopupToLevel(%d), restore_focus_to_window_under_popup=%d\n", remaining, restore_focus_to_window_under_popup);
    IM_ASSERT(remaining >= 0 && remaining < g.OpenPopupStack.Size);
 
    // Trim open popup stack
    ImGuiWindow* focus_window = g.OpenPopupStack[remaining].SourceWindow;
    ImGuiWindow* popup_window = g.OpenPopupStack[remaining].Window;
    g.OpenPopupStack.resize(remaining);
 
    if (restore_focus_to_window_under_popup)
    {
        if (focus_window && !focus_window->WasActive && popup_window)
        {
            // Fallback
            FocusTopMostWindowUnderOne(popup_window, NULL);
        }
        else
        {
            if (g.NavLayer == ImGuiNavLayer_Main && focus_window)
                focus_window = NavRestoreLastChildNavWindow(focus_window);
            FocusWindow(focus_window);
        }
    }
}

References FocusTopMostWindowUnderOne(), FocusWindow(), GImGui, IM_ASSERT, IMGUI_DEBUG_LOG_POPUP, ImGuiNavLayer_Main, ImGuiContext::NavLayer, NavRestoreLastChildNavWindow(), ImGuiContext::OpenPopupStack, ImVector< T >::resize(), ImVector< T >::Size, and ImGuiWindow::WasActive.

Referenced by BeginMenu(), BeginPopupModal(), CloseCurrentPopup(), ClosePopupsOverWindow(), EndMenu(), NavUpdate(), and OpenPopupEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollapseButton()

bool ImGui::CollapseButton	(	ImGuiID	id,
		const ImVec2 &	pos
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize) + g.Style.FramePadding * 2.0f);
    ItemAdd(bb, id);
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_None);
 
    // Render
    ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
    ImU32 text_col = GetColorU32(ImGuiCol_Text);
    ImVec2 center = bb.GetCenter();
    if (hovered || held)
        window->DrawList->AddCircleFilled(center/*+ ImVec2(0.0f, -0.5f)*/, g.FontSize * 0.5f + 1.0f, bg_col, 12);
    RenderArrow(window->DrawList, bb.Min + g.Style.FramePadding, text_col, window->Collapsed ? ImGuiDir_Right : ImGuiDir_Down, 1.0f);
 
    // Switch to moving the window after mouse is moved beyond the initial drag threshold
    if (IsItemActive() && IsMouseDragging(0))
        StartMouseMovingWindow(window);
 
    return pressed;
}

References ImDrawList::AddCircleFilled(), ButtonBehavior(), ImGuiWindow::Collapsed, ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImRect::GetCenter(), GetColorU32(), GImGui, ImGuiButtonFlags_None, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_Text, ImGuiDir_Down, ImGuiDir_Right, IsItemActive(), IsMouseDragging(), ItemAdd(), ImRect::Min, RenderArrow(), StartMouseMovingWindow(), and ImGuiContext::Style.

Referenced by RenderWindowTitleBarContents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollapsingHeader() [1/2]

bool ImGui::CollapsingHeader	(	const char *	label,
		bool *	p_visible,
		ImGuiTreeNodeFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    if (p_visible && !*p_visible)
        return false;
 
    ImGuiID id = window->GetID(label);
    flags |= ImGuiTreeNodeFlags_CollapsingHeader;
    if (p_visible)
        flags |= ImGuiTreeNodeFlags_AllowItemOverlap | ImGuiTreeNodeFlags_ClipLabelForTrailingButton;
    bool is_open = TreeNodeBehavior(id, flags, label);
    if (p_visible != NULL)
    {
        // Create a small overlapping close button
        // FIXME: We can evolve this into user accessible helpers to add extra buttons on title bars, headers, etc.
        // FIXME: CloseButton can overlap into text, need find a way to clip the text somehow.
        ImGuiContext& g = *GImGui;
        ImGuiLastItemDataBackup last_item_backup;
        float button_size = g.FontSize;
        float button_x = ImMax(window->DC.LastItemRect.Min.x, window->DC.LastItemRect.Max.x - g.Style.FramePadding.x * 2.0f - button_size);
        float button_y = window->DC.LastItemRect.Min.y;
        ImGuiID close_button_id = GetIDWithSeed("#CLOSE", NULL, id);
        if (CloseButton(close_button_id, ImVec2(button_x, button_y)))
            *p_visible = false;
        last_item_backup.Restore();
    }
 
    return is_open;
}

References CloseButton(), ImGuiWindow::DC, ImGuiContext::FontSize, ImGuiStyle::FramePadding, GetCurrentWindow(), ImGuiWindow::GetID(), GetIDWithSeed(), GImGui, ImGuiTreeNodeFlags_AllowItemOverlap, ImGuiTreeNodeFlags_ClipLabelForTrailingButton, ImGuiTreeNodeFlags_CollapsingHeader, ImMax(), ImGuiWindowTempData::LastItemRect, ImRect::Max, ImRect::Min, ImGuiLastItemDataBackup::Restore(), ImGuiWindow::SkipItems, ImGuiContext::Style, TreeNodeBehavior(), ImVec2::x, and ImVec2::y.

Here is the call graph for this function:

◆ CollapsingHeader() [2/2]

bool ImGui::CollapsingHeader	(	const char *	label,
		ImGuiTreeNodeFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    return TreeNodeBehavior(window->GetID(label), flags | ImGuiTreeNodeFlags_CollapsingHeader, label);
}

References GetCurrentWindow(), ImGuiWindow::GetID(), ImGuiTreeNodeFlags_CollapsingHeader, ImGuiWindow::SkipItems, and TreeNodeBehavior().

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorButton()

bool ImGui::ColorButton	(	const char *	desc_id,
		const ImVec4 &	col,
		ImGuiColorEditFlags	flags = `0`,
		ImVec2	size = `ImVec2(0, 0)`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiID id = window->GetID(desc_id);
    float default_size = GetFrameHeight();
    if (size.x == 0.0f)
        size.x = default_size;
    if (size.y == 0.0f)
        size.y = default_size;
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(bb, (size.y >= default_size) ? g.Style.FramePadding.y : 0.0f);
    if (!ItemAdd(bb, id))
        return false;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held);
 
    if (flags & ImGuiColorEditFlags_NoAlpha)
        flags &= ~(ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaPreviewHalf);
 
    ImVec4 col_rgb = col;
    if (flags & ImGuiColorEditFlags_InputHSV)
        ColorConvertHSVtoRGB(col_rgb.x, col_rgb.y, col_rgb.z, col_rgb.x, col_rgb.y, col_rgb.z);
 
    ImVec4 col_rgb_without_alpha(col_rgb.x, col_rgb.y, col_rgb.z, 1.0f);
    float grid_step = ImMin(size.x, size.y) / 2.99f;
    float rounding = ImMin(g.Style.FrameRounding, grid_step * 0.5f);
    ImRect bb_inner = bb;
    float off = 0.0f;
    if ((flags & ImGuiColorEditFlags_NoBorder) == 0)
    {
        off = -0.75f; // The border (using Col_FrameBg) tends to look off when color is near-opaque and rounding is enabled. This offset seemed like a good middle ground to reduce those artifacts.
        bb_inner.Expand(off);
    }
    if ((flags & ImGuiColorEditFlags_AlphaPreviewHalf) && col_rgb.w < 1.0f)
    {
        float mid_x = IM_ROUND((bb_inner.Min.x + bb_inner.Max.x) * 0.5f);
        RenderColorRectWithAlphaCheckerboard(window->DrawList, ImVec2(bb_inner.Min.x + grid_step, bb_inner.Min.y), bb_inner.Max, GetColorU32(col_rgb), grid_step, ImVec2(-grid_step + off, off), rounding, ImDrawFlags_RoundCornersRight);
        window->DrawList->AddRectFilled(bb_inner.Min, ImVec2(mid_x, bb_inner.Max.y), GetColorU32(col_rgb_without_alpha), rounding, ImDrawFlags_RoundCornersLeft);
    }
    else
    {
        // Because GetColorU32() multiplies by the global style Alpha and we don't want to display a checkerboard if the source code had no alpha
        ImVec4 col_source = (flags & ImGuiColorEditFlags_AlphaPreview) ? col_rgb : col_rgb_without_alpha;
        if (col_source.w < 1.0f)
            RenderColorRectWithAlphaCheckerboard(window->DrawList, bb_inner.Min, bb_inner.Max, GetColorU32(col_source), grid_step, ImVec2(off, off), rounding);
        else
            window->DrawList->AddRectFilled(bb_inner.Min, bb_inner.Max, GetColorU32(col_source), rounding);
    }
    RenderNavHighlight(bb, id);
    if ((flags & ImGuiColorEditFlags_NoBorder) == 0)
    {
        if (g.Style.FrameBorderSize > 0.0f)
            RenderFrameBorder(bb.Min, bb.Max, rounding);
        else
            window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), rounding); // Color button are often in need of some sort of border
    }
 
    // Drag and Drop Source
    // NB: The ActiveId test is merely an optional micro-optimization, BeginDragDropSource() does the same test.
    if (g.ActiveId == id && !(flags & ImGuiColorEditFlags_NoDragDrop) && BeginDragDropSource())
    {
        if (flags & ImGuiColorEditFlags_NoAlpha)
            SetDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_3F, &col_rgb, sizeof(float) * 3, ImGuiCond_Once);
        else
            SetDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_4F, &col_rgb, sizeof(float) * 4, ImGuiCond_Once);
        ColorButton(desc_id, col, flags);
        SameLine();
        TextEx("Color");
        EndDragDropSource();
    }
 
    // Tooltip
    if (!(flags & ImGuiColorEditFlags_NoTooltip) && hovered)
        ColorTooltip(desc_id, &col.x, flags & (ImGuiColorEditFlags__InputMask | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaPreviewHalf));
 
    return pressed;
}

References ImGuiContext::ActiveId, ImDrawList::AddRect(), ImDrawList::AddRectFilled(), BeginDragDropSource(), ButtonBehavior(), col(), ColorButton(), ColorConvertHSVtoRGB(), ColorTooltip(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, EndDragDropSource(), ImRect::Expand(), ImGuiStyle::FrameBorderSize, ImGuiStyle::FramePadding, ImGuiStyle::FrameRounding, GetColorU32(), GetCurrentWindow(), GetFrameHeight(), ImGuiWindow::GetID(), GImGui, IM_ROUND, ImDrawFlags_RoundCornersLeft, ImDrawFlags_RoundCornersRight, IMGUI_PAYLOAD_TYPE_COLOR_3F, IMGUI_PAYLOAD_TYPE_COLOR_4F, ImGuiCol_FrameBg, ImGuiColorEditFlags__InputMask, ImGuiColorEditFlags_AlphaPreview, ImGuiColorEditFlags_AlphaPreviewHalf, ImGuiColorEditFlags_InputHSV, ImGuiColorEditFlags_NoAlpha, ImGuiColorEditFlags_NoBorder, ImGuiColorEditFlags_NoDragDrop, ImGuiColorEditFlags_NoTooltip, ImGuiCond_Once, ImMin(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, RenderColorRectWithAlphaCheckerboard(), RenderFrameBorder(), RenderNavHighlight(), SameLine(), SetDragDropPayload(), ImGuiWindow::SkipItems, ImGuiContext::Style, TextEx(), ImVec4::w, ImVec2::x, ImVec4::x, ImVec2::y, ImVec4::y, and ImVec4::z.

Referenced by ColorButton(), ColorEdit4(), ColorPicker4(), ColorTooltip(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorConvertFloat4ToU32()

ImU32 ImGui::ColorConvertFloat4ToU32 ( const ImVec4 & in )

{
    ImU32 out;
    out  = ((ImU32)IM_F32_TO_INT8_SAT(in.x)) << IM_COL32_R_SHIFT;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.y)) << IM_COL32_G_SHIFT;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.z)) << IM_COL32_B_SHIFT;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.w)) << IM_COL32_A_SHIFT;
    return out;
}

References IM_COL32_A_SHIFT, IM_COL32_B_SHIFT, IM_COL32_G_SHIFT, IM_COL32_R_SHIFT, IM_F32_TO_INT8_SAT, ImVec4::w, ImVec4::x, ImVec4::y, and ImVec4::z.

Referenced by ColorPicker4(), GetColorU32(), GetColorU32(), and ImColor::operator ImU32().

Here is the caller graph for this function:

◆ ColorConvertHSVtoRGB()

void ImGui::ColorConvertHSVtoRGB	(	float	h,
		float	s,
		float	v,
		float &	out_r,
		float &	out_g,
		float &	out_b
	)

{
    if (s == 0.0f)
    {
        // gray
        out_r = out_g = out_b = v;
        return;
    }
 
    h = ImFmod(h, 1.0f) / (60.0f / 360.0f);
    int   i = (int)h;
    float f = h - (float)i;
    float p = v * (1.0f - s);
    float q = v * (1.0f - s * f);
    float t = v * (1.0f - s * (1.0f - f));
 
    switch (i)
    {
    case 0: out_r = v; out_g = t; out_b = p; break;
    case 1: out_r = q; out_g = v; out_b = p; break;
    case 2: out_r = p; out_g = v; out_b = t; break;
    case 3: out_r = p; out_g = q; out_b = v; break;
    case 4: out_r = t; out_g = p; out_b = v; break;
    case 5: default: out_r = v; out_g = p; out_b = q; break;
    }
}

References ImFmod.

Referenced by ColorButton(), ColorEdit4(), ColorPicker4(), ImColor::HSV(), ImColor::SetHSV(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ ColorConvertRGBtoHSV()

void ImGui::ColorConvertRGBtoHSV	(	float	r,
		float	g,
		float	b,
		float &	out_h,
		float &	out_s,
		float &	out_v
	)

{
    float K = 0.f;
    if (g < b)
    {
        ImSwap(g, b);
        K = -1.f;
    }
    if (r < g)
    {
        ImSwap(r, g);
        K = -2.f / 6.f - K;
    }
 
    const float chroma = r - (g < b ? g : b);
    out_h = ImFabs(K + (g - b) / (6.f * chroma + 1e-20f));
    out_s = chroma / (r + 1e-20f);
    out_v = r;
}

References ImFabs, and ImSwap().

Referenced by ColorEdit4(), and ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorConvertU32ToFloat4()

ImVec4 ImGui::ColorConvertU32ToFloat4 ( ImU32 in )

{
    float s = 1.0f / 255.0f;
    return ImVec4(
        ((in >> IM_COL32_R_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_G_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_B_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_A_SHIFT) & 0xFF) * s);
}

References IM_COL32_A_SHIFT, IM_COL32_B_SHIFT, IM_COL32_G_SHIFT, and IM_COL32_R_SHIFT.

Referenced by Slic3r::GUI::ImGuiWrapper::from_ImU32(), and PushStyleColor().

Here is the caller graph for this function:

◆ ColorEdit3()

bool ImGui::ColorEdit3	(	const char *	label,
		float	col[3],
		ImGuiColorEditFlags	flags = `0`
	)

{
    return ColorEdit4(label, col, flags | ImGuiColorEditFlags_NoAlpha);
}

References col(), ColorEdit4(), and ImGuiColorEditFlags_NoAlpha.

Referenced by MyDocument::DisplayContents(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorEdit4()

bool ImGui::ColorEdit4	(	const char *	label,
		float	col[4],
		ImGuiColorEditFlags	flags = `0`,
		const char *	current_label = `NULL`,
		const char *	original_label = `NULL`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const float square_sz = GetFrameHeight();
    const float w_full = CalcItemWidth();
    const float w_button = (flags & ImGuiColorEditFlags_NoSmallPreview) ? 0.0f : (square_sz + style.ItemInnerSpacing.x);
    const float w_inputs = w_full - w_button;
    const char* label_display_end = FindRenderedTextEnd(label);
    g.NextItemData.ClearFlags();
 
    BeginGroup();
    PushID(label);
 
    // If we're not showing any slider there's no point in doing any HSV conversions
    const ImGuiColorEditFlags flags_untouched = flags;
    if (flags & ImGuiColorEditFlags_NoInputs)
        flags = (flags & (~ImGuiColorEditFlags__DisplayMask)) | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_NoOptions;
 
    // Context menu: display and modify options (before defaults are applied)
    if (!(flags & ImGuiColorEditFlags_NoOptions))
        ColorEditOptionsPopup(col, flags);
 
    // Read stored options
    if (!(flags & ImGuiColorEditFlags__DisplayMask))
        flags |= (g.ColorEditOptions & ImGuiColorEditFlags__DisplayMask);
    if (!(flags & ImGuiColorEditFlags__DataTypeMask))
        flags |= (g.ColorEditOptions & ImGuiColorEditFlags__DataTypeMask);
    if (!(flags & ImGuiColorEditFlags__PickerMask))
        flags |= (g.ColorEditOptions & ImGuiColorEditFlags__PickerMask);
    if (!(flags & ImGuiColorEditFlags__InputMask))
        flags |= (g.ColorEditOptions & ImGuiColorEditFlags__InputMask);
    flags |= (g.ColorEditOptions & ~(ImGuiColorEditFlags__DisplayMask | ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags__PickerMask | ImGuiColorEditFlags__InputMask));
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__DisplayMask)); // Check that only 1 is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__InputMask));   // Check that only 1 is selected
 
    const bool alpha = (flags & ImGuiColorEditFlags_NoAlpha) == 0;
    const bool hdr = (flags & ImGuiColorEditFlags_HDR) != 0;
    const int components = alpha ? 4 : 3;
 
    // Convert to the formats we need
    float f[4] = { col[0], col[1], col[2], alpha ? col[3] : 1.0f };
    if ((flags & ImGuiColorEditFlags_InputHSV) && (flags & ImGuiColorEditFlags_DisplayRGB))
        ColorConvertHSVtoRGB(f[0], f[1], f[2], f[0], f[1], f[2]);
    else if ((flags & ImGuiColorEditFlags_InputRGB) && (flags & ImGuiColorEditFlags_DisplayHSV))
    {
        // Hue is lost when converting from greyscale rgb (saturation=0). Restore it.
        ColorConvertRGBtoHSV(f[0], f[1], f[2], f[0], f[1], f[2]);
        if (memcmp(g.ColorEditLastColor, col, sizeof(float) * 3) == 0)
        {
            if (f[1] == 0)
                f[0] = g.ColorEditLastHue;
            if (f[2] == 0)
                f[1] = g.ColorEditLastSat;
        }
    }
    int i[4] = { IM_F32_TO_INT8_UNBOUND(f[0]), IM_F32_TO_INT8_UNBOUND(f[1]), IM_F32_TO_INT8_UNBOUND(f[2]), IM_F32_TO_INT8_UNBOUND(f[3]) };
 
    bool value_changed = false;
    bool value_changed_as_float = false;
 
    const ImVec2 pos = window->DC.CursorPos;
    const float inputs_offset_x = (style.ColorButtonPosition == ImGuiDir_Left) ? w_button : 0.0f;
    window->DC.CursorPos.x = pos.x + inputs_offset_x;
 
    if ((flags & (ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV)) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)
    {
        // RGB/HSV 0..255 Sliders
        const float w_item_one  = ImMax(1.0f, IM_FLOOR((w_inputs - (style.ItemInnerSpacing.x) * (components - 1)) / (float)components));
        const float w_item_last = ImMax(1.0f, IM_FLOOR(w_inputs - (w_item_one + style.ItemInnerSpacing.x) * (components - 1)));
 
        const bool hide_prefix = (w_item_one <= CalcTextSize((flags & ImGuiColorEditFlags_Float) ? "M:0.000" : "M:000").x);
        static const char* ids[4] = { "##X", "##Y", "##Z", "##W" };
        static const char* fmt_table_int[3][4] =
        {
            {   "%3d",   "%3d",   "%3d",   "%3d" }, // Short display
            { "R:%3d", "G:%3d", "B:%3d", "A:%3d" }, // Long display for RGBA
            { "H:%3d", "S:%3d", "V:%3d", "A:%3d" }  // Long display for HSVA
        };
        static const char* fmt_table_float[3][4] =
        {
            {   "%0.3f",   "%0.3f",   "%0.3f",   "%0.3f" }, // Short display
            { "R:%0.3f", "G:%0.3f", "B:%0.3f", "A:%0.3f" }, // Long display for RGBA
            { "H:%0.3f", "S:%0.3f", "V:%0.3f", "A:%0.3f" }  // Long display for HSVA
        };
        const int fmt_idx = hide_prefix ? 0 : (flags & ImGuiColorEditFlags_DisplayHSV) ? 2 : 1;
 
        for (int n = 0; n < components; n++)
        {
            if (n > 0)
                SameLine(0, style.ItemInnerSpacing.x);
            SetNextItemWidth((n + 1 < components) ? w_item_one : w_item_last);
 
            // FIXME: When ImGuiColorEditFlags_HDR flag is passed HS values snap in weird ways when SV values go below 0.
            if (flags & ImGuiColorEditFlags_Float)
            {
                value_changed |= DragFloat(ids[n], &f[n], 1.0f / 255.0f, 0.0f, hdr ? 0.0f : 1.0f, fmt_table_float[fmt_idx][n]);
                value_changed_as_float |= value_changed;
            }
            else
            {
                value_changed |= DragInt(ids[n], &i[n], 1.0f, 0, hdr ? 0 : 255, fmt_table_int[fmt_idx][n]);
            }
            if (!(flags & ImGuiColorEditFlags_NoOptions))
                OpenPopupOnItemClick("context");
        }
    }
    else if ((flags & ImGuiColorEditFlags_DisplayHex) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)
    {
        // RGB Hexadecimal Input
        char buf[64];
        if (alpha)
            ImFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X%02X", ImClamp(i[0], 0, 255), ImClamp(i[1], 0, 255), ImClamp(i[2], 0, 255), ImClamp(i[3], 0, 255));
        else
            ImFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X", ImClamp(i[0], 0, 255), ImClamp(i[1], 0, 255), ImClamp(i[2], 0, 255));
        SetNextItemWidth(w_inputs);
        if (InputText("##Text", buf, IM_ARRAYSIZE(buf), ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase))
        {
            value_changed = true;
            char* p = buf;
            while (*p == '#' || ImCharIsBlankA(*p))
                p++;
            i[0] = i[1] = i[2] = 0;
            i[3] = 0xFF; // alpha default to 255 is not parsed by scanf (e.g. inputting #FFFFFF omitting alpha)
            int r;
            if (alpha)
                r = sscanf(p, "%02X%02X%02X%02X", (unsigned int*)&i[0], (unsigned int*)&i[1], (unsigned int*)&i[2], (unsigned int*)&i[3]); // Treat at unsigned (%X is unsigned)
            else
                r = sscanf(p, "%02X%02X%02X", (unsigned int*)&i[0], (unsigned int*)&i[1], (unsigned int*)&i[2]);
            IM_UNUSED(r); // Fixes C6031: Return value ignored: 'sscanf'.
        }
        if (!(flags & ImGuiColorEditFlags_NoOptions))
            OpenPopupOnItemClick("context");
    }
 
    ImGuiWindow* picker_active_window = NULL;
    if (!(flags & ImGuiColorEditFlags_NoSmallPreview))
    {
        const float button_offset_x = ((flags & ImGuiColorEditFlags_NoInputs) || (style.ColorButtonPosition == ImGuiDir_Left)) ? 0.0f : w_inputs + style.ItemInnerSpacing.x;
        window->DC.CursorPos = ImVec2(pos.x + button_offset_x, pos.y);
 
        const ImVec4 col_v4(col[0], col[1], col[2], alpha ? col[3] : 1.0f);
        if (ColorButton("##ColorButton", col_v4, flags))
        {
            if (!(flags & ImGuiColorEditFlags_NoPicker))
            {
                // Store current color and open a picker
                g.ColorPickerRef = col_v4;
                OpenPopup("picker");
                SetNextWindowPos(window->DC.LastItemRect.GetBL() + ImVec2(-1, style.ItemSpacing.y));
            }
        }
        if (!(flags & ImGuiColorEditFlags_NoOptions))
            OpenPopupOnItemClick("context");
 
        if (BeginPopup("picker"))
        {
            picker_active_window = g.CurrentWindow;
            if (label != label_display_end)
            {
                TextEx(label, label_display_end);
                Spacing();
            }
            ImGuiColorEditFlags picker_flags_to_forward = ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags__PickerMask | ImGuiColorEditFlags__InputMask | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaBar;
            ImGuiColorEditFlags picker_flags = (flags_untouched & picker_flags_to_forward) | ImGuiColorEditFlags__DisplayMask | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_AlphaPreviewHalf;
            SetNextItemWidth(square_sz * 12.0f); // Use 256 + bar sizes?
            value_changed |= ColorPicker4("##picker", col, picker_flags, &g.ColorPickerRef.x, current_label, original_label);
            EndPopup();
        }
    }
 
    if (label != label_display_end && !(flags & ImGuiColorEditFlags_NoLabel))
    {
        const float text_offset_x = (flags & ImGuiColorEditFlags_NoInputs) ? w_button : w_full + style.ItemInnerSpacing.x;
        window->DC.CursorPos = ImVec2(pos.x + text_offset_x, pos.y + style.FramePadding.y);
        TextEx(label, label_display_end);
    }
 
    // Convert back
    if (value_changed && picker_active_window == NULL)
    {
        if (!value_changed_as_float)
            for (int n = 0; n < 4; n++)
                f[n] = i[n] / 255.0f;
        if ((flags & ImGuiColorEditFlags_DisplayHSV) && (flags & ImGuiColorEditFlags_InputRGB))
        {
            g.ColorEditLastHue = f[0];
            g.ColorEditLastSat = f[1];
            ColorConvertHSVtoRGB(f[0], f[1], f[2], f[0], f[1], f[2]);
            memcpy(g.ColorEditLastColor, f, sizeof(float) * 3);
        }
        if ((flags & ImGuiColorEditFlags_DisplayRGB) && (flags & ImGuiColorEditFlags_InputHSV))
            ColorConvertRGBtoHSV(f[0], f[1], f[2], f[0], f[1], f[2]);
 
        col[0] = f[0];
        col[1] = f[1];
        col[2] = f[2];
        if (alpha)
            col[3] = f[3];
    }
 
    PopID();
    EndGroup();
 
    // Drag and Drop Target
    // NB: The flag test is merely an optional micro-optimization, BeginDragDropTarget() does the same test.
    if ((window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect) && !(flags & ImGuiColorEditFlags_NoDragDrop) && BeginDragDropTarget())
    {
        bool accepted_drag_drop = false;
        if (const ImGuiPayload* payload = AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_3F))
        {
            memcpy((float*)col, payload->Data, sizeof(float) * 3); // Preserve alpha if any //-V512
            value_changed = accepted_drag_drop = true;
        }
        if (const ImGuiPayload* payload = AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_4F))
        {
            memcpy((float*)col, payload->Data, sizeof(float) * components);
            value_changed = accepted_drag_drop = true;
        }
 
        // Drag-drop payloads are always RGB
        if (accepted_drag_drop && (flags & ImGuiColorEditFlags_InputHSV))
            ColorConvertRGBtoHSV(col[0], col[1], col[2], col[0], col[1], col[2]);
        EndDragDropTarget();
    }
 
    // When picker is being actively used, use its active id so IsItemActive() will function on ColorEdit4().
    if (picker_active_window && g.ActiveId != 0 && g.ActiveIdWindow == picker_active_window)
        window->DC.LastItemId = g.ActiveId;
 
    if (value_changed)
        MarkItemEdited(window->DC.LastItemId);
 
    return value_changed;
}

Referenced by ColorEdit3(), ColorPicker4(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), ShowDemoWindowPopups(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorEditOptionsPopup()

void ImGui::ColorEditOptionsPopup	(	const float *	col,
		ImGuiColorEditFlags	flags
	)

{
    bool allow_opt_inputs = !(flags & ImGuiColorEditFlags__DisplayMask);
    bool allow_opt_datatype = !(flags & ImGuiColorEditFlags__DataTypeMask);
    if ((!allow_opt_inputs && !allow_opt_datatype) || !BeginPopup("context"))
        return;
    ImGuiContext& g = *GImGui;
    ImGuiColorEditFlags opts = g.ColorEditOptions;
    if (allow_opt_inputs)
    {
        if (RadioButton("RGB", (opts & ImGuiColorEditFlags_DisplayRGB) != 0)) opts = (opts & ~ImGuiColorEditFlags__DisplayMask) | ImGuiColorEditFlags_DisplayRGB;
        if (RadioButton("HSV", (opts & ImGuiColorEditFlags_DisplayHSV) != 0)) opts = (opts & ~ImGuiColorEditFlags__DisplayMask) | ImGuiColorEditFlags_DisplayHSV;
        if (RadioButton("Hex", (opts & ImGuiColorEditFlags_DisplayHex) != 0)) opts = (opts & ~ImGuiColorEditFlags__DisplayMask) | ImGuiColorEditFlags_DisplayHex;
    }
    if (allow_opt_datatype)
    {
        if (allow_opt_inputs) Separator();
        if (RadioButton("0..255",     (opts & ImGuiColorEditFlags_Uint8) != 0)) opts = (opts & ~ImGuiColorEditFlags__DataTypeMask) | ImGuiColorEditFlags_Uint8;
        if (RadioButton("0.00..1.00", (opts & ImGuiColorEditFlags_Float) != 0)) opts = (opts & ~ImGuiColorEditFlags__DataTypeMask) | ImGuiColorEditFlags_Float;
    }
 
    if (allow_opt_inputs || allow_opt_datatype)
        Separator();
    if (Button("Copy as..", ImVec2(-1, 0)))
        OpenPopup("Copy");
    if (BeginPopup("Copy"))
    {
        int cr = IM_F32_TO_INT8_SAT(col[0]), cg = IM_F32_TO_INT8_SAT(col[1]), cb = IM_F32_TO_INT8_SAT(col[2]), ca = (flags & ImGuiColorEditFlags_NoAlpha) ? 255 : IM_F32_TO_INT8_SAT(col[3]);
        char buf[64];
        ImFormatString(buf, IM_ARRAYSIZE(buf), "(%.3ff, %.3ff, %.3ff, %.3ff)", col[0], col[1], col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : col[3]);
        if (Selectable(buf))
            SetClipboardText(buf);
        ImFormatString(buf, IM_ARRAYSIZE(buf), "(%d,%d,%d,%d)", cr, cg, cb, ca);
        if (Selectable(buf))
            SetClipboardText(buf);
        ImFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X", cr, cg, cb);
        if (Selectable(buf))
            SetClipboardText(buf);
        if (!(flags & ImGuiColorEditFlags_NoAlpha))
        {
            ImFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X%02X", cr, cg, cb, ca);
            if (Selectable(buf))
                SetClipboardText(buf);
        }
        EndPopup();
    }
 
    g.ColorEditOptions = opts;
    EndPopup();
}

References BeginPopup(), Button(), col(), ImGuiContext::ColorEditOptions, EndPopup(), GImGui, IM_ARRAYSIZE, IM_F32_TO_INT8_SAT, ImFormatString(), ImGuiColorEditFlags__DataTypeMask, ImGuiColorEditFlags__DisplayMask, ImGuiColorEditFlags_DisplayHex, ImGuiColorEditFlags_DisplayHSV, ImGuiColorEditFlags_DisplayRGB, ImGuiColorEditFlags_Float, ImGuiColorEditFlags_NoAlpha, ImGuiColorEditFlags_Uint8, OpenPopup(), RadioButton(), Selectable(), Separator(), and SetClipboardText().

Referenced by ColorEdit4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorPicker3()

bool ImGui::ColorPicker3	(	const char *	label,
		float	col[3],
		ImGuiColorEditFlags	flags = `0`
	)

{
    float col4[4] = { col[0], col[1], col[2], 1.0f };
    if (!ColorPicker4(label, col4, flags | ImGuiColorEditFlags_NoAlpha))
        return false;
    col[0] = col4[0]; col[1] = col4[1]; col[2] = col4[2];
    return true;
}

References col(), ColorPicker4(), and ImGuiColorEditFlags_NoAlpha.

Here is the call graph for this function:

◆ ColorPicker4()

bool ImGui::ColorPicker4	(	const char *	label,
		float	col[4],
		ImGuiColorEditFlags	flags = `0`,
		const float *	ref_col = `NULL`,
		const char *	current_label = `NULL`,
		const char *	original_label = `NULL`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImDrawList* draw_list = window->DrawList;
    ImGuiStyle& style = g.Style;
    ImGuiIO& io = g.IO;
 
    const float width = CalcItemWidth();
    g.NextItemData.ClearFlags();
 
    PushID(label);
    BeginGroup();
 
    if (!(flags & ImGuiColorEditFlags_NoSidePreview))
        flags |= ImGuiColorEditFlags_NoSmallPreview;
 
    // Context menu: display and store options.
    if (!(flags & ImGuiColorEditFlags_NoOptions))
        ColorPickerOptionsPopup(col, flags);
 
    // Read stored options
    if (!(flags & ImGuiColorEditFlags__PickerMask))
        flags |= ((g.ColorEditOptions & ImGuiColorEditFlags__PickerMask) ? g.ColorEditOptions : ImGuiColorEditFlags__OptionsDefault) & ImGuiColorEditFlags__PickerMask;
    if (!(flags & ImGuiColorEditFlags__InputMask))
        flags |= ((g.ColorEditOptions & ImGuiColorEditFlags__InputMask) ? g.ColorEditOptions : ImGuiColorEditFlags__OptionsDefault) & ImGuiColorEditFlags__InputMask;
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__PickerMask)); // Check that only 1 is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__InputMask));  // Check that only 1 is selected
    if (!(flags & ImGuiColorEditFlags_NoOptions))
        flags |= (g.ColorEditOptions & ImGuiColorEditFlags_AlphaBar);
 
    // Setup
    int components = (flags & ImGuiColorEditFlags_NoAlpha) ? 3 : 4;
    bool alpha_bar = (flags & ImGuiColorEditFlags_AlphaBar) && !(flags & ImGuiColorEditFlags_NoAlpha);
    ImVec2 picker_pos = window->DC.CursorPos;
    float square_sz = GetFrameHeight();
    float bars_width = square_sz; // Arbitrary smallish width of Hue/Alpha picking bars
    float sv_picker_size = ImMax(bars_width * 1, width - (alpha_bar ? 2 : 1) * (bars_width + style.ItemInnerSpacing.x)); // Saturation/Value picking box
    float bar0_pos_x = picker_pos.x + sv_picker_size + style.ItemInnerSpacing.x;
    float bar1_pos_x = bar0_pos_x + bars_width + style.ItemInnerSpacing.x;
    float bars_triangles_half_sz = IM_FLOOR(bars_width * 0.20f);
 
    float backup_initial_col[4];
    memcpy(backup_initial_col, col, components * sizeof(float));
 
    float wheel_thickness = sv_picker_size * 0.08f;
    float wheel_r_outer = sv_picker_size * 0.50f;
    float wheel_r_inner = wheel_r_outer - wheel_thickness;
    ImVec2 wheel_center(picker_pos.x + (sv_picker_size + bars_width)*0.5f, picker_pos.y + sv_picker_size * 0.5f);
 
    // Note: the triangle is displayed rotated with triangle_pa pointing to Hue, but most coordinates stays unrotated for logic.
    float triangle_r = wheel_r_inner - (int)(sv_picker_size * 0.027f);
    ImVec2 triangle_pa = ImVec2(triangle_r, 0.0f); // Hue point.
    ImVec2 triangle_pb = ImVec2(triangle_r * -0.5f, triangle_r * -0.866025f); // Black point.
    ImVec2 triangle_pc = ImVec2(triangle_r * -0.5f, triangle_r * +0.866025f); // White point.
 
    float H = col[0], S = col[1], V = col[2];
    float R = col[0], G = col[1], B = col[2];
    if (flags & ImGuiColorEditFlags_InputRGB)
    {
        // Hue is lost when converting from greyscale rgb (saturation=0). Restore it.
        ColorConvertRGBtoHSV(R, G, B, H, S, V);
        if (memcmp(g.ColorEditLastColor, col, sizeof(float) * 3) == 0)
        {
            if (S == 0)
                H = g.ColorEditLastHue;
            if (V == 0)
                S = g.ColorEditLastSat;
        }
    }
    else if (flags & ImGuiColorEditFlags_InputHSV)
    {
        ColorConvertHSVtoRGB(H, S, V, R, G, B);
    }
 
    bool value_changed = false, value_changed_h = false, value_changed_sv = false;
 
    PushItemFlag(ImGuiItemFlags_NoNav, true);
    if (flags & ImGuiColorEditFlags_PickerHueWheel)
    {
        // Hue wheel + SV triangle logic
        InvisibleButton("hsv", ImVec2(sv_picker_size + style.ItemInnerSpacing.x + bars_width, sv_picker_size));
        if (IsItemActive())
        {
            ImVec2 initial_off = g.IO.MouseClickedPos[0] - wheel_center;
            ImVec2 current_off = g.IO.MousePos - wheel_center;
            float initial_dist2 = ImLengthSqr(initial_off);
            if (initial_dist2 >= (wheel_r_inner - 1) * (wheel_r_inner - 1) && initial_dist2 <= (wheel_r_outer + 1) * (wheel_r_outer + 1))
            {
                // Interactive with Hue wheel
                H = ImAtan2(current_off.y, current_off.x) / IM_PI * 0.5f;
                if (H < 0.0f)
                    H += 1.0f;
                value_changed = value_changed_h = true;
            }
            float cos_hue_angle = ImCos(-H * 2.0f * IM_PI);
            float sin_hue_angle = ImSin(-H * 2.0f * IM_PI);
            if (ImTriangleContainsPoint(triangle_pa, triangle_pb, triangle_pc, ImRotate(initial_off, cos_hue_angle, sin_hue_angle)))
            {
                // Interacting with SV triangle
                ImVec2 current_off_unrotated = ImRotate(current_off, cos_hue_angle, sin_hue_angle);
                if (!ImTriangleContainsPoint(triangle_pa, triangle_pb, triangle_pc, current_off_unrotated))
                    current_off_unrotated = ImTriangleClosestPoint(triangle_pa, triangle_pb, triangle_pc, current_off_unrotated);
                float uu, vv, ww;
                ImTriangleBarycentricCoords(triangle_pa, triangle_pb, triangle_pc, current_off_unrotated, uu, vv, ww);
                V = ImClamp(1.0f - vv, 0.0001f, 1.0f);
                S = ImClamp(uu / V, 0.0001f, 1.0f);
                value_changed = value_changed_sv = true;
            }
        }
        if (!(flags & ImGuiColorEditFlags_NoOptions))
            OpenPopupOnItemClick("context");
    }
    else if (flags & ImGuiColorEditFlags_PickerHueBar)
    {
        // SV rectangle logic
        InvisibleButton("sv", ImVec2(sv_picker_size, sv_picker_size));
        if (IsItemActive())
        {
            S = ImSaturate((io.MousePos.x - picker_pos.x) / (sv_picker_size - 1));
            V = 1.0f - ImSaturate((io.MousePos.y - picker_pos.y) / (sv_picker_size - 1));
            value_changed = value_changed_sv = true;
        }
        if (!(flags & ImGuiColorEditFlags_NoOptions))
            OpenPopupOnItemClick("context");
 
        // Hue bar logic
        SetCursorScreenPos(ImVec2(bar0_pos_x, picker_pos.y));
        InvisibleButton("hue", ImVec2(bars_width, sv_picker_size));
        if (IsItemActive())
        {
            H = ImSaturate((io.MousePos.y - picker_pos.y) / (sv_picker_size - 1));
            value_changed = value_changed_h = true;
        }
    }
 
    // Alpha bar logic
    if (alpha_bar)
    {
        SetCursorScreenPos(ImVec2(bar1_pos_x, picker_pos.y));
        InvisibleButton("alpha", ImVec2(bars_width, sv_picker_size));
        if (IsItemActive())
        {
            col[3] = 1.0f - ImSaturate((io.MousePos.y - picker_pos.y) / (sv_picker_size - 1));
            value_changed = true;
        }
    }
    PopItemFlag(); // ImGuiItemFlags_NoNav
 
    if (!(flags & ImGuiColorEditFlags_NoSidePreview))
    {
        SameLine(0, style.ItemInnerSpacing.x);
        BeginGroup();
    }
 
    if (!(flags & ImGuiColorEditFlags_NoLabel))
    {
        const char* label_display_end = FindRenderedTextEnd(label);
        if (label != label_display_end)
        {
            if ((flags & ImGuiColorEditFlags_NoSidePreview))
                SameLine(0, style.ItemInnerSpacing.x);
            TextEx(label, label_display_end);
        }
    }
 
    if (!(flags & ImGuiColorEditFlags_NoSidePreview))
    {
        PushItemFlag(ImGuiItemFlags_NoNavDefaultFocus, true);
        ImVec4 col_v4(col[0], col[1], col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : col[3]);
        if ((flags & ImGuiColorEditFlags_NoLabel))
            Text("%s", current_label ? current_label : "Current");
 
        ImGuiColorEditFlags sub_flags_to_forward = ImGuiColorEditFlags__InputMask | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaPreviewHalf | ImGuiColorEditFlags_NoTooltip;
        ColorButton("##current", col_v4, (flags & sub_flags_to_forward), ImVec2(square_sz * 3, square_sz * 2));
        if (ref_col != NULL)
        {
            Text("%s", original_label ? original_label : "Original");
            ImVec4 ref_col_v4(ref_col[0], ref_col[1], ref_col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : ref_col[3]);
            if (ColorButton("##original", ref_col_v4, (flags & sub_flags_to_forward), ImVec2(square_sz * 3, square_sz * 2)))
            {
                memcpy(col, ref_col, components * sizeof(float));
                value_changed = true;
            }
        }
        PopItemFlag();
        EndGroup();
    }
 
    // Convert back color to RGB
    if (value_changed_h || value_changed_sv)
    {
        if (flags & ImGuiColorEditFlags_InputRGB)
        {
            ColorConvertHSVtoRGB(H >= 1.0f ? H - 10 * 1e-6f : H, S > 0.0f ? S : 10 * 1e-6f, V > 0.0f ? V : 1e-6f, col[0], col[1], col[2]);
            g.ColorEditLastHue = H;
            g.ColorEditLastSat = S;
            memcpy(g.ColorEditLastColor, col, sizeof(float) * 3);
        }
        else if (flags & ImGuiColorEditFlags_InputHSV)
        {
            col[0] = H;
            col[1] = S;
            col[2] = V;
        }
    }
 
    // R,G,B and H,S,V slider color editor
    bool value_changed_fix_hue_wrap = false;
    if ((flags & ImGuiColorEditFlags_NoInputs) == 0)
    {
        PushItemWidth((alpha_bar ? bar1_pos_x : bar0_pos_x) + bars_width - picker_pos.x);
        ImGuiColorEditFlags sub_flags_to_forward = ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags__InputMask | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoOptions | ImGuiColorEditFlags_NoSmallPreview | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaPreviewHalf;
        ImGuiColorEditFlags sub_flags = (flags & sub_flags_to_forward) | ImGuiColorEditFlags_NoPicker;
        if (flags & ImGuiColorEditFlags_DisplayRGB || (flags & ImGuiColorEditFlags__DisplayMask) == 0)
            if (ColorEdit4("##rgb", col, sub_flags | ImGuiColorEditFlags_DisplayRGB))
            {
                // FIXME: Hackily differentiating using the DragInt (ActiveId != 0 && !ActiveIdAllowOverlap) vs. using the InputText or DropTarget.
                // For the later we don't want to run the hue-wrap canceling code. If you are well versed in HSV picker please provide your input! (See #2050)
                value_changed_fix_hue_wrap = (g.ActiveId != 0 && !g.ActiveIdAllowOverlap);
                value_changed = true;
            }
        if (flags & ImGuiColorEditFlags_DisplayHSV || (flags & ImGuiColorEditFlags__DisplayMask) == 0)
            value_changed |= ColorEdit4("##hsv", col, sub_flags | ImGuiColorEditFlags_DisplayHSV);
        if (flags & ImGuiColorEditFlags_DisplayHex || (flags & ImGuiColorEditFlags__DisplayMask) == 0)
            value_changed |= ColorEdit4("##hex", col, sub_flags | ImGuiColorEditFlags_DisplayHex);
        PopItemWidth();
    }
 
    // Try to cancel hue wrap (after ColorEdit4 call), if any
    if (value_changed_fix_hue_wrap && (flags & ImGuiColorEditFlags_InputRGB))
    {
        float new_H, new_S, new_V;
        ColorConvertRGBtoHSV(col[0], col[1], col[2], new_H, new_S, new_V);
        if (new_H <= 0 && H > 0)
        {
            if (new_V <= 0 && V != new_V)
                ColorConvertHSVtoRGB(H, S, new_V <= 0 ? V * 0.5f : new_V, col[0], col[1], col[2]);
            else if (new_S <= 0)
                ColorConvertHSVtoRGB(H, new_S <= 0 ? S * 0.5f : new_S, new_V, col[0], col[1], col[2]);
        }
    }
 
    if (value_changed)
    {
        if (flags & ImGuiColorEditFlags_InputRGB)
        {
            R = col[0];
            G = col[1];
            B = col[2];
            ColorConvertRGBtoHSV(R, G, B, H, S, V);
            if (memcmp(g.ColorEditLastColor, col, sizeof(float) * 3) == 0) // Fix local Hue as display below will use it immediately.
            {
                if (S == 0)
                    H = g.ColorEditLastHue;
                if (V == 0)
                    S = g.ColorEditLastSat;
            }
        }
        else if (flags & ImGuiColorEditFlags_InputHSV)
        {
            H = col[0];
            S = col[1];
            V = col[2];
            ColorConvertHSVtoRGB(H, S, V, R, G, B);
        }
    }
 
    const int style_alpha8 = IM_F32_TO_INT8_SAT(style.Alpha);
    const ImU32 col_black = IM_COL32(0,0,0,style_alpha8);
    const ImU32 col_white = IM_COL32(255,255,255,style_alpha8);
    const ImU32 col_midgrey = IM_COL32(128,128,128,style_alpha8);
    const ImU32 col_hues[6 + 1] = { IM_COL32(255,0,0,style_alpha8), IM_COL32(255,255,0,style_alpha8), IM_COL32(0,255,0,style_alpha8), IM_COL32(0,255,255,style_alpha8), IM_COL32(0,0,255,style_alpha8), IM_COL32(255,0,255,style_alpha8), IM_COL32(255,0,0,style_alpha8) };
 
    ImVec4 hue_color_f(1, 1, 1, style.Alpha); ColorConvertHSVtoRGB(H, 1, 1, hue_color_f.x, hue_color_f.y, hue_color_f.z);
    ImU32 hue_color32 = ColorConvertFloat4ToU32(hue_color_f);
    ImU32 user_col32_striped_of_alpha = ColorConvertFloat4ToU32(ImVec4(R, G, B, style.Alpha)); // Important: this is still including the main rendering/style alpha!!
 
    ImVec2 sv_cursor_pos;
 
    if (flags & ImGuiColorEditFlags_PickerHueWheel)
    {
        // Render Hue Wheel
        const float aeps = 0.5f / wheel_r_outer; // Half a pixel arc length in radians (2pi cancels out).
        const int segment_per_arc = ImMax(4, (int)wheel_r_outer / 12);
        for (int n = 0; n < 6; n++)
        {
            const float a0 = (n)     /6.0f * 2.0f * IM_PI - aeps;
            const float a1 = (n+1.0f)/6.0f * 2.0f * IM_PI + aeps;
            const int vert_start_idx = draw_list->VtxBuffer.Size;
            draw_list->PathArcTo(wheel_center, (wheel_r_inner + wheel_r_outer)*0.5f, a0, a1, segment_per_arc);
            draw_list->PathStroke(col_white, 0, wheel_thickness);
            const int vert_end_idx = draw_list->VtxBuffer.Size;
 
            // Paint colors over existing vertices
            ImVec2 gradient_p0(wheel_center.x + ImCos(a0) * wheel_r_inner, wheel_center.y + ImSin(a0) * wheel_r_inner);
            ImVec2 gradient_p1(wheel_center.x + ImCos(a1) * wheel_r_inner, wheel_center.y + ImSin(a1) * wheel_r_inner);
            ShadeVertsLinearColorGradientKeepAlpha(draw_list, vert_start_idx, vert_end_idx, gradient_p0, gradient_p1, col_hues[n], col_hues[n + 1]);
        }
 
        // Render Cursor + preview on Hue Wheel
        float cos_hue_angle = ImCos(H * 2.0f * IM_PI);
        float sin_hue_angle = ImSin(H * 2.0f * IM_PI);
        ImVec2 hue_cursor_pos(wheel_center.x + cos_hue_angle * (wheel_r_inner + wheel_r_outer) * 0.5f, wheel_center.y + sin_hue_angle * (wheel_r_inner + wheel_r_outer) * 0.5f);
        float hue_cursor_rad = value_changed_h ? wheel_thickness * 0.65f : wheel_thickness * 0.55f;
        int hue_cursor_segments = ImClamp((int)(hue_cursor_rad / 1.4f), 9, 32);
        draw_list->AddCircleFilled(hue_cursor_pos, hue_cursor_rad, hue_color32, hue_cursor_segments);
        draw_list->AddCircle(hue_cursor_pos, hue_cursor_rad + 1, col_midgrey, hue_cursor_segments);
        draw_list->AddCircle(hue_cursor_pos, hue_cursor_rad, col_white, hue_cursor_segments);
 
        // Render SV triangle (rotated according to hue)
        ImVec2 tra = wheel_center + ImRotate(triangle_pa, cos_hue_angle, sin_hue_angle);
        ImVec2 trb = wheel_center + ImRotate(triangle_pb, cos_hue_angle, sin_hue_angle);
        ImVec2 trc = wheel_center + ImRotate(triangle_pc, cos_hue_angle, sin_hue_angle);
        ImVec2 uv_white = GetFontTexUvWhitePixel();
        draw_list->PrimReserve(6, 6);
        draw_list->PrimVtx(tra, uv_white, hue_color32);
        draw_list->PrimVtx(trb, uv_white, hue_color32);
        draw_list->PrimVtx(trc, uv_white, col_white);
        draw_list->PrimVtx(tra, uv_white, 0);
        draw_list->PrimVtx(trb, uv_white, col_black);
        draw_list->PrimVtx(trc, uv_white, 0);
        draw_list->AddTriangle(tra, trb, trc, col_midgrey, 1.5f);
        sv_cursor_pos = ImLerp(ImLerp(trc, tra, ImSaturate(S)), trb, ImSaturate(1 - V));
    }
    else if (flags & ImGuiColorEditFlags_PickerHueBar)
    {
        // Render SV Square
        draw_list->AddRectFilledMultiColor(picker_pos, picker_pos + ImVec2(sv_picker_size, sv_picker_size), col_white, hue_color32, hue_color32, col_white);
        draw_list->AddRectFilledMultiColor(picker_pos, picker_pos + ImVec2(sv_picker_size, sv_picker_size), 0, 0, col_black, col_black);
        RenderFrameBorder(picker_pos, picker_pos + ImVec2(sv_picker_size, sv_picker_size), 0.0f);
        sv_cursor_pos.x = ImClamp(IM_ROUND(picker_pos.x + ImSaturate(S)     * sv_picker_size), picker_pos.x + 2, picker_pos.x + sv_picker_size - 2); // Sneakily prevent the circle to stick out too much
        sv_cursor_pos.y = ImClamp(IM_ROUND(picker_pos.y + ImSaturate(1 - V) * sv_picker_size), picker_pos.y + 2, picker_pos.y + sv_picker_size - 2);
 
        // Render Hue Bar
        for (int i = 0; i < 6; ++i)
            draw_list->AddRectFilledMultiColor(ImVec2(bar0_pos_x, picker_pos.y + i * (sv_picker_size / 6)), ImVec2(bar0_pos_x + bars_width, picker_pos.y + (i + 1) * (sv_picker_size / 6)), col_hues[i], col_hues[i], col_hues[i + 1], col_hues[i + 1]);
        float bar0_line_y = IM_ROUND(picker_pos.y + H * sv_picker_size);
        RenderFrameBorder(ImVec2(bar0_pos_x, picker_pos.y), ImVec2(bar0_pos_x + bars_width, picker_pos.y + sv_picker_size), 0.0f);
        RenderArrowsForVerticalBar(draw_list, ImVec2(bar0_pos_x - 1, bar0_line_y), ImVec2(bars_triangles_half_sz + 1, bars_triangles_half_sz), bars_width + 2.0f, style.Alpha);
    }
 
    // Render cursor/preview circle (clamp S/V within 0..1 range because floating points colors may lead HSV values to be out of range)
    float sv_cursor_rad = value_changed_sv ? 10.0f : 6.0f;
    draw_list->AddCircleFilled(sv_cursor_pos, sv_cursor_rad, user_col32_striped_of_alpha, 12);
    draw_list->AddCircle(sv_cursor_pos, sv_cursor_rad + 1, col_midgrey, 12);
    draw_list->AddCircle(sv_cursor_pos, sv_cursor_rad, col_white, 12);
 
    // Render alpha bar
    if (alpha_bar)
    {
        float alpha = ImSaturate(col[3]);
        ImRect bar1_bb(bar1_pos_x, picker_pos.y, bar1_pos_x + bars_width, picker_pos.y + sv_picker_size);
        RenderColorRectWithAlphaCheckerboard(draw_list, bar1_bb.Min, bar1_bb.Max, 0, bar1_bb.GetWidth() / 2.0f, ImVec2(0.0f, 0.0f));
        draw_list->AddRectFilledMultiColor(bar1_bb.Min, bar1_bb.Max, user_col32_striped_of_alpha, user_col32_striped_of_alpha, user_col32_striped_of_alpha & ~IM_COL32_A_MASK, user_col32_striped_of_alpha & ~IM_COL32_A_MASK);
        float bar1_line_y = IM_ROUND(picker_pos.y + (1.0f - alpha) * sv_picker_size);
        RenderFrameBorder(bar1_bb.Min, bar1_bb.Max, 0.0f);
        RenderArrowsForVerticalBar(draw_list, ImVec2(bar1_pos_x - 1, bar1_line_y), ImVec2(bars_triangles_half_sz + 1, bars_triangles_half_sz), bars_width + 2.0f, style.Alpha);
    }
 
    EndGroup();
 
    if (value_changed && memcmp(backup_initial_col, col, components * sizeof(float)) == 0)
        value_changed = false;
    if (value_changed)
        MarkItemEdited(window->DC.LastItemId);
 
    PopID();
 
    return value_changed;
}

Referenced by ColorEdit4(), ColorPicker3(), ColorPickerOptionsPopup(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ ColorPickerOptionsPopup()

void ImGui::ColorPickerOptionsPopup	(	const float *	ref_col,
		ImGuiColorEditFlags	flags
	)

{
    bool allow_opt_picker = !(flags & ImGuiColorEditFlags__PickerMask);
    bool allow_opt_alpha_bar = !(flags & ImGuiColorEditFlags_NoAlpha) && !(flags & ImGuiColorEditFlags_AlphaBar);
    if ((!allow_opt_picker && !allow_opt_alpha_bar) || !BeginPopup("context"))
        return;
    ImGuiContext& g = *GImGui;
    if (allow_opt_picker)
    {
        ImVec2 picker_size(g.FontSize * 8, ImMax(g.FontSize * 8 - (GetFrameHeight() + g.Style.ItemInnerSpacing.x), 1.0f)); // FIXME: Picker size copied from main picker function
        PushItemWidth(picker_size.x);
        for (int picker_type = 0; picker_type < 2; picker_type++)
        {
            // Draw small/thumbnail version of each picker type (over an invisible button for selection)
            if (picker_type > 0) Separator();
            PushID(picker_type);
            ImGuiColorEditFlags picker_flags = ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoOptions | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoSidePreview | (flags & ImGuiColorEditFlags_NoAlpha);
            if (picker_type == 0) picker_flags |= ImGuiColorEditFlags_PickerHueBar;
            if (picker_type == 1) picker_flags |= ImGuiColorEditFlags_PickerHueWheel;
            ImVec2 backup_pos = GetCursorScreenPos();
            if (Selectable("##selectable", false, 0, picker_size)) // By default, Selectable() is closing popup
                g.ColorEditOptions = (g.ColorEditOptions & ~ImGuiColorEditFlags__PickerMask) | (picker_flags & ImGuiColorEditFlags__PickerMask);
            SetCursorScreenPos(backup_pos);
            ImVec4 previewing_ref_col;
            memcpy(&previewing_ref_col, ref_col, sizeof(float) * ((picker_flags & ImGuiColorEditFlags_NoAlpha) ? 3 : 4));
            ColorPicker4("##previewing_picker", &previewing_ref_col.x, picker_flags);
            PopID();
        }
        PopItemWidth();
    }
    if (allow_opt_alpha_bar)
    {
        if (allow_opt_picker) Separator();
        CheckboxFlags("Alpha Bar", &g.ColorEditOptions, ImGuiColorEditFlags_AlphaBar);
    }
    EndPopup();
}

Referenced by ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ColorTooltip()

void ImGui::ColorTooltip	(	const char *	text,
		const float *	col,
		ImGuiColorEditFlags	flags
	)

{
    ImGuiContext& g = *GImGui;
 
    BeginTooltipEx(0, ImGuiTooltipFlags_OverridePreviousTooltip);
    const char* text_end = text ? FindRenderedTextEnd(text, NULL) : text;
    if (text_end > text)
    {
        TextEx(text, text_end);
        Separator();
    }
 
    ImVec2 sz(g.FontSize * 3 + g.Style.FramePadding.y * 2, g.FontSize * 3 + g.Style.FramePadding.y * 2);
    ImVec4 cf(col[0], col[1], col[2], (flags & ImGuiColorEditFlags_NoAlpha) ? 1.0f : col[3]);
    int cr = IM_F32_TO_INT8_SAT(col[0]), cg = IM_F32_TO_INT8_SAT(col[1]), cb = IM_F32_TO_INT8_SAT(col[2]), ca = (flags & ImGuiColorEditFlags_NoAlpha) ? 255 : IM_F32_TO_INT8_SAT(col[3]);
    ColorButton("##preview", cf, (flags & (ImGuiColorEditFlags__InputMask | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaPreviewHalf)) | ImGuiColorEditFlags_NoTooltip, sz);
    SameLine();
    if ((flags & ImGuiColorEditFlags_InputRGB) || !(flags & ImGuiColorEditFlags__InputMask))
    {
        if (flags & ImGuiColorEditFlags_NoAlpha)
            Text("#%02X%02X%02X\nR: %d, G: %d, B: %d\n(%.3f, %.3f, %.3f)", cr, cg, cb, cr, cg, cb, col[0], col[1], col[2]);
        else
            Text("#%02X%02X%02X%02X\nR:%d, G:%d, B:%d, A:%d\n(%.3f, %.3f, %.3f, %.3f)", cr, cg, cb, ca, cr, cg, cb, ca, col[0], col[1], col[2], col[3]);
    }
    else if (flags & ImGuiColorEditFlags_InputHSV)
    {
        if (flags & ImGuiColorEditFlags_NoAlpha)
            Text("H: %.3f, S: %.3f, V: %.3f", col[0], col[1], col[2]);
        else
            Text("H: %.3f, S: %.3f, V: %.3f, A: %.3f", col[0], col[1], col[2], col[3]);
    }
    EndTooltip();
}

References BeginTooltipEx(), col(), ColorButton(), EndTooltip(), FindRenderedTextEnd(), ImGuiContext::FontSize, ImGuiStyle::FramePadding, GImGui, IM_F32_TO_INT8_SAT, ImGuiColorEditFlags__InputMask, ImGuiColorEditFlags_AlphaPreview, ImGuiColorEditFlags_AlphaPreviewHalf, ImGuiColorEditFlags_InputHSV, ImGuiColorEditFlags_InputRGB, ImGuiColorEditFlags_NoAlpha, ImGuiColorEditFlags_NoTooltip, ImGuiTooltipFlags_OverridePreviousTooltip, SameLine(), Separator(), ImGuiContext::Style, Text(), TextEx(), and ImVec2::y.

Referenced by ColorButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Columns()

void ImGui::Columns	(	int	count = `1`,
		const char *	id = `NULL`,
		bool	border = `true`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    IM_ASSERT(columns_count >= 1);
 
    ImGuiOldColumnFlags flags = (border ? 0 : ImGuiOldColumnFlags_NoBorder);
    //flags |= ImGuiOldColumnFlags_NoPreserveWidths; // NB: Legacy behavior
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns != NULL && columns->Count == columns_count && columns->Flags == flags)
        return;
 
    if (columns != NULL)
        EndColumns();
 
    if (columns_count != 1)
        BeginColumns(id, columns_count, flags);
}

References BeginColumns(), ImGuiOldColumns::Count, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, EndColumns(), ImGuiOldColumns::Flags, GetCurrentWindow(), IM_ASSERT, and ImGuiOldColumnFlags_NoBorder.

Referenced by GetColumnOffset(), SetColumnOffset(), ShowDemoWindowColumns(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Combo() [1/5]

IMGUI_API bool ImGui::Combo	(	const char *	label,
		int *	current_item,
		bool()(void data, int idx, const char **out_text)	items_getter,
		void *	data,
		int	items_count,
		int	popup_max_height_in_items = `-1`
	)

◆ Combo() [2/5]

bool ImGui::Combo	(	const char *	label,
		int *	current_item,
		const char *const	items[],
		int	items_count,
		int	popup_max_height_in_items = `-1`
	)

{
    const bool value_changed = Combo(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_in_items);
    return value_changed;
}

References Combo(), and Items_ArrayGetter().

Referenced by Combo(), Combo(), Combo(), Combo(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppConstrainedResize(), ShowExampleAppLongText(), ShowExampleMenuFile(), ShowMetricsWindow(), ShowStyleEditor(), and ShowStyleSelector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Combo() [3/5]

bool ImGui::Combo	(	const char *	label,
		int *	current_item,
		const char *	items_separated_by_zeros,
		int	popup_max_height_in_items = `-1`
	)

{
    int items_count = 0;
    const char* p = items_separated_by_zeros;       // FIXME-OPT: Avoid computing this, or at least only when combo is open
    while (*p)
    {
        p += strlen(p) + 1;
        items_count++;
    }
    bool value_changed = Combo(label, current_item, Items_SingleStringGetter, (void*)items_separated_by_zeros, items_count, height_in_items);
    return value_changed;
}

References Combo(), and Items_SingleStringGetter().

Here is the call graph for this function:

◆ Combo() [4/5]

bool ImGui::Combo	(	const char *	label,
		int *	idx,
		std::function< const char *(int)>	getter,
		int	items_count
	)

inline

{
  auto func = [](void* data, int i, const char** out_text) {
    auto &getter = *reinterpret_cast<std::function<const char *(int)> *>(data);
    const char *s = getter(i);
    if (s) { *out_text = s; return true; }
    else { return false; }
  };
  return Combo(label, idx, func, reinterpret_cast<void *>(&getter), items_count);
}

References Combo().

Here is the call graph for this function:

◆ Combo() [5/5]

bool ImGui::Combo	(	const char *	label,
		int *	idx,
		std::vector< std::string > &	values
	)

inline

{
  if (values.empty()) { return false; }
  return Combo(label, idx, vector_getter,
    static_cast<void*>(&values), values.size());
}

References Combo(), and vector_getter.

Here is the call graph for this function:

◆ CreateContext()

ImGuiContext * ImGui::CreateContext ( ImFontAtlas * shared_font_atlas = NULL )

{
    ImGuiContext* ctx = IM_NEW(ImGuiContext)(shared_font_atlas);
    if (GImGui == NULL)
        SetCurrentContext(ctx);
    Initialize(ctx);
    return ctx;
}

References GImGui, IM_NEW, Initialize(), and SetCurrentContext().

Referenced by Slic3r::GUI::ImGuiWrapper::ImGuiWrapper(), and igl::opengl::glfw::imgui::ImGuiMenu::init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateNewWindowSettings()

ImGuiWindowSettings * ImGui::CreateNewWindowSettings ( const char * name )

{
    ImGuiContext& g = *GImGui;
 
#if !IMGUI_DEBUG_INI_SETTINGS
    // Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
    // Preserve the full string when IMGUI_DEBUG_INI_SETTINGS is set to make .ini inspection easier.
    if (const char* p = strstr(name, "###"))
        name = p;
#endif
    const size_t name_len = strlen(name);
 
    // Allocate chunk
    const size_t chunk_size = sizeof(ImGuiWindowSettings) + name_len + 1;
    ImGuiWindowSettings* settings = g.SettingsWindows.alloc_chunk(chunk_size);
    IM_PLACEMENT_NEW(settings) ImGuiWindowSettings();
    settings->ID = ImHashStr(name, name_len);
    memcpy(settings->GetName(), name, name_len + 1);   // Store with zero terminator
 
    return settings;
}

References ImChunkStream< T >::alloc_chunk(), ImGuiWindowSettings::GetName(), GImGui, ImGuiWindowSettings::ID, IM_PLACEMENT_NEW, ImHashStr(), and ImGuiContext::SettingsWindows.

Referenced by FindOrCreateWindowSettings(), and WindowSettingsHandler_WriteAll().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DataTypeApplyOp()

void ImGui::DataTypeApplyOp	(	ImGuiDataType	data_type,
		int	op,
		void *	output,
		const void *	arg_1,
		const void *	arg_2
	)

{
    IM_ASSERT(op == '+' || op == '-');
    switch (data_type)
    {
        case ImGuiDataType_S8:
            if (op == '+') { *(ImS8*)output  = ImAddClampOverflow(*(const ImS8*)arg1,  *(const ImS8*)arg2,  IM_S8_MIN,  IM_S8_MAX); }
            if (op == '-') { *(ImS8*)output  = ImSubClampOverflow(*(const ImS8*)arg1,  *(const ImS8*)arg2,  IM_S8_MIN,  IM_S8_MAX); }
            return;
        case ImGuiDataType_U8:
            if (op == '+') { *(ImU8*)output  = ImAddClampOverflow(*(const ImU8*)arg1,  *(const ImU8*)arg2,  IM_U8_MIN,  IM_U8_MAX); }
            if (op == '-') { *(ImU8*)output  = ImSubClampOverflow(*(const ImU8*)arg1,  *(const ImU8*)arg2,  IM_U8_MIN,  IM_U8_MAX); }
            return;
        case ImGuiDataType_S16:
            if (op == '+') { *(ImS16*)output = ImAddClampOverflow(*(const ImS16*)arg1, *(const ImS16*)arg2, IM_S16_MIN, IM_S16_MAX); }
            if (op == '-') { *(ImS16*)output = ImSubClampOverflow(*(const ImS16*)arg1, *(const ImS16*)arg2, IM_S16_MIN, IM_S16_MAX); }
            return;
        case ImGuiDataType_U16:
            if (op == '+') { *(ImU16*)output = ImAddClampOverflow(*(const ImU16*)arg1, *(const ImU16*)arg2, IM_U16_MIN, IM_U16_MAX); }
            if (op == '-') { *(ImU16*)output = ImSubClampOverflow(*(const ImU16*)arg1, *(const ImU16*)arg2, IM_U16_MIN, IM_U16_MAX); }
            return;
        case ImGuiDataType_S32:
            if (op == '+') { *(ImS32*)output = ImAddClampOverflow(*(const ImS32*)arg1, *(const ImS32*)arg2, IM_S32_MIN, IM_S32_MAX); }
            if (op == '-') { *(ImS32*)output = ImSubClampOverflow(*(const ImS32*)arg1, *(const ImS32*)arg2, IM_S32_MIN, IM_S32_MAX); }
            return;
        case ImGuiDataType_U32:
            if (op == '+') { *(ImU32*)output = ImAddClampOverflow(*(const ImU32*)arg1, *(const ImU32*)arg2, IM_U32_MIN, IM_U32_MAX); }
            if (op == '-') { *(ImU32*)output = ImSubClampOverflow(*(const ImU32*)arg1, *(const ImU32*)arg2, IM_U32_MIN, IM_U32_MAX); }
            return;
        case ImGuiDataType_S64:
            if (op == '+') { *(ImS64*)output = ImAddClampOverflow(*(const ImS64*)arg1, *(const ImS64*)arg2, IM_S64_MIN, IM_S64_MAX); }
            if (op == '-') { *(ImS64*)output = ImSubClampOverflow(*(const ImS64*)arg1, *(const ImS64*)arg2, IM_S64_MIN, IM_S64_MAX); }
            return;
        case ImGuiDataType_U64:
            if (op == '+') { *(ImU64*)output = ImAddClampOverflow(*(const ImU64*)arg1, *(const ImU64*)arg2, IM_U64_MIN, IM_U64_MAX); }
            if (op == '-') { *(ImU64*)output = ImSubClampOverflow(*(const ImU64*)arg1, *(const ImU64*)arg2, IM_U64_MIN, IM_U64_MAX); }
            return;
        case ImGuiDataType_Float:
            if (op == '+') { *(float*)output = *(const float*)arg1 + *(const float*)arg2; }
            if (op == '-') { *(float*)output = *(const float*)arg1 - *(const float*)arg2; }
            return;
        case ImGuiDataType_Double:
            if (op == '+') { *(double*)output = *(const double*)arg1 + *(const double*)arg2; }
            if (op == '-') { *(double*)output = *(const double*)arg1 - *(const double*)arg2; }
            return;
        case ImGuiDataType_COUNT: break;
    }
    IM_ASSERT(0);
}

References IM_ASSERT, IM_S16_MAX, IM_S16_MIN, IM_S32_MAX, IM_S32_MIN, IM_S64_MAX, IM_S64_MIN, IM_S8_MAX, IM_S8_MIN, IM_U16_MAX, IM_U16_MIN, IM_U32_MAX, IM_U32_MIN, IM_U64_MAX, IM_U64_MIN, IM_U8_MAX, IM_U8_MIN, ImAddClampOverflow(), ImGuiDataType_COUNT, ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, ImGuiDataType_U8, and ImSubClampOverflow().

Referenced by InputScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DataTypeApplyOpFromText()

bool ImGui::DataTypeApplyOpFromText	(	const char *	buf,
		const char *	initial_value_buf,
		ImGuiDataType	data_type,
		void *	p_data,
		const char *	format
	)

{
    while (ImCharIsBlankA(*buf))
        buf++;
 
    // We don't support '-' op because it would conflict with inputing negative value.
    // Instead you can use +-100 to subtract from an existing value
    char op = buf[0];
    if (op == '+' || op == '*' || op == '/')
    {
        buf++;
        while (ImCharIsBlankA(*buf))
            buf++;
    }
    else
    {
        op = 0;
    }
    if (!buf[0])
        return false;
 
    // Copy the value in an opaque buffer so we can compare at the end of the function if it changed at all.
    const ImGuiDataTypeInfo* type_info = DataTypeGetInfo(data_type);
    ImGuiDataTypeTempStorage data_backup;
    memcpy(&data_backup, p_data, type_info->Size);
 
    if (format == NULL)
        format = type_info->ScanFmt;
 
    // FIXME-LEGACY: The aim is to remove those operators and write a proper expression evaluator at some point..
    int arg1i = 0;
    if (data_type == ImGuiDataType_S32)
    {
        int* v = (int*)p_data;
        int arg0i = *v;
        float arg1f = 0.0f;
        if (op && sscanf(initial_value_buf, format, &arg0i) < 1)
            return false;
        // Store operand in a float so we can use fractional value for multipliers (*1.1), but constant always parsed as integer so we can fit big integers (e.g. 2000000003) past float precision
        if (op == '+')      { if (sscanf(buf, "%d", &arg1i)) *v = (int)(arg0i + arg1i); }                   // Add (use "+-" to subtract)
        else if (op == '*') { if (sscanf(buf, "%f", &arg1f)) *v = (int)(arg0i * arg1f); }                   // Multiply
        else if (op == '/') { if (sscanf(buf, "%f", &arg1f) && arg1f != 0.0f) *v = (int)(arg0i / arg1f); }  // Divide
        else                { if (sscanf(buf, format, &arg1i) == 1) *v = arg1i; }                           // Assign constant
    }
    else if (data_type == ImGuiDataType_Float)
    {
        // For floats we have to ignore format with precision (e.g. "%.2f") because sscanf doesn't take them in
        format = "%f";
        float* v = (float*)p_data;
        float arg0f = *v, arg1f = 0.0f;
        if (op && sscanf(initial_value_buf, format, &arg0f) < 1)
            return false;
        if (sscanf(buf, format, &arg1f) < 1)
            return false;
        if (op == '+')      { *v = arg0f + arg1f; }                    // Add (use "+-" to subtract)
        else if (op == '*') { *v = arg0f * arg1f; }                    // Multiply
        else if (op == '/') { if (arg1f != 0.0f) *v = arg0f / arg1f; } // Divide
        else                { *v = arg1f; }                            // Assign constant
    }
    else if (data_type == ImGuiDataType_Double)
    {
        format = "%lf"; // scanf differentiate float/double unlike printf which forces everything to double because of ellipsis
        double* v = (double*)p_data;
        double arg0f = *v, arg1f = 0.0;
        if (op && sscanf(initial_value_buf, format, &arg0f) < 1)
            return false;
        if (sscanf(buf, format, &arg1f) < 1)
            return false;
        if (op == '+')      { *v = arg0f + arg1f; }                    // Add (use "+-" to subtract)
        else if (op == '*') { *v = arg0f * arg1f; }                    // Multiply
        else if (op == '/') { if (arg1f != 0.0f) *v = arg0f / arg1f; } // Divide
        else                { *v = arg1f; }                            // Assign constant
    }
    else if (data_type == ImGuiDataType_U32 || data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)
    {
        // All other types assign constant
        // We don't bother handling support for legacy operators since they are a little too crappy. Instead we will later implement a proper expression evaluator in the future.
        if (sscanf(buf, format, p_data) < 1)
            return false;
    }
    else
    {
        // Small types need a 32-bit buffer to receive the result from scanf()
        int v32;
        if (sscanf(buf, format, &v32) < 1)
            return false;
        if (data_type == ImGuiDataType_S8)
            *(ImS8*)p_data = (ImS8)ImClamp(v32, (int)IM_S8_MIN, (int)IM_S8_MAX);
        else if (data_type == ImGuiDataType_U8)
            *(ImU8*)p_data = (ImU8)ImClamp(v32, (int)IM_U8_MIN, (int)IM_U8_MAX);
        else if (data_type == ImGuiDataType_S16)
            *(ImS16*)p_data = (ImS16)ImClamp(v32, (int)IM_S16_MIN, (int)IM_S16_MAX);
        else if (data_type == ImGuiDataType_U16)
            *(ImU16*)p_data = (ImU16)ImClamp(v32, (int)IM_U16_MIN, (int)IM_U16_MAX);
        else
            IM_ASSERT(0);
    }
 
    return memcmp(&data_backup, p_data, type_info->Size) != 0;
}

References DataTypeGetInfo(), IM_ASSERT, IM_S16_MAX, IM_S16_MIN, IM_S8_MAX, IM_S8_MIN, IM_U16_MAX, IM_U16_MIN, IM_U8_MAX, IM_U8_MIN, ImCharIsBlankA(), ImClamp(), ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, ImGuiDataType_U8, ImGuiDataTypeInfo::ScanFmt, and ImGuiDataTypeInfo::Size.

Referenced by InputScalar(), and TempInputScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DataTypeClamp()

bool ImGui::DataTypeClamp	(	ImGuiDataType	data_type,
		void *	p_data,
		const void *	p_min,
		const void *	p_max
	)

{
    switch (data_type)
    {
    case ImGuiDataType_S8:     return DataTypeClampT<ImS8  >((ImS8*  )p_data, (const ImS8*  )p_min, (const ImS8*  )p_max);
    case ImGuiDataType_U8:     return DataTypeClampT<ImU8  >((ImU8*  )p_data, (const ImU8*  )p_min, (const ImU8*  )p_max);
    case ImGuiDataType_S16:    return DataTypeClampT<ImS16 >((ImS16* )p_data, (const ImS16* )p_min, (const ImS16* )p_max);
    case ImGuiDataType_U16:    return DataTypeClampT<ImU16 >((ImU16* )p_data, (const ImU16* )p_min, (const ImU16* )p_max);
    case ImGuiDataType_S32:    return DataTypeClampT<ImS32 >((ImS32* )p_data, (const ImS32* )p_min, (const ImS32* )p_max);
    case ImGuiDataType_U32:    return DataTypeClampT<ImU32 >((ImU32* )p_data, (const ImU32* )p_min, (const ImU32* )p_max);
    case ImGuiDataType_S64:    return DataTypeClampT<ImS64 >((ImS64* )p_data, (const ImS64* )p_min, (const ImS64* )p_max);
    case ImGuiDataType_U64:    return DataTypeClampT<ImU64 >((ImU64* )p_data, (const ImU64* )p_min, (const ImU64* )p_max);
    case ImGuiDataType_Float:  return DataTypeClampT<float >((float* )p_data, (const float* )p_min, (const float* )p_max);
    case ImGuiDataType_Double: return DataTypeClampT<double>((double*)p_data, (const double*)p_min, (const double*)p_max);
    case ImGuiDataType_COUNT:  break;
    }
    IM_ASSERT(0);
    return false;
}

References IM_ASSERT, ImGuiDataType_COUNT, ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, and ImGuiDataType_U8.

Referenced by TempInputScalar().

Here is the caller graph for this function:

◆ DataTypeCompare()

int ImGui::DataTypeCompare	(	ImGuiDataType	data_type,
		const void *	arg_1,
		const void *	arg_2
	)

{
    switch (data_type)
    {
    case ImGuiDataType_S8:     return DataTypeCompareT<ImS8  >((const ImS8*  )arg_1, (const ImS8*  )arg_2);
    case ImGuiDataType_U8:     return DataTypeCompareT<ImU8  >((const ImU8*  )arg_1, (const ImU8*  )arg_2);
    case ImGuiDataType_S16:    return DataTypeCompareT<ImS16 >((const ImS16* )arg_1, (const ImS16* )arg_2);
    case ImGuiDataType_U16:    return DataTypeCompareT<ImU16 >((const ImU16* )arg_1, (const ImU16* )arg_2);
    case ImGuiDataType_S32:    return DataTypeCompareT<ImS32 >((const ImS32* )arg_1, (const ImS32* )arg_2);
    case ImGuiDataType_U32:    return DataTypeCompareT<ImU32 >((const ImU32* )arg_1, (const ImU32* )arg_2);
    case ImGuiDataType_S64:    return DataTypeCompareT<ImS64 >((const ImS64* )arg_1, (const ImS64* )arg_2);
    case ImGuiDataType_U64:    return DataTypeCompareT<ImU64 >((const ImU64* )arg_1, (const ImU64* )arg_2);
    case ImGuiDataType_Float:  return DataTypeCompareT<float >((const float* )arg_1, (const float* )arg_2);
    case ImGuiDataType_Double: return DataTypeCompareT<double>((const double*)arg_1, (const double*)arg_2);
    case ImGuiDataType_COUNT:  break;
    }
    IM_ASSERT(0);
    return 0;
}

References IM_ASSERT, ImGuiDataType_COUNT, ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, and ImGuiDataType_U8.

Referenced by DragScalar(), and TempInputScalar().

Here is the caller graph for this function:

◆ DataTypeFormatString()

int ImGui::DataTypeFormatString	(	char *	buf,
		int	buf_size,
		ImGuiDataType	data_type,
		const void *	p_data,
		const char *	format
	)

{
    // Signedness doesn't matter when pushing integer arguments
    if (data_type == ImGuiDataType_S32 || data_type == ImGuiDataType_U32)
        return ImFormatString(buf, buf_size, format, *(const ImU32*)p_data);
    if (data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)
        return ImFormatString(buf, buf_size, format, *(const ImU64*)p_data);
    if (data_type == ImGuiDataType_Float)
        return ImFormatString(buf, buf_size, format, *(const float*)p_data);
    if (data_type == ImGuiDataType_Double)
        return ImFormatString(buf, buf_size, format, *(const double*)p_data);
    if (data_type == ImGuiDataType_S8)
        return ImFormatString(buf, buf_size, format, *(const ImS8*)p_data);
    if (data_type == ImGuiDataType_U8)
        return ImFormatString(buf, buf_size, format, *(const ImU8*)p_data);
    if (data_type == ImGuiDataType_S16)
        return ImFormatString(buf, buf_size, format, *(const ImS16*)p_data);
    if (data_type == ImGuiDataType_U16)
        return ImFormatString(buf, buf_size, format, *(const ImU16*)p_data);
    IM_ASSERT(0);
    return 0;
}

References IM_ASSERT, ImFormatString(), ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, and ImGuiDataType_U8.

Referenced by DragScalar(), InputScalar(), SliderScalar(), TempInputScalar(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DataTypeGetInfo()

const ImGuiDataTypeInfo * ImGui::DataTypeGetInfo ( ImGuiDataType data_type )

{
    IM_ASSERT(data_type >= 0 && data_type < ImGuiDataType_COUNT);
    return &GDataTypeInfo[data_type];
}

References GDataTypeInfo, IM_ASSERT, and ImGuiDataType_COUNT.

Referenced by DataTypeApplyOpFromText(), DragScalar(), InputScalar(), SliderScalar(), TempInputScalar(), and VSliderScalar().

Here is the caller graph for this function:

◆ DebugCheckVersionAndDataLayout()

bool ImGui::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
	)

{
    bool error = false;
    if (strcmp(version, IMGUI_VERSION) != 0) { error = true; IM_ASSERT(strcmp(version, IMGUI_VERSION) == 0 && "Mismatched version string!"); }
    if (sz_io != sizeof(ImGuiIO)) { error = true; IM_ASSERT(sz_io == sizeof(ImGuiIO) && "Mismatched struct layout!"); }
    if (sz_style != sizeof(ImGuiStyle)) { error = true; IM_ASSERT(sz_style == sizeof(ImGuiStyle) && "Mismatched struct layout!"); }
    if (sz_vec2 != sizeof(ImVec2)) { error = true; IM_ASSERT(sz_vec2 == sizeof(ImVec2) && "Mismatched struct layout!"); }
    if (sz_vec4 != sizeof(ImVec4)) { error = true; IM_ASSERT(sz_vec4 == sizeof(ImVec4) && "Mismatched struct layout!"); }
    if (sz_vert != sizeof(ImDrawVert)) { error = true; IM_ASSERT(sz_vert == sizeof(ImDrawVert) && "Mismatched struct layout!"); }
    if (sz_idx != sizeof(ImDrawIdx)) { error = true; IM_ASSERT(sz_idx == sizeof(ImDrawIdx) && "Mismatched struct layout!"); }
    return !error;
}

References error, IM_ASSERT, IMGUI_VERSION, and version.

◆ DebugDrawItemRect()

void ImGui::DebugDrawItemRect ( ImU32 col = IM_COL32(255,0,0,255) )

inline

2613{ ImGuiContext& g = *GImGui; ImGuiWindow* window = g.CurrentWindow; GetForegroundDrawList(window)->AddRect(window->DC.LastItemRect.Min, window->DC.LastItemRect.Max, col); }

GImGui

IMGUI_API ImGuiContext * GImGui

Definition imgui.cpp:960

ImGui::GetForegroundDrawList

IMGUI_API ImDrawList * GetForegroundDrawList()

Definition imgui.cpp:3503

References ImDrawList::AddRect(), col(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, GetForegroundDrawList(), GImGui, ImGuiWindowTempData::LastItemRect, ImRect::Max, and ImRect::Min.

Here is the call graph for this function:

◆ DebugNodeColumns()

void ImGui::DebugNodeColumns ( ImGuiOldColumns * columns )

{
    if (!TreeNode((void*)(uintptr_t)columns->ID, "Columns Id: 0x%08X, Count: %d, Flags: 0x%04X", columns->ID, columns->Count, columns->Flags))
        return;
    BulletText("Width: %.1f (MinX: %.1f, MaxX: %.1f)", columns->OffMaxX - columns->OffMinX, columns->OffMinX, columns->OffMaxX);
    for (int column_n = 0; column_n < columns->Columns.Size; column_n++)
        BulletText("Column %02d: OffsetNorm %.3f (= %.1f px)", column_n, columns->Columns[column_n].OffsetNorm, GetColumnOffsetFromNorm(columns, columns->Columns[column_n].OffsetNorm));
    TreePop();
}

References BulletText(), ImGuiOldColumns::Columns, ImGuiOldColumns::Count, ImGuiOldColumns::Flags, GetColumnOffsetFromNorm(), ImGuiOldColumns::ID, ImGuiOldColumns::OffMaxX, ImGuiOldColumns::OffMinX, ImVector< T >::Size, TreeNode(), and TreePop().

Referenced by DebugNodeWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeDrawCmdShowMeshAndBoundingBox()

void ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox	(	ImDrawList *	out_draw_list,
		const ImDrawList *	draw_list,
		const ImDrawCmd *	draw_cmd,
		bool	show_mesh,
		bool	show_aabb
	)

{
    IM_ASSERT(show_mesh || show_aabb);
    ImDrawIdx* idx_buffer = (draw_list->IdxBuffer.Size > 0) ? draw_list->IdxBuffer.Data : NULL;
    ImDrawVert* vtx_buffer = draw_list->VtxBuffer.Data + draw_cmd->VtxOffset;
 
    // Draw wire-frame version of all triangles
    ImRect clip_rect = draw_cmd->ClipRect;
    ImRect vtxs_rect(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
    ImDrawListFlags backup_flags = out_draw_list->Flags;
    out_draw_list->Flags &= ~ImDrawListFlags_AntiAliasedLines; // Disable AA on triangle outlines is more readable for very large and thin triangles.
    for (unsigned int idx_n = draw_cmd->IdxOffset; idx_n < draw_cmd->IdxOffset + draw_cmd->ElemCount; )
    {
        ImVec2 triangle[3];
        for (int n = 0; n < 3; n++, idx_n++)
            vtxs_rect.Add((triangle[n] = vtx_buffer[idx_buffer ? idx_buffer[idx_n] : idx_n].pos));
        if (show_mesh)
            out_draw_list->AddPolyline(triangle, 3, IM_COL32(255, 255, 0, 255), ImDrawFlags_Closed, 1.0f); // In yellow: mesh triangles
    }
    // Draw bounding boxes
    if (show_aabb)
    {
        out_draw_list->AddRect(ImFloor(clip_rect.Min), ImFloor(clip_rect.Max), IM_COL32(255, 0, 255, 255)); // In pink: clipping rectangle submitted to GPU
        out_draw_list->AddRect(ImFloor(vtxs_rect.Min), ImFloor(vtxs_rect.Max), IM_COL32(0, 255, 255, 255)); // In cyan: bounding box of triangles
    }
    out_draw_list->Flags = backup_flags;
}

References ImRect::Add(), ImDrawList::AddPolyline(), ImDrawList::AddRect(), ImDrawCmd::ClipRect, ImVector< T >::Data, ImDrawCmd::ElemCount, ImDrawList::Flags, ImDrawList::IdxBuffer, ImDrawCmd::IdxOffset, IM_ASSERT, IM_COL32, ImDrawFlags_Closed, ImFloor(), ImRect::Max, ImRect::Min, ImDrawVert::pos, ImVector< T >::Size, ImDrawList::VtxBuffer, and ImDrawCmd::VtxOffset.

Referenced by DebugNodeDrawList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeDrawList()

void ImGui::DebugNodeDrawList	(	ImGuiWindow *	window,
		const ImDrawList *	draw_list,
		const char *	label
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiMetricsConfig* cfg = &g.DebugMetricsConfig;
    int cmd_count = draw_list->CmdBuffer.Size;
    if (cmd_count > 0 && draw_list->CmdBuffer.back().ElemCount == 0 && draw_list->CmdBuffer.back().UserCallback == NULL)
        cmd_count--;
    bool node_open = TreeNode(draw_list, "%s: '%s' %d vtx, %d indices, %d cmds", label, draw_list->_OwnerName ? draw_list->_OwnerName : "", draw_list->VtxBuffer.Size, draw_list->IdxBuffer.Size, cmd_count);
    if (draw_list == GetWindowDrawList())
    {
        SameLine();
        TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "CURRENTLY APPENDING"); // Can't display stats for active draw list! (we don't have the data double-buffered)
        if (node_open)
            TreePop();
        return;
    }
 
    ImDrawList* fg_draw_list = GetForegroundDrawList(window); // Render additional visuals into the top-most draw list
    if (window && IsItemHovered())
        fg_draw_list->AddRect(window->Pos, window->Pos + window->Size, IM_COL32(255, 255, 0, 255));
    if (!node_open)
        return;
 
    if (window && !window->WasActive)
        TextDisabled("Warning: owning Window is inactive. This DrawList is not being rendered!");
 
    for (const ImDrawCmd* pcmd = draw_list->CmdBuffer.Data; pcmd < draw_list->CmdBuffer.Data + cmd_count; pcmd++)
    {
        if (pcmd->UserCallback)
        {
            BulletText("Callback %p, user_data %p", pcmd->UserCallback, pcmd->UserCallbackData);
            continue;
        }
 
        char buf[300];
        ImFormatString(buf, IM_ARRAYSIZE(buf), "DrawCmd:%5d tris, Tex 0x%p, ClipRect (%4.0f,%4.0f)-(%4.0f,%4.0f)",
            pcmd->ElemCount / 3, (void*)(intptr_t)pcmd->TextureId,
            pcmd->ClipRect.x, pcmd->ClipRect.y, pcmd->ClipRect.z, pcmd->ClipRect.w);
        bool pcmd_node_open = TreeNode((void*)(pcmd - draw_list->CmdBuffer.begin()), "%s", buf);
        if (IsItemHovered() && (cfg->ShowDrawCmdMesh || cfg->ShowDrawCmdBoundingBoxes) && fg_draw_list)
            DebugNodeDrawCmdShowMeshAndBoundingBox(fg_draw_list, draw_list, pcmd, cfg->ShowDrawCmdMesh, cfg->ShowDrawCmdBoundingBoxes);
        if (!pcmd_node_open)
            continue;
 
        // Calculate approximate coverage area (touched pixel count)
        // This will be in pixels squared as long there's no post-scaling happening to the renderer output.
        const ImDrawIdx* idx_buffer = (draw_list->IdxBuffer.Size > 0) ? draw_list->IdxBuffer.Data : NULL;
        const ImDrawVert* vtx_buffer = draw_list->VtxBuffer.Data + pcmd->VtxOffset;
        float total_area = 0.0f;
        for (unsigned int idx_n = pcmd->IdxOffset; idx_n < pcmd->IdxOffset + pcmd->ElemCount; )
        {
            ImVec2 triangle[3];
            for (int n = 0; n < 3; n++, idx_n++)
                triangle[n] = vtx_buffer[idx_buffer ? idx_buffer[idx_n] : idx_n].pos;
            total_area += ImTriangleArea(triangle[0], triangle[1], triangle[2]);
        }
 
        // Display vertex information summary. Hover to get all triangles drawn in wire-frame
        ImFormatString(buf, IM_ARRAYSIZE(buf), "Mesh: ElemCount: %d, VtxOffset: +%d, IdxOffset: +%d, Area: ~%0.f px", pcmd->ElemCount, pcmd->VtxOffset, pcmd->IdxOffset, total_area);
        Selectable(buf);
        if (IsItemHovered() && fg_draw_list)
            DebugNodeDrawCmdShowMeshAndBoundingBox(fg_draw_list, draw_list, pcmd, true, false);
 
        // Display individual triangles/vertices. Hover on to get the corresponding triangle highlighted.
        ImGuiListClipper clipper;
        clipper.Begin(pcmd->ElemCount / 3); // Manually coarse clip our print out of individual vertices to save CPU, only items that may be visible.
        while (clipper.Step())
            for (int prim = clipper.DisplayStart, idx_i = pcmd->IdxOffset + clipper.DisplayStart * 3; prim < clipper.DisplayEnd; prim++)
            {
                char* buf_p = buf, * buf_end = buf + IM_ARRAYSIZE(buf);
                ImVec2 triangle[3];
                for (int n = 0; n < 3; n++, idx_i++)
                {
                    const ImDrawVert& v = vtx_buffer[idx_buffer ? idx_buffer[idx_i] : idx_i];
                    triangle[n] = v.pos;
                    buf_p += ImFormatString(buf_p, buf_end - buf_p, "%s %04d: pos (%8.2f,%8.2f), uv (%.6f,%.6f), col %08X\n",
                        (n == 0) ? "Vert:" : "     ", idx_i, v.pos.x, v.pos.y, v.uv.x, v.uv.y, v.col);
                }
 
                Selectable(buf, false);
                if (fg_draw_list && IsItemHovered())
                {
                    ImDrawListFlags backup_flags = fg_draw_list->Flags;
                    fg_draw_list->Flags &= ~ImDrawListFlags_AntiAliasedLines; // Disable AA on triangle outlines is more readable for very large and thin triangles.
                    fg_draw_list->AddPolyline(triangle, 3, IM_COL32(255, 255, 0, 255), ImDrawFlags_Closed, 1.0f);
                    fg_draw_list->Flags = backup_flags;
                }
            }
        TreePop();
    }
    TreePop();
}

References ImDrawList::_OwnerName, ImDrawList::AddPolyline(), ImDrawList::AddRect(), ImVector< T >::back(), ImVector< T >::begin(), ImGuiListClipper::Begin(), BulletText(), ImDrawList::CmdBuffer, ImDrawVert::col, ImVector< T >::Data, ImGuiContext::DebugMetricsConfig, DebugNodeDrawCmdShowMeshAndBoundingBox(), ImGuiListClipper::DisplayEnd, ImGuiListClipper::DisplayStart, ImDrawCmd::ElemCount, ImDrawList::Flags, GetForegroundDrawList(), GetWindowDrawList(), GImGui, ImDrawList::IdxBuffer, IM_ARRAYSIZE, IM_COL32, ImDrawFlags_Closed, ImFormatString(), ImTriangleArea(), IsItemHovered(), ImDrawVert::pos, ImGuiWindow::Pos, SameLine(), Selectable(), ImGuiMetricsConfig::ShowDrawCmdBoundingBoxes, ImGuiMetricsConfig::ShowDrawCmdMesh, ImVector< T >::Size, ImGuiWindow::Size, ImGuiListClipper::Step(), TextColored(), TextDisabled(), TreeNode(), TreePop(), ImDrawCmd::UserCallback, ImDrawVert::uv, ImDrawList::VtxBuffer, ImGuiWindow::WasActive, ImVec2::x, and ImVec2::y.

Referenced by DebugNodeViewport(), DebugNodeWindow(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeStorage()

void ImGui::DebugNodeStorage	(	ImGuiStorage *	storage,
		const char *	label
	)

{
    if (!TreeNode(label, "%s: %d entries, %d bytes", label, storage->Data.Size, storage->Data.size_in_bytes()))
        return;
    for (int n = 0; n < storage->Data.Size; n++)
    {
        const ImGuiStorage::ImGuiStoragePair& p = storage->Data[n];
        BulletText("Key 0x%08X Value { i: %d }", p.key, p.val_i); // Important: we currently don't store a type, real value may not be integer.
    }
    TreePop();
}

References BulletText(), ImGuiStorage::Data, ImGuiStorage::ImGuiStoragePair::key, TreeNode(), and TreePop().

Referenced by DebugNodeWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeTabBar()

void ImGui::DebugNodeTabBar	(	ImGuiTabBar *	tab_bar,
		const char *	label
	)

{
    // Standalone tab bars (not associated to docking/windows functionality) currently hold no discernible strings.
    char buf[256];
    char* p = buf;
    const char* buf_end = buf + IM_ARRAYSIZE(buf);
    const bool is_active = (tab_bar->PrevFrameVisible >= GetFrameCount() - 2);
    p += ImFormatString(p, buf_end - p, "%s 0x%08X (%d tabs)%s", label, tab_bar->ID, tab_bar->Tabs.Size, is_active ? "" : " *Inactive*");
    IM_UNUSED(p);
    if (!is_active) { PushStyleColor(ImGuiCol_Text, GetStyleColorVec4(ImGuiCol_TextDisabled)); }
    bool open = TreeNode(tab_bar, "%s", buf);
    if (!is_active) { PopStyleColor(); }
    if (is_active && IsItemHovered())
    {
        ImDrawList* draw_list = GetForegroundDrawList();
        draw_list->AddRect(tab_bar->BarRect.Min, tab_bar->BarRect.Max, IM_COL32(255, 255, 0, 255));
        draw_list->AddLine(ImVec2(tab_bar->ScrollingRectMinX, tab_bar->BarRect.Min.y), ImVec2(tab_bar->ScrollingRectMinX, tab_bar->BarRect.Max.y), IM_COL32(0, 255, 0, 255));
        draw_list->AddLine(ImVec2(tab_bar->ScrollingRectMaxX, tab_bar->BarRect.Min.y), ImVec2(tab_bar->ScrollingRectMaxX, tab_bar->BarRect.Max.y), IM_COL32(0, 255, 0, 255));
    }
    if (open)
    {
        for (int tab_n = 0; tab_n < tab_bar->Tabs.Size; tab_n++)
        {
            const ImGuiTabItem* tab = &tab_bar->Tabs[tab_n];
            PushID(tab);
            if (SmallButton("<")) { TabBarQueueReorder(tab_bar, tab, -1); } SameLine(0, 2);
            if (SmallButton(">")) { TabBarQueueReorder(tab_bar, tab, +1); } SameLine();
            Text("%02d%c Tab 0x%08X '%s' Offset: %.1f, Width: %.1f/%.1f",
                tab_n, (tab->ID == tab_bar->SelectedTabId) ? '*' : ' ', tab->ID, (tab->NameOffset != -1) ? tab_bar->GetTabName(tab) : "", tab->Offset, tab->Width, tab->ContentWidth);
            PopID();
        }
        TreePop();
    }
}

References ImDrawList::AddLine(), ImDrawList::AddRect(), ImGuiTabBar::BarRect, ImGuiTabItem::ContentWidth, GetForegroundDrawList(), GetFrameCount(), GetStyleColorVec4(), ImGuiTabBar::GetTabName(), ImGuiTabItem::ID, ImGuiTabBar::ID, IM_ARRAYSIZE, IM_COL32, IM_UNUSED, ImFormatString(), ImGuiCol_Text, ImGuiCol_TextDisabled, IsItemHovered(), ImRect::Max, ImRect::Min, ImGuiTabItem::NameOffset, ImGuiTabItem::Offset, PopID(), PopStyleColor(), ImGuiTabBar::PrevFrameVisible, PushID(), PushStyleColor(), SameLine(), ImGuiTabBar::ScrollingRectMaxX, ImGuiTabBar::ScrollingRectMinX, ImGuiTabBar::SelectedTabId, ImVector< T >::Size, SmallButton(), TabBarQueueReorder(), ImGuiTabBar::Tabs, Text(), TreeNode(), TreePop(), ImGuiTabItem::Width, and ImVec2::y.

Referenced by ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeTable()

void ImGui::DebugNodeTable ( ImGuiTable * table )

{
    char buf[512];
    char* p = buf;
    const char* buf_end = buf + IM_ARRAYSIZE(buf);
    const bool is_active = (table->LastFrameActive >= ImGui::GetFrameCount() - 2); // Note that fully clipped early out scrolling tables will appear as inactive here.
    ImFormatString(p, buf_end - p, "Table 0x%08X (%d columns, in '%s')%s", table->ID, table->ColumnsCount, table->OuterWindow->Name, is_active ? "" : " *Inactive*");
    if (!is_active) { PushStyleColor(ImGuiCol_Text, GetStyleColorVec4(ImGuiCol_TextDisabled)); }
    bool open = TreeNode(table, "%s", buf);
    if (!is_active) { PopStyleColor(); }
    if (IsItemHovered())
        GetForegroundDrawList()->AddRect(table->OuterRect.Min, table->OuterRect.Max, IM_COL32(255, 255, 0, 255));
    if (IsItemVisible() && table->HoveredColumnBody != -1)
        GetForegroundDrawList()->AddRect(GetItemRectMin(), GetItemRectMax(), IM_COL32(255, 255, 0, 255));
    if (!open)
        return;
    bool clear_settings = SmallButton("Clear settings");
    BulletText("OuterRect: Pos: (%.1f,%.1f) Size: (%.1f,%.1f) Sizing: '%s'", table->OuterRect.Min.x, table->OuterRect.Min.y, table->OuterRect.GetWidth(), table->OuterRect.GetHeight(), DebugNodeTableGetSizingPolicyDesc(table->Flags));
    BulletText("ColumnsGivenWidth: %.1f, ColumnsAutoFitWidth: %.1f, InnerWidth: %.1f%s", table->ColumnsGivenWidth, table->ColumnsAutoFitWidth, table->InnerWidth, table->InnerWidth == 0.0f ? " (auto)" : "");
    BulletText("CellPaddingX: %.1f, CellSpacingX: %.1f/%.1f, OuterPaddingX: %.1f", table->CellPaddingX, table->CellSpacingX1, table->CellSpacingX2, table->OuterPaddingX);
    BulletText("HoveredColumnBody: %d, HoveredColumnBorder: %d", table->HoveredColumnBody, table->HoveredColumnBorder);
    BulletText("ResizedColumn: %d, ReorderColumn: %d, HeldHeaderColumn: %d", table->ResizedColumn, table->ReorderColumn, table->HeldHeaderColumn);
    //BulletText("BgDrawChannels: %d/%d", 0, table->BgDrawChannelUnfrozen);
    float sum_weights = 0.0f;
    for (int n = 0; n < table->ColumnsCount; n++)
        if (table->Columns[n].Flags & ImGuiTableColumnFlags_WidthStretch)
            sum_weights += table->Columns[n].StretchWeight;
    for (int n = 0; n < table->ColumnsCount; n++)
    {
        ImGuiTableColumn* column = &table->Columns[n];
        const char* name = TableGetColumnName(table, n);
        ImFormatString(buf, IM_ARRAYSIZE(buf),
            "Column %d order %d '%s': offset %+.2f to %+.2f%s\n"
            "Enabled: %d, VisibleX/Y: %d/%d, RequestOutput: %d, SkipItems: %d, DrawChannels: %d,%d\n"
            "WidthGiven: %.1f, Request/Auto: %.1f/%.1f, StretchWeight: %.3f (%.1f%%)\n"
            "MinX: %.1f, MaxX: %.1f (%+.1f), ClipRect: %.1f to %.1f (+%.1f)\n"
            "ContentWidth: %.1f,%.1f, HeadersUsed/Ideal %.1f/%.1f\n"
            "Sort: %d%s, UserID: 0x%08X, Flags: 0x%04X: %s%s%s..",
            n, column->DisplayOrder, name, column->MinX - table->WorkRect.Min.x, column->MaxX - table->WorkRect.Min.x, (n < table->FreezeColumnsRequest) ? " (Frozen)" : "",
            column->IsEnabled, column->IsVisibleX, column->IsVisibleY, column->IsRequestOutput, column->IsSkipItems, column->DrawChannelFrozen, column->DrawChannelUnfrozen,
            column->WidthGiven, column->WidthRequest, column->WidthAuto, column->StretchWeight, column->StretchWeight > 0.0f ? (column->StretchWeight / sum_weights) * 100.0f : 0.0f,
            column->MinX, column->MaxX, column->MaxX - column->MinX, column->ClipRect.Min.x, column->ClipRect.Max.x, column->ClipRect.Max.x - column->ClipRect.Min.x,
            column->ContentMaxXFrozen - column->WorkMinX, column->ContentMaxXUnfrozen - column->WorkMinX, column->ContentMaxXHeadersUsed - column->WorkMinX, column->ContentMaxXHeadersIdeal - column->WorkMinX,
            column->SortOrder, (column->SortDirection == ImGuiSortDirection_Ascending) ? " (Asc)" : (column->SortDirection == ImGuiSortDirection_Descending) ? " (Des)" : "", column->UserID, column->Flags,
            (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? "WidthStretch " : "",
            (column->Flags & ImGuiTableColumnFlags_WidthFixed) ? "WidthFixed " : "",
            (column->Flags & ImGuiTableColumnFlags_NoResize) ? "NoResize " : "");
        Bullet();
        Selectable(buf);
        if (IsItemHovered())
        {
            ImRect r(column->MinX, table->OuterRect.Min.y, column->MaxX, table->OuterRect.Max.y);
            GetForegroundDrawList()->AddRect(r.Min, r.Max, IM_COL32(255, 255, 0, 255));
        }
    }
    if (ImGuiTableSettings* settings = TableGetBoundSettings(table))
        DebugNodeTableSettings(settings);
    if (clear_settings)
        table->IsResetAllRequest = true;
    TreePop();
}

Referenced by ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeTableSettings()

void ImGui::DebugNodeTableSettings ( ImGuiTableSettings * settings )

{
    if (!TreeNode((void*)(intptr_t)settings->ID, "Settings 0x%08X (%d columns)", settings->ID, settings->ColumnsCount))
        return;
    BulletText("SaveFlags: 0x%08X", settings->SaveFlags);
    BulletText("ColumnsCount: %d (max %d)", settings->ColumnsCount, settings->ColumnsCountMax);
    for (int n = 0; n < settings->ColumnsCount; n++)
    {
        ImGuiTableColumnSettings* column_settings = &settings->GetColumnSettings()[n];
        ImGuiSortDirection sort_dir = (column_settings->SortOrder != -1) ? (ImGuiSortDirection)column_settings->SortDirection : ImGuiSortDirection_None;
        BulletText("Column %d Order %d SortOrder %d %s Vis %d %s %7.3f UserID 0x%08X",
            n, column_settings->DisplayOrder, column_settings->SortOrder,
            (sort_dir == ImGuiSortDirection_Ascending) ? "Asc" : (sort_dir == ImGuiSortDirection_Descending) ? "Des" : "---",
            column_settings->IsEnabled, column_settings->IsStretch ? "Weight" : "Width ", column_settings->WidthOrWeight, column_settings->UserID);
    }
    TreePop();
}

References BulletText(), ImGuiTableSettings::ColumnsCount, ImGuiTableSettings::ColumnsCountMax, ImGuiTableColumnSettings::DisplayOrder, ImGuiTableSettings::GetColumnSettings(), ImGuiTableSettings::ID, ImGuiSortDirection_Ascending, ImGuiSortDirection_Descending, ImGuiSortDirection_None, ImGuiTableColumnSettings::IsEnabled, ImGuiTableColumnSettings::IsStretch, ImGuiTableSettings::SaveFlags, ImGuiTableColumnSettings::SortDirection, ImGuiTableColumnSettings::SortOrder, TreeNode(), TreePop(), ImGuiTableColumnSettings::UserID, and ImGuiTableColumnSettings::WidthOrWeight.

Referenced by DebugNodeTable(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeViewport()

void ImGui::DebugNodeViewport ( ImGuiViewportP * viewport )

{
    SetNextItemOpen(true, ImGuiCond_Once);
    if (TreeNode("viewport0", "Viewport #%d", 0))
    {
        ImGuiWindowFlags flags = viewport->Flags;
        BulletText("Main Pos: (%.0f,%.0f), Size: (%.0f,%.0f)\nWorkArea Offset Left: %.0f Top: %.0f, Right: %.0f, Bottom: %.0f",
            viewport->Pos.x, viewport->Pos.y, viewport->Size.x, viewport->Size.y,
            viewport->WorkOffsetMin.x, viewport->WorkOffsetMin.y, viewport->WorkOffsetMax.x, viewport->WorkOffsetMax.y);
        BulletText("Flags: 0x%04X =%s%s%s", viewport->Flags,
            (flags & ImGuiViewportFlags_IsPlatformWindow)  ? " IsPlatformWindow"  : "",
            (flags & ImGuiViewportFlags_IsPlatformMonitor) ? " IsPlatformMonitor" : "",
            (flags & ImGuiViewportFlags_OwnedByApp)        ? " OwnedByApp"        : "");
        for (int layer_i = 0; layer_i < IM_ARRAYSIZE(viewport->DrawDataBuilder.Layers); layer_i++)
            for (int draw_list_i = 0; draw_list_i < viewport->DrawDataBuilder.Layers[layer_i].Size; draw_list_i++)
                DebugNodeDrawList(NULL, viewport->DrawDataBuilder.Layers[layer_i][draw_list_i], "DrawList");
        TreePop();
    }
}

References BulletText(), DebugNodeDrawList(), ImGuiViewportP::DrawDataBuilder, ImGuiViewport::Flags, IM_ARRAYSIZE, ImGuiCond_Once, ImGuiViewportFlags_IsPlatformMonitor, ImGuiViewportFlags_IsPlatformWindow, ImGuiViewportFlags_OwnedByApp, ImDrawDataBuilder::Layers, ImGuiViewport::Pos, SetNextItemOpen(), ImVector< T >::Size, ImGuiViewport::Size, TreeNode(), TreePop(), ImGuiViewportP::WorkOffsetMax, ImGuiViewportP::WorkOffsetMin, ImVec2::x, and ImVec2::y.

Referenced by ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeWindow()

void ImGui::DebugNodeWindow	(	ImGuiWindow *	window,
		const char *	label
	)

{
    if (window == NULL)
    {
        BulletText("%s: NULL", label);
        return;
    }
 
    ImGuiContext& g = *GImGui;
    const bool is_active = window->WasActive;
    ImGuiTreeNodeFlags tree_node_flags = (window == g.NavWindow) ? ImGuiTreeNodeFlags_Selected : ImGuiTreeNodeFlags_None;
    if (!is_active) { PushStyleColor(ImGuiCol_Text, GetStyleColorVec4(ImGuiCol_TextDisabled)); }
    const bool open = TreeNodeEx(label, tree_node_flags, "%s '%s'%s", label, window->Name, is_active ? "" : " *Inactive*");
    if (!is_active) { PopStyleColor(); }
    if (IsItemHovered() && is_active)
        GetForegroundDrawList(window)->AddRect(window->Pos, window->Pos + window->Size, IM_COL32(255, 255, 0, 255));
    if (!open)
        return;
 
    if (window->MemoryCompacted)
        TextDisabled("Note: some memory buffers have been compacted/freed.");
 
    ImGuiWindowFlags flags = window->Flags;
    DebugNodeDrawList(window, window->DrawList, "DrawList");
    BulletText("Pos: (%.1f,%.1f), Size: (%.1f,%.1f), ContentSize (%.1f,%.1f) Ideal (%.1f,%.1f)", window->Pos.x, window->Pos.y, window->Size.x, window->Size.y, window->ContentSize.x, window->ContentSize.y, window->ContentSizeIdeal.x, window->ContentSizeIdeal.y);
    BulletText("Flags: 0x%08X (%s%s%s%s%s%s%s%s%s..)", flags,
        (flags & ImGuiWindowFlags_ChildWindow)  ? "Child " : "",      (flags & ImGuiWindowFlags_Tooltip)     ? "Tooltip "   : "",  (flags & ImGuiWindowFlags_Popup) ? "Popup " : "",
        (flags & ImGuiWindowFlags_Modal)        ? "Modal " : "",      (flags & ImGuiWindowFlags_ChildMenu)   ? "ChildMenu " : "",  (flags & ImGuiWindowFlags_NoSavedSettings) ? "NoSavedSettings " : "",
        (flags & ImGuiWindowFlags_NoMouseInputs)? "NoMouseInputs":"", (flags & ImGuiWindowFlags_NoNavInputs) ? "NoNavInputs" : "", (flags & ImGuiWindowFlags_AlwaysAutoResize) ? "AlwaysAutoResize" : "");
    BulletText("Scroll: (%.2f/%.2f,%.2f/%.2f) Scrollbar:%s%s", window->Scroll.x, window->ScrollMax.x, window->Scroll.y, window->ScrollMax.y, window->ScrollbarX ? "X" : "", window->ScrollbarY ? "Y" : "");
    BulletText("Active: %d/%d, WriteAccessed: %d, BeginOrderWithinContext: %d", window->Active, window->WasActive, window->WriteAccessed, (window->Active || window->WasActive) ? window->BeginOrderWithinContext : -1);
    BulletText("Appearing: %d, Hidden: %d (CanSkip %d Cannot %d), SkipItems: %d", window->Appearing, window->Hidden, window->HiddenFramesCanSkipItems, window->HiddenFramesCannotSkipItems, window->SkipItems);
    for (int layer = 0; layer < ImGuiNavLayer_COUNT; layer++)
    {
        ImRect r = window->NavRectRel[layer];
        if (r.Min.x >= r.Max.y && r.Min.y >= r.Max.y)
        {
            BulletText("NavLastIds[%d]: 0x%08X", layer, window->NavLastIds[layer]);
            continue;
        }
        BulletText("NavLastIds[%d]: 0x%08X at +(%.1f,%.1f)(%.1f,%.1f)", layer, window->NavLastIds[layer], r.Min.x, r.Min.y, r.Max.x, r.Max.y);
        if (IsItemHovered())
            GetForegroundDrawList(window)->AddRect(r.Min + window->Pos, r.Max + window->Pos, IM_COL32(255, 255, 0, 255));
    }
    BulletText("NavLayersActiveMask: %X, NavLastChildNavWindow: %s", window->DC.NavLayersActiveMask, window->NavLastChildNavWindow ? window->NavLastChildNavWindow->Name : "NULL");
    if (window->RootWindow != window)       { DebugNodeWindow(window->RootWindow, "RootWindow"); }
    if (window->ParentWindow != NULL)       { DebugNodeWindow(window->ParentWindow, "ParentWindow"); }
    if (window->DC.ChildWindows.Size > 0)   { DebugNodeWindowsList(&window->DC.ChildWindows, "ChildWindows"); }
    if (window->ColumnsStorage.Size > 0 && TreeNode("Columns", "Columns sets (%d)", window->ColumnsStorage.Size))
    {
        for (int n = 0; n < window->ColumnsStorage.Size; n++)
            DebugNodeColumns(&window->ColumnsStorage[n]);
        TreePop();
    }
    DebugNodeStorage(&window->StateStorage, "Storage");
    TreePop();
}

References ImGuiWindow::Active, ImDrawList::AddRect(), ImGuiWindow::Appearing, ImGuiWindow::BeginOrderWithinContext, BulletText(), ImGuiWindowTempData::ChildWindows, ImGuiWindow::ColumnsStorage, ImGuiWindow::ContentSize, ImGuiWindow::ContentSizeIdeal, ImGuiWindow::DC, DebugNodeColumns(), DebugNodeDrawList(), DebugNodeStorage(), DebugNodeWindow(), DebugNodeWindowsList(), ImGuiWindow::DrawList, ImGuiWindow::Flags, GetForegroundDrawList(), GetStyleColorVec4(), GImGui, ImGuiWindow::Hidden, ImGuiWindow::HiddenFramesCannotSkipItems, ImGuiWindow::HiddenFramesCanSkipItems, IM_COL32, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiNavLayer_COUNT, ImGuiTreeNodeFlags_None, ImGuiTreeNodeFlags_Selected, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_Modal, ImGuiWindowFlags_NoMouseInputs, ImGuiWindowFlags_NoNavInputs, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_Popup, ImGuiWindowFlags_Tooltip, IsItemHovered(), ImRect::Max, ImGuiWindow::MemoryCompacted, ImRect::Min, ImGuiWindow::Name, ImGuiWindow::NavLastChildNavWindow, ImGuiWindow::NavLastIds, ImGuiWindowTempData::NavLayersActiveMask, ImGuiWindow::NavRectRel, ImGuiContext::NavWindow, ImGuiWindow::ParentWindow, PopStyleColor(), ImGuiWindow::Pos, PushStyleColor(), ImGuiWindow::RootWindow, ImGuiWindow::Scroll, ImGuiWindow::ScrollbarX, ImGuiWindow::ScrollbarY, ImGuiWindow::ScrollMax, ImVector< T >::Size, ImGuiWindow::Size, ImGuiWindow::SkipItems, ImGuiWindow::StateStorage, TextDisabled(), TreeNode(), TreeNodeEx(), TreePop(), ImGuiWindow::WasActive, ImGuiWindow::WriteAccessed, ImVec2::x, and ImVec2::y.

Referenced by DebugNodeWindow(), and DebugNodeWindowsList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeWindowSettings()

void ImGui::DebugNodeWindowSettings ( ImGuiWindowSettings * settings )

{
    Text("0x%08X \"%s\" Pos (%d,%d) Size (%d,%d) Collapsed=%d",
        settings->ID, settings->GetName(), settings->Pos.x, settings->Pos.y, settings->Size.x, settings->Size.y, settings->Collapsed);
}

References ImGuiWindowSettings::Collapsed, ImGuiWindowSettings::GetName(), ImGuiWindowSettings::ID, ImGuiWindowSettings::Pos, ImGuiWindowSettings::Size, Text(), ImVec2ih::x, and ImVec2ih::y.

Referenced by ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugNodeWindowsList()

void ImGui::DebugNodeWindowsList	(	ImVector< ImGuiWindow * > *	windows,
		const char *	label
	)

{
    if (!TreeNode(label, "%s (%d)", label, windows->Size))
        return;
    Text("(In front-to-back order:)");
    for (int i = windows->Size - 1; i >= 0; i--) // Iterate front to back
    {
        PushID((*windows)[i]);
        DebugNodeWindow((*windows)[i], "Window");
        PopID();
    }
    TreePop();
}

References DebugNodeWindow(), PopID(), PushID(), ImVector< T >::Size, Text(), TreeNode(), and TreePop().

Referenced by DebugNodeWindow(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugRenderViewportThumbnail()

void ImGui::DebugRenderViewportThumbnail	(	ImDrawList *	draw_list,
		ImGuiViewportP *	viewport,
		const ImRect &	bb
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    ImVec2 scale = bb.GetSize() / viewport->Size;
    ImVec2 off = bb.Min - viewport->Pos * scale;
    float alpha_mul = 1.0f;
    window->DrawList->AddRectFilled(bb.Min, bb.Max, GetColorU32(ImGuiCol_Border, alpha_mul * 0.40f));
    for (int i = 0; i != g.Windows.Size; i++)
    {
        ImGuiWindow* thumb_window = g.Windows[i];
        if (!thumb_window->WasActive || (thumb_window->Flags & ImGuiWindowFlags_ChildWindow))
            continue;
 
        ImRect thumb_r = thumb_window->Rect();
        ImRect title_r = thumb_window->TitleBarRect();
        thumb_r = ImRect(ImFloor(off + thumb_r.Min * scale), ImFloor(off +  thumb_r.Max * scale));
        title_r = ImRect(ImFloor(off + title_r.Min * scale), ImFloor(off +  ImVec2(title_r.Max.x, title_r.Min.y) * scale) + ImVec2(0,5)); // Exaggerate title bar height
        thumb_r.ClipWithFull(bb);
        title_r.ClipWithFull(bb);
        const bool window_is_focused = (g.NavWindow && thumb_window->RootWindowForTitleBarHighlight == g.NavWindow->RootWindowForTitleBarHighlight);
        window->DrawList->AddRectFilled(thumb_r.Min, thumb_r.Max, GetColorU32(ImGuiCol_WindowBg, alpha_mul));
        window->DrawList->AddRectFilled(title_r.Min, title_r.Max, GetColorU32(window_is_focused ? ImGuiCol_TitleBgActive : ImGuiCol_TitleBg, alpha_mul));
        window->DrawList->AddRect(thumb_r.Min, thumb_r.Max, GetColorU32(ImGuiCol_Border, alpha_mul));
        window->DrawList->AddText(g.Font, g.FontSize * 1.0f, title_r.Min, GetColorU32(ImGuiCol_Text, alpha_mul), thumb_window->Name, FindRenderedTextEnd(thumb_window->Name));
    }
    draw_list->AddRect(bb.Min, bb.Max, GetColorU32(ImGuiCol_Border, alpha_mul));
}

References ImDrawList::AddRect(), ImDrawList::AddRectFilled(), ImDrawList::AddText(), ImRect::ClipWithFull(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, FindRenderedTextEnd(), ImGuiWindow::Flags, ImGuiContext::Font, ImGuiContext::FontSize, GetColorU32(), ImRect::GetSize(), GImGui, ImFloor(), ImGuiCol_Border, ImGuiCol_Text, ImGuiCol_TitleBg, ImGuiCol_TitleBgActive, ImGuiCol_WindowBg, ImGuiWindowFlags_ChildWindow, ImRect::Max, ImRect::Min, ImGuiWindow::Name, ImGuiContext::NavWindow, ImGuiViewport::Pos, ImGuiWindow::Rect(), ImGuiWindow::RootWindowForTitleBarHighlight, scale(), ImVector< T >::Size, ImGuiViewport::Size, ImGuiWindow::TitleBarRect(), ImGuiWindow::WasActive, ImGuiContext::Windows, ImVec2::x, and ImVec2::y.

Referenced by RenderViewportsThumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebugStartItemPicker()

void ImGui::DebugStartItemPicker ( )

inline

2614{ ImGuiContext& g = *GImGui; g.DebugItemPickerActive = true; }

ImGuiContext::DebugItemPickerActive

bool DebugItemPickerActive

Definition imgui_internal.h:1582

References ImGuiContext::DebugItemPickerActive, and GImGui.

Referenced by ShowMetricsWindow().

Here is the caller graph for this function:

◆ DestroyContext()

void ImGui::DestroyContext ( ImGuiContext * ctx = NULL )

{
    if (ctx == NULL)
        ctx = GImGui;
    Shutdown(ctx);
    if (GImGui == ctx)
        SetCurrentContext(NULL);
    IM_DELETE(ctx);
}

References GImGui, IM_DELETE(), SetCurrentContext(), and Shutdown().

Referenced by Slic3r::GUI::ImGuiWrapper::~ImGuiWrapper(), and igl::opengl::glfw::imgui::ImGuiMenu::shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragBehavior()

bool ImGui::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
	)

{
    // Read imgui.cpp "API BREAKING CHANGES" section for 1.78 if you hit this assert.
    IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_InvalidMask_) == 0) && "Invalid ImGuiSliderFlags flags! Has the 'float power' argument been mistakenly cast to flags? Call function with ImGuiSliderFlags_Logarithmic flags instead.");
 
    ImGuiContext& g = *GImGui;
    if (g.ActiveId == id)
    {
        if (g.ActiveIdSource == ImGuiInputSource_Mouse && !g.IO.MouseDown[0])
            ClearActiveID();
        else if (g.ActiveIdSource == ImGuiInputSource_Nav && g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)
            ClearActiveID();
    }
    if (g.ActiveId != id)
        return false;
    if ((g.CurrentItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly))
        return false;
 
    switch (data_type)
    {
    case ImGuiDataType_S8:     { ImS32 v32 = (ImS32)*(ImS8*)p_v;  bool r = DragBehaviorT<ImS32, ImS32, float>(ImGuiDataType_S32, &v32, v_speed, p_min ? *(const ImS8*) p_min : IM_S8_MIN,  p_max ? *(const ImS8*)p_max  : IM_S8_MAX,  format, flags); if (r) *(ImS8*)p_v = (ImS8)v32; return r; }
    case ImGuiDataType_U8:     { ImU32 v32 = (ImU32)*(ImU8*)p_v;  bool r = DragBehaviorT<ImU32, ImS32, float>(ImGuiDataType_U32, &v32, v_speed, p_min ? *(const ImU8*) p_min : IM_U8_MIN,  p_max ? *(const ImU8*)p_max  : IM_U8_MAX,  format, flags); if (r) *(ImU8*)p_v = (ImU8)v32; return r; }
    case ImGuiDataType_S16:    { ImS32 v32 = (ImS32)*(ImS16*)p_v; bool r = DragBehaviorT<ImS32, ImS32, float>(ImGuiDataType_S32, &v32, v_speed, p_min ? *(const ImS16*)p_min : IM_S16_MIN, p_max ? *(const ImS16*)p_max : IM_S16_MAX, format, flags); if (r) *(ImS16*)p_v = (ImS16)v32; return r; }
    case ImGuiDataType_U16:    { ImU32 v32 = (ImU32)*(ImU16*)p_v; bool r = DragBehaviorT<ImU32, ImS32, float>(ImGuiDataType_U32, &v32, v_speed, p_min ? *(const ImU16*)p_min : IM_U16_MIN, p_max ? *(const ImU16*)p_max : IM_U16_MAX, format, flags); if (r) *(ImU16*)p_v = (ImU16)v32; return r; }
    case ImGuiDataType_S32:    return DragBehaviorT<ImS32, ImS32, float >(data_type, (ImS32*)p_v,  v_speed, p_min ? *(const ImS32* )p_min : IM_S32_MIN, p_max ? *(const ImS32* )p_max : IM_S32_MAX, format, flags);
    case ImGuiDataType_U32:    return DragBehaviorT<ImU32, ImS32, float >(data_type, (ImU32*)p_v,  v_speed, p_min ? *(const ImU32* )p_min : IM_U32_MIN, p_max ? *(const ImU32* )p_max : IM_U32_MAX, format, flags);
    case ImGuiDataType_S64:    return DragBehaviorT<ImS64, ImS64, double>(data_type, (ImS64*)p_v,  v_speed, p_min ? *(const ImS64* )p_min : IM_S64_MIN, p_max ? *(const ImS64* )p_max : IM_S64_MAX, format, flags);
    case ImGuiDataType_U64:    return DragBehaviorT<ImU64, ImS64, double>(data_type, (ImU64*)p_v,  v_speed, p_min ? *(const ImU64* )p_min : IM_U64_MIN, p_max ? *(const ImU64* )p_max : IM_U64_MAX, format, flags);
    case ImGuiDataType_Float:  return DragBehaviorT<float, float, float >(data_type, (float*)p_v,  v_speed, p_min ? *(const float* )p_min : -FLT_MAX,   p_max ? *(const float* )p_max : FLT_MAX,    format, flags);
    case ImGuiDataType_Double: return DragBehaviorT<double,double,double>(data_type, (double*)p_v, v_speed, p_min ? *(const double*)p_min : -DBL_MAX,   p_max ? *(const double*)p_max : DBL_MAX,    format, flags);
    case ImGuiDataType_COUNT:  break;
    }
    IM_ASSERT(0);
    return false;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdIsJustActivated, ImGuiContext::ActiveIdSource, ClearActiveID(), ImGuiContext::CurrentItemFlags, GImGui, IM_ASSERT, IM_S16_MAX, IM_S16_MIN, IM_S32_MAX, IM_S32_MIN, IM_S64_MAX, IM_S64_MIN, IM_S8_MAX, IM_S8_MIN, IM_U16_MAX, IM_U16_MIN, IM_U32_MAX, IM_U32_MIN, IM_U64_MAX, IM_U64_MIN, IM_U8_MAX, IM_U8_MIN, ImGuiDataType_COUNT, ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, ImGuiDataType_U8, ImGuiInputSource_Mouse, ImGuiInputSource_Nav, ImGuiItemFlags_ReadOnly, ImGuiSliderFlags_InvalidMask_, ImGuiSliderFlags_ReadOnly, ImGuiContext::IO, ImGuiIO::MouseDown, and ImGuiContext::NavActivatePressedId.

Referenced by DragScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragBehaviorT()

template<typename T , typename SIGNED_T , typename FLOAT_T >

IMGUI_API bool ImGui::DragBehaviorT	(	ImGuiDataType	data_type,
		T *	v,
		float	v_speed,
		T	v_min,
		T	v_max,
		const char *	format,
		ImGuiSliderFlags	flags
	)

◆ DragFloat() [1/2]

static bool ImGui::DragFloat	(	const char *	label,
		float *	v,
		float	v_speed,
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2795{ return DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, format, power); }

ImGui::DragScalar

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)

Definition imgui_widgets.cpp:2307

References DragFloat(), DragScalar(), and ImGuiDataType_Float.

Here is the call graph for this function:

◆ DragFloat() [2/2]

bool ImGui::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`
	)

{
    return DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, format, flags);
}

References DragScalar(), and ImGuiDataType_Float.

Referenced by ColorEdit4(), Slic3r::GUI::ImGuiWrapper::drag_optional_float(), DragFloat(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowFont(), ShowPlaceholderObject(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragFloat2() [1/2]

static bool ImGui::DragFloat2	(	const char *	label,
		float	v[2],
		float	v_speed,
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2796{ return DragScalarN(label, ImGuiDataType_Float, v, 2, v_speed, &v_min, &v_max, format, power); }

ImGui::DragScalarN

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)

Definition imgui_widgets.cpp:2391

References DragFloat2(), DragScalarN(), and ImGuiDataType_Float.

Here is the call graph for this function:

◆ DragFloat2() [2/2]

bool ImGui::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`
	)

{
    return DragScalarN(label, ImGuiDataType_Float, v, 2, v_speed, &v_min, &v_max, format, flags);
}

References DragScalarN(), and ImGuiDataType_Float.

Referenced by DragFloat2(), ShowDemoWindowLayout(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragFloat3() [1/2]

static bool ImGui::DragFloat3	(	const char *	label,
		float	v[3],
		float	v_speed,
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2797{ return DragScalarN(label, ImGuiDataType_Float, v, 3, v_speed, &v_min, &v_max, format, power); }

References DragFloat3(), DragScalarN(), and ImGuiDataType_Float.

Here is the call graph for this function:

◆ DragFloat3() [2/2]

bool ImGui::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`
	)

{
    return DragScalarN(label, ImGuiDataType_Float, v, 3, v_speed, &v_min, &v_max, format, flags);
}

References DragScalarN(), and ImGuiDataType_Float.

Referenced by DragFloat3(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragFloat4() [1/2]

static bool ImGui::DragFloat4	(	const char *	label,
		float	v[4],
		float	v_speed,
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2798{ return DragScalarN(label, ImGuiDataType_Float, v, 4, v_speed, &v_min, &v_max, format, power); }

References DragFloat4(), DragScalarN(), and ImGuiDataType_Float.

Here is the call graph for this function:

◆ DragFloat4() [2/2]

bool ImGui::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`
	)

{
    return DragScalarN(label, ImGuiDataType_Float, v, 4, v_speed, &v_min, &v_max, format, flags);
}

References DragScalarN(), and ImGuiDataType_Float.

Referenced by DragFloat4(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragFloatRange2()

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    PushID(label);
    BeginGroup();
    PushMultiItemsWidths(2, CalcItemWidth());
 
    float min_min = (v_min >= v_max) ? -FLT_MAX : v_min;
    float min_max = (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max);
    ImGuiSliderFlags min_flags = flags | ((min_min == min_max) ? ImGuiSliderFlags_ReadOnly : 0);
    bool value_changed = DragScalar("##min", ImGuiDataType_Float, v_current_min, v_speed, &min_min, &min_max, format, min_flags);
    PopItemWidth();
    SameLine(0, g.Style.ItemInnerSpacing.x);
 
    float max_min = (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min);
    float max_max = (v_min >= v_max) ? FLT_MAX : v_max;
    ImGuiSliderFlags max_flags = flags | ((max_min == max_max) ? ImGuiSliderFlags_ReadOnly : 0);
    value_changed |= DragScalar("##max", ImGuiDataType_Float, v_current_max, v_speed, &max_min, &max_max, format_max ? format_max : format, max_flags);
    PopItemWidth();
    SameLine(0, g.Style.ItemInnerSpacing.x);
 
    TextEx(label, FindRenderedTextEnd(label));
    EndGroup();
    PopID();
    return value_changed;
}

References BeginGroup(), CalcItemWidth(), DragScalar(), EndGroup(), FindRenderedTextEnd(), GetCurrentWindow(), GImGui, ImGuiDataType_Float, ImGuiSliderFlags_ReadOnly, ImMax(), ImMin(), ImGuiStyle::ItemInnerSpacing, PopID(), PopItemWidth(), PushID(), PushMultiItemsWidths(), SameLine(), ImGuiWindow::SkipItems, ImGuiContext::Style, TextEx(), and ImVec2::x.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragInt()

bool ImGui::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`
	)

{
    return DragScalar(label, ImGuiDataType_S32, v, v_speed, &v_min, &v_max, format, flags);
}

References DragScalar(), and ImGuiDataType_S32.

Referenced by ColorEdit4(), DragIntRange2(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppConstrainedResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragInt2()

bool ImGui::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`
	)

{
    return DragScalarN(label, ImGuiDataType_S32, v, 2, v_speed, &v_min, &v_max, format, flags);
}

References DragScalarN(), and ImGuiDataType_S32.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragInt3()

bool ImGui::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`
	)

{
    return DragScalarN(label, ImGuiDataType_S32, v, 3, v_speed, &v_min, &v_max, format, flags);
}

References DragScalarN(), and ImGuiDataType_S32.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragInt4()

bool ImGui::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`
	)

{
    return DragScalarN(label, ImGuiDataType_S32, v, 4, v_speed, &v_min, &v_max, format, flags);
}

References DragScalarN(), and ImGuiDataType_S32.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragIntRange2()

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    PushID(label);
    BeginGroup();
    PushMultiItemsWidths(2, CalcItemWidth());
 
    int min_min = (v_min >= v_max) ? INT_MIN : v_min;
    int min_max = (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max);
    ImGuiSliderFlags min_flags = flags | ((min_min == min_max) ? ImGuiSliderFlags_ReadOnly : 0);
    bool value_changed = DragInt("##min", v_current_min, v_speed, min_min, min_max, format, min_flags);
    PopItemWidth();
    SameLine(0, g.Style.ItemInnerSpacing.x);
 
    int max_min = (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min);
    int max_max = (v_min >= v_max) ? INT_MAX : v_max;
    ImGuiSliderFlags max_flags = flags | ((max_min == max_max) ? ImGuiSliderFlags_ReadOnly : 0);
    value_changed |= DragInt("##max", v_current_max, v_speed, max_min, max_max, format_max ? format_max : format, max_flags);
    PopItemWidth();
    SameLine(0, g.Style.ItemInnerSpacing.x);
 
    TextEx(label, FindRenderedTextEnd(label));
    EndGroup();
    PopID();
 
    return value_changed;
}

References BeginGroup(), CalcItemWidth(), DragInt(), EndGroup(), FindRenderedTextEnd(), GetCurrentWindow(), GImGui, ImGuiSliderFlags_ReadOnly, ImMax(), ImMin(), ImGuiStyle::ItemInnerSpacing, PopID(), PopItemWidth(), PushID(), PushMultiItemsWidths(), SameLine(), ImGuiWindow::SkipItems, ImGuiContext::Style, TextEx(), and ImVec2::x.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragScalar() [1/2]

bool ImGui::DragScalar	(	const char *	label,
		ImGuiDataType	data_type,
		void *	p_data,
		float	v_speed,
		const void *	p_min,
		const void *	p_max,
		const char *	format,
		float	power
	)

{
    ImGuiSliderFlags drag_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        IM_ASSERT(p_min != NULL && p_max != NULL);  // When using a power curve the drag needs to have known bounds
        drag_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return DragScalar(label, data_type, p_data, v_speed, p_min, p_max, format, drag_flags);
}

References DragScalar(), IM_ASSERT, ImGuiSliderFlags_Logarithmic, and ImGuiSliderFlags_None.

Here is the call graph for this function:

◆ DragScalar() [2/2]

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    const float w = CalcItemWidth();
 
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
    const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y * 2.0f));
    const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
 
    const bool temp_input_allowed = (flags & ImGuiSliderFlags_NoInput) == 0;
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, id, &frame_bb, temp_input_allowed ? ImGuiItemAddFlags_Focusable : 0))
        return false;
 
    // Default format string when passing NULL
    if (format == NULL)
        format = DataTypeGetInfo(data_type)->PrintFmt;
    else if (data_type == ImGuiDataType_S32 && strcmp(format, "%d") != 0) // (FIXME-LEGACY: Patch old "%.0f" format string to use "%d", read function more details.)
        format = PatchFormatStringFloatToInt(format);
 
    // Tabbing or CTRL-clicking on Drag turns it into an InputText
    const bool hovered = ItemHoverable(frame_bb, id);
    bool temp_input_is_active = temp_input_allowed && TempInputIsActive(id);
    if (!temp_input_is_active)
    {
        const bool focus_requested = temp_input_allowed && (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_Focused) != 0;
        const bool clicked = (hovered && g.IO.MouseClicked[0]);
        const bool double_clicked = (hovered && g.IO.MouseDoubleClicked[0]);
        if (focus_requested || clicked || double_clicked || g.NavActivateId == id || g.NavInputId == id)
        {
            SetActiveID(id, window);
            SetFocusID(id, window);
            FocusWindow(window);
            g.ActiveIdUsingNavDirMask = (1 << ImGuiDir_Left) | (1 << ImGuiDir_Right);
            if (temp_input_allowed && (focus_requested || (clicked && g.IO.KeyCtrl) || double_clicked || g.NavInputId == id))
                temp_input_is_active = true;
        }
        // Experimental: simple click (without moving) turns Drag into an InputText
        // FIXME: Currently polling ImGuiConfigFlags_IsTouchScreen, may either poll an hypothetical ImGuiBackendFlags_HasKeyboard and/or an explicit drag settings.
        if (g.IO.ConfigDragClickToInputText && temp_input_allowed && !temp_input_is_active)
            if (g.ActiveId == id && hovered && g.IO.MouseReleased[0] && !IsMouseDragPastThreshold(0, g.IO.MouseDragThreshold * DRAG_MOUSE_THRESHOLD_FACTOR))
            {
                g.NavInputId = id;
                temp_input_is_active = true;
            }
    }
 
    if (temp_input_is_active)
    {
        // Only clamp CTRL+Click input when ImGuiSliderFlags_AlwaysClamp is set
        const bool is_clamp_input = (flags & ImGuiSliderFlags_AlwaysClamp) != 0 && (p_min == NULL || p_max == NULL || DataTypeCompare(data_type, p_min, p_max) < 0);
        return TempInputScalar(frame_bb, id, label, data_type, p_data, format, is_clamp_input ? p_min : NULL, is_clamp_input ? p_max : NULL);
    }
 
    // Draw frame
    const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : g.HoveredId == id ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
    RenderNavHighlight(frame_bb, id);
    RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, true, style.FrameRounding);
 
    // Drag behavior
    const bool value_changed = DragBehavior(id, data_type, p_data, v_speed, p_min, p_max, format, flags);
    if (value_changed)
        MarkItemEdited(id);
 
    // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
    char value_buf[64];
    const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_ARRAYSIZE(value_buf), data_type, p_data, format);
    if (g.LogEnabled)
        LogSetNextTextDecoration("{", "}");
    RenderTextClipped(frame_bb.Min, frame_bb.Max, value_buf, value_buf_end, NULL, ImVec2(0.5f, 0.5f));
 
    if (label_size.x > 0.0f)
        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    return value_changed;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdUsingNavDirMask, CalcItemWidth(), CalcTextSize(), ImGuiIO::ConfigDragClickToInputText, ImGuiWindowTempData::CursorPos, DataTypeCompare(), DataTypeFormatString(), DataTypeGetInfo(), ImGuiWindow::DC, DRAG_MOUSE_THRESHOLD_FACTOR, DragBehavior(), FocusWindow(), GetColorU32(), GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, ImGuiContext::HoveredId, IM_ARRAYSIZE, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiDataType_S32, ImGuiDir_Left, ImGuiDir_Right, ImGuiItemAddFlags_Focusable, ImGuiItemStatusFlags_Focused, ImGuiSliderFlags_AlwaysClamp, ImGuiSliderFlags_NoInput, ImGuiContext::IO, IsMouseDragPastThreshold(), ItemAdd(), ItemHoverable(), ItemSize(), ImGuiIO::KeyCtrl, ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::LogEnabled, LogSetNextTextDecoration(), MarkItemEdited(), ImRect::Max, ImRect::Min, ImGuiIO::MouseClicked, ImGuiIO::MouseDoubleClicked, ImGuiIO::MouseDragThreshold, ImGuiIO::MouseReleased, ImGuiContext::NavActivateId, ImGuiContext::NavInputId, PatchFormatStringFloatToInt(), ImGuiDataTypeInfo::PrintFmt, RenderFrame(), RenderNavHighlight(), RenderText(), RenderTextClipped(), SetActiveID(), SetFocusID(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, TempInputIsActive(), TempInputScalar(), ImVec2::x, and ImVec2::y.

Referenced by DragFloat(), DragFloat(), DragFloatRange2(), DragInt(), DragScalar(), DragScalarN(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DragScalarN() [1/2]

bool ImGui::DragScalarN	(	const char *	label,
		ImGuiDataType	data_type,
		void *	p_data,
		int	components,
		float	v_speed,
		const void *	p_min,
		const void *	p_max,
		const char *	format,
		float	power
	)

{
    ImGuiSliderFlags drag_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        IM_ASSERT(p_min != NULL && p_max != NULL);  // When using a power curve the drag needs to have known bounds
        drag_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return DragScalarN(label, data_type, p_data, components, v_speed, p_min, p_max, format, drag_flags);
}

References DragScalarN(), IM_ASSERT, ImGuiSliderFlags_Logarithmic, and ImGuiSliderFlags_None.

Here is the call graph for this function:

◆ DragScalarN() [2/2]

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    bool value_changed = false;
    BeginGroup();
    PushID(label);
    PushMultiItemsWidths(components, CalcItemWidth());
    size_t type_size = GDataTypeInfo[data_type].Size;
    for (int i = 0; i < components; i++)
    {
        PushID(i);
        if (i > 0)
            SameLine(0, g.Style.ItemInnerSpacing.x);
        value_changed |= DragScalar("", data_type, p_data, v_speed, p_min, p_max, format, flags);
        PopID();
        PopItemWidth();
        p_data = (void*)((char*)p_data + type_size);
    }
    PopID();
 
    const char* label_end = FindRenderedTextEnd(label);
    if (label != label_end)
    {
        SameLine(0, g.Style.ItemInnerSpacing.x);
        TextEx(label, label_end);
    }
 
    EndGroup();
    return value_changed;
}

References BeginGroup(), CalcItemWidth(), DragScalar(), EndGroup(), FindRenderedTextEnd(), GDataTypeInfo, GetCurrentWindow(), GImGui, ImGuiStyle::ItemInnerSpacing, PopID(), PopItemWidth(), PushID(), PushMultiItemsWidths(), SameLine(), ImGuiDataTypeInfo::Size, ImGuiWindow::SkipItems, ImGuiContext::Style, TextEx(), and ImVec2::x.

Referenced by DragFloat2(), DragFloat2(), DragFloat3(), DragFloat3(), DragFloat4(), DragFloat4(), DragInt2(), DragInt3(), DragInt4(), and DragScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Dummy()

void ImGui::Dummy ( const ImVec2 & size )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(size);
    ItemAdd(bb, 0);
}

References ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), ItemAdd(), ItemSize(), and ImGuiWindow::SkipItems.

Referenced by InputTextEx(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GCodeViewer::render_legend(), RenderViewportsThumbnails(), ShowDemoWindowLayout(), ShowExampleAppCustomRendering(), ShowExampleMenuFile(), ShowFont(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ End()

void ImGui::End ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    // Error checking: verify that user hasn't called End() too many times!
    if (g.CurrentWindowStack.Size <= 1 && g.WithinFrameScopeWithImplicitWindow)
    {
        IM_ASSERT_USER_ERROR(g.CurrentWindowStack.Size > 1, "Calling End() too many times!");
        return;
    }
    IM_ASSERT(g.CurrentWindowStack.Size > 0);
 
    // Error checking: verify that user doesn't directly call End() on a child window.
    if (window->Flags & ImGuiWindowFlags_ChildWindow)
        IM_ASSERT_USER_ERROR(g.WithinEndChild, "Must call EndChild() and not End()!");
 
    // Close anything that is open
    if (window->DC.CurrentColumns)
        EndColumns();
    PopClipRect();   // Inner window clip rectangle
 
    // Stop logging
    if (!(window->Flags & ImGuiWindowFlags_ChildWindow))    // FIXME: add more options for scope of logging
        LogFinish();
 
    // Pop from window stack
    g.CurrentWindowStack.pop_back();
    if (window->Flags & ImGuiWindowFlags_Popup)
        g.BeginPopupStack.pop_back();
    window->DC.StackSizesOnBegin.CompareWithCurrentState();
    SetCurrentWindow(g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back());
}

References ImVector< T >::back(), ImGuiContext::BeginPopupStack, ImGuiStackSizes::CompareWithCurrentState(), ImGuiWindowTempData::CurrentColumns, ImGuiContext::CurrentWindow, ImGuiContext::CurrentWindowStack, ImGuiWindow::DC, ImVector< T >::empty(), EndColumns(), ImGuiWindow::Flags, GImGui, IM_ASSERT, IM_ASSERT_USER_ERROR, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_Popup, LogFinish(), ImVector< T >::pop_back(), PopClipRect(), SetCurrentWindow(), ImVector< T >::Size, ImGuiWindowTempData::StackSizesOnBegin, ImGuiContext::WithinEndChild, and ImGuiContext::WithinFrameScopeWithImplicitWindow.

Referenced by BeginMainMenuBar(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), Slic3r::GUI::ImGuiWrapper::end(), EndChild(), EndFrame(), EndMainMenuBar(), EndPopup(), EndTooltip(), ErrorCheckEndFrameRecover(), ErrorCheckEndFrameSanityChecks(), NavUpdateWindowingOverlay(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), ShowAboutWindow(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppAutoResize(), ShowExampleAppConstrainedResize(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppFullscreen(), ShowExampleAppLayout(), ShowExampleAppLog(), ShowExampleAppLongText(), ShowExampleAppPropertyEditor(), ShowExampleAppSimpleOverlay(), ShowExampleAppWindowTitles(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndChild()

void ImGui::EndChild ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    IM_ASSERT(g.WithinEndChild == false);
    IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow);   // Mismatched BeginChild()/EndChild() calls
 
    g.WithinEndChild = true;
    if (window->BeginCount > 1)
    {
        End();
    }
    else
    {
        ImVec2 sz = window->Size;
        if (window->AutoFitChildAxises & (1 << ImGuiAxis_X)) // Arbitrary minimum zero-ish child size of 4.0f causes less trouble than a 0.0f
            sz.x = ImMax(4.0f, sz.x);
        if (window->AutoFitChildAxises & (1 << ImGuiAxis_Y))
            sz.y = ImMax(4.0f, sz.y);
        End();
 
        ImGuiWindow* parent_window = g.CurrentWindow;
        ImRect bb(parent_window->DC.CursorPos, parent_window->DC.CursorPos + sz);
        ItemSize(sz);
        if ((window->DC.NavLayersActiveMask != 0 || window->DC.NavHasScroll) && !(window->Flags & ImGuiWindowFlags_NavFlattened))
        {
            ItemAdd(bb, window->ChildId);
            RenderNavHighlight(bb, window->ChildId);
 
            // When browsing a window that has no activable items (scroll only) we keep a highlight on the child
            if (window->DC.NavLayersActiveMask == 0 && window == g.NavWindow)
                RenderNavHighlight(ImRect(bb.Min - ImVec2(2, 2), bb.Max + ImVec2(2, 2)), g.NavId, ImGuiNavHighlightFlags_TypeThin);
        }
        else
        {
            // Not navigable into
            ItemAdd(bb, 0);
        }
        if (g.HoveredWindow == window)
            parent_window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_HoveredWindow;
    }
    g.WithinEndChild = false;
    g.LogLinePosY = -FLT_MAX; // To enforce a carriage return
}

References ImGuiWindow::AutoFitChildAxises, ImGuiWindow::BeginCount, ImGuiWindow::ChildId, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, End(), ImGuiWindow::Flags, GImGui, ImGuiContext::HoveredWindow, IM_ASSERT, ImGuiAxis_X, ImGuiAxis_Y, ImGuiItemStatusFlags_HoveredWindow, ImGuiNavHighlightFlags_TypeThin, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NavFlattened, ImMax(), ItemAdd(), ItemSize(), ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::LogLinePosY, ImRect::Max, ImRect::Min, ImGuiWindowTempData::NavHasScroll, ImGuiContext::NavId, ImGuiWindowTempData::NavLayersActiveMask, ImGuiContext::NavWindow, RenderNavHighlight(), ImGuiWindow::Size, ImGuiContext::WithinEndChild, ImVec2::x, and ImVec2::y.

Referenced by ExampleAppConsole::Draw(), ExampleAppLog::Draw(), EndChildFrame(), EndTable(), ErrorCheckEndFrameRecover(), InputTextEx(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppLayout(), ShowExampleAppLongText(), ShowExampleMenuFile(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndChildFrame()

void ImGui::EndChildFrame ( )

{
    EndChild();
}

References EndChild().

Referenced by EndListBox(), ShowAboutWindow(), and ShowExampleAppDocuments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndColumns()

void ImGui::EndColumns ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    IM_ASSERT(columns != NULL);
 
    PopItemWidth();
    if (columns->Count > 1)
    {
        PopClipRect();
        columns->Splitter.Merge(window->DrawList);
    }
 
    const ImGuiOldColumnFlags flags = columns->Flags;
    columns->LineMaxY = ImMax(columns->LineMaxY, window->DC.CursorPos.y);
    window->DC.CursorPos.y = columns->LineMaxY;
    if (!(flags & ImGuiOldColumnFlags_GrowParentContentsSize))
        window->DC.CursorMaxPos.x = columns->HostCursorMaxPosX;  // Restore cursor max pos, as columns don't grow parent
 
    // Draw columns borders and handle resize
    // The IsBeingResized flag ensure we preserve pre-resize columns width so back-and-forth are not lossy
    bool is_being_resized = false;
    if (!(flags & ImGuiOldColumnFlags_NoBorder) && !window->SkipItems)
    {
        // We clip Y boundaries CPU side because very long triangles are mishandled by some GPU drivers.
        const float y1 = ImMax(columns->HostCursorPosY, window->ClipRect.Min.y);
        const float y2 = ImMin(window->DC.CursorPos.y, window->ClipRect.Max.y);
        int dragging_column = -1;
        for (int n = 1; n < columns->Count; n++)
        {
            ImGuiOldColumnData* column = &columns->Columns[n];
            float x = window->Pos.x + GetColumnOffset(n);
            const ImGuiID column_id = columns->ID + ImGuiID(n);
            const float column_hit_hw = COLUMNS_HIT_RECT_HALF_WIDTH;
            const ImRect column_hit_rect(ImVec2(x - column_hit_hw, y1), ImVec2(x + column_hit_hw, y2));
            KeepAliveID(column_id);
            if (IsClippedEx(column_hit_rect, column_id, false))
                continue;
 
            bool hovered = false, held = false;
            if (!(flags & ImGuiOldColumnFlags_NoResize))
            {
                ButtonBehavior(column_hit_rect, column_id, &hovered, &held);
                if (hovered || held)
                    g.MouseCursor = ImGuiMouseCursor_ResizeEW;
                if (held && !(column->Flags & ImGuiOldColumnFlags_NoResize))
                    dragging_column = n;
            }
 
            // Draw column
            const ImU32 col = GetColorU32(held ? ImGuiCol_SeparatorActive : hovered ? ImGuiCol_SeparatorHovered : ImGuiCol_Separator);
            const float xi = IM_FLOOR(x);
            window->DrawList->AddLine(ImVec2(xi, y1 + 1.0f), ImVec2(xi, y2), col);
        }
 
        // Apply dragging after drawing the column lines, so our rendered lines are in sync with how items were displayed during the frame.
        if (dragging_column != -1)
        {
            if (!columns->IsBeingResized)
                for (int n = 0; n < columns->Count + 1; n++)
                    columns->Columns[n].OffsetNormBeforeResize = columns->Columns[n].OffsetNorm;
            columns->IsBeingResized = is_being_resized = true;
            float x = GetDraggedColumnOffset(columns, dragging_column);
            SetColumnOffset(dragging_column, x);
        }
    }
    columns->IsBeingResized = is_being_resized;
 
    window->WorkRect = window->ParentWorkRect;
    window->ParentWorkRect = columns->HostBackupParentWorkRect;
    window->DC.CurrentColumns = NULL;
    window->DC.ColumnsOffset.x = 0.0f;
    window->DC.CursorPos.x = IM_FLOOR(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
}

References ImDrawList::AddLine(), ButtonBehavior(), ImGuiWindow::ClipRect, col(), ImGuiOldColumns::Columns, COLUMNS_HIT_RECT_HALF_WIDTH, ImGuiWindowTempData::ColumnsOffset, ImGuiOldColumns::Count, ImGuiWindowTempData::CurrentColumns, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiOldColumnData::Flags, ImGuiOldColumns::Flags, GetColorU32(), GetColumnOffset(), GetCurrentWindow(), GetDraggedColumnOffset(), GImGui, ImGuiOldColumns::HostBackupParentWorkRect, ImGuiOldColumns::HostCursorMaxPosX, ImGuiOldColumns::HostCursorPosY, ImGuiOldColumns::ID, IM_ASSERT, IM_FLOOR, ImGuiCol_Separator, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiMouseCursor_ResizeEW, ImGuiOldColumnFlags_GrowParentContentsSize, ImGuiOldColumnFlags_NoBorder, ImGuiOldColumnFlags_NoResize, ImMax(), ImMin(), ImGuiWindowTempData::Indent, ImGuiOldColumns::IsBeingResized, IsClippedEx(), KeepAliveID(), ImGuiOldColumns::LineMaxY, ImRect::Max, ImDrawListSplitter::Merge(), ImRect::Min, ImGuiContext::MouseCursor, ImGuiWindow::ParentWorkRect, PopClipRect(), PopItemWidth(), ImGuiWindow::Pos, SetColumnOffset(), ImGuiWindow::SkipItems, ImGuiOldColumns::Splitter, ImGuiWindow::WorkRect, ImVec2::x, ImVec1::x, and ImVec2::y.

Referenced by Columns(), and End().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndCombo()

void ImGui::EndCombo ( )

{
    EndPopup();
}

References EndPopup().

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::ImGuiWrapper::combo(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), EditTableSizingFlags(), Slic3r::GUI::render_extruders_combo(), ShowDemoWindowWidgets(), ShowFontSelector(), and TabBarTabListPopupButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndDragDropSource()

void ImGui::EndDragDropSource ( )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.DragDropActive);
    IM_ASSERT(g.DragDropWithinSource && "Not after a BeginDragDropSource()?");
 
    if (!(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
        EndTooltip();
 
    // Discard the drag if have not called SetDragDropPayload()
    if (g.DragDropPayload.DataFrameCount == -1)
        ClearDragDrop();
    g.DragDropWithinSource = false;
}

References ClearDragDrop(), ImGuiPayload::DataFrameCount, ImGuiContext::DragDropActive, ImGuiContext::DragDropPayload, ImGuiContext::DragDropSourceFlags, ImGuiContext::DragDropWithinSource, EndTooltip(), GImGui, IM_ASSERT, and ImGuiDragDropFlags_SourceNoPreviewTooltip.

Referenced by ColorButton(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndDragDropTarget()

void ImGui::EndDragDropTarget ( )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.DragDropActive);
    IM_ASSERT(g.DragDropWithinTarget);
    g.DragDropWithinTarget = false;
}

References ImGuiContext::DragDropActive, ImGuiContext::DragDropWithinTarget, GImGui, and IM_ASSERT.

Referenced by ColorEdit4(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ EndFrame()

void ImGui::EndFrame ( )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.Initialized);
 
    // Don't process EndFrame() multiple times.
    if (g.FrameCountEnded == g.FrameCount)
        return;
    IM_ASSERT(g.WithinFrameScope && "Forgot to call ImGui::NewFrame()?");
 
    CallContextHooks(&g, ImGuiContextHookType_EndFramePre);
 
    ErrorCheckEndFrameSanityChecks();
 
    // Notify OS when our Input Method Editor cursor has moved (e.g. CJK inputs using Microsoft IME)
    if (g.IO.ImeSetInputScreenPosFn && (g.PlatformImeLastPos.x == FLT_MAX || ImLengthSqr(g.PlatformImeLastPos - g.PlatformImePos) > 0.0001f))
    {
        g.IO.ImeSetInputScreenPosFn((int)g.PlatformImePos.x, (int)g.PlatformImePos.y);
        g.PlatformImeLastPos = g.PlatformImePos;
    }
 
    // Hide implicit/fallback "Debug" window if it hasn't been used
    g.WithinFrameScopeWithImplicitWindow = false;
    if (g.CurrentWindow && !g.CurrentWindow->WriteAccessed)
        g.CurrentWindow->Active = false;
    End();
 
    // Update navigation: CTRL+Tab, wrap-around requests
    NavEndFrame();
 
    // Drag and Drop: Elapse payload (if delivered, or if source stops being submitted)
    if (g.DragDropActive)
    {
        bool is_delivered = g.DragDropPayload.Delivery;
        bool is_elapsed = (g.DragDropPayload.DataFrameCount + 1 < g.FrameCount) && ((g.DragDropSourceFlags & ImGuiDragDropFlags_SourceAutoExpirePayload) || !IsMouseDown(g.DragDropMouseButton));
        if (is_delivered || is_elapsed)
            ClearDragDrop();
    }
 
    // Drag and Drop: Fallback for source tooltip. This is not ideal but better than nothing.
    if (g.DragDropActive && g.DragDropSourceFrameCount < g.FrameCount && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
    {
        g.DragDropWithinSource = true;
        SetTooltip("...");
        g.DragDropWithinSource = false;
    }
 
    // End frame
    g.WithinFrameScope = false;
    g.FrameCountEnded = g.FrameCount;
 
    // Initiate moving window + handle left-click and right-click focus
    UpdateMouseMovingWindowEndFrame();
 
    // Sort the window list so that all child windows are after their parent
    // We cannot do that on FocusWindow() because children may not exist yet
    g.WindowsTempSortBuffer.resize(0);
    g.WindowsTempSortBuffer.reserve(g.Windows.Size);
    for (int i = 0; i != g.Windows.Size; i++)
    {
        ImGuiWindow* window = g.Windows[i];
        if (window->Active && (window->Flags & ImGuiWindowFlags_ChildWindow))       // if a child is active its parent will add it
            continue;
        AddWindowToSortBuffer(&g.WindowsTempSortBuffer, window);
    }
 
    // This usually assert if there is a mismatch between the ImGuiWindowFlags_ChildWindow / ParentWindow values and DC.ChildWindows[] in parents, aka we've done something wrong.
    IM_ASSERT(g.Windows.Size == g.WindowsTempSortBuffer.Size);
    g.Windows.swap(g.WindowsTempSortBuffer);
    g.IO.MetricsActiveWindows = g.WindowsActiveCount;
 
    // Unlock font atlas
    g.IO.Fonts->Locked = false;
 
    // Clear Input data for next frame
    g.IO.MouseWheel = g.IO.MouseWheelH = 0.0f;
    g.IO.InputQueueCharacters.resize(0);
    memset(g.IO.NavInputs, 0, sizeof(g.IO.NavInputs));
 
    CallContextHooks(&g, ImGuiContextHookType_EndFramePost);
}

References ImGuiWindow::Active, AddWindowToSortBuffer(), CallContextHooks(), ClearDragDrop(), ImGuiContext::CurrentWindow, ImGuiPayload::DataFrameCount, ImGuiPayload::Delivery, ImGuiContext::DragDropActive, ImGuiContext::DragDropMouseButton, ImGuiContext::DragDropPayload, ImGuiContext::DragDropSourceFlags, ImGuiContext::DragDropSourceFrameCount, ImGuiContext::DragDropWithinSource, End(), ErrorCheckEndFrameSanityChecks(), ImGuiWindow::Flags, ImGuiIO::Fonts, ImGuiContext::FrameCount, ImGuiContext::FrameCountEnded, GImGui, IM_ASSERT, ImGuiIO::ImeSetInputScreenPosFn, ImGuiContextHookType_EndFramePost, ImGuiContextHookType_EndFramePre, ImGuiDragDropFlags_SourceAutoExpirePayload, ImGuiDragDropFlags_SourceNoPreviewTooltip, ImGuiWindowFlags_ChildWindow, ImLengthSqr(), ImGuiContext::Initialized, ImGuiIO::InputQueueCharacters, ImGuiContext::IO, IsMouseDown(), ImFontAtlas::Locked, ImGuiIO::MetricsActiveWindows, ImGuiIO::MouseWheel, ImGuiIO::MouseWheelH, NavEndFrame(), ImGuiIO::NavInputs, ImGuiContext::PlatformImeLastPos, ImGuiContext::PlatformImePos, ImVector< T >::reserve(), ImVector< T >::resize(), SetTooltip(), ImVector< T >::Size, ImVector< T >::swap(), UpdateMouseMovingWindowEndFrame(), ImGuiContext::Windows, ImGuiContext::WindowsActiveCount, ImGuiContext::WindowsTempSortBuffer, ImGuiContext::WithinFrameScope, ImGuiContext::WithinFrameScopeWithImplicitWindow, ImGuiWindow::WriteAccessed, ImVec2::x, and ImVec2::y.

Referenced by Render(), and Slic3r::GUI::ImGuiWrapper::set_language().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndGroup()

void ImGui::EndGroup ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.GroupStack.Size > 0); // Mismatched BeginGroup()/EndGroup() calls
 
    ImGuiGroupData& group_data = g.GroupStack.back();
    IM_ASSERT(group_data.WindowID == window->ID); // EndGroup() in wrong window?
 
    ImRect group_bb(group_data.BackupCursorPos, ImMax(window->DC.CursorMaxPos, group_data.BackupCursorPos));
 
    window->DC.CursorPos = group_data.BackupCursorPos;
    window->DC.CursorMaxPos = ImMax(group_data.BackupCursorMaxPos, window->DC.CursorMaxPos);
    window->DC.Indent = group_data.BackupIndent;
    window->DC.GroupOffset = group_data.BackupGroupOffset;
    window->DC.CurrLineSize = group_data.BackupCurrLineSize;
    window->DC.CurrLineTextBaseOffset = group_data.BackupCurrLineTextBaseOffset;
    if (g.LogEnabled)
        g.LogLinePosY = -FLT_MAX; // To enforce a carriage return
 
    if (!group_data.EmitItem)
    {
        g.GroupStack.pop_back();
        return;
    }
 
    window->DC.CurrLineTextBaseOffset = ImMax(window->DC.PrevLineTextBaseOffset, group_data.BackupCurrLineTextBaseOffset);      // FIXME: Incorrect, we should grab the base offset from the *first line* of the group but it is hard to obtain now.
    ItemSize(group_bb.GetSize());
    ItemAdd(group_bb, 0);
 
    // If the current ActiveId was declared within the boundary of our group, we copy it to LastItemId so IsItemActive(), IsItemDeactivated() etc. will be functional on the entire group.
    // It would be be neater if we replaced window.DC.LastItemId by e.g. 'bool LastItemIsActive', but would put a little more burden on individual widgets.
    // Also if you grep for LastItemId you'll notice it is only used in that context.
    // (The two tests not the same because ActiveIdIsAlive is an ID itself, in order to be able to handle ActiveId being overwritten during the frame.)
    const bool group_contains_curr_active_id = (group_data.BackupActiveIdIsAlive != g.ActiveId) && (g.ActiveIdIsAlive == g.ActiveId) && g.ActiveId;
    const bool group_contains_prev_active_id = (group_data.BackupActiveIdPreviousFrameIsAlive == false) && (g.ActiveIdPreviousFrameIsAlive == true);
    if (group_contains_curr_active_id)
        window->DC.LastItemId = g.ActiveId;
    else if (group_contains_prev_active_id)
        window->DC.LastItemId = g.ActiveIdPreviousFrame;
    window->DC.LastItemRect = group_bb;
 
    // Forward Hovered flag
    const bool group_contains_curr_hovered_id = (group_data.BackupHoveredIdIsAlive == false) && g.HoveredId != 0;
    if (group_contains_curr_hovered_id)
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_HoveredWindow;
 
    // Forward Edited flag
    if (group_contains_curr_active_id && g.ActiveIdHasBeenEditedThisFrame)
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_Edited;
 
    // Forward Deactivated flag
    window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_HasDeactivated;
    if (group_contains_prev_active_id && g.ActiveId != g.ActiveIdPreviousFrame)
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_Deactivated;
 
    g.GroupStack.pop_back();
    //window->DrawList->AddRect(group_bb.Min, group_bb.Max, IM_COL32(255,0,255,255));   // [Debug]
}

Referenced by ColorEdit4(), ColorPicker4(), DragFloatRange2(), DragIntRange2(), DragScalarN(), EndListBox(), EndMenuBar(), ErrorCheckEndFrameRecover(), InputScalar(), InputScalarN(), InputTextEx(), Slic3r::GUI::render_extruders_combo(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppLayout(), ShowStyleEditor(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndListBox()

void ImGui::EndListBox ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT((window->Flags & ImGuiWindowFlags_ChildWindow) && "Mismatched BeginListBox/EndListBox calls. Did you test the return value of BeginListBox?");
    IM_UNUSED(window);
 
    EndChildFrame();
    EndGroup(); // This is only required to be able to do IsItemXXX query on the whole ListBox including label
}

References ImGuiContext::CurrentWindow, EndChildFrame(), EndGroup(), ImGuiWindow::Flags, GImGui, IM_ASSERT, IM_UNUSED, and ImGuiWindowFlags_ChildWindow.

Referenced by ListBoxFooter(), ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndMainMenuBar()

void ImGui::EndMainMenuBar ( )

{
    EndMenuBar();
 
    // When the user has left the menu layer (typically: closed menus through activation of an item), we restore focus to the previous window
    // FIXME: With this strategy we won't be able to restore a NULL focus.
    ImGuiContext& g = *GImGui;
    if (g.CurrentWindow == g.NavWindow && g.NavLayer == ImGuiNavLayer_Main && !g.NavAnyRequest)
        FocusTopMostWindowUnderOne(g.NavWindow, NULL);
 
    End();
}

References ImGuiContext::CurrentWindow, End(), EndMenuBar(), FocusTopMostWindowUnderOne(), GImGui, ImGuiNavLayer_Main, ImGuiContext::NavAnyRequest, ImGuiContext::NavLayer, and ImGuiContext::NavWindow.

Referenced by ShowExampleAppMainMenuBar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndMenu()

void ImGui::EndMenu ( )

{
    // Nav: When a left move request _within our child menu_ failed, close ourselves (the _parent_ menu).
    // A menu doesn't close itself because EndMenuBar() wants the catch the last Left<>Right inputs.
    // However, it means that with the current code, a BeginMenu() from outside another menu or a menu-bar won't be closable with the Left direction.
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (g.NavWindow && g.NavWindow->ParentWindow == window && g.NavMoveDir == ImGuiDir_Left && NavMoveRequestButNoResultYet() && window->DC.LayoutType == ImGuiLayoutType_Vertical)
    {
        ClosePopupToLevel(g.BeginPopupStack.Size, true);
        NavMoveRequestCancel();
    }
 
    EndPopup();
}

References ImGuiContext::BeginPopupStack, ClosePopupToLevel(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, EndPopup(), GImGui, ImGuiDir_Left, ImGuiLayoutType_Vertical, ImGuiWindowTempData::LayoutType, ImGuiContext::NavMoveDir, NavMoveRequestButNoResultYet(), NavMoveRequestCancel(), ImGuiContext::NavWindow, ImGuiWindow::ParentWindow, and ImVector< T >::Size.

Referenced by ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowExampleAppDocuments(), ShowExampleAppLayout(), ShowExampleAppMainMenuBar(), and ShowExampleMenuFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndMenuBar()

void ImGui::EndMenuBar ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
    ImGuiContext& g = *GImGui;
 
    // Nav: When a move request within one of our child menu failed, capture the request to navigate among our siblings.
    if (NavMoveRequestButNoResultYet() && (g.NavMoveDir == ImGuiDir_Left || g.NavMoveDir == ImGuiDir_Right) && (g.NavWindow->Flags & ImGuiWindowFlags_ChildMenu))
    {
        ImGuiWindow* nav_earliest_child = g.NavWindow;
        while (nav_earliest_child->ParentWindow && (nav_earliest_child->ParentWindow->Flags & ImGuiWindowFlags_ChildMenu))
            nav_earliest_child = nav_earliest_child->ParentWindow;
        if (nav_earliest_child->ParentWindow == window && nav_earliest_child->DC.ParentLayoutType == ImGuiLayoutType_Horizontal && g.NavMoveRequestForward == ImGuiNavForward_None)
        {
            // To do so we claim focus back, restore NavId and then process the movement request for yet another frame.
            // This involve a one-frame delay which isn't very problematic in this situation. We could remove it by scoring in advance for multiple window (probably not worth the hassle/cost)
            const ImGuiNavLayer layer = ImGuiNavLayer_Menu;
            IM_ASSERT(window->DC.NavLayersActiveMaskNext & (1 << layer)); // Sanity check
            FocusWindow(window);
            SetNavID(window->NavLastIds[layer], layer, 0, window->NavRectRel[layer]);
            g.NavDisableHighlight = true; // Hide highlight for the current frame so we don't see the intermediary selection.
            g.NavDisableMouseHover = g.NavMousePosDirty = true;
            g.NavMoveRequestForward = ImGuiNavForward_ForwardQueued;
            NavMoveRequestCancel();
        }
    }
 
    IM_MSVC_WARNING_SUPPRESS(6011); // Static Analysis false positive "warning C6011: Dereferencing NULL pointer 'window'"
    IM_ASSERT(window->Flags & ImGuiWindowFlags_MenuBar);
    IM_ASSERT(window->DC.MenuBarAppending);
    PopClipRect();
    PopID();
    window->DC.MenuBarOffset.x = window->DC.CursorPos.x - window->Pos.x; // Save horizontal position so next append can reuse it. This is kinda equivalent to a per-layer CursorPos.
    g.GroupStack.back().EmitItem = false;
    EndGroup(); // Restore position on layer 0
    window->DC.LayoutType = ImGuiLayoutType_Vertical;
    window->DC.NavLayerCurrent = ImGuiNavLayer_Main;
    window->DC.MenuBarAppending = false;
}

References ImVector< T >::back(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiGroupData::EmitItem, EndGroup(), ImGuiWindow::Flags, FocusWindow(), GetCurrentWindow(), GImGui, ImGuiContext::GroupStack, IM_ASSERT, IM_MSVC_WARNING_SUPPRESS, ImGuiDir_Left, ImGuiDir_Right, ImGuiLayoutType_Horizontal, ImGuiLayoutType_Vertical, ImGuiNavForward_ForwardQueued, ImGuiNavForward_None, ImGuiNavLayer_Main, ImGuiNavLayer_Menu, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_MenuBar, ImGuiWindowTempData::LayoutType, ImGuiWindowTempData::MenuBarAppending, ImGuiWindowTempData::MenuBarOffset, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiWindow::NavLastIds, ImGuiWindowTempData::NavLayerCurrent, ImGuiWindowTempData::NavLayersActiveMaskNext, ImGuiContext::NavMousePosDirty, ImGuiContext::NavMoveDir, NavMoveRequestButNoResultYet(), NavMoveRequestCancel(), ImGuiContext::NavMoveRequestForward, ImGuiWindow::NavRectRel, ImGuiContext::NavWindow, ImGuiWindowTempData::ParentLayoutType, ImGuiWindow::ParentWindow, PopClipRect(), PopID(), ImGuiWindow::Pos, SetNavID(), ImGuiWindow::SkipItems, and ImVec2::x.

Referenced by EndMainMenuBar(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowExampleAppDocuments(), and ShowExampleAppLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndPopup()

void ImGui::EndPopup ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup);  // Mismatched BeginPopup()/EndPopup() calls
    IM_ASSERT(g.BeginPopupStack.Size > 0);
 
    // Make all menus and popups wrap around for now, may need to expose that policy.
    if (g.NavWindow == window)
        NavMoveRequestTryWrapping(window, ImGuiNavMoveFlags_LoopY);
 
    // Child-popups don't need to be laid out
    IM_ASSERT(g.WithinEndChild == false);
    if (window->Flags & ImGuiWindowFlags_ChildWindow)
        g.WithinEndChild = true;
    End();
    g.WithinEndChild = false;
}

References ImGuiContext::BeginPopupStack, ImGuiContext::CurrentWindow, End(), ImGuiWindow::Flags, GImGui, IM_ASSERT, ImGuiNavMoveFlags_LoopY, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_Popup, NavMoveRequestTryWrapping(), ImGuiContext::NavWindow, ImVector< T >::Size, and ImGuiContext::WithinEndChild.

Referenced by BeginCombo(), BeginPopupEx(), BeginPopupModal(), ColorEdit4(), ColorEditOptionsPopup(), ColorPickerOptionsPopup(), MyDocument::DisplayContextMenu(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_add_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_button(), EndCombo(), EndMenu(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppSimpleOverlay(), and TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndTabBar()

void ImGui::EndTabBar ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;
 
    ImGuiTabBar* tab_bar = g.CurrentTabBar;
    if (tab_bar == NULL)
    {
        IM_ASSERT_USER_ERROR(tab_bar != NULL, "Mismatched BeginTabBar()/EndTabBar()!");
        return;
    }
 
    // Fallback in case no TabItem have been submitted
    if (tab_bar->WantLayout)
        TabBarLayout(tab_bar);
 
    // Restore the last visible height if no tab is visible, this reduce vertical flicker/movement when a tabs gets removed without calling SetTabItemClosed().
    const bool tab_bar_appearing = (tab_bar->PrevFrameVisible + 1 < g.FrameCount);
    if (tab_bar->VisibleTabWasSubmitted || tab_bar->VisibleTabId == 0 || tab_bar_appearing)
    {
        tab_bar->CurrTabsContentsHeight = ImMax(window->DC.CursorPos.y - tab_bar->BarRect.Max.y, tab_bar->CurrTabsContentsHeight);
        window->DC.CursorPos.y = tab_bar->BarRect.Max.y + tab_bar->CurrTabsContentsHeight;
    }
    else
    {
        window->DC.CursorPos.y = tab_bar->BarRect.Max.y + tab_bar->PrevTabsContentsHeight;
    }
    if (tab_bar->BeginCount > 1)
        window->DC.CursorPos = tab_bar->BackupCursorPos;
 
    if ((tab_bar->Flags & ImGuiTabBarFlags_DockNode) == 0)
        PopID();
 
    g.CurrentTabBarStack.pop_back();
    g.CurrentTabBar = g.CurrentTabBarStack.empty() ? NULL : GetTabBarFromTabBarRef(g.CurrentTabBarStack.back());
}

References ImVector< T >::back(), ImGuiTabBar::BackupCursorPos, ImGuiTabBar::BarRect, ImGuiTabBar::BeginCount, ImGuiContext::CurrentTabBar, ImGuiContext::CurrentTabBarStack, ImGuiContext::CurrentWindow, ImGuiTabBar::CurrTabsContentsHeight, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImVector< T >::empty(), ImGuiTabBar::Flags, ImGuiContext::FrameCount, GetTabBarFromTabBarRef(), GImGui, IM_ASSERT_USER_ERROR, ImGuiTabBarFlags_DockNode, ImMax(), ImRect::Max, ImVector< T >::pop_back(), PopID(), ImGuiTabBar::PrevFrameVisible, ImGuiTabBar::PrevTabsContentsHeight, ImGuiWindow::SkipItems, TabBarLayout(), ImGuiTabBar::VisibleTabId, ImGuiTabBar::VisibleTabWasSubmitted, ImGuiTabBar::WantLayout, and ImVec2::y.

Referenced by ErrorCheckEndFrameRecover(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppLayout(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndTabItem()

void ImGui::EndTabItem ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;
 
    ImGuiTabBar* tab_bar = g.CurrentTabBar;
    if (tab_bar == NULL)
    {
        IM_ASSERT_USER_ERROR(tab_bar != NULL, "Needs to be called between BeginTabBar() and EndTabBar()!");
        return;
    }
    IM_ASSERT(tab_bar->LastTabItemIdx >= 0);
    ImGuiTabItem* tab = &tab_bar->Tabs[tab_bar->LastTabItemIdx];
    if (!(tab->Flags & ImGuiTabItemFlags_NoPushId))
        PopID();
}

References ImGuiContext::CurrentTabBar, ImGuiContext::CurrentWindow, ImGuiTabItem::Flags, GImGui, IM_ASSERT, IM_ASSERT_USER_ERROR, ImGuiTabItemFlags_NoPushId, ImGuiTabBar::LastTabItemIdx, PopID(), ImGuiWindow::SkipItems, and ImGuiTabBar::Tabs.

Referenced by ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppLayout(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndTable()

void ImGui::EndTable ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Only call EndTable() if BeginTable() returns true!");
 
    // This assert would be very useful to catch a common error... unfortunately it would probably trigger in some
    // cases, and for consistency user may sometimes output empty tables (and still benefit from e.g. outer border)
    //IM_ASSERT(table->IsLayoutLocked && "Table unused: never called TableNextRow(), is that the intent?");
 
    // If the user never got to call TableNextRow() or TableNextColumn(), we call layout ourselves to ensure all our
    // code paths are consistent (instead of just hoping that TableBegin/TableEnd will work), get borders drawn, etc.
    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);
 
    const ImGuiTableFlags flags = table->Flags;
    ImGuiWindow* inner_window = table->InnerWindow;
    ImGuiWindow* outer_window = table->OuterWindow;
    ImGuiTableTempData* temp_data = table->TempData;
    IM_ASSERT(inner_window == g.CurrentWindow);
    IM_ASSERT(outer_window == inner_window || outer_window == inner_window->ParentWindow);
 
    if (table->IsInsideRow)
        TableEndRow(table);
 
    // Context menu in columns body
    if (flags & ImGuiTableFlags_ContextMenuInBody)
        if (table->HoveredColumnBody != -1 && !IsAnyItemHovered() && IsMouseReleased(ImGuiMouseButton_Right))
            TableOpenContextMenu((int)table->HoveredColumnBody);
 
    // Finalize table height
    inner_window->DC.PrevLineSize = temp_data->HostBackupPrevLineSize;
    inner_window->DC.CurrLineSize = temp_data->HostBackupCurrLineSize;
    inner_window->DC.CursorMaxPos = temp_data->HostBackupCursorMaxPos;
    const float inner_content_max_y = table->RowPosY2;
    IM_ASSERT(table->RowPosY2 == inner_window->DC.CursorPos.y);
    if (inner_window != outer_window)
        inner_window->DC.CursorMaxPos.y = inner_content_max_y;
    else if (!(flags & ImGuiTableFlags_NoHostExtendY))
        table->OuterRect.Max.y = table->InnerRect.Max.y = ImMax(table->OuterRect.Max.y, inner_content_max_y); // Patch OuterRect/InnerRect height
    table->WorkRect.Max.y = ImMax(table->WorkRect.Max.y, table->OuterRect.Max.y);
    table->LastOuterHeight = table->OuterRect.GetHeight();
 
    // Setup inner scrolling range
    // FIXME: This ideally should be done earlier, in BeginTable() SetNextWindowContentSize call, just like writing to inner_window->DC.CursorMaxPos.y,
    // but since the later is likely to be impossible to do we'd rather update both axises together.
    if (table->Flags & ImGuiTableFlags_ScrollX)
    {
        const float outer_padding_for_border = (table->Flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
        float max_pos_x = table->InnerWindow->DC.CursorMaxPos.x;
        if (table->RightMostEnabledColumn != -1)
            max_pos_x = ImMax(max_pos_x, table->Columns[table->RightMostEnabledColumn].WorkMaxX + table->CellPaddingX + table->OuterPaddingX - outer_padding_for_border);
        if (table->ResizedColumn != -1)
            max_pos_x = ImMax(max_pos_x, table->ResizeLockMinContentsX2);
        table->InnerWindow->DC.CursorMaxPos.x = max_pos_x;
    }
 
    // Pop clipping rect
    if (!(flags & ImGuiTableFlags_NoClip))
        inner_window->DrawList->PopClipRect();
    inner_window->ClipRect = inner_window->DrawList->_ClipRectStack.back();
 
    // Draw borders
    if ((flags & ImGuiTableFlags_Borders) != 0)
        TableDrawBorders(table);
 
#if 0
    // Strip out dummy channel draw calls
    // We have no way to prevent user submitting direct ImDrawList calls into a hidden column (but ImGui:: calls will be clipped out)
    // Pros: remove draw calls which will have no effect. since they'll have zero-size cliprect they may be early out anyway.
    // Cons: making it harder for users watching metrics/debugger to spot the wasted vertices.
    if (table->DummyDrawChannel != (ImGuiTableColumnIdx)-1)
    {
        ImDrawChannel* dummy_channel = &table->DrawSplitter._Channels[table->DummyDrawChannel];
        dummy_channel->_CmdBuffer.resize(0);
        dummy_channel->_IdxBuffer.resize(0);
    }
#endif
 
    // Flatten channels and merge draw calls
    ImDrawListSplitter* splitter = table->DrawSplitter;
    splitter->SetCurrentChannel(inner_window->DrawList, 0);
    if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
        TableMergeDrawChannels(table);
    splitter->Merge(inner_window->DrawList);
 
    // Update ColumnsAutoFitWidth to get us ahead for host using our size to auto-resize without waiting for next BeginTable()
    const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1);
    table->ColumnsAutoFitWidth = width_spacings + (table->CellPaddingX * 2.0f) * table->ColumnsEnabledCount;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        if (table->EnabledMaskByIndex & ((ImU64)1 << column_n))
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && !(column->Flags & ImGuiTableColumnFlags_NoResize))
                table->ColumnsAutoFitWidth += column->WidthRequest;
            else
                table->ColumnsAutoFitWidth += TableGetColumnWidthAuto(table, column);
        }
 
    // Update scroll
    if ((table->Flags & ImGuiTableFlags_ScrollX) == 0 && inner_window != outer_window)
    {
        inner_window->Scroll.x = 0.0f;
    }
    else if (table->LastResizedColumn != -1 && table->ResizedColumn == -1 && inner_window->ScrollbarX && table->InstanceInteracted == table->InstanceCurrent)
    {
        // When releasing a column being resized, scroll to keep the resulting column in sight
        const float neighbor_width_to_keep_visible = table->MinColumnWidth + table->CellPaddingX * 2.0f;
        ImGuiTableColumn* column = &table->Columns[table->LastResizedColumn];
        if (column->MaxX < table->InnerClipRect.Min.x)
            SetScrollFromPosX(inner_window, column->MaxX - inner_window->Pos.x - neighbor_width_to_keep_visible, 1.0f);
        else if (column->MaxX > table->InnerClipRect.Max.x)
            SetScrollFromPosX(inner_window, column->MaxX - inner_window->Pos.x + neighbor_width_to_keep_visible, 1.0f);
    }
 
    // Apply resizing/dragging at the end of the frame
    if (table->ResizedColumn != -1 && table->InstanceCurrent == table->InstanceInteracted)
    {
        ImGuiTableColumn* column = &table->Columns[table->ResizedColumn];
        const float new_x2 = (g.IO.MousePos.x - g.ActiveIdClickOffset.x + TABLE_RESIZE_SEPARATOR_HALF_THICKNESS);
        const float new_width = ImFloor(new_x2 - column->MinX - table->CellSpacingX1 - table->CellPaddingX * 2.0f);
        table->ResizedColumnNextWidth = new_width;
    }
 
    // Pop from id stack
    IM_ASSERT_USER_ERROR(inner_window->IDStack.back() == table->ID + table->InstanceCurrent, "Mismatching PushID/PopID!");
    IM_ASSERT_USER_ERROR(outer_window->DC.ItemWidthStack.Size >= temp_data->HostBackupItemWidthStackSize, "Too many PopItemWidth!");
    PopID();
 
    // Restore window data that we modified
    const ImVec2 backup_outer_max_pos = outer_window->DC.CursorMaxPos;
    inner_window->WorkRect = temp_data->HostBackupWorkRect;
    inner_window->ParentWorkRect = temp_data->HostBackupParentWorkRect;
    inner_window->SkipItems = table->HostSkipItems;
    outer_window->DC.CursorPos = table->OuterRect.Min;
    outer_window->DC.ItemWidth = temp_data->HostBackupItemWidth;
    outer_window->DC.ItemWidthStack.Size = temp_data->HostBackupItemWidthStackSize;
    outer_window->DC.ColumnsOffset = temp_data->HostBackupColumnsOffset;
 
    // Layout in outer window
    // (FIXME: To allow auto-fit and allow desirable effect of SameLine() we dissociate 'used' vs 'ideal' size by overriding
    // CursorPosPrevLine and CursorMaxPos manually. That should be a more general layout feature, see same problem e.g. #3414)
    if (inner_window != outer_window)
    {
        EndChild();
    }
    else
    {
        ItemSize(table->OuterRect.GetSize());
        ItemAdd(table->OuterRect, 0);
    }
 
    // Override declared contents width/height to enable auto-resize while not needlessly adding a scrollbar
    if (table->Flags & ImGuiTableFlags_NoHostExtendX)
    {
        // FIXME-TABLE: Could we remove this section?
        // ColumnsAutoFitWidth may be one frame ahead here since for Fixed+NoResize is calculated from latest contents
        IM_ASSERT((table->Flags & ImGuiTableFlags_ScrollX) == 0);
        outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth);
    }
    else if (temp_data->UserOuterSize.x <= 0.0f)
    {
        const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.x : 0.0f;
        outer_window->DC.IdealMaxPos.x = ImMax(outer_window->DC.IdealMaxPos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth + decoration_size - temp_data->UserOuterSize.x);
        outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, ImMin(table->OuterRect.Max.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth));
    }
    else
    {
        outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, table->OuterRect.Max.x);
    }
    if (temp_data->UserOuterSize.y <= 0.0f)
    {
        const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollY) ? inner_window->ScrollbarSizes.y : 0.0f;
        outer_window->DC.IdealMaxPos.y = ImMax(outer_window->DC.IdealMaxPos.y, inner_content_max_y + decoration_size - temp_data->UserOuterSize.y);
        outer_window->DC.CursorMaxPos.y = ImMax(backup_outer_max_pos.y, ImMin(table->OuterRect.Max.y, inner_content_max_y));
    }
    else
    {
        // OuterRect.Max.y may already have been pushed downward from the initial value (unless ImGuiTableFlags_NoHostExtendY is set)
        outer_window->DC.CursorMaxPos.y = ImMax(backup_outer_max_pos.y, table->OuterRect.Max.y);
    }
 
    // Save settings
    if (table->IsSettingsDirty)
        TableSaveSettings(table);
    table->IsInitializing = false;
 
    // Clear or restore current table, if any
    IM_ASSERT(g.CurrentWindow == outer_window && g.CurrentTable == table);
    IM_ASSERT(g.CurrentTableStackIdx >= 0);
    g.CurrentTableStackIdx--;
    temp_data = g.CurrentTableStackIdx >= 0 ? &g.TablesTempDataStack[g.CurrentTableStackIdx] : NULL;
    g.CurrentTable = temp_data ? g.Tables.GetByIndex(temp_data->TableIndex) : NULL;
    if (g.CurrentTable)
    {
        g.CurrentTable->TempData = temp_data;
        g.CurrentTable->DrawSplitter = &temp_data->DrawSplitter;
    }
    outer_window->DC.CurrentTableIdx = g.CurrentTable ? g.Tables.GetIndex(g.CurrentTable) : -1;
}

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), ErrorCheckEndFrameRecover(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppPropertyEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndTooltip()

void ImGui::EndTooltip ( )

{
    IM_ASSERT(GetCurrentWindowRead()->Flags & ImGuiWindowFlags_Tooltip);   // Mismatched BeginTooltip()/EndTooltip() calls
    End();
}

References End(), GetCurrentWindowRead(), IM_ASSERT, and ImGuiWindowFlags_Tooltip.

Referenced by ColorTooltip(), EditTableSizingFlags(), EndDragDropSource(), HelpMarker(), MetricsHelpMarker(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::HintNotification::render_documentation_button(), Slic3r::GUI::NotificationManager::ExportFinishedNotification::render_eject_button(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay(), Slic3r::GUI::NotificationManager::HintNotification::render_preferences_button(), Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button(), SetTooltipV(), ShowDemoWindowWidgets(), ShowFont(), ShowStyleEditor(), Slic3r::GUI::ImGuiWrapper::tooltip(), and UpdateDebugToolItemPicker().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ErrorCheckEndFrameRecover()

void ImGui::ErrorCheckEndFrameRecover	(	ImGuiErrorLogCallback	log_callback,
		void *	user_data = `NULL`
	)

{
    // PVS-Studio V1044 is "Loop break conditions do not depend on the number of iterations"
    ImGuiContext& g = *GImGui;
    while (g.CurrentWindowStack.Size > 0)
    {
        while (g.CurrentTable && (g.CurrentTable->OuterWindow == g.CurrentWindow || g.CurrentTable->InnerWindow == g.CurrentWindow))
        {
            if (log_callback) log_callback(user_data, "Recovered from missing EndTable() in '%s'", g.CurrentTable->OuterWindow->Name);
            EndTable();
        }
        ImGuiWindow* window = g.CurrentWindow;
        IM_ASSERT(window != NULL);
        while (g.CurrentTabBar != NULL) //-V1044
        {
            if (log_callback) log_callback(user_data, "Recovered from missing EndTabBar() in '%s'", window->Name);
            EndTabBar();
        }
        while (window->DC.TreeDepth > 0)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing TreePop() in '%s'", window->Name);
            TreePop();
        }
        while (g.GroupStack.Size > window->DC.StackSizesOnBegin.SizeOfGroupStack)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing EndGroup() in '%s'", window->Name);
            EndGroup();
        }
        while (window->IDStack.Size > 1)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing PopID() in '%s'", window->Name);
            PopID();
        }
        while (g.ColorStack.Size > window->DC.StackSizesOnBegin.SizeOfColorStack)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing PopStyleColor() in '%s' for ImGuiCol_%s", window->Name, GetStyleColorName(g.ColorStack.back().Col));
            PopStyleColor();
        }
        while (g.StyleVarStack.Size > window->DC.StackSizesOnBegin.SizeOfStyleVarStack)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing PopStyleVar() in '%s'", window->Name);
            PopStyleVar();
        }
        while (g.FocusScopeStack.Size > window->DC.StackSizesOnBegin.SizeOfFocusScopeStack)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing PopFocusScope() in '%s'", window->Name);
            PopFocusScope();
        }
        if (g.CurrentWindowStack.Size == 1)
        {
            IM_ASSERT(g.CurrentWindow->IsFallbackWindow);
            break;
        }
        IM_ASSERT(window == g.CurrentWindow);
        if (window->Flags & ImGuiWindowFlags_ChildWindow)
        {
            if (log_callback) log_callback(user_data, "Recovered from missing EndChild() for '%s'", window->Name);
            EndChild();
        }
        else
        {
            if (log_callback) log_callback(user_data, "Recovered from missing End() for '%s'", window->Name);
            End();
        }
    }
}

References ImVector< T >::back(), ImGuiColorMod::Col, ImGuiContext::ColorStack, ImGuiContext::CurrentTabBar, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiContext::CurrentWindowStack, ImGuiWindow::DC, End(), EndChild(), EndGroup(), EndTabBar(), EndTable(), ImGuiWindow::Flags, ImGuiContext::FocusScopeStack, GetStyleColorName(), GImGui, ImGuiContext::GroupStack, ImGuiWindow::IDStack, IM_ASSERT, ImGuiWindowFlags_ChildWindow, ImGuiTable::InnerWindow, ImGuiWindow::IsFallbackWindow, ImGuiWindow::Name, ImGuiTable::OuterWindow, PopFocusScope(), PopID(), PopStyleColor(), PopStyleVar(), ImVector< T >::Size, ImGuiStackSizes::SizeOfColorStack, ImGuiStackSizes::SizeOfFocusScopeStack, ImGuiStackSizes::SizeOfGroupStack, ImGuiStackSizes::SizeOfStyleVarStack, ImGuiWindowTempData::StackSizesOnBegin, ImGuiContext::StyleVarStack, ImGuiWindowTempData::TreeDepth, and TreePop().

Here is the call graph for this function:

◆ ErrorCheckEndFrameSanityChecks()

static void ImGui::ErrorCheckEndFrameSanityChecks ( )

static

{
    ImGuiContext& g = *GImGui;
 
    // Verify that io.KeyXXX fields haven't been tampered with. Key mods should not be modified between NewFrame() and EndFrame()
    // One possible reason leading to this assert is that your backends update inputs _AFTER_ NewFrame().
    // It is known that when some modal native windows called mid-frame takes focus away, some backends such as GLFW will
    // send key release events mid-frame. This would normally trigger this assertion and lead to sheared inputs.
    // We silently accommodate for this case by ignoring/ the case where all io.KeyXXX modifiers were released (aka key_mod_flags == 0),
    // while still correctly asserting on mid-frame key press events.
    const ImGuiKeyModFlags key_mod_flags = GetMergedKeyModFlags();
    IM_ASSERT((key_mod_flags == 0 || g.IO.KeyMods == key_mod_flags) && "Mismatching io.KeyCtrl/io.KeyShift/io.KeyAlt/io.KeySuper vs io.KeyMods");
    IM_UNUSED(key_mod_flags);
 
    // Recover from errors
    //ErrorCheckEndFrameRecover();
 
    // Report when there is a mismatch of Begin/BeginChild vs End/EndChild calls. Important: Remember that the Begin/BeginChild API requires you
    // to always call End/EndChild even if Begin/BeginChild returns false! (this is unfortunately inconsistent with most other Begin* API).
    if (g.CurrentWindowStack.Size != 1)
    {
        if (g.CurrentWindowStack.Size > 1)
        {
            IM_ASSERT_USER_ERROR(g.CurrentWindowStack.Size == 1, "Mismatched Begin/BeginChild vs End/EndChild calls: did you forget to call End/EndChild?");
            while (g.CurrentWindowStack.Size > 1)
                End();
        }
        else
        {
            IM_ASSERT_USER_ERROR(g.CurrentWindowStack.Size == 1, "Mismatched Begin/BeginChild vs End/EndChild calls: did you call End/EndChild too much?");
        }
    }
 
    IM_ASSERT_USER_ERROR(g.GroupStack.Size == 0, "Missing EndGroup call!");
}

References ImGuiContext::CurrentWindowStack, End(), GetMergedKeyModFlags(), GImGui, ImGuiContext::GroupStack, IM_ASSERT, IM_ASSERT_USER_ERROR, IM_UNUSED, ImGuiContext::IO, ImGuiIO::KeyMods, and ImVector< T >::Size.

Referenced by EndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ErrorCheckNewFrameSanityChecks()

static void ImGui::ErrorCheckNewFrameSanityChecks ( )

static

{
    ImGuiContext& g = *GImGui;
 
    // Check user IM_ASSERT macro
    // (IF YOU GET A WARNING OR COMPILE ERROR HERE: it means your assert macro is incorrectly defined!
    //  If your macro uses multiple statements, it NEEDS to be surrounded by a 'do { ... } while (0)' block.
    //  This is a common C/C++ idiom to allow multiple statements macros to be used in control flow blocks.)
    // #define IM_ASSERT(EXPR)   if (SomeCode(EXPR)) SomeMoreCode();                    // Wrong!
    // #define IM_ASSERT(EXPR)   do { if (SomeCode(EXPR)) SomeMoreCode(); } while (0)   // Correct!
    if (true) IM_ASSERT(1); else IM_ASSERT(0);
 
    // Check user data
    // (We pass an error message in the assert expression to make it visible to programmers who are not using a debugger, as most assert handlers display their argument)
    IM_ASSERT(g.Initialized);
    IM_ASSERT((g.IO.DeltaTime > 0.0f || g.FrameCount == 0)              && "Need a positive DeltaTime!");
    IM_ASSERT((g.FrameCount == 0 || g.FrameCountEnded == g.FrameCount)  && "Forgot to call Render() or EndFrame() at the end of the previous frame?");
    IM_ASSERT(g.IO.DisplaySize.x >= 0.0f && g.IO.DisplaySize.y >= 0.0f  && "Invalid DisplaySize value!");
    IM_ASSERT(g.IO.Fonts->Fonts.Size > 0                                && "Font Atlas not built. Did you call io.Fonts->GetTexDataAsRGBA32() / GetTexDataAsAlpha8()?");
    IM_ASSERT(g.IO.Fonts->Fonts[0]->IsLoaded()                          && "Font Atlas not built. Did you call io.Fonts->GetTexDataAsRGBA32() / GetTexDataAsAlpha8()?");
    IM_ASSERT(g.Style.CurveTessellationTol > 0.0f                       && "Invalid style setting!");
    IM_ASSERT(g.Style.CircleTessellationMaxError  > 0.0f                && "Invalid style setting!");
    IM_ASSERT(g.Style.Alpha >= 0.0f && g.Style.Alpha <= 1.0f            && "Invalid style setting!"); // Allows us to avoid a few clamps in color computations
    IM_ASSERT(g.Style.WindowMinSize.x >= 1.0f && g.Style.WindowMinSize.y >= 1.0f && "Invalid style setting.");
    IM_ASSERT(g.Style.WindowMenuButtonPosition == ImGuiDir_None || g.Style.WindowMenuButtonPosition == ImGuiDir_Left || g.Style.WindowMenuButtonPosition == ImGuiDir_Right);
    for (int n = 0; n < ImGuiKey_COUNT; n++)
        IM_ASSERT(g.IO.KeyMap[n] >= -1 && g.IO.KeyMap[n] < IM_ARRAYSIZE(g.IO.KeysDown) && "io.KeyMap[] contains an out of bound value (need to be 0..512, or -1 for unmapped key)");
 
    // Check: required key mapping (we intentionally do NOT check all keys to not pressure user into setting up everything, but Space is required and was only added in 1.60 WIP)
    if (g.IO.ConfigFlags & ImGuiConfigFlags_NavEnableKeyboard)
        IM_ASSERT(g.IO.KeyMap[ImGuiKey_Space] != -1 && "ImGuiKey_Space is not mapped, required for keyboard navigation.");
 
    // Check: the io.ConfigWindowsResizeFromEdges option requires backend to honor mouse cursor changes and set the ImGuiBackendFlags_HasMouseCursors flag accordingly.
    if (g.IO.ConfigWindowsResizeFromEdges && !(g.IO.BackendFlags & ImGuiBackendFlags_HasMouseCursors))
        g.IO.ConfigWindowsResizeFromEdges = false;
}

References ImGuiStyle::Alpha, ImGuiIO::BackendFlags, ImGuiStyle::CircleTessellationMaxError, ImGuiIO::ConfigFlags, ImGuiIO::ConfigWindowsResizeFromEdges, ImGuiStyle::CurveTessellationTol, ImGuiIO::DeltaTime, ImGuiIO::DisplaySize, ImGuiIO::Fonts, ImFontAtlas::Fonts, ImGuiContext::FrameCount, ImGuiContext::FrameCountEnded, GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiBackendFlags_HasMouseCursors, ImGuiConfigFlags_NavEnableKeyboard, ImGuiDir_Left, ImGuiDir_None, ImGuiDir_Right, ImGuiKey_COUNT, ImGuiKey_Space, ImGuiContext::Initialized, ImGuiContext::IO, ImGuiIO::KeyMap, ImGuiIO::KeysDown, ImVector< T >::Size, ImGuiContext::Style, ImGuiStyle::WindowMenuButtonPosition, ImGuiStyle::WindowMinSize, ImVec2::x, and ImVec2::y.

Referenced by NewFrame().

Here is the caller graph for this function:

◆ FindBestWindowPosForPopup()

ImVec2 ImGui::FindBestWindowPosForPopup ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
 
    ImRect r_outer = GetWindowAllowedExtentRect(window);
    if (window->Flags & ImGuiWindowFlags_ChildMenu)
    {
        // Child menus typically request _any_ position within the parent menu item, and then we move the new menu outside the parent bounds.
        // This is how we end up with child menus appearing (most-commonly) on the right of the parent menu.
        IM_ASSERT(g.CurrentWindow == window);
        ImGuiWindow* parent_window = g.CurrentWindowStack[g.CurrentWindowStack.Size - 2];
        float horizontal_overlap = g.Style.ItemInnerSpacing.x; // We want some overlap to convey the relative depth of each menu (currently the amount of overlap is hard-coded to style.ItemSpacing.x).
        ImRect r_avoid;
        if (parent_window->DC.MenuBarAppending)
            r_avoid = ImRect(-FLT_MAX, parent_window->ClipRect.Min.y, FLT_MAX, parent_window->ClipRect.Max.y); // Avoid parent menu-bar. If we wanted multi-line menu-bar, we may instead want to have the calling window setup e.g. a NextWindowData.PosConstraintAvoidRect field
        else
            r_avoid = ImRect(parent_window->Pos.x + horizontal_overlap, -FLT_MAX, parent_window->Pos.x + parent_window->Size.x - horizontal_overlap - parent_window->ScrollbarSizes.x, FLT_MAX);
        return FindBestWindowPosForPopupEx(window->Pos, window->Size, &window->AutoPosLastDirection, r_outer, r_avoid, ImGuiPopupPositionPolicy_Default);
    }
    if (window->Flags & ImGuiWindowFlags_Popup)
    {
        ImRect r_avoid = ImRect(window->Pos.x - 1, window->Pos.y - 1, window->Pos.x + 1, window->Pos.y + 1);
        return FindBestWindowPosForPopupEx(window->Pos, window->Size, &window->AutoPosLastDirection, r_outer, r_avoid, ImGuiPopupPositionPolicy_Default);
    }
    if (window->Flags & ImGuiWindowFlags_Tooltip)
    {
        // Position tooltip (always follows mouse)
        float sc = g.Style.MouseCursorScale;
        ImVec2 ref_pos = NavCalcPreferredRefPos();
        ImRect r_avoid;
        if (!g.NavDisableHighlight && g.NavDisableMouseHover && !(g.IO.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos))
            r_avoid = ImRect(ref_pos.x - 16, ref_pos.y - 8, ref_pos.x + 16, ref_pos.y + 8);
        else
            r_avoid = ImRect(ref_pos.x - 16, ref_pos.y - 8, ref_pos.x + 24 * sc, ref_pos.y + 24 * sc); // FIXME: Hard-coded based on mouse cursor shape expectation. Exact dimension not very important.
        return FindBestWindowPosForPopupEx(ref_pos, window->Size, &window->AutoPosLastDirection, r_outer, r_avoid, ImGuiPopupPositionPolicy_Tooltip);
    }
    IM_ASSERT(0);
    return window->Pos;
}

References ImGuiWindow::AutoPosLastDirection, ImGuiWindow::ClipRect, ImGuiIO::ConfigFlags, ImGuiContext::CurrentWindow, ImGuiContext::CurrentWindowStack, ImGuiWindow::DC, FindBestWindowPosForPopupEx(), ImGuiWindow::Flags, GetWindowAllowedExtentRect(), GImGui, IM_ASSERT, ImGuiConfigFlags_NavEnableSetMousePos, ImGuiPopupPositionPolicy_Default, ImGuiPopupPositionPolicy_Tooltip, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_Popup, ImGuiWindowFlags_Tooltip, ImGuiContext::IO, ImGuiStyle::ItemInnerSpacing, ImRect::Max, ImGuiWindowTempData::MenuBarAppending, ImRect::Min, ImGuiStyle::MouseCursorScale, NavCalcPreferredRefPos(), ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiWindow::Pos, ImGuiWindow::ScrollbarSizes, ImVector< T >::Size, ImGuiWindow::Size, ImGuiContext::Style, ImVec2::x, and ImVec2::y.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindBestWindowPosForPopupEx()

ImVec2 ImGui::FindBestWindowPosForPopupEx	(	const ImVec2 &	ref_pos,
		const ImVec2 &	size,
		ImGuiDir *	last_dir,
		const ImRect &	r_outer,
		const ImRect &	r_avoid,
		ImGuiPopupPositionPolicy	policy
	)

{
    ImVec2 base_pos_clamped = ImClamp(ref_pos, r_outer.Min, r_outer.Max - size);
    //GetForegroundDrawList()->AddRect(r_avoid.Min, r_avoid.Max, IM_COL32(255,0,0,255));
    //GetForegroundDrawList()->AddRect(r_outer.Min, r_outer.Max, IM_COL32(0,255,0,255));
 
    // Combo Box policy (we want a connecting edge)
    if (policy == ImGuiPopupPositionPolicy_ComboBox)
    {
        const ImGuiDir dir_prefered_order[ImGuiDir_COUNT] = { ImGuiDir_Down, ImGuiDir_Right, ImGuiDir_Left, ImGuiDir_Up };
        for (int n = (*last_dir != ImGuiDir_None) ? -1 : 0; n < ImGuiDir_COUNT; n++)
        {
            const ImGuiDir dir = (n == -1) ? *last_dir : dir_prefered_order[n];
            if (n != -1 && dir == *last_dir) // Already tried this direction?
                continue;
            ImVec2 pos;
            if (dir == ImGuiDir_Down)  pos = ImVec2(r_avoid.Min.x, r_avoid.Max.y);          // Below, Toward Right (default)
            if (dir == ImGuiDir_Right) pos = ImVec2(r_avoid.Min.x, r_avoid.Min.y - size.y); // Above, Toward Right
            if (dir == ImGuiDir_Left)  pos = ImVec2(r_avoid.Max.x - size.x, r_avoid.Max.y); // Below, Toward Left
            if (dir == ImGuiDir_Up)    pos = ImVec2(r_avoid.Max.x - size.x, r_avoid.Min.y - size.y); // Above, Toward Left
            if (!r_outer.Contains(ImRect(pos, pos + size)))
                continue;
            *last_dir = dir;
            return pos;
        }
    }
 
    // Tooltip and Default popup policy
    // (Always first try the direction we used on the last frame, if any)
    if (policy == ImGuiPopupPositionPolicy_Tooltip || policy == ImGuiPopupPositionPolicy_Default)
    {
        const ImGuiDir dir_prefered_order[ImGuiDir_COUNT] = { ImGuiDir_Right, ImGuiDir_Down, ImGuiDir_Up, ImGuiDir_Left };
        for (int n = (*last_dir != ImGuiDir_None) ? -1 : 0; n < ImGuiDir_COUNT; n++)
        {
            const ImGuiDir dir = (n == -1) ? *last_dir : dir_prefered_order[n];
            if (n != -1 && dir == *last_dir) // Already tried this direction?
                continue;
 
            const float avail_w = (dir == ImGuiDir_Left ? r_avoid.Min.x : r_outer.Max.x) - (dir == ImGuiDir_Right ? r_avoid.Max.x : r_outer.Min.x);
            const float avail_h = (dir == ImGuiDir_Up ? r_avoid.Min.y : r_outer.Max.y) - (dir == ImGuiDir_Down ? r_avoid.Max.y : r_outer.Min.y);
 
            // If there not enough room on one axis, there's no point in positioning on a side on this axis (e.g. when not enough width, use a top/bottom position to maximize available width)
            if (avail_w < size.x && (dir == ImGuiDir_Left || dir == ImGuiDir_Right))
                continue;
            if (avail_h < size.y && (dir == ImGuiDir_Up || dir == ImGuiDir_Down))
                continue;
 
            ImVec2 pos;
            pos.x = (dir == ImGuiDir_Left) ? r_avoid.Min.x - size.x : (dir == ImGuiDir_Right) ? r_avoid.Max.x : base_pos_clamped.x;
            pos.y = (dir == ImGuiDir_Up) ? r_avoid.Min.y - size.y : (dir == ImGuiDir_Down) ? r_avoid.Max.y : base_pos_clamped.y;
 
            // Clamp top-left corner of popup
            pos.x = ImMax(pos.x, r_outer.Min.x);
            pos.y = ImMax(pos.y, r_outer.Min.y);
 
            *last_dir = dir;
            return pos;
        }
    }
 
    // Fallback when not enough room:
    *last_dir = ImGuiDir_None;
 
    // For tooltip we prefer avoiding the cursor at all cost even if it means that part of the tooltip won't be visible.
    if (policy == ImGuiPopupPositionPolicy_Tooltip)
        return ref_pos + ImVec2(2, 2);
 
    // Otherwise try to keep within display
    ImVec2 pos = ref_pos;
    pos.x = ImMax(ImMin(pos.x + size.x, r_outer.Max.x) - size.x, r_outer.Min.x);
    pos.y = ImMax(ImMin(pos.y + size.y, r_outer.Max.y) - size.y, r_outer.Min.y);
    return pos;
}

References ImRect::Contains(), ImClamp(), ImGuiDir_COUNT, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_None, ImGuiDir_Right, ImGuiDir_Up, ImGuiPopupPositionPolicy_ComboBox, ImGuiPopupPositionPolicy_Default, ImGuiPopupPositionPolicy_Tooltip, ImMax(), ImMin(), ImRect::Max, ImRect::Min, ImVec2::x, and ImVec2::y.

Referenced by BeginCombo(), and FindBestWindowPosForPopup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindOrCreateColumns()

ImGuiOldColumns * ImGui::FindOrCreateColumns	(	ImGuiWindow *	window,
		ImGuiID	id
	)

{
    // We have few columns per window so for now we don't need bother much with turning this into a faster lookup.
    for (int n = 0; n < window->ColumnsStorage.Size; n++)
        if (window->ColumnsStorage[n].ID == id)
            return &window->ColumnsStorage[n];
 
    window->ColumnsStorage.push_back(ImGuiOldColumns());
    ImGuiOldColumns* columns = &window->ColumnsStorage.back();
    columns->ID = id;
    return columns;
}

References ImVector< T >::back(), ImGuiWindow::ColumnsStorage, ImGuiOldColumns::ID, ImVector< T >::push_back(), and ImVector< T >::Size.

Referenced by BeginColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindOrCreateWindowSettings()

ImGuiWindowSettings * ImGui::FindOrCreateWindowSettings ( const char * name )

{
    if (ImGuiWindowSettings* settings = FindWindowSettings(ImHashStr(name)))
        return settings;
    return CreateNewWindowSettings(name);
}

References CreateNewWindowSettings(), FindWindowSettings(), and ImHashStr().

Referenced by WindowSettingsHandler_ReadOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindRenderedTextEnd()

const char * ImGui::FindRenderedTextEnd	(	const char *	text,
		const char *	text_end = `NULL`
	)

{
    const char* text_display_end = text;
    if (!text_end)
        text_end = (const char*)-1;
 
    while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
        text_display_end++;
    return text_display_end;
}

Referenced by CalcTextSize(), ColorEdit4(), ColorPicker4(), ColorTooltip(), DebugRenderViewportThumbnail(), DragFloatRange2(), DragIntRange2(), DragScalarN(), InputScalar(), InputScalarN(), LogRenderedText(), NavUpdateWindowingOverlay(), RenderText(), RenderTextClipped(), RenderTextEllipsis(), SliderScalarN(), TabItemEx(), TableHeader(), and TreeNodeBehavior().

Here is the caller graph for this function:

◆ FindSettingsHandler()

ImGuiSettingsHandler * ImGui::FindSettingsHandler ( const char * type_name )

{
    ImGuiContext& g = *GImGui;
    const ImGuiID type_hash = ImHashStr(type_name);
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].TypeHash == type_hash)
            return &g.SettingsHandlers[handler_n];
    return NULL;
}

References GImGui, ImHashStr(), ImGuiContext::SettingsHandlers, and ImVector< T >::Size.

Referenced by LoadIniSettingsFromMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindWindowByID()

ImGuiWindow * ImGui::FindWindowByID ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    return (ImGuiWindow*)g.WindowsById.GetVoidPtr(id);
}

References ImGuiStorage::GetVoidPtr(), GImGui, and ImGuiContext::WindowsById.

Referenced by FindWindowByName(), and WindowSettingsHandler_ApplyAll().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindWindowByName()

ImGuiWindow * ImGui::FindWindowByName ( const char * name )

{
    ImGuiID id = ImHashStr(name);
    return FindWindowByID(id);
}

References FindWindowByID(), and ImHashStr().

Referenced by Begin(), BeginCombo(), BeginTooltipEx(), BeginViewportSideBar(), priv::change_window_position(), NavUpdateWindowingOverlay(), SetWindowCollapsed(), SetWindowFocus(), SetWindowPos(), and SetWindowSize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindWindowFocusIndex()

static int ImGui::FindWindowFocusIndex ( ImGuiWindow * window )

static

{
    ImGuiContext& g = *GImGui;
    IM_UNUSED(g);
    int order = window->FocusOrder;
    IM_ASSERT(g.WindowsFocusOrder[order] == window);
    return order;
}

References ImGuiWindow::FocusOrder, GImGui, IM_ASSERT, IM_UNUSED, and ImGuiContext::WindowsFocusOrder.

Referenced by FocusTopMostWindowUnderOne(), and NavUpdateWindowingHighlightWindow().

Here is the caller graph for this function:

◆ FindWindowSettings()

ImGuiWindowSettings * ImGui::FindWindowSettings ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
        if (settings->ID == id)
            return settings;
    return NULL;
}

References ImChunkStream< T >::begin(), GImGui, ImChunkStream< T >::next_chunk(), and ImGuiContext::SettingsWindows.

Referenced by CreateNewWindow(), FindOrCreateWindowSettings(), and WindowSettingsHandler_WriteAll().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FocusableItemRegister()

bool ImGui::FocusableItemRegister	(	ImGuiWindow *	window,
		ImGuiID	id
	)

inline

2378{ IM_ASSERT(0); IM_UNUSED(window); IM_UNUSED(id); return false; } // -> pass ImGuiItemAddFlags_Focusable flag to ItemAdd()

References IM_ASSERT, and IM_UNUSED.

◆ FocusableItemUnregister()

void ImGui::FocusableItemUnregister ( ImGuiWindow * window )

inline

2379{ IM_ASSERT(0); IM_UNUSED(window); } // -> unnecessary: TempInputText() uses ImGuiInputTextFlags_MergedItem

References IM_ASSERT, and IM_UNUSED.

◆ FocusTopMostWindowUnderOne()

void ImGui::FocusTopMostWindowUnderOne	(	ImGuiWindow *	under_this_window,
		ImGuiWindow *	ignore_window
	)

{
    ImGuiContext& g = *GImGui;
 
    const int start_idx = ((under_this_window != NULL) ? FindWindowFocusIndex(under_this_window) : g.WindowsFocusOrder.Size) - 1;
    for (int i = start_idx; i >= 0; i--)
    {
        // We may later decide to test for different NoXXXInputs based on the active navigation input (mouse vs nav) but that may feel more confusing to the user.
        ImGuiWindow* window = g.WindowsFocusOrder[i];
        IM_ASSERT(window == window->RootWindow);
        if (window != ignore_window && window->WasActive)
            if ((window->Flags & (ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs)) != (ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs))
            {
                ImGuiWindow* focus_window = NavRestoreLastChildNavWindow(window);
                FocusWindow(focus_window);
                return;
            }
    }
    FocusWindow(NULL);
}

References FindWindowFocusIndex(), ImGuiWindow::Flags, FocusWindow(), GImGui, IM_ASSERT, ImGuiWindowFlags_NoMouseInputs, ImGuiWindowFlags_NoNavInputs, NavRestoreLastChildNavWindow(), ImGuiWindow::RootWindow, ImVector< T >::Size, ImGuiWindow::WasActive, and ImGuiContext::WindowsFocusOrder.

Referenced by ClosePopupToLevel(), EndMainMenuBar(), and NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FocusWindow()

void ImGui::FocusWindow ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
 
    if (g.NavWindow != window)
    {
        g.NavWindow = window;
        if (window && g.NavDisableMouseHover)
            g.NavMousePosDirty = true;
        g.NavId = window ? window->NavLastIds[0] : 0; // Restore NavId
        g.NavFocusScopeId = 0;
        g.NavIdIsAlive = false;
        g.NavLayer = ImGuiNavLayer_Main;
        g.NavInitRequest = g.NavMoveRequest = false;
        NavUpdateAnyRequestFlag();
        //IMGUI_DEBUG_LOG("FocusWindow(\"%s\")\n", window ? window->Name : NULL);
    }
 
    // Close popups if any
    ClosePopupsOverWindow(window, false);
 
    // Move the root window to the top of the pile
    IM_ASSERT(window == NULL || window->RootWindow != NULL);
    ImGuiWindow* focus_front_window = window ? window->RootWindow : NULL; // NB: In docking branch this is window->RootWindowDockStop
    ImGuiWindow* display_front_window = window ? window->RootWindow : NULL;
 
    // Steal active widgets. Some of the cases it triggers includes:
    // - Focus a window while an InputText in another window is active, if focus happens before the old InputText can run.
    // - When using Nav to activate menu items (due to timing of activating on press->new window appears->losing ActiveId)
    if (g.ActiveId != 0 && g.ActiveIdWindow && g.ActiveIdWindow->RootWindow != focus_front_window)
        if (!g.ActiveIdNoClearOnFocusLoss)
            ClearActiveID();
 
    // Passing NULL allow to disable keyboard focus
    if (!window)
        return;
 
    // Bring to front
    BringWindowToFocusFront(focus_front_window);
    if (((window->Flags | display_front_window->Flags) & ImGuiWindowFlags_NoBringToFrontOnFocus) == 0)
        BringWindowToDisplayFront(display_front_window);
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdNoClearOnFocusLoss, ImGuiContext::ActiveIdWindow, BringWindowToDisplayFront(), BringWindowToFocusFront(), ClearActiveID(), ClosePopupsOverWindow(), ImGuiWindow::Flags, GImGui, IM_ASSERT, ImGuiNavLayer_Main, ImGuiWindowFlags_NoBringToFrontOnFocus, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavFocusScopeId, ImGuiContext::NavId, ImGuiContext::NavIdIsAlive, ImGuiContext::NavInitRequest, ImGuiWindow::NavLastIds, ImGuiContext::NavLayer, ImGuiContext::NavMousePosDirty, ImGuiContext::NavMoveRequest, NavUpdateAnyRequestFlag(), ImGuiContext::NavWindow, and ImGuiWindow::RootWindow.

Referenced by Begin(), BeginChildEx(), BeginDragDropSource(), ButtonBehavior(), ClosePopupToLevel(), DragScalar(), EndMenuBar(), FocusTopMostWindowUnderOne(), InputTextEx(), NavUpdate(), NavUpdateWindowing(), SetWindowFocus(), SetWindowFocus(), SliderScalar(), StartMouseMovingWindow(), UpdateMouseMovingWindowEndFrame(), UpdateMouseMovingWindowNewFrame(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GcAwakeTransientWindowBuffers()

void ImGui::GcAwakeTransientWindowBuffers ( ImGuiWindow * window )

{
    // We stored capacity of the ImDrawList buffer to reduce growth-caused allocation/copy when awakening.
    // The other buffers tends to amortize much faster.
    window->MemoryCompacted = false;
    window->DrawList->IdxBuffer.reserve(window->MemoryDrawListIdxCapacity);
    window->DrawList->VtxBuffer.reserve(window->MemoryDrawListVtxCapacity);
    window->MemoryDrawListIdxCapacity = window->MemoryDrawListVtxCapacity = 0;
}

References ImGuiWindow::DrawList, ImDrawList::IdxBuffer, ImGuiWindow::MemoryCompacted, ImGuiWindow::MemoryDrawListIdxCapacity, ImGuiWindow::MemoryDrawListVtxCapacity, ImVector< T >::reserve(), and ImDrawList::VtxBuffer.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GcCompactTransientMiscBuffers()

void ImGui::GcCompactTransientMiscBuffers ( )

{
    ImGuiContext& g = *GImGui;
    g.ItemFlagsStack.clear();
    g.GroupStack.clear();
    TableGcCompactSettings();
}

References ImVector< T >::clear(), GImGui, ImGuiContext::GroupStack, ImGuiContext::ItemFlagsStack, and TableGcCompactSettings().

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GcCompactTransientWindowBuffers()

void ImGui::GcCompactTransientWindowBuffers ( ImGuiWindow * window )

{
    window->MemoryCompacted = true;
    window->MemoryDrawListIdxCapacity = window->DrawList->IdxBuffer.Capacity;
    window->MemoryDrawListVtxCapacity = window->DrawList->VtxBuffer.Capacity;
    window->IDStack.clear();
    window->DrawList->_ClearFreeMemory();
    window->DC.ChildWindows.clear();
    window->DC.ItemWidthStack.clear();
    window->DC.TextWrapPosStack.clear();
}

References ImDrawList::_ClearFreeMemory(), ImVector< T >::Capacity, ImGuiWindowTempData::ChildWindows, ImVector< T >::clear(), ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiWindow::IDStack, ImDrawList::IdxBuffer, ImGuiWindowTempData::ItemWidthStack, ImGuiWindow::MemoryCompacted, ImGuiWindow::MemoryDrawListIdxCapacity, ImGuiWindow::MemoryDrawListVtxCapacity, ImGuiWindowTempData::TextWrapPosStack, and ImDrawList::VtxBuffer.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetActiveID()

ImGuiID ImGui::GetActiveID ( )

inline

2343{ ImGuiContext& g = *GImGui; return g.ActiveId; }

References ImGuiContext::ActiveId, and GImGui.

Referenced by Slic3r::GUI::ImGuiWrapper::slider_float().

Here is the caller graph for this function:

◆ GetAllocatorFunctions()

void ImGui::GetAllocatorFunctions	(	ImGuiMemAllocFunc *	p_alloc_func,
		ImGuiMemFreeFunc *	p_free_func,
		void **	p_user_data
	)

{
    *p_alloc_func = GImAllocatorAllocFunc;
    *p_free_func = GImAllocatorFreeFunc;
    *p_user_data = GImAllocatorUserData;
}

References GImAllocatorAllocFunc, GImAllocatorFreeFunc, and GImAllocatorUserData.

◆ GetBackgroundDrawList() [1/2]

ImDrawList * ImGui::GetBackgroundDrawList ( )

{
    ImGuiContext& g = *GImGui;
    return GetBackgroundDrawList(g.Viewports[0]);
}

References GetBackgroundDrawList(), GImGui, and ImGuiContext::Viewports.

Referenced by GetBackgroundDrawList(), Render(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBackgroundDrawList() [2/2]

ImDrawList * ImGui::GetBackgroundDrawList ( ImGuiViewport * viewport )

{
    return GetViewportDrawList((ImGuiViewportP*)viewport, 0, "##Background");
}

References GetViewportDrawList().

Here is the call graph for this function:

◆ GetClipboardText()

const char * ImGui::GetClipboardText ( )

{
    ImGuiContext& g = *GImGui;
    return g.IO.GetClipboardTextFn ? g.IO.GetClipboardTextFn(g.IO.ClipboardUserData) : "";
}

References ImGuiIO::ClipboardUserData, ImGuiIO::GetClipboardTextFn, GImGui, and ImGuiContext::IO.

Referenced by InputTextEx().

Here is the caller graph for this function:

◆ GetColorU32() [1/3]

ImU32 ImGui::GetColorU32 ( const ImVec4 & col )

{
    ImGuiStyle& style = GImGui->Style;
    ImVec4 c = col;
    c.w *= style.Alpha;
    return ColorConvertFloat4ToU32(c);
}

References col(), ColorConvertFloat4ToU32(), GImGui, ImGuiContext::Style, and style.

Here is the call graph for this function:

◆ GetColorU32() [2/3]

ImU32 ImGui::GetColorU32	(	ImGuiCol	idx,
		float	alpha_mul = `1.0f`
	)

{
    ImGuiStyle& style = GImGui->Style;
    ImVec4 c = style.Colors[idx];
    c.w *= style.Alpha * alpha_mul;
    return ColorConvertFloat4ToU32(c);
}

References ColorConvertFloat4ToU32(), GImGui, ImGuiContext::Style, and style.

Referenced by AcceptDragDropPayload(), ArrowButtonEx(), Begin(), BeginCombo(), BeginMenu(), BeginTabBarEx(), BeginTableEx(), Bullet(), BulletTextV(), ButtonEx(), Checkbox(), CloseButton(), CollapseButton(), ColorButton(), DebugRenderViewportThumbnail(), DragScalar(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), igl::opengl::glfw::imgui::ImGuiMenu::draw_text(), EndColumns(), Image(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), InputTextEx(), MenuItem(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), PlotEx(), ProgressBar(), RadioButton(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GLGizmoCut3D::render_flip_plane_button(), Slic3r::GUI::GCodeViewer::render_legend(), RenderArrow(), RenderBullet(), RenderColorRectWithAlphaCheckerboard(), RenderFrame(), RenderFrameBorder(), RenderNavHighlight(), ImFont::RenderText(), RenderText(), RenderTextClippedEx(), RenderTextEllipsis(), RenderTextWrapped(), RenderWindowDecorations(), RenderWindowOuterBorders(), ScrollbarEx(), Slic3r::GUI::selectable(), Selectable(), SeparatorEx(), ShowDemoWindowMisc(), ShowDemoWindowTables(), ShowExampleAppCustomRendering(), ShowExampleMenuFile(), ShowFont(), ShowStyleEditor(), SliderScalar(), SplitterBehavior(), TabItemBackground(), TabItemEx(), TableBeginRow(), TableDrawBorders(), TableEndRow(), TableHeader(), Slic3r::GUI::ImGuiWrapper::to_ImU32(), TreeNodeBehavior(), UpdateWindowManualResize(), and VSliderScalar().

Here is the call graph for this function:

◆ GetColorU32() [3/3]

ImU32 ImGui::GetColorU32 ( ImU32 col )

{
    ImGuiStyle& style = GImGui->Style;
    if (style.Alpha >= 1.0f)
        return col;
    ImU32 a = (col & IM_COL32_A_MASK) >> IM_COL32_A_SHIFT;
    a = (ImU32)(a * style.Alpha); // We don't need to clamp 0..255 because Style.Alpha is in 0..1 range.
    return (col & ~IM_COL32_A_MASK) | (a << IM_COL32_A_SHIFT);
}

References col(), GImGui, IM_COL32_A_MASK, IM_COL32_A_SHIFT, ImGuiContext::Style, and style.

Here is the call graph for this function:

◆ GetColumnIndex()

int ImGui::GetColumnIndex ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CurrentColumns ? window->DC.CurrentColumns->Current : 0;
}

References ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, and GetCurrentWindowRead().

Referenced by ShowDemoWindowColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetColumnNormFromOffset()

float ImGui::GetColumnNormFromOffset	(	const ImGuiOldColumns *	columns,
		float	offset
	)

{
    return offset / (columns->OffMaxX - columns->OffMinX);
}

References ImGuiOldColumns::OffMaxX, and ImGuiOldColumns::OffMinX.

Referenced by SetColumnOffset().

Here is the caller graph for this function:

◆ GetColumnOffset()

float ImGui::GetColumnOffset ( int column_index = -1 )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns == NULL)
        return 0.0f;
 
    if (column_index < 0)
        column_index = columns->Current;
    IM_ASSERT(column_index < columns->Columns.Size);
 
    const float t = columns->Columns[column_index].OffsetNorm;
    const float x_offset = ImLerp(columns->OffMinX, columns->OffMaxX, t);
    return x_offset;
}

References Columns(), ImGuiOldColumns::Columns, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, GetCurrentWindowRead(), IM_ASSERT, ImLerp(), ImGuiOldColumns::OffMaxX, and ImGuiOldColumns::OffMinX.

Referenced by BeginColumns(), EndColumns(), GetDraggedColumnOffset(), NextColumn(), SetColumnWidth(), and ShowDemoWindowColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetColumnOffsetFromNorm()

float ImGui::GetColumnOffsetFromNorm	(	const ImGuiOldColumns *	columns,
		float	offset_norm
	)

{
    return offset_norm * (columns->OffMaxX - columns->OffMinX);
}

References ImGuiOldColumns::OffMaxX, and ImGuiOldColumns::OffMinX.

Referenced by DebugNodeColumns(), GetColumnWidth(), and GetColumnWidthEx().

Here is the caller graph for this function:

◆ GetColumnsCount()

int ImGui::GetColumnsCount ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CurrentColumns ? window->DC.CurrentColumns->Count : 1;
}

References ImGuiOldColumns::Count, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, and GetCurrentWindowRead().

Here is the call graph for this function:

◆ GetColumnsID()

ImGuiID ImGui::GetColumnsID	(	const char *	str_id,
		int	count
	)

{
    ImGuiWindow* window = GetCurrentWindow();
 
    // Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
    // In addition, when an identifier isn't explicitly provided we include the number of columns in the hash to make it uniquer.
    PushID(0x11223347 + (str_id ? 0 : columns_count));
    ImGuiID id = window->GetID(str_id ? str_id : "columns");
    PopID();
 
    return id;
}

References GetCurrentWindow(), ImGuiWindow::GetID(), PopID(), and PushID().

Referenced by BeginColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetColumnWidth()

float ImGui::GetColumnWidth ( int column_index = -1 )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns == NULL)
        return GetContentRegionAvail().x;
 
    if (column_index < 0)
        column_index = columns->Current;
    return GetColumnOffsetFromNorm(columns, columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm);
}

References ImGuiOldColumns::Columns, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GetColumnOffsetFromNorm(), GetContentRegionAvail(), GImGui, and ImVec2::x.

Referenced by ShowDemoWindowColumns(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetContentRegionAvail()

ImVec2 ImGui::GetContentRegionAvail ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return GetContentRegionMaxAbs() - window->DC.CursorPos;
}

References ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetContentRegionMaxAbs(), and GImGui.

Referenced by BeginChildEx(), BeginMenu(), BeginTableEx(), GetColumnWidth(), GetContentRegionAvailWidth(), MenuItem(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowTables(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetContentRegionAvailWidth()

static float ImGui::GetContentRegionAvailWidth ( )

inlinestatic

2812{ return GetContentRegionAvail().x; }

References GetContentRegionAvail(), GetContentRegionAvailWidth(), and ImVec2::x.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and GetContentRegionAvailWidth().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetContentRegionMax()

ImVec2 ImGui::GetContentRegionMax ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max - window->Pos;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x - window->Pos.x;
    return mx;
}

References ImGuiWindow::ContentRegionRect, ImGuiWindowTempData::CurrentColumns, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImRect::Max, ImGuiWindow::Pos, ImGuiWindow::WorkRect, and ImVec2::x.

◆ GetContentRegionMaxAbs()

ImVec2 ImGui::GetContentRegionMaxAbs ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x;
    return mx;
}

References ImGuiWindow::ContentRegionRect, ImGuiWindowTempData::CurrentColumns, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImRect::Max, ImGuiWindow::WorkRect, and ImVec2::x.

Referenced by CalcItemSize(), CalcItemWidth(), and GetContentRegionAvail().

Here is the caller graph for this function:

◆ GetCurrentContext()

ImGuiContext * ImGui::GetCurrentContext ( )

{
    return GImGui;
}

References GImGui.

Referenced by InputTextFilterCharacter(), and ShowDemoWindow().

Here is the caller graph for this function:

◆ GetCurrentTable()

ImGuiTable * ImGui::GetCurrentTable ( )

inline

2460{ ImGuiContext& g = *GImGui; return g.CurrentTable; }

References ImGuiContext::CurrentTable, and GImGui.

◆ GetCurrentWindow()

ImGuiWindow * ImGui::GetCurrentWindow ( )

inline

2280{ ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }

References ImGuiContext::CurrentWindow, GImGui, and ImGuiWindow::WriteAccessed.

Referenced by Slic3r::GUI::GLGizmoCut3D::add_horizontal_scaled_interval(), Slic3r::GUI::GLGizmoCut3D::add_horizontal_shift(), Slic3r::GUI::GLGizmoCut3D::add_vertical_scaled_interval(), AlignTextToFramePadding(), ArrowButtonEx(), BeginChild(), BeginColumns(), BeginCombo(), BeginListBox(), BeginMenu(), BeginMenuBar(), BeginTableEx(), Bullet(), BulletTextV(), ButtonBehavior(), ButtonEx(), Checkbox(), CollapsingHeader(), CollapsingHeader(), ColorButton(), ColorEdit4(), ColorPicker4(), Columns(), DragFloatRange2(), DragIntRange2(), DragScalar(), DragScalarN(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), Dummy(), EndColumns(), EndMenuBar(), GetColumnsID(), GetWindowDrawList(), Image(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), Indent(), InputScalar(), InputScalarN(), InputTextEx(), InvisibleButton(), LabelTextV(), MenuItem(), NewLine(), NextColumn(), PlotEx(), PopClipRect(), PopItemWidth(), PopTextWrapPos(), ProgressBar(), PushClipRect(), PushTextWrapPos(), RadioButton(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GLGizmoCut3D::render_color_marker(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GCodeViewer::render_legend(), RenderArrow(), RenderBullet(), SameLine(), Slic3r::GUI::ImGuiWrapper::search_list(), Slic3r::GUI::selectable(), Selectable(), SeparatorEx(), SetCursorPos(), SetCursorPosX(), SetCursorPosY(), SetCursorScreenPos(), SetWindowFontScale(), Slic3r::GUI::ImGuiWrapper::slider_float(), SliderScalar(), SliderScalarN(), Spacing(), TextEx(), TextV(), TreeNode(), TreeNodeBehavior(), TreeNodeEx(), TreeNodeExV(), TreeNodeExV(), TreePush(), TreePush(), Unindent(), and VSliderScalar().

◆ GetCurrentWindowRead()

ImGuiWindow * ImGui::GetCurrentWindowRead ( )

inline

2279{ ImGuiContext& g = *GImGui; return g.CurrentWindow; }

References ImGuiContext::CurrentWindow, and GImGui.

Referenced by EndTooltip(), GetColumnIndex(), GetColumnOffset(), GetColumnsCount(), GetCursorPos(), GetCursorPosX(), GetCursorPosY(), GetCursorScreenPos(), GetCursorStartPos(), GetItemRectMax(), GetItemRectMin(), GetItemRectSize(), GetWindowSize(), IsItemEdited(), IsItemVisible(), IsWindowAppearing(), IsWindowCollapsed(), PopColumnsBackground(), PushColumnClipRect(), PushColumnsBackground(), SetColumnWidth(), and SetWindowPos().

Here is the caller graph for this function:

◆ GetCursorPos()

ImVec2 ImGui::GetCursorPos ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CursorPos - window->Pos + window->Scroll;
}

References ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiWindow::Pos, and ImGuiWindow::Scroll.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), ShowDemoWindowWidgets(), and Slic3r::GUI::ImGuiWrapper::text_wrapped().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCursorPosX()

float ImGui::GetCursorPosX ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CursorPos.x - window->Pos.x + window->Scroll.x;
}

References ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiWindow::Pos, ImGuiWindow::Scroll, and ImVec2::x.

Referenced by Slic3r::GUI::clickable(), EditTableSizingFlags(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay(), ShowDemoWindowLayout(), and TreeAdvanceToLabelPos().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCursorPosY()

float ImGui::GetCursorPosY ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CursorPos.y - window->Pos.y + window->Scroll.y;
}

References ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiWindow::Pos, ImGuiWindow::Scroll, and ImVec2::y.

Here is the call graph for this function:

◆ GetCursorScreenPos()

ImVec2 ImGui::GetCursorScreenPos ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CursorPos;
}

References ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, and GetCurrentWindowRead().

Referenced by ColorPickerOptionsPopup(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::render_extruders_combo(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleMenuFile(), ShowFont(), ShowStyleEditor(), and TableHeadersRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCursorStartPos()

ImVec2 ImGui::GetCursorStartPos ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.CursorStartPos - window->Pos;
}

References ImGuiWindowTempData::CursorStartPos, ImGuiWindow::DC, GetCurrentWindowRead(), and ImGuiWindow::Pos.

Referenced by ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDefaultFont()

ImFont * ImGui::GetDefaultFont ( )

inline

2303{ ImGuiContext& g = *GImGui; return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }

ImGuiIO::FontDefault

ImFont * FontDefault

Definition imgui.h:1798

References ImGuiIO::FontDefault, ImGuiIO::Fonts, ImFontAtlas::Fonts, GImGui, and ImGuiContext::IO.

Referenced by NewFrame(), PopFont(), and PushFont().

Here is the caller graph for this function:

◆ GetDragDropPayload()

const ImGuiPayload * ImGui::GetDragDropPayload ( )

{
    ImGuiContext& g = *GImGui;
    return g.DragDropActive ? &g.DragDropPayload : NULL;
}

References ImGuiContext::DragDropActive, ImGuiContext::DragDropPayload, and GImGui.

◆ GetDrawData()

ImDrawData * ImGui::GetDrawData ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiViewportP* viewport = g.Viewports[0];
    return viewport->DrawDataP.Valid ? &viewport->DrawDataP : NULL;
}

References ImGuiViewportP::DrawDataP, GImGui, ImDrawData::Valid, and ImGuiContext::Viewports.

Referenced by Slic3r::GUI::ImGuiWrapper::render().

Here is the caller graph for this function:

◆ GetDrawListSharedData()

ImDrawListSharedData * ImGui::GetDrawListSharedData ( )

{
    return &GImGui->DrawListSharedData;
}

References ImGuiContext::DrawListSharedData, and GImGui.

◆ GetFocusedFocusScope()

ImGuiID ImGui::GetFocusedFocusScope ( )

inline

2418{ ImGuiContext& g = *GImGui; return g.NavFocusScopeId; } // Focus scope which is actually active

References GImGui, and ImGuiContext::NavFocusScopeId.

◆ GetFocusID()

ImGuiID ImGui::GetFocusID ( )

inline

2344{ ImGuiContext& g = *GImGui; return g.NavId; }

References GImGui, and ImGuiContext::NavId.

◆ GetFocusScope()

ImGuiID ImGui::GetFocusScope ( )

inline

2419{ ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.NavFocusScopeIdCurrent; } // Focus scope we are outputting into, set by PushFocusScope()

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, and ImGuiWindowTempData::NavFocusScopeIdCurrent.

◆ GetFont()

ImFont * ImGui::GetFont ( )

{
    return GImGui->Font;
}

References ImGuiContext::Font, and GImGui.

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_text(), ShowDemoWindowLayout(), and ShowFontSelector().

Here is the caller graph for this function:

◆ GetFontSize()

float ImGui::GetFontSize ( )

{
    return GImGui->FontSize;
}

References ImGuiContext::FontSize, and GImGui.

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_text(), EditTableSizingFlags(), HelpMarker(), Slic3r::GUI::ImGuiWrapper::image_button(), MetricsHelpMarker(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::render_reset_button(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowFont(), ShowMetricsWindow(), ShowStyleEditor(), and Slic3r::GUI::ImGuiWrapper::slider_float().

Here is the caller graph for this function:

◆ GetFontTexUvWhitePixel()

ImVec2 ImGui::GetFontTexUvWhitePixel ( )

{
    return GImGui->DrawListSharedData.TexUvWhitePixel;
}

References ImGuiContext::DrawListSharedData, GImGui, and ImDrawListSharedData::TexUvWhitePixel.

Referenced by ColorPicker4().

Here is the caller graph for this function:

◆ GetForegroundDrawList() [1/3]

ImDrawList * ImGui::GetForegroundDrawList ( )

{
    ImGuiContext& g = *GImGui;
    return GetForegroundDrawList(g.Viewports[0]);
}

References GetForegroundDrawList(), GImGui, and ImGuiContext::Viewports.

Referenced by DebugDrawItemRect(), DebugNodeDrawList(), DebugNodeTabBar(), DebugNodeTable(), DebugNodeWindow(), GetForegroundDrawList(), GetForegroundDrawList(), GetOverlayDrawList(), ItemHoverable(), NavScoreItem(), NavUpdate(), Render(), ShowDemoWindowMisc(), ShowExampleAppCustomRendering(), ShowMetricsWindow(), TabItemEx(), and TableMergeDrawChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetForegroundDrawList() [2/3]

ImDrawList * ImGui::GetForegroundDrawList ( ImGuiViewport * viewport )

{
    return GetViewportDrawList((ImGuiViewportP*)viewport, 1, "##Foreground");
}

References GetViewportDrawList().

Here is the call graph for this function:

◆ GetForegroundDrawList() [3/3]

ImDrawList * ImGui::GetForegroundDrawList ( ImGuiWindow * window )

inline

2304{ IM_UNUSED(window); return GetForegroundDrawList(); } // This seemingly unnecessary wrapper simplifies compatibility between the 'master' and 'docking' branches.

References GetForegroundDrawList(), and IM_UNUSED.

Here is the call graph for this function:

◆ GetFrameCount()

int ImGui::GetFrameCount ( )

{
    return GImGui->FrameCount;
}

References ImGuiContext::FrameCount, and GImGui.

Referenced by DebugNodeTabBar(), DebugNodeTable(), ImGuiOnceUponAFrame::operator bool(), ShowExampleAppLog(), and ShowExampleAppWindowTitles().

Here is the caller graph for this function:

◆ GetFrameHeight()

float ImGui::GetFrameHeight ( )

{
    ImGuiContext& g = *GImGui;
    return g.FontSize + g.Style.FramePadding.y * 2.0f;
}

References ImGuiContext::FontSize, ImGuiStyle::FramePadding, GImGui, ImGuiContext::Style, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), ArrowButton(), ArrowButtonEx(), BeginCombo(), BeginMainMenuBar(), Checkbox(), ColorButton(), ColorEdit4(), ColorPicker4(), ColorPickerOptionsPopup(), Slic3r::GUI::GLGizmoSimplify::create_gui_cfg(), InputScalar(), RadioButton(), ShowDemoWindowTables(), and ShowExampleAppCustomRendering().

Here is the caller graph for this function:

◆ GetFrameHeightWithSpacing()

float ImGui::GetFrameHeightWithSpacing ( )

{
    ImGuiContext& g = *GImGui;
    return g.FontSize + g.Style.FramePadding.y * 2.0f + g.Style.ItemSpacing.y;
}

References ImGuiContext::FontSize, ImGuiStyle::FramePadding, GImGui, ImGuiStyle::ItemSpacing, ImGuiContext::Style, and ImVec2::y.

Referenced by ExampleAppConsole::Draw(), ShowDemoWindowLayout(), and ShowExampleAppLayout().

Here is the caller graph for this function:

◆ GetHoveredID()

ImGuiID ImGui::GetHoveredID ( )

{
    ImGuiContext& g = *GImGui;
    return g.HoveredId ? g.HoveredId : g.HoveredIdPreviousFrame;
}

References GImGui, ImGuiContext::HoveredId, and ImGuiContext::HoveredIdPreviousFrame.

◆ GetID() [1/3]

ImGuiID ImGui::GetID ( const char * str_id )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->GetID(str_id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), and GImGui.

Referenced by BeginListBox(), BeginTable(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowAboutWindow(), ShowDemoWindowLayout(), and ShowExampleAppDocuments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetID() [2/3]

ImGuiID ImGui::GetID	(	const char *	str_id_begin,
		const char *	str_id_end
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->GetID(str_id_begin, str_id_end);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), and GImGui.

Here is the call graph for this function:

◆ GetID() [3/3]

ImGuiID ImGui::GetID ( const void * ptr_id )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->GetID(ptr_id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), and GImGui.

Here is the call graph for this function:

◆ GetIDWithSeed()

ImGuiID ImGui::GetIDWithSeed	(	const char *	str_id_begin,
		const char *	str_id_end,
		ImGuiID	seed
	)

{
    ImGuiID id = ImHashStr(str, str_end ? (str_end - str) : 0, seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO2(id, ImGuiDataType_String, str, str_end);
#endif
    return id;
}

References GImGui, IMGUI_TEST_ENGINE_ID_INFO2, ImGuiDataType_String, ImHashStr(), and KeepAliveID().

Referenced by CollapsingHeader(), and TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInputTextState()

ImGuiInputTextState * ImGui::GetInputTextState ( ImGuiID id )

inline

2592{ ImGuiContext& g = *GImGui; return (g.InputTextState.ID == id) ? &g.InputTextState : NULL; } // Get input text state if active

ImGuiContext::InputTextState

ImGuiInputTextState InputTextState

Definition imgui_internal.h:1534

ImGuiInputTextState::ID

ImGuiID ID

Definition imgui_internal.h:1019

References GImGui, ImGuiInputTextState::ID, and ImGuiContext::InputTextState.

Referenced by InputTextEx().

Here is the caller graph for this function:

◆ GetIO()

ImGuiIO & ImGui::GetIO ( )

{
    IM_ASSERT(GImGui != NULL && "No current context. Did you call ImGui::CreateContext() and ImGui::SetCurrentContext() ?");
    return GImGui->IO;
}

References GImGui, IM_ASSERT, and ImGuiContext::IO.

Here is the caller graph for this function:

◆ GetItemFlags()

ImGuiItemFlags ImGui::GetItemFlags ( )

inline

2345{ ImGuiContext& g = *GImGui; return g.CurrentItemFlags; }

References ImGuiContext::CurrentItemFlags, and GImGui.

◆ GetItemID()

ImGuiID ImGui::GetItemID ( )

inline

2341{ ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.LastItemId; } // Get ID of last item (~~ often same ImGui::GetID(label) beforehand)

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, and ImGuiWindowTempData::LastItemId.

◆ GetItemRectMax()

ImVec2 ImGui::GetItemRectMax ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.LastItemRect.Max;
}

References ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiWindowTempData::LastItemRect, and ImRect::Max.

Referenced by DebugNodeTable(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::NotificationManager::PopNotification::render_hypertext(), ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetItemRectMin()

ImVec2 ImGui::GetItemRectMin ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.LastItemRect.Min;
}

References ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiWindowTempData::LastItemRect, and ImRect::Min.

Referenced by DebugNodeTable(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::NotificationManager::PopNotification::render_hypertext(), ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetItemRectSize()

ImVec2 ImGui::GetItemRectSize ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->DC.LastItemRect.GetSize();
}

References ImGuiWindow::DC, GetCurrentWindowRead(), ImRect::GetSize(), and ImGuiWindowTempData::LastItemRect.

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetItemStatusFlags()

ImGuiItemStatusFlags ImGui::GetItemStatusFlags ( )

inline

2342{ ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.LastItemStatusFlags; }

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, and ImGuiWindowTempData::LastItemStatusFlags.

◆ GetKeyIndex()

int ImGui::GetKeyIndex ( ImGuiKey imgui_key )

{
    IM_ASSERT(imgui_key >= 0 && imgui_key < ImGuiKey_COUNT);
    ImGuiContext& g = *GImGui;
    return g.IO.KeyMap[imgui_key];
}

References GImGui, IM_ASSERT, ImGuiKey_COUNT, ImGuiContext::IO, and ImGuiIO::KeyMap.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::process_key_down(), and ShowDemoWindow().

Here is the caller graph for this function:

◆ GetKeyPressedAmount()

int ImGui::GetKeyPressedAmount	(	int	key_index,
		float	repeat_delay,
		float	rate
	)

{
    ImGuiContext& g = *GImGui;
    if (key_index < 0)
        return 0;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[key_index];
    return CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, repeat_delay, repeat_rate);
}

References CalcTypematicRepeatAmount(), ImGuiIO::DeltaTime, GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::KeysDown, and ImGuiIO::KeysDownDuration.

Referenced by IsKeyPressed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMainViewport()

ImGuiViewport * ImGui::GetMainViewport ( )

{
    ImGuiContext& g = *GImGui;
    return g.Viewports[0];
}

References GImGui, and ImGuiContext::Viewports.

Referenced by Begin(), BeginMainMenuBar(), BeginPopupModal(), BeginViewportSideBar(), CalcWindowAutoFitSize(), priv::change_window_position(), CreateNewWindow(), GetWindowAllowedExtentRect(), NavCalcPreferredRefPos(), NavUpdateWindowingOverlay(), ShowDemoWindow(), ShowDemoWindowPopups(), ShowExampleAppFullscreen(), ShowExampleAppSimpleOverlay(), and ShowExampleAppWindowTitles().

Here is the caller graph for this function:

◆ GetMergedKeyModFlags()

ImGuiKeyModFlags ImGui::GetMergedKeyModFlags ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiKeyModFlags key_mod_flags = ImGuiKeyModFlags_None;
    if (g.IO.KeyCtrl)   { key_mod_flags |= ImGuiKeyModFlags_Ctrl; }
    if (g.IO.KeyShift)  { key_mod_flags |= ImGuiKeyModFlags_Shift; }
    if (g.IO.KeyAlt)    { key_mod_flags |= ImGuiKeyModFlags_Alt; }
    if (g.IO.KeySuper)  { key_mod_flags |= ImGuiKeyModFlags_Super; }
    return key_mod_flags;
}

References GImGui, ImGuiKeyModFlags_Alt, ImGuiKeyModFlags_Ctrl, ImGuiKeyModFlags_None, ImGuiKeyModFlags_Shift, ImGuiKeyModFlags_Super, ImGuiContext::IO, ImGuiIO::KeyAlt, ImGuiIO::KeyCtrl, ImGuiIO::KeyShift, and ImGuiIO::KeySuper.

Referenced by ErrorCheckEndFrameSanityChecks(), InputTextEx(), and NewFrame().

Here is the caller graph for this function:

◆ GetMouseCursor()

ImGuiMouseCursor ImGui::GetMouseCursor ( )

{
    return GImGui->MouseCursor;
}

References GImGui, and ImGuiContext::MouseCursor.

Referenced by ShowDemoWindowMisc().

Here is the caller graph for this function:

◆ GetMouseDragDelta()

ImVec2 ImGui::GetMouseDragDelta	(	ImGuiMouseButton	button = `0`,
		float	lock_threshold = `-1.0f`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    if (g.IO.MouseDown[button] || g.IO.MouseReleased[button])
        if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
            if (IsMousePosValid(&g.IO.MousePos) && IsMousePosValid(&g.IO.MouseClickedPos[button]))
                return g.IO.MousePos - g.IO.MouseClickedPos[button];
    return ImVec2(0.0f, 0.0f);
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, IsMousePosValid(), ImGuiIO::MouseClickedPos, ImGuiIO::MouseDown, ImGuiIO::MouseDragMaxDistanceSqr, ImGuiIO::MouseDragThreshold, ImGuiIO::MousePos, and ImGuiIO::MouseReleased.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_style_list(), ShowDemoWindowMisc(), ShowDemoWindowWidgets(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMousePos()

ImVec2 ImGui::GetMousePos ( )

{
    ImGuiContext& g = *GImGui;
    return g.IO.MousePos;
}

References GImGui, ImGuiContext::IO, and ImGuiIO::MousePos.

Referenced by Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::NotificationManager::PopNotification::render(), and TableHeadersRow().

Here is the caller graph for this function:

◆ GetMousePosOnOpeningCurrentPopup()

ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup ( )

{
    ImGuiContext& g = *GImGui;
    if (g.BeginPopupStack.Size > 0)
        return g.OpenPopupStack[g.BeginPopupStack.Size - 1].OpenMousePos;
    return g.IO.MousePos;
}

References ImGuiContext::BeginPopupStack, GImGui, ImGuiContext::IO, ImGuiIO::MousePos, ImGuiContext::OpenPopupStack, and ImVector< T >::Size.

◆ GetNavInputAmount()

float ImGui::GetNavInputAmount	(	ImGuiNavInput	n,
		ImGuiInputReadMode	mode
	)

{
    ImGuiContext& g = *GImGui;
    if (mode == ImGuiInputReadMode_Down)
        return g.IO.NavInputs[n];                         // Instant, read analog input (0.0f..1.0f, as provided by user)
 
    const float t = g.IO.NavInputsDownDuration[n];
    if (t < 0.0f && mode == ImGuiInputReadMode_Released)  // Return 1.0f when just released, no repeat, ignore analog input.
        return (g.IO.NavInputsDownDurationPrev[n] >= 0.0f ? 1.0f : 0.0f);
    if (t < 0.0f)
        return 0.0f;
    if (mode == ImGuiInputReadMode_Pressed)               // Return 1.0f when just pressed, no repeat, ignore analog input.
        return (t == 0.0f) ? 1.0f : 0.0f;
    if (mode == ImGuiInputReadMode_Repeat)
        return (float)CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay * 0.72f, g.IO.KeyRepeatRate * 0.80f);
    if (mode == ImGuiInputReadMode_RepeatSlow)
        return (float)CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay * 1.25f, g.IO.KeyRepeatRate * 2.00f);
    if (mode == ImGuiInputReadMode_RepeatFast)
        return (float)CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay * 0.72f, g.IO.KeyRepeatRate * 0.30f);
    return 0.0f;
}

References CalcTypematicRepeatAmount(), ImGuiIO::DeltaTime, GImGui, ImGuiInputReadMode_Down, ImGuiInputReadMode_Pressed, ImGuiInputReadMode_Released, ImGuiInputReadMode_Repeat, ImGuiInputReadMode_RepeatFast, ImGuiInputReadMode_RepeatSlow, ImGuiContext::IO, ImGuiIO::KeyRepeatDelay, ImGuiIO::KeyRepeatRate, ImGuiIO::NavInputs, ImGuiIO::NavInputsDownDuration, and ImGuiIO::NavInputsDownDurationPrev.

Referenced by GetNavInputAmount2d(), and IsNavInputTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNavInputAmount2d()

ImVec2 ImGui::GetNavInputAmount2d	(	ImGuiNavDirSourceFlags	dir_sources,
		ImGuiInputReadMode	mode,
		float	slow_factor = `0.0f`,
		float	fast_factor = `0.0f`
	)

{
    ImVec2 delta(0.0f, 0.0f);
    if (dir_sources & ImGuiNavDirSourceFlags_Keyboard)
        delta += ImVec2(GetNavInputAmount(ImGuiNavInput_KeyRight_, mode)   - GetNavInputAmount(ImGuiNavInput_KeyLeft_,   mode), GetNavInputAmount(ImGuiNavInput_KeyDown_,   mode) - GetNavInputAmount(ImGuiNavInput_KeyUp_,   mode));
    if (dir_sources & ImGuiNavDirSourceFlags_PadDPad)
        delta += ImVec2(GetNavInputAmount(ImGuiNavInput_DpadRight, mode)   - GetNavInputAmount(ImGuiNavInput_DpadLeft,   mode), GetNavInputAmount(ImGuiNavInput_DpadDown,   mode) - GetNavInputAmount(ImGuiNavInput_DpadUp,   mode));
    if (dir_sources & ImGuiNavDirSourceFlags_PadLStick)
        delta += ImVec2(GetNavInputAmount(ImGuiNavInput_LStickRight, mode) - GetNavInputAmount(ImGuiNavInput_LStickLeft, mode), GetNavInputAmount(ImGuiNavInput_LStickDown, mode) - GetNavInputAmount(ImGuiNavInput_LStickUp, mode));
    if (slow_factor != 0.0f && IsNavInputDown(ImGuiNavInput_TweakSlow))
        delta *= slow_factor;
    if (fast_factor != 0.0f && IsNavInputDown(ImGuiNavInput_TweakFast))
        delta *= fast_factor;
    return delta;
}

References GetNavInputAmount(), ImGuiNavDirSourceFlags_Keyboard, ImGuiNavDirSourceFlags_PadDPad, ImGuiNavDirSourceFlags_PadLStick, ImGuiNavInput_DpadDown, ImGuiNavInput_DpadLeft, ImGuiNavInput_DpadRight, ImGuiNavInput_DpadUp, ImGuiNavInput_KeyDown_, ImGuiNavInput_KeyLeft_, ImGuiNavInput_KeyRight_, ImGuiNavInput_KeyUp_, ImGuiNavInput_LStickDown, ImGuiNavInput_LStickLeft, ImGuiNavInput_LStickRight, ImGuiNavInput_LStickUp, ImGuiNavInput_TweakFast, ImGuiNavInput_TweakSlow, and IsNavInputDown().

Referenced by NavUpdate(), NavUpdateWindowing(), and UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOverlayDrawList()

static ImDrawList * ImGui::GetOverlayDrawList ( )

inlinestatic

2814{ return GetForegroundDrawList(); }

References GetForegroundDrawList(), and GetOverlayDrawList().

Referenced by Slic3r::GUI::ImGuiWrapper::draw_cross_hair(), and GetOverlayDrawList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetScrollMaxX()

float ImGui::GetScrollMaxX ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ScrollMax.x;
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::ScrollMax, and ImVec2::x.

Referenced by ShowDemoWindowLayout(), and ShowDemoWindowTables().

Here is the caller graph for this function:

◆ GetScrollMaxY()

float ImGui::GetScrollMaxY ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ScrollMax.y;
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::ScrollMax, and ImVec2::y.

Referenced by ExampleAppConsole::Draw(), ExampleAppLog::Draw(), InputTextEx(), ShowDemoWindowLayout(), and ShowDemoWindowTables().

Here is the caller graph for this function:

◆ GetScrollX()

float ImGui::GetScrollX ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->Scroll.x;
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::Scroll, and ImVec2::x.

Referenced by ShowDemoWindowLayout(), and ShowDemoWindowTables().

Here is the caller graph for this function:

◆ GetScrollY()

float ImGui::GetScrollY ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->Scroll.y;
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::Scroll, and ImVec2::y.

Referenced by ExampleAppConsole::Draw(), ExampleAppLog::Draw(), ShowDemoWindowLayout(), and ShowDemoWindowTables().

Here is the caller graph for this function:

◆ GetStateStorage()

ImGuiStorage * ImGui::GetStateStorage ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->DC.StateStorage;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, and ImGuiWindowTempData::StateStorage.

◆ GetStyle()

ImGuiStyle & ImGui::GetStyle ( )

{
    IM_ASSERT(GImGui != NULL && "No current context. Did you call ImGui::CreateContext() and ImGui::SetCurrentContext() ?");
    return GImGui->Style;
}

References GImGui, IM_ASSERT, and ImGuiContext::Style.

Here is the caller graph for this function:

◆ GetStyleColorName()

const char * ImGui::GetStyleColorName ( ImGuiCol idx )

{
    // Create switch-case from enum with regexp: ImGuiCol_{.*}, --> case ImGuiCol_\1: return "\1";
    switch (idx)
    {
    case ImGuiCol_Text: return "Text";
    case ImGuiCol_TextDisabled: return "TextDisabled";
    case ImGuiCol_WindowBg: return "WindowBg";
    case ImGuiCol_ChildBg: return "ChildBg";
    case ImGuiCol_PopupBg: return "PopupBg";
    case ImGuiCol_Border: return "Border";
    case ImGuiCol_BorderShadow: return "BorderShadow";
    case ImGuiCol_FrameBg: return "FrameBg";
    case ImGuiCol_FrameBgHovered: return "FrameBgHovered";
    case ImGuiCol_FrameBgActive: return "FrameBgActive";
    case ImGuiCol_TitleBg: return "TitleBg";
    case ImGuiCol_TitleBgActive: return "TitleBgActive";
    case ImGuiCol_TitleBgCollapsed: return "TitleBgCollapsed";
    case ImGuiCol_MenuBarBg: return "MenuBarBg";
    case ImGuiCol_ScrollbarBg: return "ScrollbarBg";
    case ImGuiCol_ScrollbarGrab: return "ScrollbarGrab";
    case ImGuiCol_ScrollbarGrabHovered: return "ScrollbarGrabHovered";
    case ImGuiCol_ScrollbarGrabActive: return "ScrollbarGrabActive";
    case ImGuiCol_CheckMark: return "CheckMark";
    case ImGuiCol_SliderGrab: return "SliderGrab";
    case ImGuiCol_SliderGrabActive: return "SliderGrabActive";
    case ImGuiCol_Button: return "Button";
    case ImGuiCol_ButtonHovered: return "ButtonHovered";
    case ImGuiCol_ButtonActive: return "ButtonActive";
    case ImGuiCol_Header: return "Header";
    case ImGuiCol_HeaderHovered: return "HeaderHovered";
    case ImGuiCol_HeaderActive: return "HeaderActive";
    case ImGuiCol_Separator: return "Separator";
    case ImGuiCol_SeparatorHovered: return "SeparatorHovered";
    case ImGuiCol_SeparatorActive: return "SeparatorActive";
    case ImGuiCol_ResizeGrip: return "ResizeGrip";
    case ImGuiCol_ResizeGripHovered: return "ResizeGripHovered";
    case ImGuiCol_ResizeGripActive: return "ResizeGripActive";
    case ImGuiCol_Tab: return "Tab";
    case ImGuiCol_TabHovered: return "TabHovered";
    case ImGuiCol_TabActive: return "TabActive";
    case ImGuiCol_TabUnfocused: return "TabUnfocused";
    case ImGuiCol_TabUnfocusedActive: return "TabUnfocusedActive";
    case ImGuiCol_PlotLines: return "PlotLines";
    case ImGuiCol_PlotLinesHovered: return "PlotLinesHovered";
    case ImGuiCol_PlotHistogram: return "PlotHistogram";
    case ImGuiCol_PlotHistogramHovered: return "PlotHistogramHovered";
    case ImGuiCol_TableHeaderBg: return "TableHeaderBg";
    case ImGuiCol_TableBorderStrong: return "TableBorderStrong";
    case ImGuiCol_TableBorderLight: return "TableBorderLight";
    case ImGuiCol_TableRowBg: return "TableRowBg";
    case ImGuiCol_TableRowBgAlt: return "TableRowBgAlt";
    case ImGuiCol_TextSelectedBg: return "TextSelectedBg";
    case ImGuiCol_DragDropTarget: return "DragDropTarget";
    case ImGuiCol_NavHighlight: return "NavHighlight";
    case ImGuiCol_NavWindowingHighlight: return "NavWindowingHighlight";
    case ImGuiCol_NavWindowingDimBg: return "NavWindowingDimBg";
    case ImGuiCol_ModalWindowDimBg: return "ModalWindowDimBg";
    }
    IM_ASSERT(0);
    return "Unknown";
}

References IM_ASSERT, ImGuiCol_Border, ImGuiCol_BorderShadow, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_CheckMark, ImGuiCol_ChildBg, ImGuiCol_DragDropTarget, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiCol_Header, ImGuiCol_HeaderActive, ImGuiCol_HeaderHovered, ImGuiCol_MenuBarBg, ImGuiCol_ModalWindowDimBg, ImGuiCol_NavHighlight, ImGuiCol_NavWindowingDimBg, ImGuiCol_NavWindowingHighlight, ImGuiCol_PlotHistogram, ImGuiCol_PlotHistogramHovered, ImGuiCol_PlotLines, ImGuiCol_PlotLinesHovered, ImGuiCol_PopupBg, ImGuiCol_ResizeGrip, ImGuiCol_ResizeGripActive, ImGuiCol_ResizeGripHovered, ImGuiCol_ScrollbarBg, ImGuiCol_ScrollbarGrab, ImGuiCol_ScrollbarGrabActive, ImGuiCol_ScrollbarGrabHovered, ImGuiCol_Separator, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiCol_SliderGrab, ImGuiCol_SliderGrabActive, ImGuiCol_Tab, ImGuiCol_TabActive, ImGuiCol_TabHovered, ImGuiCol_TableBorderLight, ImGuiCol_TableBorderStrong, ImGuiCol_TableHeaderBg, ImGuiCol_TableRowBg, ImGuiCol_TableRowBgAlt, ImGuiCol_TabUnfocused, ImGuiCol_TabUnfocusedActive, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiCol_TextSelectedBg, ImGuiCol_TitleBg, ImGuiCol_TitleBgActive, ImGuiCol_TitleBgCollapsed, and ImGuiCol_WindowBg.

Referenced by ErrorCheckEndFrameRecover(), ShowExampleMenuFile(), and ShowStyleEditor().

Here is the caller graph for this function:

◆ GetStyleColorVec4()

const ImVec4 & ImGui::GetStyleColorVec4 ( ImGuiCol idx )

{
    ImGuiStyle& style = GImGui->Style;
    return style.Colors[idx];
}

References GImGui, ImGuiContext::Style, and style.

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), DebugNodeTabBar(), DebugNodeTable(), DebugNodeWindow(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::NotificationManager::PopNotification::push_background_color(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::push_background_color(), Slic3r::GUI::NotificationManager::PopNotification::render(), Slic3r::GUI::NotificationManager::PopNotification::render_minimize_button(), Slic3r::GUI::NotificationManager::HintNotification::render_preferences_button(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), and UpdateDebugToolItemPicker().

Here is the caller graph for this function:

◆ GetTextLineHeight()

float ImGui::GetTextLineHeight ( )

{
    ImGuiContext& g = *GImGui;
    return g.FontSize;
}

References ImGuiContext::FontSize, and GImGui.

Referenced by Slic3r::GUI::GLGizmoEmboss::create_gui_configuration(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::render_extruders_combo(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleMenuFile(), ShowMetricsWindow(), TableGetHeaderRowHeight(), and TextEx().

Here is the caller graph for this function:

◆ GetTextLineHeightWithSpacing()

float ImGui::GetTextLineHeightWithSpacing ( )

{
    ImGuiContext& g = *GImGui;
    return g.FontSize + g.Style.ItemSpacing.y;
}

References ImGuiContext::FontSize, GImGui, ImGuiStyle::ItemSpacing, ImGuiContext::Style, and ImVec2::y.

Referenced by BeginListBox(), Slic3r::GUI::GLGizmoSimplify::create_gui_cfg(), Slic3r::GUI::GLGizmoEmboss::create_gui_configuration(), ListBoxHeader(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowAboutWindow(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppDocuments().

Here is the caller graph for this function:

◆ GetTime()

double ImGui::GetTime ( )

{
    return GImGui->Time;
}

References GImGui, and ImGuiContext::Time.

Referenced by ShowDemoWindow(), ShowDemoWindowWidgets(), ShowExampleAppLog(), and ShowExampleAppWindowTitles().

Here is the caller graph for this function:

◆ GetTopMostPopupModal()

ImGuiWindow * ImGui::GetTopMostPopupModal ( )

{
    ImGuiContext& g = *GImGui;
    for (int n = g.OpenPopupStack.Size - 1; n >= 0; n--)
        if (ImGuiWindow* popup = g.OpenPopupStack.Data[n].Window)
            if (popup->Flags & ImGuiWindowFlags_Modal)
                return popup;
    return NULL;
}

References ImVector< T >::Data, GImGui, ImGuiWindowFlags_Modal, ImGuiContext::OpenPopupStack, ImVector< T >::Size, and ImGuiPopupData::Window.

Referenced by Begin(), BeginPopupContextVoid(), NavUpdateWindowing(), NewFrame(), UpdateHoveredWindowAndCaptureFlags(), and UpdateMouseMovingWindowEndFrame().

Here is the caller graph for this function:

◆ GetTreeNodeToLabelSpacing()

float ImGui::GetTreeNodeToLabelSpacing ( )

{
    ImGuiContext& g = *GImGui;
    return g.FontSize + (g.Style.FramePadding.x * 2.0f);
}

References ImGuiContext::FontSize, ImGuiStyle::FramePadding, GImGui, ImGuiContext::Style, and ImVec2::x.

Referenced by ShowDemoWindowWidgets(), ShowMetricsWindow(), and TreeAdvanceToLabelPos().

Here is the caller graph for this function:

◆ GetVersion()

const char * ImGui::GetVersion ( )

{
    return IMGUI_VERSION;
}

References IMGUI_VERSION.

Referenced by ShowAboutWindow(), and ShowMetricsWindow().

Here is the caller graph for this function:

◆ GetWindowAllowedExtentRect()

ImRect ImGui::GetWindowAllowedExtentRect ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
    IM_UNUSED(window);
    ImRect r_screen = ((ImGuiViewportP*)(void*)GetMainViewport())->GetMainRect();
    ImVec2 padding = g.Style.DisplaySafeAreaPadding;
    r_screen.Expand(ImVec2((r_screen.GetWidth() > padding.x * 2) ? -padding.x : 0.0f, (r_screen.GetHeight() > padding.y * 2) ? -padding.y : 0.0f));
    return r_screen;
}

References ImGuiStyle::DisplaySafeAreaPadding, ImRect::Expand(), ImRect::GetHeight(), GetMainViewport(), ImRect::GetWidth(), GImGui, IM_UNUSED, ImGuiContext::Style, ImVec2::x, and ImVec2::y.

Referenced by BeginCombo(), and FindBestWindowPosForPopup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWindowContentRegionMax()

ImVec2 ImGui::GetWindowContentRegionMax ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ContentRegionRect.Max - window->Pos;
}

References ImGuiWindow::ContentRegionRect, ImGuiContext::CurrentWindow, GImGui, ImRect::Max, and ImGuiWindow::Pos.

Referenced by ShowDemoWindowLayout().

Here is the caller graph for this function:

◆ GetWindowContentRegionMin()

ImVec2 ImGui::GetWindowContentRegionMin ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ContentRegionRect.Min - window->Pos;
}

References ImGuiWindow::ContentRegionRect, ImGuiContext::CurrentWindow, GImGui, ImRect::Min, and ImGuiWindow::Pos.

◆ GetWindowContentRegionWidth()

float ImGui::GetWindowContentRegionWidth ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ContentRegionRect.GetWidth();
}

References ImGuiWindow::ContentRegionRect, ImGuiContext::CurrentWindow, ImRect::GetWidth(), and GImGui.

Referenced by Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWindowDrawList()

ImDrawList * ImGui::GetWindowDrawList ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    return window->DrawList;
}

References ImGuiWindow::DrawList, and GetCurrentWindow().

Referenced by DebugNodeDrawList(), igl::opengl::glfw::imgui::ImGuiMenu::draw_text(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::NotificationManager::ProgressBarNotification::render_bar(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::render_extruders_combo(), Slic3r::GUI::NotificationManager::PopNotification::render_hypertext(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleMenuFile(), ShowFont(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWindowHeight()

float ImGui::GetWindowHeight ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->Size.y;
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::Size, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::GLGizmoCut3D::adjust_window_position(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoSlaSupports::on_render_input_window(), and Slic3r::GUI::GCodeViewer::render_legend().

Here is the caller graph for this function:

◆ GetWindowPos()

ImVec2 ImGui::GetWindowPos ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    return window->Pos;
}

References ImGuiContext::CurrentWindow, GImGui, and ImGuiWindow::Pos.

Referenced by Slic3r::GUI::GLGizmoCut3D::render_debug_input_window(), ShowDemoWindowLayout(), and ShowExampleAppCustomRendering().

Here is the caller graph for this function:

◆ GetWindowResizeBorderID()

ImGuiID ImGui::GetWindowResizeBorderID	(	ImGuiWindow *	window,
		ImGuiDir	dir
	)

{
    IM_ASSERT(dir >= 0 && dir < 4);
    int n = (int)dir + 4;
    ImGuiID id = window->ID;
    id = ImHashStr("#RESIZE", 0, id);
    id = ImHashData(&n, sizeof(int), id);
    return id;
}

References ImGuiWindow::ID, IM_ASSERT, ImHashData(), and ImHashStr().

Here is the call graph for this function:

◆ GetWindowResizeCornerID()

ImGuiID ImGui::GetWindowResizeCornerID	(	ImGuiWindow *	window,
		int	n
	)

{
    IM_ASSERT(n >= 0 && n < 4);
    ImGuiID id = window->ID;
    id = ImHashStr("#RESIZE", 0, id);
    id = ImHashData(&n, sizeof(int), id);
    return id;
}

References ImGuiWindow::ID, IM_ASSERT, ImHashData(), and ImHashStr().

Here is the call graph for this function:

◆ GetWindowScrollbarID()

ImGuiID ImGui::GetWindowScrollbarID	(	ImGuiWindow *	window,
		ImGuiAxis	axis
	)

{
    return window->GetIDNoKeepAlive(axis == ImGuiAxis_X ? "#SCROLLX" : "#SCROLLY");
}

References ImGuiWindow::GetIDNoKeepAlive(), and ImGuiAxis_X.

Referenced by InputTextEx(), and Scrollbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWindowScrollbarRect()

ImRect ImGui::GetWindowScrollbarRect	(	ImGuiWindow *	window,
		ImGuiAxis	axis
	)

{
    const ImRect outer_rect = window->Rect();
    const ImRect inner_rect = window->InnerRect;
    const float border_size = window->WindowBorderSize;
    const float scrollbar_size = window->ScrollbarSizes[axis ^ 1]; // (ScrollbarSizes.x = width of Y scrollbar; ScrollbarSizes.y = height of X scrollbar)
    IM_ASSERT(scrollbar_size > 0.0f);
    if (axis == ImGuiAxis_X)
        return ImRect(inner_rect.Min.x, ImMax(outer_rect.Min.y, outer_rect.Max.y - border_size - scrollbar_size), inner_rect.Max.x, outer_rect.Max.y);
    else
        return ImRect(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y, outer_rect.Max.x, inner_rect.Max.y);
}

References IM_ASSERT, ImGuiAxis_X, ImMax(), ImGuiWindow::InnerRect, ImRect::Max, ImRect::Min, ImGuiWindow::Rect(), ImGuiWindow::ScrollbarSizes, ImGuiWindow::WindowBorderSize, ImVec2::x, and ImVec2::y.

Referenced by Scrollbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWindowSize()

ImVec2 ImGui::GetWindowSize ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->Size;
}

References GetCurrentWindowRead(), and ImGuiWindow::Size.

Referenced by Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::NotificationManager::PopNotification::render(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), Slic3r::GUI::GLGizmoEmboss::set_minimal_window_size(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWindowWidth()

float ImGui::GetWindowWidth ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->Size.x;
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::Size, and ImVec2::x.

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GCodeViewer::render_legend(), and ShowStyleEditor().

Here is the caller graph for this function:

◆ Image()

void ImGui::Image	(	ImTextureID	user_texture_id,
		const ImVec2 &	size,
		const ImVec2 &	uv0 = `ImVec2(0, 0)`,
		const ImVec2 &	uv1 = `ImVec2(1,1)`,
		const ImVec4 &	tint_col = `ImVec4(1,1,1,1)`,
		const ImVec4 &	border_col = `ImVec4(0,0,0,0)`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    if (border_col.w > 0.0f)
        bb.Max += ImVec2(2, 2);
    ItemSize(bb);
    if (!ItemAdd(bb, 0))
        return;
 
    if (border_col.w > 0.0f)
    {
        window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(border_col), 0.0f);
        window->DrawList->AddImage(user_texture_id, bb.Min + ImVec2(1, 1), bb.Max - ImVec2(1, 1), uv0, uv1, GetColorU32(tint_col));
    }
    else
    {
        window->DrawList->AddImage(user_texture_id, bb.Min, bb.Max, uv0, uv1, GetColorU32(tint_col));
    }
}

References ImDrawList::AddImage(), ImDrawList::AddRect(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, GetColorU32(), GetCurrentWindow(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, ImGuiWindow::SkipItems, and ImVec4::w.

Referenced by Slic3r::GUI::draw(), Slic3r::GUI::GLGizmoEmboss::draw_font_preview(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_window(), ShowDemoWindowWidgets(), and ShowFontAtlas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImageButton()

bool ImGui::ImageButton	(	ImTextureID	user_texture_id,
		const ImVec2 &	size,
		const ImVec2 &	uv0 = `ImVec2(0, 0)`,
		const ImVec2 &	uv1 = `ImVec2(1,1)`,
		int	frame_padding = `-1`,
		const ImVec4 &	bg_col = `ImVec4(0,0,0,0)`,
		const ImVec4 &	tint_col = `ImVec4(1,1,1,1)`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    // Default to using texture ID as ID. User can still push string/integer prefixes.
    PushID((void*)(intptr_t)user_texture_id);
    const ImGuiID id = window->GetID("#image");
    PopID();
 
    const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float)frame_padding, (float)frame_padding) : g.Style.FramePadding;
    return ImageButtonEx(id, user_texture_id, size, uv0, uv1, padding, bg_col, tint_col);
}

References ImGuiContext::CurrentWindow, ImGuiStyle::FramePadding, ImGuiWindow::GetID(), GImGui, ImageButtonEx(), PopID(), PushID(), ImGuiWindow::SkipItems, and ImGuiContext::Style.

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImageButtonEx()

bool ImGui::ImageButtonEx	(	ImGuiID	id,
		ImTextureID	texture_id,
		const ImVec2 &	size,
		const ImVec2 &	uv0,
		const ImVec2 &	uv1,
		const ImVec2 &	padding,
		const ImVec4 &	bg_col,
		const ImVec4 &	tint_col
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size + padding * 2);
    ItemSize(bb);
    if (!ItemAdd(bb, id))
        return false;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held);
 
    // Render
    const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
    RenderNavHighlight(bb, id);
    RenderFrame(bb.Min, bb.Max, col, true, ImClamp((float)ImMin(padding.x, padding.y), 0.0f, g.Style.FrameRounding));
    if (bg_col.w > 0.0f)
        window->DrawList->AddRectFilled(bb.Min + padding, bb.Max - padding, GetColorU32(bg_col));
    window->DrawList->AddImage(texture_id, bb.Min + padding, bb.Max - padding, uv0, uv1, GetColorU32(tint_col));
 
    return pressed;
}

References ImDrawList::AddImage(), ImDrawList::AddRectFilled(), ButtonBehavior(), col(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiStyle::FrameRounding, GetColorU32(), GetCurrentWindow(), GImGui, ImClamp(), ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImMin(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, RenderFrame(), RenderNavHighlight(), ImGuiWindow::SkipItems, ImGuiContext::Style, ImVec4::w, ImVec2::x, and ImVec2::y.

Referenced by ImageButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Indent()

void ImGui::Indent ( float indent_w = 0.0f )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.Indent.x += (indent_w != 0.0f) ? indent_w : g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x;
}

References ImGuiWindowTempData::ColumnsOffset, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), GImGui, ImGuiWindowTempData::Indent, ImGuiStyle::IndentSpacing, ImGuiWindow::Pos, ImGuiContext::Style, ImVec2::x, and ImVec1::x.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_window(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppFullscreen(), ShowMetricsWindow(), ShowUserGuide(), TreePush(), TreePush(), and TreePushOverrideID().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Initialize()

void ImGui::Initialize ( ImGuiContext * context )

{
    ImGuiContext& g = *context;
    IM_ASSERT(!g.Initialized && !g.SettingsLoaded);
 
    // Add .ini handle for ImGuiWindow type
    {
        ImGuiSettingsHandler ini_handler;
        ini_handler.TypeName = "Window";
        ini_handler.TypeHash = ImHashStr("Window");
        ini_handler.ClearAllFn = WindowSettingsHandler_ClearAll;
        ini_handler.ReadOpenFn = WindowSettingsHandler_ReadOpen;
        ini_handler.ReadLineFn = WindowSettingsHandler_ReadLine;
        ini_handler.ApplyAllFn = WindowSettingsHandler_ApplyAll;
        ini_handler.WriteAllFn = WindowSettingsHandler_WriteAll;
        g.SettingsHandlers.push_back(ini_handler);
    }
 
    // Add .ini handle for ImGuiTable type
    TableSettingsInstallHandler(context);
 
    // Create default viewport
    ImGuiViewportP* viewport = IM_NEW(ImGuiViewportP)();
    g.Viewports.push_back(viewport);
 
#ifdef IMGUI_HAS_DOCK
#endif // #ifdef IMGUI_HAS_DOCK
 
    g.Initialized = true;
}

References ImGuiSettingsHandler::ApplyAllFn, ImGuiSettingsHandler::ClearAllFn, IM_ASSERT, IM_NEW, ImHashStr(), ImGuiContext::Initialized, ImVector< T >::push_back(), ImGuiSettingsHandler::ReadLineFn, ImGuiSettingsHandler::ReadOpenFn, ImGuiContext::SettingsHandlers, ImGuiContext::SettingsLoaded, TableSettingsInstallHandler(), ImGuiSettingsHandler::TypeHash, ImGuiSettingsHandler::TypeName, ImGuiContext::Viewports, WindowSettingsHandler_ApplyAll(), WindowSettingsHandler_ClearAll(), WindowSettingsHandler_ReadLine(), WindowSettingsHandler_ReadOpen(), WindowSettingsHandler_WriteAll(), and ImGuiSettingsHandler::WriteAllFn.

Referenced by CreateContext().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputDouble()

bool ImGui::InputDouble	(	const char *	label,
		double *	v,
		double	step = `0.0`,
		double	step_fast = `0.0`,
		const char *	format = `"%.6f"`,
		ImGuiInputTextFlags	flags = `0`
	)

{
    flags |= ImGuiInputTextFlags_CharsScientific;
    return InputScalar(label, ImGuiDataType_Double, (void*)v, (void*)(step > 0.0 ? &step : NULL), (void*)(step_fast > 0.0 ? &step_fast : NULL), format, flags);
}

References ImGuiDataType_Double, ImGuiInputTextFlags_CharsScientific, and InputScalar().

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoCut3D::render_double_input(), Slic3r::GUI::GLGizmoCut3D::render_move_center_input(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputFloat()

bool ImGui::InputFloat	(	const char *	label,
		float *	v,
		float	step = `0.0f`,
		float	step_fast = `0.0f`,
		const char *	format = `"%.3f"`,
		ImGuiInputTextFlags	flags = `0`
	)

{
    flags |= ImGuiInputTextFlags_CharsScientific;
    return InputScalar(label, ImGuiDataType_Float, (void*)v, (void*)(step > 0.0f ? &step : NULL), (void*)(step_fast > 0.0f ? &step_fast : NULL), format, flags);
}

References ImGuiDataType_Float, ImGuiInputTextFlags_CharsScientific, and InputScalar().

Referenced by Slic3r::GUI::ImGuiWrapper::input_optional_float(), Slic3r::GUI::GLGizmoEmboss::rev_input(), ShowDemoWindowColumns(), ShowDemoWindowWidgets(), ShowExampleMenuFile(), and ShowPlaceholderObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputFloat2()

bool ImGui::InputFloat2	(	const char *	label,
		float	v[2],
		const char *	format = `"%.3f"`,
		ImGuiInputTextFlags	flags = `0`
	)

{
    return InputScalarN(label, ImGuiDataType_Float, v, 2, NULL, NULL, format, flags);
}

References ImGuiDataType_Float, and InputScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputFloat3()

bool ImGui::InputFloat3	(	const char *	label,
		float	v[3],
		const char *	format = `"%.3f"`,
		ImGuiInputTextFlags	flags = `0`
	)

{
    return InputScalarN(label, ImGuiDataType_Float, v, 3, NULL, NULL, format, flags);
}

References ImGuiDataType_Float, and InputScalarN().

Referenced by Slic3r::GUI::Mouse3DController::render_settings_dialog(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputFloat4()

bool ImGui::InputFloat4	(	const char *	label,
		float	v[4],
		const char *	format = `"%.3f"`,
		ImGuiInputTextFlags	flags = `0`
	)

{
    return InputScalarN(label, ImGuiDataType_Float, v, 4, NULL, NULL, format, flags);
}

References ImGuiDataType_Float, and InputScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputInt()

bool ImGui::InputInt	(	const char *	label,
		int *	v,
		int	step = `1`,
		int	step_fast = `100`,
		ImGuiInputTextFlags	flags = `0`
	)

{
    // Hexadecimal input provided as a convenience but the flag name is awkward. Typically you'd use InputText() to parse your own data, if you want to handle prefixes.
    const char* format = (flags & ImGuiInputTextFlags_CharsHexadecimal) ? "%08X" : "%d";
    return InputScalar(label, ImGuiDataType_S32, (void*)v, (void*)(step > 0 ? &step : NULL), (void*)(step_fast > 0 ? &step_fast : NULL), format, flags);
}

References ImGuiDataType_S32, ImGuiInputTextFlags_CharsHexadecimal, and InputScalar().

Referenced by Slic3r::GUI::ImGuiWrapper::input_optional_int(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputInt2()

bool ImGui::InputInt2	(	const char *	label,
		int	v[2],
		ImGuiInputTextFlags	flags = `0`
	)

{
    return InputScalarN(label, ImGuiDataType_S32, v, 2, NULL, NULL, "%d", flags);
}

References ImGuiDataType_S32, and InputScalarN().

Referenced by Slic3r::GUI::Mouse3DController::render_settings_dialog(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputInt3()

bool ImGui::InputInt3	(	const char *	label,
		int	v[3],
		ImGuiInputTextFlags	flags = `0`
	)

{
    return InputScalarN(label, ImGuiDataType_S32, v, 3, NULL, NULL, "%d", flags);
}

References ImGuiDataType_S32, and InputScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputInt4()

bool ImGui::InputInt4	(	const char *	label,
		int	v[4],
		ImGuiInputTextFlags	flags = `0`
	)

{
    return InputScalarN(label, ImGuiDataType_S32, v, 4, NULL, NULL, "%d", flags);
}

References ImGuiDataType_S32, and InputScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputScalar()

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    ImGuiStyle& style = g.Style;
 
    if (format == NULL)
        format = DataTypeGetInfo(data_type)->PrintFmt;
 
    char buf[64];
    DataTypeFormatString(buf, IM_ARRAYSIZE(buf), data_type, p_data, format);
 
    bool value_changed = false;
    if ((flags & (ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsScientific)) == 0)
        flags |= ImGuiInputTextFlags_CharsDecimal;
    flags |= ImGuiInputTextFlags_AutoSelectAll;
    flags |= ImGuiInputTextFlags_NoMarkEdited;  // We call MarkItemEdited() ourselves by comparing the actual data rather than the string.
 
    if (p_step != NULL)
    {
        const float button_size = GetFrameHeight();
 
        BeginGroup(); // The only purpose of the group here is to allow the caller to query item data e.g. IsItemActive()
        PushID(label);
        SetNextItemWidth(ImMax(1.0f, CalcItemWidth() - (button_size + style.ItemInnerSpacing.x) * 2));
        if (InputText("", buf, IM_ARRAYSIZE(buf), flags)) // PushId(label) + "" gives us the expected ID from outside point of view
            value_changed = DataTypeApplyOpFromText(buf, g.InputTextState.InitialTextA.Data, data_type, p_data, format);
 
        // Step buttons
        const ImVec2 backup_frame_padding = style.FramePadding;
        style.FramePadding.x = style.FramePadding.y;
        ImGuiButtonFlags button_flags = ImGuiButtonFlags_Repeat | ImGuiButtonFlags_DontClosePopups;
        if (flags & ImGuiInputTextFlags_ReadOnly)
            button_flags |= ImGuiButtonFlags_Disabled;
        SameLine(0, style.ItemInnerSpacing.x);
        if (ButtonEx("-", ImVec2(button_size, button_size), button_flags))
        {
            DataTypeApplyOp(data_type, '-', p_data, p_data, g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);
            value_changed = true;
        }
        SameLine(0, style.ItemInnerSpacing.x);
        if (ButtonEx("+", ImVec2(button_size, button_size), button_flags))
        {
            DataTypeApplyOp(data_type, '+', p_data, p_data, g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);
            value_changed = true;
        }
 
        const char* label_end = FindRenderedTextEnd(label);
        if (label != label_end)
        {
            SameLine(0, style.ItemInnerSpacing.x);
            TextEx(label, label_end);
        }
        style.FramePadding = backup_frame_padding;
 
        PopID();
        EndGroup();
    }
    else
    {
        if (InputText(label, buf, IM_ARRAYSIZE(buf), flags))
            value_changed = DataTypeApplyOpFromText(buf, g.InputTextState.InitialTextA.Data, data_type, p_data, format);
    }
    if (value_changed)
        MarkItemEdited(window->DC.LastItemId);
 
    return value_changed;
}

References BeginGroup(), ButtonEx(), CalcItemWidth(), ImVector< T >::Data, DataTypeApplyOp(), DataTypeApplyOpFromText(), DataTypeFormatString(), DataTypeGetInfo(), ImGuiWindow::DC, EndGroup(), FindRenderedTextEnd(), GetCurrentWindow(), GetFrameHeight(), GImGui, IM_ARRAYSIZE, ImGuiButtonFlags_Disabled, ImGuiButtonFlags_DontClosePopups, ImGuiButtonFlags_Repeat, ImGuiInputTextFlags_AutoSelectAll, ImGuiInputTextFlags_CharsDecimal, ImGuiInputTextFlags_CharsHexadecimal, ImGuiInputTextFlags_CharsScientific, ImGuiInputTextFlags_NoMarkEdited, ImGuiInputTextFlags_ReadOnly, ImMax(), ImGuiInputTextState::InitialTextA, InputText(), ImGuiContext::InputTextState, ImGuiContext::IO, ImGuiIO::KeyCtrl, ImGuiWindowTempData::LastItemId, MarkItemEdited(), PopID(), ImGuiDataTypeInfo::PrintFmt, PushID(), SameLine(), SetNextItemWidth(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, and TextEx().

Referenced by InputDouble(), InputFloat(), InputInt(), InputScalarN(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputScalarN()

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    bool value_changed = false;
    BeginGroup();
    PushID(label);
    PushMultiItemsWidths(components, CalcItemWidth());
    size_t type_size = GDataTypeInfo[data_type].Size;
    for (int i = 0; i < components; i++)
    {
        PushID(i);
        if (i > 0)
            SameLine(0, g.Style.ItemInnerSpacing.x);
        value_changed |= InputScalar("", data_type, p_data, p_step, p_step_fast, format, flags);
        PopID();
        PopItemWidth();
        p_data = (void*)((char*)p_data + type_size);
    }
    PopID();
 
    const char* label_end = FindRenderedTextEnd(label);
    if (label != label_end)
    {
        SameLine(0.0f, g.Style.ItemInnerSpacing.x);
        TextEx(label, label_end);
    }
 
    EndGroup();
    return value_changed;
}

References BeginGroup(), CalcItemWidth(), EndGroup(), FindRenderedTextEnd(), GDataTypeInfo, GetCurrentWindow(), GImGui, InputScalar(), ImGuiStyle::ItemInnerSpacing, PopID(), PopItemWidth(), PushID(), PushMultiItemsWidths(), SameLine(), ImGuiDataTypeInfo::Size, ImGuiWindow::SkipItems, ImGuiContext::Style, TextEx(), and ImVec2::x.

Referenced by InputFloat2(), InputFloat3(), InputFloat4(), InputInt2(), InputInt3(), and InputInt4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputText() [1/3]

bool ImGui::InputText	(	const char *	label,
		char *	buf,
		size_t	buf_size,
		ImGuiInputTextFlags	flags = `0`,
		ImGuiInputTextCallback	callback = `NULL`,
		void *	user_data = `NULL`
	)

{
    IM_ASSERT(!(flags & ImGuiInputTextFlags_Multiline)); // call InputTextMultiline()
    return InputTextEx(label, NULL, buf, (int)buf_size, ImVec2(0, 0), flags, callback, user_data);
}

References IM_ASSERT, ImGuiInputTextFlags_Multiline, and InputTextEx().

Referenced by ColorEdit4(), ImGuiTextFilter::Draw(), ExampleAppConsole::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), InputScalar(), InputText(), InputText(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputText() [2/3]

bool ImGui::InputText	(	const char *	label,
		std::string &	str,
		ImGuiInputTextFlags	flags = `0`,
		ImGuiTextEditCallback	callback = `NULL`,
		void *	user_data = `NULL`
	)

inline

{
  char buf[1024];
  std::fill_n(buf, 1024, 0);
  std::copy_n(str.begin(), std::min(1024, (int) str.size()), buf);
  if (ImGui::InputText(label, buf, 1024, flags, callback, user_data))
  {
    str = std::string(buf);
    return true;
  }
  return false;
}

References InputText().

Here is the call graph for this function:

◆ InputText() [3/3]

bool ImGui::InputText	(	const char *	label,
		std::string *	str,
		ImGuiInputTextFlags	flags = `0`,
		ImGuiInputTextCallback	callback = `NULL`,
		void *	user_data = `NULL`
	)

{
    IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
    flags |= ImGuiInputTextFlags_CallbackResize;
 
    InputTextCallback_UserData cb_user_data;
    cb_user_data.Str = str;
    cb_user_data.ChainCallback = callback;
    cb_user_data.ChainCallbackUserData = user_data;
    return InputText(label, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data);
}

References InputTextCallback_UserData::ChainCallback, InputTextCallback_UserData::ChainCallbackUserData, IM_ASSERT, ImGuiInputTextFlags_CallbackResize, InputText(), InputTextCallback(), and InputTextCallback_UserData::Str.

Here is the call graph for this function:

◆ InputTextEx()

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    IM_ASSERT(buf != NULL && buf_size >= 0);
    IM_ASSERT(!((flags & ImGuiInputTextFlags_CallbackHistory) && (flags & ImGuiInputTextFlags_Multiline)));        // Can't use both together (they both use up/down keys)
    IM_ASSERT(!((flags & ImGuiInputTextFlags_CallbackCompletion) && (flags & ImGuiInputTextFlags_AllowTabInput))); // Can't use both together (they both use tab key)
 
    ImGuiContext& g = *GImGui;
    ImGuiIO& io = g.IO;
    const ImGuiStyle& style = g.Style;
 
    const bool RENDER_SELECTION_WHEN_INACTIVE = false;
    const bool is_multiline = (flags & ImGuiInputTextFlags_Multiline) != 0;
    const bool is_readonly = (flags & ImGuiInputTextFlags_ReadOnly) != 0;
    const bool is_password = (flags & ImGuiInputTextFlags_Password) != 0;
    const bool is_undoable = (flags & ImGuiInputTextFlags_NoUndoRedo) == 0;
    const bool is_resizable = (flags & ImGuiInputTextFlags_CallbackResize) != 0;
    if (is_resizable)
        IM_ASSERT(callback != NULL); // Must provide a callback if you set the ImGuiInputTextFlags_CallbackResize flag!
 
    if (is_multiline) // Open group before calling GetID() because groups tracks id created within their scope,
        BeginGroup();
    const ImGuiID id = window->GetID(label);
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
    const ImVec2 frame_size = CalcItemSize(size_arg, CalcItemWidth(), (is_multiline ? g.FontSize * 8.0f : label_size.y) + style.FramePadding.y * 2.0f); // Arbitrary default of 8 lines high for multi-line
    const ImVec2 total_size = ImVec2(frame_size.x + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), frame_size.y);
 
    const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);
    const ImRect total_bb(frame_bb.Min, frame_bb.Min + total_size);
 
    ImGuiWindow* draw_window = window;
    ImVec2 inner_size = frame_size;
    if (is_multiline)
    {
        if (!ItemAdd(total_bb, id, &frame_bb, ImGuiItemAddFlags_Focusable))
        {
            ItemSize(total_bb, style.FramePadding.y);
            EndGroup();
            return false;
        }
 
        // We reproduce the contents of BeginChildFrame() in order to provide 'label' so our window internal data are easier to read/debug.
        PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);
        PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
        PushStyleVar(ImGuiStyleVar_ChildBorderSize, style.FrameBorderSize);
        bool child_visible = BeginChildEx(label, id, frame_bb.GetSize(), true, ImGuiWindowFlags_NoMove);
        PopStyleVar(2);
        PopStyleColor();
        if (!child_visible)
        {
            EndChild();
            EndGroup();
            return false;
        }
        draw_window = g.CurrentWindow; // Child window
        draw_window->DC.NavLayersActiveMaskNext |= (1 << draw_window->DC.NavLayerCurrent); // This is to ensure that EndChild() will display a navigation highlight so we can "enter" into it.
        draw_window->DC.CursorPos += style.FramePadding;
        inner_size.x -= draw_window->ScrollbarSizes.x;
    }
    else
    {
        // Support for internal ImGuiInputTextFlags_MergedItem flag, which could be redesigned as an ItemFlags if needed (with test performed in ItemAdd)
        ItemSize(total_bb, style.FramePadding.y);
        if (!(flags & ImGuiInputTextFlags_MergedItem))
            if (!ItemAdd(total_bb, id, &frame_bb, ImGuiItemAddFlags_Focusable))
                return false;
    }
    const bool hovered = ItemHoverable(frame_bb, id);
    if (hovered)
        g.MouseCursor = ImGuiMouseCursor_TextInput;
 
    // We are only allowed to access the state if we are already the active widget.
    ImGuiInputTextState* state = GetInputTextState(id);
 
    const bool focus_requested_by_code = (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_FocusedByCode) != 0;
    const bool focus_requested_by_tabbing = (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_FocusedByTabbing) != 0;
 
    const bool user_clicked = hovered && io.MouseClicked[0];
    const bool user_nav_input_start = (g.ActiveId != id) && ((g.NavInputId == id) || (g.NavActivateId == id && g.NavInputSource == ImGuiInputSource_Keyboard));
    const bool user_scroll_finish = is_multiline && state != NULL && g.ActiveId == 0 && g.ActiveIdPreviousFrame == GetWindowScrollbarID(draw_window, ImGuiAxis_Y);
    const bool user_scroll_active = is_multiline && state != NULL && g.ActiveId == GetWindowScrollbarID(draw_window, ImGuiAxis_Y);
 
    bool clear_active_id = false;
    bool select_all = (g.ActiveId != id) && ((flags & ImGuiInputTextFlags_AutoSelectAll) != 0 || user_nav_input_start) && (!is_multiline);
 
    float scroll_y = is_multiline ? draw_window->Scroll.y : FLT_MAX;
 
    const bool init_changed_specs = (state != NULL && state->Stb.single_line != !is_multiline);
    const bool init_make_active = (user_clicked || user_scroll_finish || user_nav_input_start || focus_requested_by_code || focus_requested_by_tabbing);
    const bool init_state = (init_make_active || user_scroll_active);
    if ((init_state && g.ActiveId != id) || init_changed_specs)
    {
        // Access state even if we don't own it yet.
        state = &g.InputTextState;
        state->CursorAnimReset();
 
        // Take a copy of the initial buffer value (both in original UTF-8 format and converted to wchar)
        // From the moment we focused we are ignoring the content of 'buf' (unless we are in read-only mode)
        const int buf_len = (int)strlen(buf);
        state->InitialTextA.resize(buf_len + 1);    // UTF-8. we use +1 to make sure that .Data is always pointing to at least an empty string.
        memcpy(state->InitialTextA.Data, buf, buf_len + 1);
 
        // Start edition
        const char* buf_end = NULL;
        state->TextW.resize(buf_size + 1);          // wchar count <= UTF-8 count. we use +1 to make sure that .Data is always pointing to at least an empty string.
        state->TextA.resize(0);
        state->TextAIsValid = false;                // TextA is not valid yet (we will display buf until then)
        state->CurLenW = ImTextStrFromUtf8(state->TextW.Data, buf_size, buf, NULL, &buf_end);
        state->CurLenA = (int)(buf_end - buf);      // We can't get the result from ImStrncpy() above because it is not UTF-8 aware. Here we'll cut off malformed UTF-8.
 
        // Preserve cursor position and undo/redo stack if we come back to same widget
        // FIXME: For non-readonly widgets we might be able to require that TextAIsValid && TextA == buf ? (untested) and discard undo stack if user buffer has changed.
        const bool recycle_state = (state->ID == id && !init_changed_specs);
        if (recycle_state)
        {
            // Recycle existing cursor/selection/undo stack but clamp position
            // Note a single mouse click will override the cursor/position immediately by calling stb_textedit_click handler.
            state->CursorClamp();
        }
        else
        {
            state->ID = id;
            state->ScrollX = 0.0f;
            stb_textedit_initialize_state(&state->Stb, !is_multiline);
            if (!is_multiline && focus_requested_by_code)
                select_all = true;
        }
        if (flags & ImGuiInputTextFlags_AlwaysOverwrite)
            state->Stb.insert_mode = 1; // stb field name is indeed incorrect (see #2863)
        if (!is_multiline && (focus_requested_by_tabbing || (user_clicked && io.KeyCtrl)))
            select_all = true;
    }
 
    if (g.ActiveId != id && init_make_active)
    {
        IM_ASSERT(state && state->ID == id);
        SetActiveID(id, window);
        SetFocusID(id, window);
        FocusWindow(window);
 
        // Declare our inputs
        IM_ASSERT(ImGuiNavInput_COUNT < 32);
        g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Left) | (1 << ImGuiDir_Right);
        if (is_multiline || (flags & ImGuiInputTextFlags_CallbackHistory))
            g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Up) | (1 << ImGuiDir_Down);
        g.ActiveIdUsingNavInputMask |= (1 << ImGuiNavInput_Cancel);
        g.ActiveIdUsingKeyInputMask |= ((ImU64)1 << ImGuiKey_Home) | ((ImU64)1 << ImGuiKey_End);
        if (is_multiline)
            g.ActiveIdUsingKeyInputMask |= ((ImU64)1 << ImGuiKey_PageUp) | ((ImU64)1 << ImGuiKey_PageDown);
        if (flags & (ImGuiInputTextFlags_CallbackCompletion | ImGuiInputTextFlags_AllowTabInput))  // Disable keyboard tabbing out as we will use the \t character.
            g.ActiveIdUsingKeyInputMask |= ((ImU64)1 << ImGuiKey_Tab);
    }
 
    // We have an edge case if ActiveId was set through another widget (e.g. widget being swapped), clear id immediately (don't wait until the end of the function)
    if (g.ActiveId == id && state == NULL)
        ClearActiveID();
 
    // Release focus when we click outside
    if (g.ActiveId == id && io.MouseClicked[0] && !init_state && !init_make_active) //-V560
        clear_active_id = true;
 
    // Lock the decision of whether we are going to take the path displaying the cursor or selection
    const bool render_cursor = (g.ActiveId == id) || (state && user_scroll_active);
    bool render_selection = state && state->HasSelection() && (RENDER_SELECTION_WHEN_INACTIVE || render_cursor);
    bool value_changed = false;
    bool enter_pressed = false;
 
    // When read-only we always use the live data passed to the function
    // FIXME-OPT: Because our selection/cursor code currently needs the wide text we need to convert it when active, which is not ideal :(
    if (is_readonly && state != NULL && (render_cursor || render_selection))
    {
        const char* buf_end = NULL;
        state->TextW.resize(buf_size + 1);
        state->CurLenW = ImTextStrFromUtf8(state->TextW.Data, state->TextW.Size, buf, NULL, &buf_end);
        state->CurLenA = (int)(buf_end - buf);
        state->CursorClamp();
        render_selection &= state->HasSelection();
    }
 
    // Select the buffer to render.
    const bool buf_display_from_state = (render_cursor || render_selection || g.ActiveId == id) && !is_readonly && state && state->TextAIsValid;
    const bool is_displaying_hint = (hint != NULL && (buf_display_from_state ? state->TextA.Data : buf)[0] == 0);
 
    // Password pushes a temporary font with only a fallback glyph
    if (is_password && !is_displaying_hint)
    {
        const ImFontGlyph* glyph = g.Font->FindGlyph('*');
        ImFont* password_font = &g.InputTextPasswordFont;
        password_font->FontSize = g.Font->FontSize;
        password_font->Scale = g.Font->Scale;
        password_font->Ascent = g.Font->Ascent;
        password_font->Descent = g.Font->Descent;
        password_font->ContainerAtlas = g.Font->ContainerAtlas;
        password_font->FallbackGlyph = glyph;
        password_font->FallbackAdvanceX = glyph->AdvanceX;
        IM_ASSERT(password_font->Glyphs.empty() && password_font->IndexAdvanceX.empty() && password_font->IndexLookup.empty());
        PushFont(password_font);
    }
 
    // Process mouse inputs and character inputs
    int backup_current_text_length = 0;
    if (g.ActiveId == id)
    {
        IM_ASSERT(state != NULL);
        backup_current_text_length = state->CurLenA;
        state->Edited = false;
        state->BufCapacityA = buf_size;
        state->Flags = flags;
        state->UserCallback = callback;
        state->UserCallbackData = callback_user_data;
 
        // Although we are active we don't prevent mouse from hovering other elements unless we are interacting right now with the widget.
        // Down the line we should have a cleaner library-wide concept of Selected vs Active.
        g.ActiveIdAllowOverlap = !io.MouseDown[0];
        g.WantTextInputNextFrame = 1;
 
        // Edit in progress
        const float mouse_x = (io.MousePos.x - frame_bb.Min.x - style.FramePadding.x) + state->ScrollX;
        const float mouse_y = (is_multiline ? (io.MousePos.y - draw_window->DC.CursorPos.y) : (g.FontSize * 0.5f));
 
        const bool is_osx = io.ConfigMacOSXBehaviors;
        if (select_all || (hovered && !is_osx && io.MouseDoubleClicked[0]))
        {
            state->SelectAll();
            state->SelectedAllMouseLock = true;
        }
        else if (hovered && is_osx && io.MouseDoubleClicked[0])
        {
            // Double-click select a word only, OS X style (by simulating keystrokes)
            state->OnKeyPressed(STB_TEXTEDIT_K_WORDLEFT);
            state->OnKeyPressed(STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT);
        }
        else if (io.MouseClicked[0] && !state->SelectedAllMouseLock)
        {
            if (hovered)
            {
                stb_textedit_click(state, &state->Stb, mouse_x, mouse_y);
                state->CursorAnimReset();
            }
        }
        else if (io.MouseDown[0] && !state->SelectedAllMouseLock && (io.MouseDelta.x != 0.0f || io.MouseDelta.y != 0.0f))
        {
            stb_textedit_drag(state, &state->Stb, mouse_x, mouse_y);
            state->CursorAnimReset();
            state->CursorFollow = true;
        }
        if (state->SelectedAllMouseLock && !io.MouseDown[0])
            state->SelectedAllMouseLock = false;
 
        // It is ill-defined whether the backend needs to send a \t character when pressing the TAB keys.
        // Win32 and GLFW naturally do it but not SDL.
        const bool ignore_char_inputs = (io.KeyCtrl && !io.KeyAlt) || (is_osx && io.KeySuper);
        if ((flags & ImGuiInputTextFlags_AllowTabInput) && IsKeyPressedMap(ImGuiKey_Tab) && !ignore_char_inputs && !io.KeyShift && !is_readonly)
            if (!io.InputQueueCharacters.contains('\t'))
            {
                unsigned int c = '\t'; // Insert TAB
                if (InputTextFilterCharacter(&c, flags, callback, callback_user_data, ImGuiInputSource_Keyboard))
                    state->OnKeyPressed((int)c);
            }
 
        // Process regular text input (before we check for Return because using some IME will effectively send a Return?)
        // We ignore CTRL inputs, but need to allow ALT+CTRL as some keyboards (e.g. German) use AltGR (which _is_ Alt+Ctrl) to input certain characters.
        if (io.InputQueueCharacters.Size > 0)
        {
            if (!ignore_char_inputs && !is_readonly && !user_nav_input_start)
                for (int n = 0; n < io.InputQueueCharacters.Size; n++)
                {
                    // Insert character if they pass filtering
                    unsigned int c = (unsigned int)io.InputQueueCharacters[n];
                    if (c == '\t' && io.KeyShift)
                        continue;
                    if (InputTextFilterCharacter(&c, flags, callback, callback_user_data, ImGuiInputSource_Keyboard))
                        state->OnKeyPressed((int)c);
                }
 
            // Consume characters
            io.InputQueueCharacters.resize(0);
        }
    }
 
    // Process other shortcuts/key-presses
    bool cancel_edit = false;
    if (g.ActiveId == id && !g.ActiveIdIsJustActivated && !clear_active_id)
    {
        IM_ASSERT(state != NULL);
        IM_ASSERT(io.KeyMods == GetMergedKeyModFlags() && "Mismatching io.KeyCtrl/io.KeyShift/io.KeyAlt/io.KeySuper vs io.KeyMods"); // We rarely do this check, but if anything let's do it here.
 
        const int row_count_per_page = ImMax((int)((inner_size.y - style.FramePadding.y) / g.FontSize), 1);
        state->Stb.row_count_per_page = row_count_per_page;
 
        const int k_mask = (io.KeyShift ? STB_TEXTEDIT_K_SHIFT : 0);
        const bool is_osx = io.ConfigMacOSXBehaviors;
        const bool is_osx_shift_shortcut = is_osx && (io.KeyMods == (ImGuiKeyModFlags_Super | ImGuiKeyModFlags_Shift));
        const bool is_wordmove_key_down = is_osx ? io.KeyAlt : io.KeyCtrl;                     // OS X style: Text editing cursor movement using Alt instead of Ctrl
        const bool is_startend_key_down = is_osx && io.KeySuper && !io.KeyCtrl && !io.KeyAlt;  // OS X style: Line/Text Start and End using Cmd+Arrows instead of Home/End
        const bool is_ctrl_key_only = (io.KeyMods == ImGuiKeyModFlags_Ctrl);
        const bool is_shift_key_only = (io.KeyMods == ImGuiKeyModFlags_Shift);
        const bool is_shortcut_key = g.IO.ConfigMacOSXBehaviors ? (io.KeyMods == ImGuiKeyModFlags_Super) : (io.KeyMods == ImGuiKeyModFlags_Ctrl);
 
        const bool is_cut   = ((is_shortcut_key && IsKeyPressedMap(ImGuiKey_X)) || (is_shift_key_only && IsKeyPressedMap(ImGuiKey_Delete))) && !is_readonly && !is_password && (!is_multiline || state->HasSelection());
        const bool is_copy  = ((is_shortcut_key && IsKeyPressedMap(ImGuiKey_C)) || (is_ctrl_key_only  && IsKeyPressedMap(ImGuiKey_Insert))) && !is_password && (!is_multiline || state->HasSelection());
        const bool is_paste = ((is_shortcut_key && IsKeyPressedMap(ImGuiKey_V)) || (is_shift_key_only && IsKeyPressedMap(ImGuiKey_Insert))) && !is_readonly;
        const bool is_undo  = ((is_shortcut_key && IsKeyPressedMap(ImGuiKey_Z)) && !is_readonly && is_undoable);
        const bool is_redo  = ((is_shortcut_key && IsKeyPressedMap(ImGuiKey_Y)) || (is_osx_shift_shortcut && IsKeyPressedMap(ImGuiKey_Z))) && !is_readonly && is_undoable;
 
        if (IsKeyPressedMap(ImGuiKey_LeftArrow))                        { state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_LINESTART : is_wordmove_key_down ? STB_TEXTEDIT_K_WORDLEFT : STB_TEXTEDIT_K_LEFT) | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_RightArrow))                  { state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_LINEEND : is_wordmove_key_down ? STB_TEXTEDIT_K_WORDRIGHT : STB_TEXTEDIT_K_RIGHT) | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_UpArrow) && is_multiline)     { if (io.KeyCtrl) SetScrollY(draw_window, ImMax(draw_window->Scroll.y - g.FontSize, 0.0f)); else state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_TEXTSTART : STB_TEXTEDIT_K_UP) | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_DownArrow) && is_multiline)   { if (io.KeyCtrl) SetScrollY(draw_window, ImMin(draw_window->Scroll.y + g.FontSize, GetScrollMaxY())); else state->OnKeyPressed((is_startend_key_down ? STB_TEXTEDIT_K_TEXTEND : STB_TEXTEDIT_K_DOWN) | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_PageUp) && is_multiline)      { state->OnKeyPressed(STB_TEXTEDIT_K_PGUP | k_mask); scroll_y -= row_count_per_page * g.FontSize; }
        else if (IsKeyPressedMap(ImGuiKey_PageDown) && is_multiline)    { state->OnKeyPressed(STB_TEXTEDIT_K_PGDOWN | k_mask); scroll_y += row_count_per_page * g.FontSize; }
        else if (IsKeyPressedMap(ImGuiKey_Home))                        { state->OnKeyPressed(io.KeyCtrl ? STB_TEXTEDIT_K_TEXTSTART | k_mask : STB_TEXTEDIT_K_LINESTART | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_End))                         { state->OnKeyPressed(io.KeyCtrl ? STB_TEXTEDIT_K_TEXTEND | k_mask : STB_TEXTEDIT_K_LINEEND | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_Delete) && !is_readonly)      { state->OnKeyPressed(STB_TEXTEDIT_K_DELETE | k_mask); }
        else if (IsKeyPressedMap(ImGuiKey_Backspace) && !is_readonly)
        {
            if (!state->HasSelection())
            {
                if (is_wordmove_key_down)
                    state->OnKeyPressed(STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT);
                else if (is_osx && io.KeySuper && !io.KeyAlt && !io.KeyCtrl)
                    state->OnKeyPressed(STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT);
            }
            state->OnKeyPressed(STB_TEXTEDIT_K_BACKSPACE | k_mask);
        }
        else if (IsKeyPressedMap(ImGuiKey_Enter) || IsKeyPressedMap(ImGuiKey_KeyPadEnter))
        {
            bool ctrl_enter_for_new_line = (flags & ImGuiInputTextFlags_CtrlEnterForNewLine) != 0;
            if (!is_multiline || (ctrl_enter_for_new_line && !io.KeyCtrl) || (!ctrl_enter_for_new_line && io.KeyCtrl))
            {
                enter_pressed = clear_active_id = true;
            }
            else if (!is_readonly)
            {
                unsigned int c = '\n'; // Insert new line
                if (InputTextFilterCharacter(&c, flags, callback, callback_user_data, ImGuiInputSource_Keyboard))
                    state->OnKeyPressed((int)c);
            }
        }
        else if (IsKeyPressedMap(ImGuiKey_Escape))
        {
            clear_active_id = cancel_edit = true;
        }
        else if (is_undo || is_redo)
        {
            state->OnKeyPressed(is_undo ? STB_TEXTEDIT_K_UNDO : STB_TEXTEDIT_K_REDO);
            state->ClearSelection();
        }
        else if (is_shortcut_key && IsKeyPressedMap(ImGuiKey_A))
        {
            state->SelectAll();
            state->CursorFollow = true;
        }
        else if (is_cut || is_copy)
        {
            // Cut, Copy
            if (io.SetClipboardTextFn)
            {
                const int ib = state->HasSelection() ? ImMin(state->Stb.select_start, state->Stb.select_end) : 0;
                const int ie = state->HasSelection() ? ImMax(state->Stb.select_start, state->Stb.select_end) : state->CurLenW;
                const int clipboard_data_len = ImTextCountUtf8BytesFromStr(state->TextW.Data + ib, state->TextW.Data + ie) + 1;
                char* clipboard_data = (char*)IM_ALLOC(clipboard_data_len * sizeof(char));
                ImTextStrToUtf8(clipboard_data, clipboard_data_len, state->TextW.Data + ib, state->TextW.Data + ie);
                SetClipboardText(clipboard_data);
                MemFree(clipboard_data);
            }
            if (is_cut)
            {
                if (!state->HasSelection())
                    state->SelectAll();
                state->CursorFollow = true;
                stb_textedit_cut(state, &state->Stb);
            }
        }
        else if (is_paste)
        {
            if (const char* clipboard = GetClipboardText())
            {
                // Filter pasted buffer
                const int clipboard_len = (int)strlen(clipboard);
                ImWchar* clipboard_filtered = (ImWchar*)IM_ALLOC((clipboard_len + 1) * sizeof(ImWchar));
                int clipboard_filtered_len = 0;
                for (const char* s = clipboard; *s; )
                {
                    unsigned int c;
                    s += ImTextCharFromUtf8(&c, s, NULL);
                    if (c == 0)
                        break;
                    if (!InputTextFilterCharacter(&c, flags, callback, callback_user_data, ImGuiInputSource_Clipboard))
                        continue;
                    clipboard_filtered[clipboard_filtered_len++] = (ImWchar)c;
                }
                clipboard_filtered[clipboard_filtered_len] = 0;
                if (clipboard_filtered_len > 0) // If everything was filtered, ignore the pasting operation
                {
                    stb_textedit_paste(state, &state->Stb, clipboard_filtered, clipboard_filtered_len);
                    state->CursorFollow = true;
                }
                MemFree(clipboard_filtered);
            }
        }
 
        // Update render selection flag after events have been handled, so selection highlight can be displayed during the same frame.
        render_selection |= state->HasSelection() && (RENDER_SELECTION_WHEN_INACTIVE || render_cursor);
    }
 
    // Process callbacks and apply result back to user's buffer.
    if (g.ActiveId == id)
    {
        IM_ASSERT(state != NULL);
        const char* apply_new_text = NULL;
        int apply_new_text_length = 0;
        if (cancel_edit)
        {
            // Restore initial value. Only return true if restoring to the initial value changes the current buffer contents.
            if (!is_readonly && strcmp(buf, state->InitialTextA.Data) != 0)
            {
                // Push records into the undo stack so we can CTRL+Z the revert operation itself
                apply_new_text = state->InitialTextA.Data;
                apply_new_text_length = state->InitialTextA.Size - 1;
                ImVector<ImWchar> w_text;
                if (apply_new_text_length > 0)
                {
                    w_text.resize(ImTextCountCharsFromUtf8(apply_new_text, apply_new_text + apply_new_text_length) + 1);
                    ImTextStrFromUtf8(w_text.Data, w_text.Size, apply_new_text, apply_new_text + apply_new_text_length);
                }
                stb_textedit_replace(state, &state->Stb, w_text.Data, (apply_new_text_length > 0) ? (w_text.Size - 1) : 0);
            }
        }
 
        // When using 'ImGuiInputTextFlags_EnterReturnsTrue' as a special case we reapply the live buffer back to the input buffer before clearing ActiveId, even though strictly speaking it wasn't modified on this frame.
        // If we didn't do that, code like InputInt() with ImGuiInputTextFlags_EnterReturnsTrue would fail.
        // This also allows the user to use InputText() with ImGuiInputTextFlags_EnterReturnsTrue without maintaining any user-side storage (please note that if you use this property along ImGuiInputTextFlags_CallbackResize you can end up with your temporary string object unnecessarily allocating once a frame, either store your string data, either if you don't then don't use ImGuiInputTextFlags_CallbackResize).
        bool apply_edit_back_to_user_buffer = !cancel_edit || (enter_pressed && (flags & ImGuiInputTextFlags_EnterReturnsTrue) != 0);
        if (apply_edit_back_to_user_buffer)
        {
            // Apply new value immediately - copy modified buffer back
            // Note that as soon as the input box is active, the in-widget value gets priority over any underlying modification of the input buffer
            // FIXME: We actually always render 'buf' when calling DrawList->AddText, making the comment above incorrect.
            // FIXME-OPT: CPU waste to do this every time the widget is active, should mark dirty state from the stb_textedit callbacks.
            if (!is_readonly)
            {
                state->TextAIsValid = true;
                state->TextA.resize(state->TextW.Size * 4 + 1);
                ImTextStrToUtf8(state->TextA.Data, state->TextA.Size, state->TextW.Data, NULL);
            }
 
            // User callback
            if ((flags & (ImGuiInputTextFlags_CallbackCompletion | ImGuiInputTextFlags_CallbackHistory | ImGuiInputTextFlags_CallbackEdit | ImGuiInputTextFlags_CallbackAlways)) != 0)
            {
                IM_ASSERT(callback != NULL);
 
                // The reason we specify the usage semantic (Completion/History) is that Completion needs to disable keyboard TABBING at the moment.
                ImGuiInputTextFlags event_flag = 0;
                ImGuiKey event_key = ImGuiKey_COUNT;
                if ((flags & ImGuiInputTextFlags_CallbackCompletion) != 0 && IsKeyPressedMap(ImGuiKey_Tab))
                {
                    event_flag = ImGuiInputTextFlags_CallbackCompletion;
                    event_key = ImGuiKey_Tab;
                }
                else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressedMap(ImGuiKey_UpArrow))
                {
                    event_flag = ImGuiInputTextFlags_CallbackHistory;
                    event_key = ImGuiKey_UpArrow;
                }
                else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressedMap(ImGuiKey_DownArrow))
                {
                    event_flag = ImGuiInputTextFlags_CallbackHistory;
                    event_key = ImGuiKey_DownArrow;
                }
                else if ((flags & ImGuiInputTextFlags_CallbackEdit) && state->Edited)
                {
                    event_flag = ImGuiInputTextFlags_CallbackEdit;
                }
                else if (flags & ImGuiInputTextFlags_CallbackAlways)
                {
                    event_flag = ImGuiInputTextFlags_CallbackAlways;
                }
 
                if (event_flag)
                {
                    ImGuiInputTextCallbackData callback_data;
                    memset(&callback_data, 0, sizeof(ImGuiInputTextCallbackData));
                    callback_data.EventFlag = event_flag;
                    callback_data.Flags = flags;
                    callback_data.UserData = callback_user_data;
 
                    callback_data.EventKey = event_key;
                    callback_data.Buf = state->TextA.Data;
                    callback_data.BufTextLen = state->CurLenA;
                    callback_data.BufSize = state->BufCapacityA;
                    callback_data.BufDirty = false;
 
                    // We have to convert from wchar-positions to UTF-8-positions, which can be pretty slow (an incentive to ditch the ImWchar buffer, see https://github.com/nothings/stb/issues/188)
                    ImWchar* text = state->TextW.Data;
                    const int utf8_cursor_pos = callback_data.CursorPos = ImTextCountUtf8BytesFromStr(text, text + state->Stb.cursor);
                    const int utf8_selection_start = callback_data.SelectionStart = ImTextCountUtf8BytesFromStr(text, text + state->Stb.select_start);
                    const int utf8_selection_end = callback_data.SelectionEnd = ImTextCountUtf8BytesFromStr(text, text + state->Stb.select_end);
 
                    // Call user code
                    callback(&callback_data);
 
                    // Read back what user may have modified
                    IM_ASSERT(callback_data.Buf == state->TextA.Data);  // Invalid to modify those fields
                    IM_ASSERT(callback_data.BufSize == state->BufCapacityA);
                    IM_ASSERT(callback_data.Flags == flags);
                    const bool buf_dirty = callback_data.BufDirty;
                    if (callback_data.CursorPos != utf8_cursor_pos || buf_dirty)            { state->Stb.cursor = ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.CursorPos); state->CursorFollow = true; }
                    if (callback_data.SelectionStart != utf8_selection_start || buf_dirty)  { state->Stb.select_start = (callback_data.SelectionStart == callback_data.CursorPos) ? state->Stb.cursor : ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.SelectionStart); }
                    if (callback_data.SelectionEnd != utf8_selection_end || buf_dirty)      { state->Stb.select_end = (callback_data.SelectionEnd == callback_data.SelectionStart) ? state->Stb.select_start : ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.SelectionEnd); }
                    if (buf_dirty)
                    {
                        IM_ASSERT(callback_data.BufTextLen == (int)strlen(callback_data.Buf)); // You need to maintain BufTextLen if you change the text!
                        if (callback_data.BufTextLen > backup_current_text_length && is_resizable)
                            state->TextW.resize(state->TextW.Size + (callback_data.BufTextLen - backup_current_text_length));
                        state->CurLenW = ImTextStrFromUtf8(state->TextW.Data, state->TextW.Size, callback_data.Buf, NULL);
                        state->CurLenA = callback_data.BufTextLen;  // Assume correct length and valid UTF-8 from user, saves us an extra strlen()
                        state->CursorAnimReset();
                    }
                }
            }
 
            // Will copy result string if modified
            if (!is_readonly && strcmp(state->TextA.Data, buf) != 0)
            {
                apply_new_text = state->TextA.Data;
                apply_new_text_length = state->CurLenA;
            }
        }
 
        // Copy result to user buffer
        if (apply_new_text)
        {
            // We cannot test for 'backup_current_text_length != apply_new_text_length' here because we have no guarantee that the size
            // of our owned buffer matches the size of the string object held by the user, and by design we allow InputText() to be used
            // without any storage on user's side.
            IM_ASSERT(apply_new_text_length >= 0);
            if (is_resizable)
            {
                ImGuiInputTextCallbackData callback_data;
                callback_data.EventFlag = ImGuiInputTextFlags_CallbackResize;
                callback_data.Flags = flags;
                callback_data.Buf = buf;
                callback_data.BufTextLen = apply_new_text_length;
                callback_data.BufSize = ImMax(buf_size, apply_new_text_length + 1);
                callback_data.UserData = callback_user_data;
                callback(&callback_data);
                buf = callback_data.Buf;
                buf_size = callback_data.BufSize;
                apply_new_text_length = ImMin(callback_data.BufTextLen, buf_size - 1);
                IM_ASSERT(apply_new_text_length <= buf_size);
            }
            //IMGUI_DEBUG_LOG("InputText(\"%s\"): apply_new_text length %d\n", label, apply_new_text_length);
 
            // If the underlying buffer resize was denied or not carried to the next frame, apply_new_text_length+1 may be >= buf_size.
            ImStrncpy(buf, apply_new_text, ImMin(apply_new_text_length + 1, buf_size));
            value_changed = true;
        }
 
        // Clear temporary user storage
        state->Flags = ImGuiInputTextFlags_None;
        state->UserCallback = NULL;
        state->UserCallbackData = NULL;
    }
 
    // Release active ID at the end of the function (so e.g. pressing Return still does a final application of the value)
    if (clear_active_id && g.ActiveId == id)
        ClearActiveID();
 
    // Render frame
    if (!is_multiline)
    {
        RenderNavHighlight(frame_bb, id);
        RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
    }
 
    const ImVec4 clip_rect(frame_bb.Min.x, frame_bb.Min.y, frame_bb.Min.x + inner_size.x, frame_bb.Min.y + inner_size.y); // Not using frame_bb.Max because we have adjusted size
    ImVec2 draw_pos = is_multiline ? draw_window->DC.CursorPos : frame_bb.Min + style.FramePadding;
    ImVec2 text_size(0.0f, 0.0f);
 
    // Set upper limit of single-line InputTextEx() at 2 million characters strings. The current pathological worst case is a long line
    // without any carriage return, which would makes ImFont::RenderText() reserve too many vertices and probably crash. Avoid it altogether.
    // Note that we only use this limit on single-line InputText(), so a pathologically large line on a InputTextMultiline() would still crash.
    const int buf_display_max_length = 2 * 1024 * 1024;
    const char* buf_display = buf_display_from_state ? state->TextA.Data : buf; //-V595
    const char* buf_display_end = NULL; // We have specialized paths below for setting the length
    if (is_displaying_hint)
    {
        buf_display = hint;
        buf_display_end = hint + strlen(hint);
    }
 
    // Render text. We currently only render selection when the widget is active or while scrolling.
    // FIXME: We could remove the '&& render_cursor' to keep rendering selection when inactive.
    if (render_cursor || render_selection)
    {
        IM_ASSERT(state != NULL);
        if (!is_displaying_hint)
            buf_display_end = buf_display + state->CurLenA;
 
        // Render text (with cursor and selection)
        // This is going to be messy. We need to:
        // - Display the text (this alone can be more easily clipped)
        // - Handle scrolling, highlight selection, display cursor (those all requires some form of 1d->2d cursor position calculation)
        // - Measure text height (for scrollbar)
        // We are attempting to do most of that in **one main pass** to minimize the computation cost (non-negligible for large amount of text) + 2nd pass for selection rendering (we could merge them by an extra refactoring effort)
        // FIXME: This should occur on buf_display but we'd need to maintain cursor/select_start/select_end for UTF-8.
        const ImWchar* text_begin = state->TextW.Data;
        ImVec2 cursor_offset, select_start_offset;
 
        {
            // Find lines numbers straddling 'cursor' (slot 0) and 'select_start' (slot 1) positions.
            const ImWchar* searches_input_ptr[2] = { NULL, NULL };
            int searches_result_line_no[2] = { -1000, -1000 };
            int searches_remaining = 0;
            if (render_cursor)
            {
                searches_input_ptr[0] = text_begin + state->Stb.cursor;
                searches_result_line_no[0] = -1;
                searches_remaining++;
            }
            if (render_selection)
            {
                searches_input_ptr[1] = text_begin + ImMin(state->Stb.select_start, state->Stb.select_end);
                searches_result_line_no[1] = -1;
                searches_remaining++;
            }
 
            // Iterate all lines to find our line numbers
            // In multi-line mode, we never exit the loop until all lines are counted, so add one extra to the searches_remaining counter.
            searches_remaining += is_multiline ? 1 : 0;
            int line_count = 0;
            //for (const ImWchar* s = text_begin; (s = (const ImWchar*)wcschr((const wchar_t*)s, (wchar_t)'\n')) != NULL; s++)  // FIXME-OPT: Could use this when wchar_t are 16-bit
            for (const ImWchar* s = text_begin; *s != 0; s++)
                if (*s == '\n')
                {
                    line_count++;
                    if (searches_result_line_no[0] == -1 && s >= searches_input_ptr[0]) { searches_result_line_no[0] = line_count; if (--searches_remaining <= 0) break; }
                    if (searches_result_line_no[1] == -1 && s >= searches_input_ptr[1]) { searches_result_line_no[1] = line_count; if (--searches_remaining <= 0) break; }
                }
            line_count++;
            if (searches_result_line_no[0] == -1)
                searches_result_line_no[0] = line_count;
            if (searches_result_line_no[1] == -1)
                searches_result_line_no[1] = line_count;
 
            // Calculate 2d position by finding the beginning of the line and measuring distance
            cursor_offset.x = InputTextCalcTextSizeW(ImStrbolW(searches_input_ptr[0], text_begin), searches_input_ptr[0]).x;
            cursor_offset.y = searches_result_line_no[0] * g.FontSize;
            if (searches_result_line_no[1] >= 0)
            {
                select_start_offset.x = InputTextCalcTextSizeW(ImStrbolW(searches_input_ptr[1], text_begin), searches_input_ptr[1]).x;
                select_start_offset.y = searches_result_line_no[1] * g.FontSize;
            }
 
            // Store text height (note that we haven't calculated text width at all, see GitHub issues #383, #1224)
            if (is_multiline)
                text_size = ImVec2(inner_size.x, line_count * g.FontSize);
        }
 
        // Scroll
        if (render_cursor && state->CursorFollow)
        {
            // Horizontal scroll in chunks of quarter width
            if (!(flags & ImGuiInputTextFlags_NoHorizontalScroll))
            {
                const float scroll_increment_x = inner_size.x * 0.25f;
                const float visible_width = inner_size.x - style.FramePadding.x;
                if (cursor_offset.x < state->ScrollX)
                    state->ScrollX = IM_FLOOR(ImMax(0.0f, cursor_offset.x - scroll_increment_x));
                else if (cursor_offset.x - visible_width >= state->ScrollX)
                    state->ScrollX = IM_FLOOR(cursor_offset.x - visible_width + scroll_increment_x);
            }
            else
            {
                state->ScrollX = 0.0f;
            }
 
            // Vertical scroll
            if (is_multiline)
            {
                // Test if cursor is vertically visible
                if (cursor_offset.y - g.FontSize < scroll_y)
                    scroll_y = ImMax(0.0f, cursor_offset.y - g.FontSize);
                else if (cursor_offset.y - inner_size.y >= scroll_y)
                    scroll_y = cursor_offset.y - inner_size.y + style.FramePadding.y * 2.0f;
                const float scroll_max_y = ImMax((text_size.y + style.FramePadding.y * 2.0f) - inner_size.y, 0.0f);
                scroll_y = ImClamp(scroll_y, 0.0f, scroll_max_y);
                draw_pos.y += (draw_window->Scroll.y - scroll_y);   // Manipulate cursor pos immediately avoid a frame of lag
                draw_window->Scroll.y = scroll_y;
            }
 
            state->CursorFollow = false;
        }
 
        // Draw selection
        const ImVec2 draw_scroll = ImVec2(state->ScrollX, 0.0f);
        if (render_selection)
        {
            const ImWchar* text_selected_begin = text_begin + ImMin(state->Stb.select_start, state->Stb.select_end);
            const ImWchar* text_selected_end = text_begin + ImMax(state->Stb.select_start, state->Stb.select_end);
 
            ImU32 bg_color = GetColorU32(ImGuiCol_TextSelectedBg, render_cursor ? 1.0f : 0.6f); // FIXME: current code flow mandate that render_cursor is always true here, we are leaving the transparent one for tests.
            float bg_offy_up = is_multiline ? 0.0f : -1.0f;    // FIXME: those offsets should be part of the style? they don't play so well with multi-line selection.
            float bg_offy_dn = is_multiline ? 0.0f : 2.0f;
            ImVec2 rect_pos = draw_pos + select_start_offset - draw_scroll;
            for (const ImWchar* p = text_selected_begin; p < text_selected_end; )
            {
                if (rect_pos.y > clip_rect.w + g.FontSize)
                    break;
                if (rect_pos.y < clip_rect.y)
                {
                    //p = (const ImWchar*)wmemchr((const wchar_t*)p, '\n', text_selected_end - p);  // FIXME-OPT: Could use this when wchar_t are 16-bit
                    //p = p ? p + 1 : text_selected_end;
                    while (p < text_selected_end)
                        if (*p++ == '\n')
                            break;
                }
                else
                {
                    ImVec2 rect_size = InputTextCalcTextSizeW(p, text_selected_end, &p, NULL, true);
                    if (rect_size.x <= 0.0f) rect_size.x = IM_FLOOR(g.Font->GetCharAdvance((ImWchar)' ') * 0.50f); // So we can see selected empty lines
                    ImRect rect(rect_pos + ImVec2(0.0f, bg_offy_up - g.FontSize), rect_pos + ImVec2(rect_size.x, bg_offy_dn));
                    rect.ClipWith(clip_rect);
                    if (rect.Overlaps(clip_rect))
                        draw_window->DrawList->AddRectFilled(rect.Min, rect.Max, bg_color);
                }
                rect_pos.x = draw_pos.x - draw_scroll.x;
                rect_pos.y += g.FontSize;
            }
        }
 
        // We test for 'buf_display_max_length' as a way to avoid some pathological cases (e.g. single-line 1 MB string) which would make ImDrawList crash.
        if (is_multiline || (buf_display_end - buf_display) < buf_display_max_length)
        {
            ImU32 col = GetColorU32(is_displaying_hint ? ImGuiCol_TextDisabled : ImGuiCol_Text);
            draw_window->DrawList->AddText(g.Font, g.FontSize, draw_pos - draw_scroll, col, buf_display, buf_display_end, 0.0f, is_multiline ? NULL : &clip_rect);
        }
 
        // Draw blinking cursor
        if (render_cursor)
        {
            state->CursorAnim += io.DeltaTime;
            bool cursor_is_visible = (!g.IO.ConfigInputTextCursorBlink) || (state->CursorAnim <= 0.0f) || ImFmod(state->CursorAnim, 1.20f) <= 0.80f;
            ImVec2 cursor_screen_pos = ImFloor(draw_pos + cursor_offset - draw_scroll);
            ImRect cursor_screen_rect(cursor_screen_pos.x, cursor_screen_pos.y - g.FontSize + 0.5f, cursor_screen_pos.x + 1.0f, cursor_screen_pos.y - 1.5f);
            if (cursor_is_visible && cursor_screen_rect.Overlaps(clip_rect))
                draw_window->DrawList->AddLine(cursor_screen_rect.Min, cursor_screen_rect.GetBL(), GetColorU32(ImGuiCol_Text));
 
            // Notify OS of text input position for advanced IME (-1 x offset so that Windows IME can cover our cursor. Bit of an extra nicety.)
            if (!is_readonly)
                g.PlatformImePos = ImVec2(cursor_screen_pos.x - 1.0f, cursor_screen_pos.y - g.FontSize);
        }
    }
    else
    {
        // Render text only (no selection, no cursor)
        if (is_multiline)
            text_size = ImVec2(inner_size.x, InputTextCalcTextLenAndLineCount(buf_display, &buf_display_end) * g.FontSize); // We don't need width
        else if (!is_displaying_hint && g.ActiveId == id)
            buf_display_end = buf_display + state->CurLenA;
        else if (!is_displaying_hint)
            buf_display_end = buf_display + strlen(buf_display);
 
        if (is_multiline || (buf_display_end - buf_display) < buf_display_max_length)
        {
            ImU32 col = GetColorU32(is_displaying_hint ? ImGuiCol_TextDisabled : ImGuiCol_Text);
            draw_window->DrawList->AddText(g.Font, g.FontSize, draw_pos, col, buf_display, buf_display_end, 0.0f, is_multiline ? NULL : &clip_rect);
        }
    }
 
    if (is_password && !is_displaying_hint)
        PopFont();
 
    if (is_multiline)
    {
        Dummy(ImVec2(text_size.x, text_size.y + style.FramePadding.y));
        EndChild();
        EndGroup();
    }
 
    // Log as text
    if (g.LogEnabled && (!is_password || is_displaying_hint))
    {
        LogSetNextTextDecoration("{", "}");
        LogRenderedText(&draw_pos, buf_display, buf_display_end);
    }
 
    if (label_size.x > 0)
        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
    if (value_changed && !(flags & ImGuiInputTextFlags_NoMarkEdited))
        MarkItemEdited(id);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    if ((flags & ImGuiInputTextFlags_EnterReturnsTrue) != 0)
        return enter_pressed;
    else
        return value_changed;
}

Referenced by InputText(), InputTextMultiline(), InputTextWithHint(), Slic3r::GUI::ImGuiWrapper::search_list(), and TempInputText().

Here is the caller graph for this function:

◆ InputTextMultiline() [1/2]

bool ImGui::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`
	)

{
    return InputTextEx(label, NULL, buf, (int)buf_size, size, flags | ImGuiInputTextFlags_Multiline, callback, user_data);
}

References ImGuiInputTextFlags_Multiline, and InputTextEx().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input(), InputTextMultiline(), ShowDemoWindowWidgets(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputTextMultiline() [2/2]

bool ImGui::InputTextMultiline	(	const char *	label,
		std::string *	str,
		const ImVec2 &	size = `ImVec2(0, 0)`,
		ImGuiInputTextFlags	flags = `0`,
		ImGuiInputTextCallback	callback = `NULL`,
		void *	user_data = `NULL`
	)

{
    IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
    flags |= ImGuiInputTextFlags_CallbackResize;
 
    InputTextCallback_UserData cb_user_data;
    cb_user_data.Str = str;
    cb_user_data.ChainCallback = callback;
    cb_user_data.ChainCallbackUserData = user_data;
    return InputTextMultiline(label, (char*)str->c_str(), str->capacity() + 1, size, flags, InputTextCallback, &cb_user_data);
}

References InputTextCallback_UserData::ChainCallback, InputTextCallback_UserData::ChainCallbackUserData, IM_ASSERT, ImGuiInputTextFlags_CallbackResize, InputTextCallback(), InputTextMultiline(), and InputTextCallback_UserData::Str.

Here is the call graph for this function:

◆ InputTextWithHint() [1/2]

bool ImGui::InputTextWithHint	(	const char *	label,
		const char *	hint,
		char *	buf,
		size_t	buf_size,
		ImGuiInputTextFlags	flags = `0`,
		ImGuiInputTextCallback	callback = `NULL`,
		void *	user_data = `NULL`
	)

{
    IM_ASSERT(!(flags & ImGuiInputTextFlags_Multiline)); // call InputTextMultiline()
    return InputTextEx(label, hint, buf, (int)buf_size, ImVec2(0, 0), flags, callback, user_data);
}

References IM_ASSERT, ImGuiInputTextFlags_Multiline, and InputTextEx().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_list(), InputTextWithHint(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputTextWithHint() [2/2]

bool ImGui::InputTextWithHint	(	const char *	label,
		const char *	hint,
		std::string *	str,
		ImGuiInputTextFlags	flags = `0`,
		ImGuiInputTextCallback	callback = `NULL`,
		void *	user_data = `NULL`
	)

{
    IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
    flags |= ImGuiInputTextFlags_CallbackResize;
 
    InputTextCallback_UserData cb_user_data;
    cb_user_data.Str = str;
    cb_user_data.ChainCallback = callback;
    cb_user_data.ChainCallbackUserData = user_data;
    return InputTextWithHint(label, hint, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data);
}

References InputTextCallback_UserData::ChainCallback, InputTextCallback_UserData::ChainCallbackUserData, IM_ASSERT, ImGuiInputTextFlags_CallbackResize, InputTextCallback(), InputTextWithHint(), and InputTextCallback_UserData::Str.

Here is the call graph for this function:

◆ InvisibleButton()

bool ImGui::InvisibleButton	(	const char *	str_id,
		const ImVec2 &	size,
		ImGuiButtonFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    // Cannot use zero-size for InvisibleButton(). Unlike Button() there is not way to fallback using the label size.
    IM_ASSERT(size_arg.x != 0.0f && size_arg.y != 0.0f);
 
    const ImGuiID id = window->GetID(str_id);
    ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(size);
    if (!ItemAdd(bb, id))
        return false;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
 
    return pressed;
}

References ButtonBehavior(), CalcItemSize(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), ImGuiWindow::GetID(), IM_ASSERT, ItemAdd(), ItemSize(), ImGuiWindow::SkipItems, ImVec2::x, and ImVec2::y.

Referenced by ColorPicker4(), ShowDemoWindowLayout(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsActiveIdUsingKey()

bool ImGui::IsActiveIdUsingKey ( ImGuiKey key )

inline

2426{ ImGuiContext& g = *GImGui; IM_ASSERT(key < 64); return (g.ActiveIdUsingKeyInputMask & ((ImU64)1 << key)) != 0; }

References ImGuiContext::ActiveIdUsingKeyInputMask, GImGui, and IM_ASSERT.

Referenced by ItemFocusable(), and NavUpdatePageUpPageDown().

Here is the caller graph for this function:

◆ IsActiveIdUsingNavDir()

bool ImGui::IsActiveIdUsingNavDir ( ImGuiDir dir )

inline

2424{ ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavDirMask & (1 << dir)) != 0; }

References ImGuiContext::ActiveIdUsingNavDirMask, and GImGui.

Referenced by NavUpdate().

Here is the caller graph for this function:

◆ IsActiveIdUsingNavInput()

bool ImGui::IsActiveIdUsingNavInput ( ImGuiNavInput input )

inline

2425{ ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavInputMask & (1 << input)) != 0; }

input

static int input(void)

References ImGuiContext::ActiveIdUsingNavInputMask, GImGui, and input().

Referenced by NavUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAnyItemActive()

bool ImGui::IsAnyItemActive ( )

{
    ImGuiContext& g = *GImGui;
    return g.ActiveId != 0;
}

References ImGuiContext::ActiveId, and GImGui.

Referenced by Slic3r::GUI::ImGuiWrapper::search_list().

Here is the caller graph for this function:

◆ IsAnyItemFocused()

bool ImGui::IsAnyItemFocused ( )

{
    ImGuiContext& g = *GImGui;
    return g.NavId != 0 && !g.NavDisableHighlight;
}

References GImGui, ImGuiContext::NavDisableHighlight, and ImGuiContext::NavId.

Referenced by Slic3r::GUI::ImGuiWrapper::search_list().

Here is the caller graph for this function:

◆ IsAnyItemHovered()

bool ImGui::IsAnyItemHovered ( )

{
    ImGuiContext& g = *GImGui;
    return g.HoveredId != 0 || g.HoveredIdPreviousFrame != 0;
}

References GImGui, ImGuiContext::HoveredId, and ImGuiContext::HoveredIdPreviousFrame.

Referenced by BeginPopupContextWindow(), EndTable(), and ShowDemoWindowTables().

Here is the caller graph for this function:

◆ IsAnyMouseDown()

bool ImGui::IsAnyMouseDown ( )

{
    ImGuiContext& g = *GImGui;
    for (int n = 0; n < IM_ARRAYSIZE(g.IO.MouseDown); n++)
        if (g.IO.MouseDown[n])
            return true;
    return false;
}

References GImGui, IM_ARRAYSIZE, ImGuiContext::IO, and ImGuiIO::MouseDown.

◆ IsClippedEx()

bool ImGui::IsClippedEx	(	const ImRect &	bb,
		ImGuiID	id,
		bool	clip_even_when_logged
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (!bb.Overlaps(window->ClipRect))
        if (id == 0 || (id != g.ActiveId && id != g.NavId))
            if (clip_even_when_logged || !g.LogEnabled)
                return true;
    return false;
}

References ImGuiContext::ActiveId, ImGuiWindow::ClipRect, ImGuiContext::CurrentWindow, GImGui, ImGuiContext::LogEnabled, ImGuiContext::NavId, and ImRect::Overlaps().

Referenced by BeginTableEx(), EndColumns(), ItemAdd(), and TextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDragDropPayloadBeingAccepted()

bool ImGui::IsDragDropPayloadBeingAccepted ( )

{
    ImGuiContext& g = *GImGui;
    return g.DragDropActive && g.DragDropAcceptIdPrev != 0;
}

References ImGuiContext::DragDropAcceptIdPrev, ImGuiContext::DragDropActive, and GImGui.

◆ IsItemActivated()

bool ImGui::IsItemActivated ( )

{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = g.CurrentWindow;
        if (g.ActiveId == window->DC.LastItemId && g.ActiveIdPreviousFrame != window->DC.LastItemId)
            return true;
    }
    return false;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdPreviousFrame, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, and ImGuiWindowTempData::LastItemId.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_list(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ IsItemActive()

bool ImGui::IsItemActive ( )

{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = g.CurrentWindow;
        return g.ActiveId == window->DC.LastItemId;
    }
    return false;
}

References ImGuiContext::ActiveId, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, and ImGuiWindowTempData::LastItemId.

Referenced by CollapseButton(), ColorPicker4(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), and ShowStyleEditor().

Here is the caller graph for this function:

◆ IsItemClicked()

bool ImGui::IsItemClicked ( ImGuiMouseButton mouse_button = 0 )

{
    return IsMouseClicked(mouse_button) && IsItemHovered(ImGuiHoveredFlags_None);
}

References ImGuiHoveredFlags_None, IsItemHovered(), and IsMouseClicked().

Referenced by Slic3r::GUI::clickable(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowDemoWindowWidgets(), Slic3r::GUI::ImGuiWrapper::slider_float(), and Slic3r::GUI::ImGuiWrapper::undo_redo_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsItemDeactivated()

bool ImGui::IsItemDeactivated ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HasDeactivated)
        return (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_Deactivated) != 0;
    return (g.ActiveIdPreviousFrame == window->DC.LastItemId && g.ActiveIdPreviousFrame != 0 && g.ActiveId != window->DC.LastItemId);
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdPreviousFrame, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiItemStatusFlags_Deactivated, ImGuiItemStatusFlags_HasDeactivated, ImGuiWindowTempData::LastItemId, and ImGuiWindowTempData::LastItemStatusFlags.

Referenced by IsItemDeactivatedAfterEdit(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ IsItemDeactivatedAfterEdit()

bool ImGui::IsItemDeactivatedAfterEdit ( )

{
    ImGuiContext& g = *GImGui;
    return IsItemDeactivated() && (g.ActiveIdPreviousFrameHasBeenEditedBefore || (g.ActiveId == 0 && g.ActiveIdHasBeenEditedBefore));
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdHasBeenEditedBefore, ImGuiContext::ActiveIdPreviousFrameHasBeenEditedBefore, GImGui, and IsItemDeactivated().

Referenced by ShowDemoWindowWidgets(), and Slic3r::GUI::ImGuiWrapper::slider_float().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsItemEdited()

bool ImGui::IsItemEdited ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_Edited) != 0;
}

References ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiItemStatusFlags_Edited, and ImGuiWindowTempData::LastItemStatusFlags.

Referenced by Slic3r::GUI::ImGuiWrapper::search_list(), ShowDemoWindowWidgets(), and Slic3r::GUI::ImGuiWrapper::slider_float().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsItemFocused()

bool ImGui::IsItemFocused ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    if (g.NavId != window->DC.LastItemId || g.NavId == 0)
        return false;
    return true;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiWindowTempData::LastItemId, and ImGuiContext::NavId.

Referenced by IsItemHovered(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ IsItemHovered()

bool ImGui::IsItemHovered ( ImGuiHoveredFlags flags = 0 )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (g.NavDisableMouseHover && !g.NavDisableHighlight)
        return IsItemFocused();
 
    // Test for bounding box overlap, as updated as ItemAdd()
    ImGuiItemStatusFlags status_flags = window->DC.LastItemStatusFlags;
    if (!(status_flags & ImGuiItemStatusFlags_HoveredRect))
        return false;
    IM_ASSERT((flags & (ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows)) == 0);   // Flags not supported by this function
 
    // Test if we are hovering the right window (our window could be behind another window)
    // [2021/03/02] Reworked / reverted the revert, finally. Note we want e.g. BeginGroup/ItemAdd/EndGroup to work as well. (#3851)
    // [2017/10/16] Reverted commit 344d48be3 and testing RootWindow instead. I believe it is correct to NOT test for RootWindow but this leaves us unable
    // to use IsItemHovered() after EndChild() itself. Until a solution is found I believe reverting to the test from 2017/09/27 is safe since this was
    // the test that has been running for a long while.
    if (g.HoveredWindow != window && (status_flags & ImGuiItemStatusFlags_HoveredWindow) == 0)
        if ((flags & ImGuiHoveredFlags_AllowWhenOverlapped) == 0)
            return false;
 
    // Test if another item is active (e.g. being dragged)
    if ((flags & ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) == 0)
        if (g.ActiveId != 0 && g.ActiveId != window->DC.LastItemId && !g.ActiveIdAllowOverlap && g.ActiveId != window->MoveId)
            return false;
 
    // Test if interactions on this window are blocked by an active popup or modal.
    // The ImGuiHoveredFlags_AllowWhenBlockedByPopup flag will be tested here.
    if (!IsWindowContentHoverable(window, flags))
        return false;
 
    // Test if the item is disabled
    if ((g.CurrentItemFlags & ImGuiItemFlags_Disabled) && !(flags & ImGuiHoveredFlags_AllowWhenDisabled))
        return false;
 
    // Special handling for calling after Begin() which represent the title bar or tab.
    // When the window is collapsed (SkipItems==true) that last item will never be overwritten so we need to detect the case.
    if (window->DC.LastItemId == window->MoveId && window->WriteAccessed)
        return false;
    return true;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdAllowOverlap, ImGuiContext::CurrentItemFlags, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiContext::HoveredWindow, IM_ASSERT, ImGuiHoveredFlags_AllowWhenBlockedByActiveItem, ImGuiHoveredFlags_AllowWhenDisabled, ImGuiHoveredFlags_AllowWhenOverlapped, ImGuiHoveredFlags_ChildWindows, ImGuiHoveredFlags_RootWindow, ImGuiItemFlags_Disabled, ImGuiItemStatusFlags_HoveredRect, ImGuiItemStatusFlags_HoveredWindow, IsItemFocused(), IsWindowContentHoverable(), ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemStatusFlags, ImGuiWindow::MoveId, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, and ImGuiWindow::WriteAccessed.

Here is the call graph for this function:

◆ IsItemToggledOpen()

bool ImGui::IsItemToggledOpen ( )

{
    ImGuiContext& g = *GImGui;
    return (g.CurrentWindow->DC.LastItemStatusFlags & ImGuiItemStatusFlags_ToggledOpen) ? true : false;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiItemStatusFlags_ToggledOpen, and ImGuiWindowTempData::LastItemStatusFlags.

Referenced by ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ IsItemToggledSelection()

bool ImGui::IsItemToggledSelection ( )

{
    ImGuiContext& g = *GImGui;
    return (g.CurrentWindow->DC.LastItemStatusFlags & ImGuiItemStatusFlags_ToggledSelection) ? true : false;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiItemStatusFlags_ToggledSelection, and ImGuiWindowTempData::LastItemStatusFlags.

◆ IsItemVisible()

bool ImGui::IsItemVisible ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->ClipRect.Overlaps(window->DC.LastItemRect);
}

References ImGuiWindow::ClipRect, ImGuiWindow::DC, GetCurrentWindowRead(), ImGuiWindowTempData::LastItemRect, and ImRect::Overlaps().

Referenced by DebugNodeTable(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), SetItemDefaultFocus(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsKeyDown()

bool ImGui::IsKeyDown ( int user_key_index )

{
    if (user_key_index < 0)
        return false;
    ImGuiContext& g = *GImGui;
    IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    return g.IO.KeysDown[user_key_index];
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, and ImGuiIO::KeysDown.

Referenced by NavUpdatePageUpPageDown(), Slic3r::GUI::process_key_down(), and ShowDemoWindowMisc().

Here is the caller graph for this function:

◆ IsKeyPressed()

bool ImGui::IsKeyPressed	(	int	user_key_index,
		bool	repeat = `true`
	)

{
    ImGuiContext& g = *GImGui;
    if (user_key_index < 0)
        return false;
    IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[user_key_index];
    if (t == 0.0f)
        return true;
    if (repeat && t > g.IO.KeyRepeatDelay)
        return GetKeyPressedAmount(user_key_index, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate) > 0;
    return false;
}

References GetKeyPressedAmount(), GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::KeyRepeatDelay, ImGuiIO::KeyRepeatRate, ImGuiIO::KeysDown, and ImGuiIO::KeysDownDuration.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_list(), IsKeyPressedMap(), NavUpdatePageUpPageDown(), ShowDemoWindow(), and ShowDemoWindowMisc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsKeyPressedMap()

bool ImGui::IsKeyPressedMap	(	ImGuiKey	key,
		bool	repeat = `true`
	)

inline

2428{ ImGuiContext& g = *GImGui; const int key_index = g.IO.KeyMap[key]; return (key_index >= 0) ? IsKeyPressed(key_index, repeat) : false; }

ImGui::IsKeyPressed

IMGUI_API bool IsKeyPressed(int user_key_index, bool repeat=true)

Definition imgui.cpp:4671

References GImGui, ImGuiContext::IO, IsKeyPressed(), and ImGuiIO::KeyMap.

Referenced by InputTextEx(), NavScoreItem(), NavUpdateWindowing(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), UpdateDebugToolItemPicker(), and UpdateTabFocus().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsKeyReleased()

bool ImGui::IsKeyReleased ( int user_key_index )

{
    ImGuiContext& g = *GImGui;
    if (user_key_index < 0) return false;
    IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    return g.IO.KeysDownDurationPrev[user_key_index] >= 0.0f && !g.IO.KeysDown[user_key_index];
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::KeysDown, and ImGuiIO::KeysDownDurationPrev.

Referenced by ShowDemoWindowMisc().

Here is the caller graph for this function:

◆ IsMouseClicked()

bool ImGui::IsMouseClicked	(	ImGuiMouseButton	button,
		bool	repeat = `false`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    const float t = g.IO.MouseDownDuration[button];
    if (t == 0.0f)
        return true;
 
    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        // FIXME: 2019/05/03: Our old repeat code was wrong here and led to doubling the repeat rate, which made it an ok rate for repeat on mouse hold.
        int amount = CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate * 0.50f);
        if (amount > 0)
            return true;
    }
    return false;
}

References CalcTypematicRepeatAmount(), ImGuiIO::DeltaTime, GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::KeyRepeatDelay, ImGuiIO::KeyRepeatRate, ImGuiIO::MouseDown, and ImGuiIO::MouseDownDuration.

Referenced by ButtonBehavior(), IsItemClicked(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowDemoWindowMisc(), ShowExampleAppCustomRendering(), TabItemEx(), TabItemLabelAndCloseButton(), and UpdateDebugToolItemPicker().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsMouseDoubleClicked()

bool ImGui::IsMouseDoubleClicked ( ImGuiMouseButton button )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    return g.IO.MouseDoubleClicked[button];
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::MouseDoubleClicked, and ImGuiIO::MouseDown.

Referenced by ShowDemoWindowMisc(), ShowDemoWindowWidgets(), and TableUpdateBorders().

Here is the caller graph for this function:

◆ IsMouseDown()

bool ImGui::IsMouseDown ( ImGuiMouseButton button )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    return g.IO.MouseDown[button];
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, and ImGuiIO::MouseDown.

Referenced by AcceptDragDropPayload(), EndFrame(), ShowDemoWindowMisc(), and ShowExampleAppCustomRendering().

Here is the caller graph for this function:

◆ IsMouseDragging()

bool ImGui::IsMouseDragging	(	ImGuiMouseButton	button,
		float	lock_threshold = `-1.0f`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (!g.IO.MouseDown[button])
        return false;
    return IsMouseDragPastThreshold(button, lock_threshold);
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, IsMouseDragPastThreshold(), and ImGuiIO::MouseDown.

Referenced by BeginDragDropSource(), CollapseButton(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowExampleAppCustomRendering(), TabItemEx(), and TableHeader().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsMouseDragPastThreshold()

bool ImGui::IsMouseDragPastThreshold	(	ImGuiMouseButton	button,
		float	lock_threshold = `-1.0f`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    return g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold;
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::MouseDown, ImGuiIO::MouseDragMaxDistanceSqr, and ImGuiIO::MouseDragThreshold.

Referenced by DragScalar(), and IsMouseDragging().

Here is the caller graph for this function:

◆ IsMouseHoveringRect()

bool ImGui::IsMouseHoveringRect	(	const ImVec2 &	r_min,
		const ImVec2 &	r_max,
		bool	clip = `true`
	)

{
    ImGuiContext& g = *GImGui;
 
    // Clip
    ImRect rect_clipped(r_min, r_max);
    if (clip)
        rect_clipped.ClipWith(g.CurrentWindow->ClipRect);
 
    // Expand for touch input
    const ImRect rect_for_touch(rect_clipped.Min - g.Style.TouchExtraPadding, rect_clipped.Max + g.Style.TouchExtraPadding);
    if (!rect_for_touch.Contains(g.IO.MousePos))
        return false;
    return true;
}

References ImGuiWindow::ClipRect, ImRect::ClipWith(), ImRect::Contains(), ImGuiContext::CurrentWindow, GImGui, ImGuiContext::IO, ImRect::Max, ImRect::Min, ImGuiIO::MousePos, ImGuiContext::Style, and ImGuiStyle::TouchExtraPadding.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsMousePosValid()

bool ImGui::IsMousePosValid ( const ImVec2 * mouse_pos = NULL )

{
    // The assert is only to silence a false-positive in XCode Static Analysis.
    // Because GImGui is not dereferenced in every code path, the static analyzer assume that it may be NULL (which it doesn't for other functions).
    IM_ASSERT(GImGui != NULL);
    const float MOUSE_INVALID = -256000.0f;
    ImVec2 p = mouse_pos ? *mouse_pos : GImGui->IO.MousePos;
    return p.x >= MOUSE_INVALID && p.y >= MOUSE_INVALID;
}

References GImGui, IM_ASSERT, ImGuiContext::IO, ImGuiIO::MousePos, ImVec2::x, and ImVec2::y.

Referenced by GetMouseDragDelta(), NavCalcPreferredRefPos(), NavUpdateWindowing(), OpenPopupEx(), ShowDemoWindowMisc(), ShowExampleAppSimpleOverlay(), UpdateMouseInputs(), UpdateMouseMovingWindowNewFrame(), and UpdateMouseWheel().

Here is the caller graph for this function:

◆ IsMouseReleased()

bool ImGui::IsMouseReleased ( ImGuiMouseButton button )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    return g.IO.MouseReleased[button];
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::MouseDown, and ImGuiIO::MouseReleased.

Referenced by BeginPopupContextItem(), BeginPopupContextVoid(), BeginPopupContextWindow(), EndTable(), OpenPopupOnItemClick(), ShowDemoWindowMisc(), ShowDemoWindowTables(), ShowExampleAppCustomRendering(), TabItemEx(), TableHeader(), and TableHeadersRow().

Here is the caller graph for this function:

◆ IsNavInputDown()

bool ImGui::IsNavInputDown ( ImGuiNavInput n )

inline

2429{ ImGuiContext& g = *GImGui; return g.IO.NavInputs[n] > 0.0f; }

References GImGui, ImGuiContext::IO, and ImGuiIO::NavInputs.

Referenced by GetNavInputAmount2d(), NavUpdate(), and NavUpdateWindowing().

Here is the caller graph for this function:

◆ IsNavInputTest()

bool ImGui::IsNavInputTest	(	ImGuiNavInput	n,
		ImGuiInputReadMode	rm
	)

inline

2430{ return (GetNavInputAmount(n, rm) > 0.0f); }

References GetNavInputAmount().

Referenced by ButtonBehavior(), NavUpdate(), and NavUpdateWindowing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsPopupOpen() [1/2]

bool ImGui::IsPopupOpen	(	const char *	str_id,
		ImGuiPopupFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiID id = (popup_flags & ImGuiPopupFlags_AnyPopupId) ? 0 : g.CurrentWindow->GetID(str_id);
    if ((popup_flags & ImGuiPopupFlags_AnyPopupLevel) && id != 0)
        IM_ASSERT(0 && "Cannot use IsPopupOpen() with a string id and ImGuiPopupFlags_AnyPopupLevel."); // But non-string version is legal and used internally
    return IsPopupOpen(id, popup_flags);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), GImGui, IM_ASSERT, ImGuiPopupFlags_AnyPopupId, ImGuiPopupFlags_AnyPopupLevel, and IsPopupOpen().

Referenced by BeginCombo(), BeginMenu(), BeginPopupEx(), BeginPopupModal(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), IsPopupOpen(), OpenPopupEx(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), ShowExampleAppDocuments(), and UpdateMouseMovingWindowEndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsPopupOpen() [2/2]

bool ImGui::IsPopupOpen	(	ImGuiID	id,
		ImGuiPopupFlags	popup_flags
	)

{
    ImGuiContext& g = *GImGui;
    if (popup_flags & ImGuiPopupFlags_AnyPopupId)
    {
        // Return true if any popup is open at the current BeginPopup() level of the popup stack
        // This may be used to e.g. test for another popups already opened to handle popups priorities at the same level.
        IM_ASSERT(id == 0);
        if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
            return g.OpenPopupStack.Size > 0;
        else
            return g.OpenPopupStack.Size > g.BeginPopupStack.Size;
    }
    else
    {
        if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
        {
            // Return true if the popup is open anywhere in the popup stack
            for (int n = 0; n < g.OpenPopupStack.Size; n++)
                if (g.OpenPopupStack[n].PopupId == id)
                    return true;
            return false;
        }
        else
        {
            // Return true if the popup is open at the current BeginPopup() level of the popup stack (this is the most-common query)
            return g.OpenPopupStack.Size > g.BeginPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].PopupId == id;
        }
    }
}

References ImGuiContext::BeginPopupStack, GImGui, IM_ASSERT, ImGuiPopupFlags_AnyPopupId, ImGuiPopupFlags_AnyPopupLevel, ImGuiContext::OpenPopupStack, and ImVector< T >::Size.

◆ IsRectVisible() [1/2]

bool ImGui::IsRectVisible	(	const ImVec2 &	rect_min,
		const ImVec2 &	rect_max
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ClipRect.Overlaps(ImRect(rect_min, rect_max));
}

References ImGuiWindow::ClipRect, ImGuiContext::CurrentWindow, GImGui, and ImRect::Overlaps().

Here is the call graph for this function:

◆ IsRectVisible() [2/2]

bool ImGui::IsRectVisible ( const ImVec2 & size )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    return window->ClipRect.Overlaps(ImRect(window->DC.CursorPos, window->DC.CursorPos + size));
}

References ImGuiWindow::ClipRect, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GImGui, and ImRect::Overlaps().

Referenced by BeginListBox(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsWindowAbove()

bool ImGui::IsWindowAbove	(	ImGuiWindow *	potential_above,
		ImGuiWindow *	potential_below
	)

{
    ImGuiContext& g = *GImGui;
    for (int i = g.Windows.Size - 1; i >= 0; i--)
    {
        ImGuiWindow* candidate_window = g.Windows[i];
        if (candidate_window == potential_above)
            return true;
        if (candidate_window == potential_below)
            return false;
    }
    return false;
}

References GImGui, ImVector< T >::Size, and ImGuiContext::Windows.

Referenced by UpdateMouseMovingWindowEndFrame().

Here is the caller graph for this function:

◆ IsWindowAppearing()

bool ImGui::IsWindowAppearing ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->Appearing;
}

References ImGuiWindow::Appearing, and GetCurrentWindowRead().

Here is the call graph for this function:

◆ IsWindowChildOf()

bool ImGui::IsWindowChildOf	(	ImGuiWindow *	window,
		ImGuiWindow *	potential_parent
	)

{
    if (window->RootWindow == potential_parent)
        return true;
    while (window != NULL)
    {
        if (window == potential_parent)
            return true;
        window = window->ParentWindow;
    }
    return false;
}

References ImGuiWindow::ParentWindow, and ImGuiWindow::RootWindow.

Referenced by IsWindowFocused(), IsWindowHovered(), and UpdateHoveredWindowAndCaptureFlags().

Here is the caller graph for this function:

◆ IsWindowCollapsed()

bool ImGui::IsWindowCollapsed ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    return window->Collapsed;
}

References ImGuiWindow::Collapsed, and GetCurrentWindowRead().

Here is the call graph for this function:

◆ IsWindowFocused()

bool ImGui::IsWindowFocused ( ImGuiFocusedFlags flags = 0 )

{
    ImGuiContext& g = *GImGui;
 
    if (flags & ImGuiFocusedFlags_AnyWindow)
        return g.NavWindow != NULL;
 
    IM_ASSERT(g.CurrentWindow);     // Not inside a Begin()/End()
    switch (flags & (ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows))
    {
    case ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows:
        return g.NavWindow && g.NavWindow->RootWindow == g.CurrentWindow->RootWindow;
    case ImGuiFocusedFlags_RootWindow:
        return g.NavWindow == g.CurrentWindow->RootWindow;
    case ImGuiFocusedFlags_ChildWindows:
        return g.NavWindow && IsWindowChildOf(g.NavWindow, g.CurrentWindow);
    default:
        return g.NavWindow == g.CurrentWindow;
    }
}

References ImGuiContext::CurrentWindow, GImGui, IM_ASSERT, ImGuiFocusedFlags_AnyWindow, ImGuiFocusedFlags_ChildWindows, ImGuiFocusedFlags_RootWindow, IsWindowChildOf(), ImGuiContext::NavWindow, and ImGuiWindow::RootWindow.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_list(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsWindowHovered()

bool ImGui::IsWindowHovered ( ImGuiHoveredFlags flags = 0 )

{
    IM_ASSERT((flags & ImGuiHoveredFlags_AllowWhenOverlapped) == 0);   // Flags not supported by this function
    ImGuiContext& g = *GImGui;
    if (g.HoveredWindow == NULL)
        return false;
 
    if ((flags & ImGuiHoveredFlags_AnyWindow) == 0)
    {
        ImGuiWindow* window = g.CurrentWindow;
        switch (flags & (ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows))
        {
        case ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows:
            if (g.HoveredWindow->RootWindow != window->RootWindow)
                return false;
            break;
        case ImGuiHoveredFlags_RootWindow:
            if (g.HoveredWindow != window->RootWindow)
                return false;
            break;
        case ImGuiHoveredFlags_ChildWindows:
            if (!IsWindowChildOf(g.HoveredWindow, window))
                return false;
            break;
        default:
            if (g.HoveredWindow != window)
                return false;
            break;
        }
    }
 
    if (!IsWindowContentHoverable(g.HoveredWindow, flags))
        return false;
    if (!(flags & ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))
        if (g.ActiveId != 0 && !g.ActiveIdAllowOverlap && g.ActiveId != g.HoveredWindow->MoveId)
            return false;
    return true;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdAllowOverlap, ImGuiContext::CurrentWindow, GImGui, ImGuiContext::HoveredWindow, IM_ASSERT, ImGuiHoveredFlags_AllowWhenBlockedByActiveItem, ImGuiHoveredFlags_AllowWhenOverlapped, ImGuiHoveredFlags_AnyWindow, ImGuiHoveredFlags_ChildWindows, ImGuiHoveredFlags_RootWindow, IsWindowChildOf(), IsWindowContentHoverable(), ImGuiWindow::MoveId, and ImGuiWindow::RootWindow.

Referenced by BeginPopupContextVoid(), BeginPopupContextWindow(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsWindowNavFocusable()

bool ImGui::IsWindowNavFocusable ( ImGuiWindow * window )

{
    return window->WasActive && window == window->RootWindow && !(window->Flags & ImGuiWindowFlags_NoNavFocus);
}

References ImGuiWindow::Flags, ImGuiWindowFlags_NoNavFocus, ImGuiWindow::RootWindow, and ImGuiWindow::WasActive.

Referenced by FindWindowNavFocusable(), and NavUpdateWindowingOverlay().

Here is the caller graph for this function:

◆ ItemAdd()

bool ImGui::ItemAdd	(	const ImRect &	bb,
		ImGuiID	id,
		const ImRect *	nav_bb = `NULL`,
		ImGuiItemAddFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    if (id != 0)
    {
        // Navigation processing runs prior to clipping early-out
        //  (a) So that NavInitRequest can be honored, for newly opened windows to select a default widget
        //  (b) So that we can scroll up/down past clipped items. This adds a small O(N) cost to regular navigation requests
        //      unfortunately, but it is still limited to one window. It may not scale very well for windows with ten of
        //      thousands of item, but at least NavMoveRequest is only set on user interaction, aka maximum once a frame.
        //      We could early out with "if (is_clipped && !g.NavInitRequest) return false;" but when we wouldn't be able
        //      to reach unclipped widgets. This would work if user had explicit scrolling control (e.g. mapped on a stick).
        // We intentionally don't check if g.NavWindow != NULL because g.NavAnyRequest should only be set when it is non null.
        // If we crash on a NULL g.NavWindow we need to fix the bug elsewhere.
        window->DC.NavLayersActiveMaskNext |= (1 << window->DC.NavLayerCurrent);
        if (g.NavId == id || g.NavAnyRequest)
            if (g.NavWindow->RootWindowForNav == window->RootWindowForNav)
                if (window == g.NavWindow || ((window->Flags | g.NavWindow->Flags) & ImGuiWindowFlags_NavFlattened))
                    NavProcessItem(window, nav_bb_arg ? *nav_bb_arg : bb, id);
 
        // [DEBUG] Item Picker tool, when enabling the "extended" version we perform the check in ItemAdd()
#ifdef IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
        if (id == g.DebugItemPickerBreakId)
        {
            IM_DEBUG_BREAK();
            g.DebugItemPickerBreakId = 0;
        }
#endif
    }
 
    // Equivalent to calling SetLastItemData()
    window->DC.LastItemId = id;
    window->DC.LastItemRect = bb;
    window->DC.LastItemStatusFlags = ImGuiItemStatusFlags_None;
    g.NextItemData.Flags = ImGuiNextItemDataFlags_None;
 
#ifdef IMGUI_ENABLE_TEST_ENGINE
    if (id != 0)
        IMGUI_TEST_ENGINE_ITEM_ADD(nav_bb_arg ? *nav_bb_arg : bb, id);
#endif
 
    // Clipping test
    const bool is_clipped = IsClippedEx(bb, id, false);
    if (is_clipped)
        return false;
    //if (g.IO.KeyAlt) window->DrawList->AddRect(bb.Min, bb.Max, IM_COL32(255,255,0,120)); // [DEBUG]
 
    // Tab stop handling (previously was using internal ItemFocusable() api)
    // FIXME-NAV: We would now want to move this above the clipping test, but this would require being able to scroll and currently this would mean an extra frame. (#4079, #343)
    if (flags & ImGuiItemAddFlags_Focusable)
        ItemFocusable(window, id);
 
    // We need to calculate this now to take account of the current clipping rectangle (as items like Selectable may change them)
    if (IsMouseHoveringRect(bb.Min, bb.Max))
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_HoveredRect;
    return true;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiContext::DebugItemPickerBreakId, ImGuiNextItemData::Flags, ImGuiWindow::Flags, GImGui, IM_DEBUG_BREAK, IMGUI_TEST_ENGINE_ITEM_ADD, ImGuiItemAddFlags_Focusable, ImGuiItemStatusFlags_HoveredRect, ImGuiItemStatusFlags_None, ImGuiNextItemDataFlags_None, ImGuiWindowFlags_NavFlattened, IsClippedEx(), IsMouseHoveringRect(), ItemFocusable(), ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemRect, ImGuiWindowTempData::LastItemStatusFlags, ImRect::Max, ImRect::Min, ImGuiContext::NavAnyRequest, ImGuiContext::NavId, ImGuiWindowTempData::NavLayerCurrent, ImGuiWindowTempData::NavLayersActiveMaskNext, NavProcessItem(), ImGuiContext::NavWindow, ImGuiContext::NextItemData, and ImGuiWindow::RootWindowForNav.

Referenced by ArrowButtonEx(), BeginCombo(), BeginListBox(), Bullet(), BulletTextV(), ButtonEx(), Checkbox(), CloseButton(), CollapseButton(), ColorButton(), DragScalar(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), Dummy(), EndChild(), EndGroup(), EndTable(), Image(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), InputTextEx(), InvisibleButton(), LabelTextV(), PlotEx(), ProgressBar(), RadioButton(), Slic3r::GUI::ImGuiWrapper::search_list(), Slic3r::GUI::selectable(), Selectable(), SeparatorEx(), SliderScalar(), SplitterBehavior(), TabItemEx(), TableHeader(), TextEx(), TreeNodeBehavior(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ItemFocusable()

void ImGui::ItemFocusable	(	ImGuiWindow *	window,
		ImGuiID	id
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(id != 0 && id == window->DC.LastItemId);
 
    // Increment counters
    // FIXME: ImGuiItemFlags_Disabled should disable more.
    const bool is_tab_stop = (g.CurrentItemFlags & (ImGuiItemFlags_NoTabStop | ImGuiItemFlags_Disabled)) == 0;
    window->DC.FocusCounterRegular++;
    if (is_tab_stop)
    {
        window->DC.FocusCounterTabStop++;
        if (g.NavId == id)
            g.NavIdTabCounter = window->DC.FocusCounterTabStop;
    }
 
    // Process TAB/Shift-TAB to tab *OUT* of the currently focused item.
    // (Note that we can always TAB out of a widget that doesn't allow tabbing in)
    if (g.ActiveId == id && g.TabFocusPressed && !IsActiveIdUsingKey(ImGuiKey_Tab) && g.TabFocusRequestNextWindow == NULL)
    {
        g.TabFocusRequestNextWindow = window;
        g.TabFocusRequestNextCounterTabStop = window->DC.FocusCounterTabStop + (g.IO.KeyShift ? (is_tab_stop ? -1 : 0) : +1); // Modulo on index will be applied at the end of frame once we've got the total counter of items.
    }
 
    // Handle focus requests
    if (g.TabFocusRequestCurrWindow == window)
    {
        if (window->DC.FocusCounterRegular == g.TabFocusRequestCurrCounterRegular)
        {
            window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_FocusedByCode;
            return;
        }
        if (is_tab_stop && window->DC.FocusCounterTabStop == g.TabFocusRequestCurrCounterTabStop)
        {
            g.NavJustTabbedId = id;
            window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_FocusedByTabbing;
            return;
        }
 
        // If another item is about to be focused, we clear our own active id
        if (g.ActiveId == id)
            ClearActiveID();
    }
}

References ImGuiContext::ActiveId, ClearActiveID(), ImGuiContext::CurrentItemFlags, ImGuiWindow::DC, ImGuiWindowTempData::FocusCounterRegular, ImGuiWindowTempData::FocusCounterTabStop, GImGui, IM_ASSERT, ImGuiItemFlags_Disabled, ImGuiItemFlags_NoTabStop, ImGuiItemStatusFlags_FocusedByCode, ImGuiItemStatusFlags_FocusedByTabbing, ImGuiKey_Tab, ImGuiContext::IO, IsActiveIdUsingKey(), ImGuiIO::KeyShift, ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::NavId, ImGuiContext::NavIdTabCounter, ImGuiContext::NavJustTabbedId, ImGuiContext::TabFocusPressed, ImGuiContext::TabFocusRequestCurrCounterRegular, ImGuiContext::TabFocusRequestCurrCounterTabStop, ImGuiContext::TabFocusRequestCurrWindow, ImGuiContext::TabFocusRequestNextCounterTabStop, and ImGuiContext::TabFocusRequestNextWindow.

Referenced by ItemAdd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ItemHoverable()

bool ImGui::ItemHoverable	(	const ImRect &	bb,
		ImGuiID	id
	)

{
    ImGuiContext& g = *GImGui;
    if (g.HoveredId != 0 && g.HoveredId != id && !g.HoveredIdAllowOverlap)
        return false;
 
    ImGuiWindow* window = g.CurrentWindow;
    if (g.HoveredWindow != window)
        return false;
    if (g.ActiveId != 0 && g.ActiveId != id && !g.ActiveIdAllowOverlap)
        return false;
    if (!IsMouseHoveringRect(bb.Min, bb.Max))
        return false;
    if (g.NavDisableMouseHover)
        return false;
    if (!IsWindowContentHoverable(window, ImGuiHoveredFlags_None) || (g.CurrentItemFlags & ImGuiItemFlags_Disabled))
    {
        g.HoveredIdDisabled = true;
        return false;
    }
 
    // We exceptionally allow this function to be called with id==0 to allow using it for easy high-level
    // hover test in widgets code. We could also decide to split this function is two.
    if (id != 0)
    {
        SetHoveredID(id);
 
        // [DEBUG] Item Picker tool!
        // We perform the check here because SetHoveredID() is not frequently called (1~ time a frame), making
        // the cost of this tool near-zero. We can get slightly better call-stack and support picking non-hovered
        // items if we perform the test in ItemAdd(), but that would incur a small runtime cost.
        // #define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX in imconfig.h if you want this check to also be performed in ItemAdd().
        if (g.DebugItemPickerActive && g.HoveredIdPreviousFrame == id)
            GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(255, 255, 0, 255));
        if (g.DebugItemPickerBreakId == id)
            IM_DEBUG_BREAK();
    }
 
    return true;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdAllowOverlap, ImDrawList::AddRect(), ImGuiContext::CurrentItemFlags, ImGuiContext::CurrentWindow, ImGuiContext::DebugItemPickerActive, ImGuiContext::DebugItemPickerBreakId, GetForegroundDrawList(), GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdAllowOverlap, ImGuiContext::HoveredIdDisabled, ImGuiContext::HoveredIdPreviousFrame, ImGuiContext::HoveredWindow, IM_COL32, IM_DEBUG_BREAK, ImGuiHoveredFlags_None, ImGuiItemFlags_Disabled, IsMouseHoveringRect(), IsWindowContentHoverable(), ImRect::Max, ImRect::Min, ImGuiContext::NavDisableMouseHover, and SetHoveredID().

Referenced by BeginDragDropSource(), BeginMenu(), ButtonBehavior(), DragScalar(), InputTextEx(), PlotEx(), SliderScalar(), TableUpdateLayout(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ItemSize() [1/2]

void ImGui::ItemSize	(	const ImRect &	bb,
		float	text_baseline_y = `-1.0f`
	)

{
    ItemSize(bb.GetSize(), text_baseline_y);
}

References ImRect::GetSize(), and ItemSize().

Here is the call graph for this function:

◆ ItemSize() [2/2]

void ImGui::ItemSize	(	const ImVec2 &	size,
		float	text_baseline_y = `-1.0f`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;
 
    // We increase the height in this function to accommodate for baseline offset.
    // In theory we should be offsetting the starting position (window->DC.CursorPos), that will be the topic of a larger refactor,
    // but since ItemSize() is not yet an API that moves the cursor (to handle e.g. wrapping) enlarging the height has the same effect.
    const float offset_to_match_baseline_y = (text_baseline_y >= 0) ? ImMax(0.0f, window->DC.CurrLineTextBaseOffset - text_baseline_y) : 0.0f;
    const float line_height = ImMax(window->DC.CurrLineSize.y, size.y + offset_to_match_baseline_y);
 
    // Always align ourselves on pixel boundaries
    //if (g.IO.KeyAlt) window->DrawList->AddRect(window->DC.CursorPos, window->DC.CursorPos + ImVec2(size.x, line_height), IM_COL32(255,0,0,200)); // [DEBUG]
    window->DC.CursorPosPrevLine.x = window->DC.CursorPos.x + size.x;
    window->DC.CursorPosPrevLine.y = window->DC.CursorPos.y;
    window->DC.CursorPos.x = IM_FLOOR(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);    // Next line
    window->DC.CursorPos.y = IM_FLOOR(window->DC.CursorPos.y + line_height + g.Style.ItemSpacing.y);        // Next line
    window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, window->DC.CursorPosPrevLine.x);
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, window->DC.CursorPos.y - g.Style.ItemSpacing.y);
    //if (g.IO.KeyAlt) window->DrawList->AddCircle(window->DC.CursorMaxPos, 3.0f, IM_COL32(255,0,0,255), 4); // [DEBUG]
 
    window->DC.PrevLineSize.y = line_height;
    window->DC.CurrLineSize.y = 0.0f;
    window->DC.PrevLineTextBaseOffset = ImMax(window->DC.CurrLineTextBaseOffset, text_baseline_y);
    window->DC.CurrLineTextBaseOffset = 0.0f;
 
    // Horizontal layout mode
    if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)
        SameLine();
}

Referenced by ArrowButtonEx(), BeginCombo(), BeginListBox(), BeginTableEx(), Bullet(), BulletTextV(), ButtonEx(), Checkbox(), ColorButton(), DragScalar(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), Dummy(), EndChild(), EndGroup(), EndTable(), Image(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), InputTextEx(), InvisibleButton(), ItemSize(), LabelTextV(), NewLine(), PlotEx(), ProgressBar(), RadioButton(), Slic3r::GUI::ImGuiWrapper::search_list(), Slic3r::GUI::selectable(), Selectable(), SeparatorEx(), SliderScalar(), Spacing(), TabBarLayout(), TabItemEx(), TableHeader(), TextEx(), TreeNodeBehavior(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ KeepAliveID()

void ImGui::KeepAliveID ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId == id)
        g.ActiveIdIsAlive = id;
    if (g.ActiveIdPreviousFrame == id)
        g.ActiveIdPreviousFrameIsAlive = true;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdIsAlive, ImGuiContext::ActiveIdPreviousFrame, ImGuiContext::ActiveIdPreviousFrameIsAlive, and GImGui.

Referenced by EndColumns(), ImGuiWindow::GetID(), ImGuiWindow::GetID(), ImGuiWindow::GetID(), ImGuiWindow::GetIDFromRectangle(), GetIDWithSeed(), NewFrame(), Scrollbar(), TabBarCalcTabID(), TableUpdateBorders(), and UpdateMouseMovingWindowNewFrame().

Here is the caller graph for this function:

◆ LabelText()

void ImGui::LabelText	(	const char *	label,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    LabelTextV(label, fmt, args);
    va_end(args);
}

References LabelTextV().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LabelTextV()

void ImGui::LabelTextV	(	const char *	label,
		const char *	fmt,
		va_list	args
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const float w = CalcItemWidth();
 
    const char* value_text_begin = &g.TempBuffer[0];
    const char* value_text_end = value_text_begin + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    const ImVec2 value_size = CalcTextSize(value_text_begin, value_text_end, false);
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    const ImVec2 pos = window->DC.CursorPos;
    const ImRect value_bb(pos, pos + ImVec2(w, value_size.y + style.FramePadding.y * 2));
    const ImRect total_bb(pos, pos + ImVec2(w + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), ImMax(value_size.y, label_size.y) + style.FramePadding.y * 2));
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, 0))
        return;
 
    // Render
    RenderTextClipped(value_bb.Min + style.FramePadding, value_bb.Max, value_text_begin, value_text_end, &value_size, ImVec2(0.0f, 0.0f));
    if (label_size.x > 0.0f)
        RenderText(ImVec2(value_bb.Max.x + style.ItemInnerSpacing.x, value_bb.Min.y + style.FramePadding.y), label);
}

References CalcItemWidth(), CalcTextSize(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), GImGui, IM_ARRAYSIZE, ImFormatStringV(), ImMax(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, RenderText(), RenderTextClipped(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImGuiContext::TempBuffer, ImVec2::x, and ImVec2::y.

Referenced by LabelText().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ListBox() [1/3]

IMGUI_API bool ImGui::ListBox	(	const char *	label,
		int *	current_item,
		bool()(void data, int idx, const char **out_text)	items_getter,
		void *	data,
		int	items_count,
		int	height_in_items = `-1`
	)

◆ ListBox() [2/3]

bool ImGui::ListBox	(	const char *	label,
		int *	current_item,
		const char *const	items[],
		int	items_count,
		int	height_in_items = `-1`
	)

{
    const bool value_changed = ListBox(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_items);
    return value_changed;
}

References Items_ArrayGetter(), and ListBox().

Referenced by ListBox(), ListBox(), ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ListBox() [3/3]

bool ImGui::ListBox	(	const char *	label,
		int *	idx,
		std::vector< std::string > &	values
	)

inline

{
  if (values.empty()) { return false; }
  return ListBox(label, idx, vector_getter,
    static_cast<void*>(&values), values.size());
}

References ListBox(), and vector_getter.

Here is the call graph for this function:

◆ ListBoxFooter()

static void ImGui::ListBoxFooter ( )

inlinestatic

2787{ EndListBox(); }

ImGui::EndListBox

IMGUI_API void EndListBox()

Definition imgui_widgets.cpp:6233

References EndListBox(), and ListBoxFooter().

Referenced by ListBoxFooter(), Slic3r::GUI::ImGuiWrapper::search_list(), and Slic3r::GUI::ImGuiWrapper::undo_redo_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ListBoxHeader() [1/2]

static bool ImGui::ListBoxHeader	(	const char *	label,
		const ImVec2 &	size = `ImVec2(0, 0)`
	)

inlinestatic

2786{ return BeginListBox(label, size); }

ImGui::BeginListBox

IMGUI_API bool BeginListBox(const char *label, const ImVec2 &size=ImVec2(0, 0))

Definition imgui_widgets.cpp:6180

References BeginListBox(), and ListBoxHeader().

Here is the call graph for this function:

◆ ListBoxHeader() [2/2]

bool ImGui::ListBoxHeader	(	const char *	label,
		int	items_count,
		int	height_in_items = `-1`
	)

{
    // If height_in_items == -1, default height is maximum 7.
    ImGuiContext& g = *GImGui;
    float height_in_items_f = (height_in_items < 0 ? ImMin(items_count, 7) : height_in_items) + 0.25f;
    ImVec2 size;
    size.x = 0.0f;
    size.y = GetTextLineHeightWithSpacing() * height_in_items_f + g.Style.FramePadding.y * 2.0f;
    return BeginListBox(label, size);
}

References BeginListBox(), ImGuiStyle::FramePadding, GetTextLineHeightWithSpacing(), GImGui, ImMin(), ImGuiContext::Style, and ImVec2::y.

Referenced by ListBoxHeader(), and Slic3r::GUI::ImGuiWrapper::undo_redo_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadIniSettingsFromDisk()

void ImGui::LoadIniSettingsFromDisk ( const char * ini_filename )

{
    size_t file_data_size = 0;
    char* file_data = (char*)ImFileLoadToMemory(ini_filename, "rb", &file_data_size);
    if (!file_data)
        return;
    LoadIniSettingsFromMemory(file_data, (size_t)file_data_size);
    IM_FREE(file_data);
}

References IM_FREE, ImFileLoadToMemory(), and LoadIniSettingsFromMemory().

Referenced by UpdateSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadIniSettingsFromMemory()

void ImGui::LoadIniSettingsFromMemory	(	const char *	ini_data,
		size_t	ini_size = `0`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.Initialized);
    //IM_ASSERT(!g.WithinFrameScope && "Cannot be called between NewFrame() and EndFrame()");
    //IM_ASSERT(g.SettingsLoaded == false && g.FrameCount == 0);
 
    // For user convenience, we allow passing a non zero-terminated string (hence the ini_size parameter).
    // For our convenience and to make the code simpler, we'll also write zero-terminators within the buffer. So let's create a writable copy..
    if (ini_size == 0)
        ini_size = strlen(ini_data);
    g.SettingsIniData.Buf.resize((int)ini_size + 1);
    char* const buf = g.SettingsIniData.Buf.Data;
    char* const buf_end = buf + ini_size;
    memcpy(buf, ini_data, ini_size);
    buf_end[0] = 0;
 
    // Call pre-read handlers
    // Some types will clear their data (e.g. dock information) some types will allow merge/override (window)
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].ReadInitFn)
            g.SettingsHandlers[handler_n].ReadInitFn(&g, &g.SettingsHandlers[handler_n]);
 
    void* entry_data = NULL;
    ImGuiSettingsHandler* entry_handler = NULL;
 
    char* line_end = NULL;
    for (char* line = buf; line < buf_end; line = line_end + 1)
    {
        // Skip new lines markers, then find end of the line
        while (*line == '\n' || *line == '\r')
            line++;
        line_end = line;
        while (line_end < buf_end && *line_end != '\n' && *line_end != '\r')
            line_end++;
        line_end[0] = 0;
        if (line[0] == ';')
            continue;
        if (line[0] == '[' && line_end > line && line_end[-1] == ']')
        {
            // Parse "[Type][Name]". Note that 'Name' can itself contains [] characters, which is acceptable with the current format and parsing code.
            line_end[-1] = 0;
            const char* name_end = line_end - 1;
            const char* type_start = line + 1;
            char* type_end = (char*)(void*)ImStrchrRange(type_start, name_end, ']');
            const char* name_start = type_end ? ImStrchrRange(type_end + 1, name_end, '[') : NULL;
            if (!type_end || !name_start)
                continue;
            *type_end = 0; // Overwrite first ']'
            name_start++;  // Skip second '['
            entry_handler = FindSettingsHandler(type_start);
            entry_data = entry_handler ? entry_handler->ReadOpenFn(&g, entry_handler, name_start) : NULL;
        }
        else if (entry_handler != NULL && entry_data != NULL)
        {
            // Let type handler parse the line
            entry_handler->ReadLineFn(&g, entry_handler, entry_data, line);
        }
    }
    g.SettingsLoaded = true;
 
    // [DEBUG] Restore untouched copy so it can be browsed in Metrics (not strictly necessary)
    memcpy(buf, ini_data, ini_size);
 
    // Call post-read handlers
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].ApplyAllFn)
            g.SettingsHandlers[handler_n].ApplyAllFn(&g, &g.SettingsHandlers[handler_n]);
}

References ImGuiTextBuffer::Buf, ImVector< T >::Data, FindSettingsHandler(), GImGui, IM_ASSERT, ImStrchrRange(), ImGuiContext::Initialized, ImGuiSettingsHandler::ReadLineFn, ImGuiSettingsHandler::ReadOpenFn, ImVector< T >::resize(), ImGuiContext::SettingsHandlers, ImGuiContext::SettingsIniData, ImGuiContext::SettingsLoaded, and ImVector< T >::Size.

Referenced by LoadIniSettingsFromDisk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogBegin()

void ImGui::LogBegin	(	ImGuiLogType	type,
		int	auto_open_depth
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.LogEnabled == false);
    IM_ASSERT(g.LogFile == NULL);
    IM_ASSERT(g.LogBuffer.empty());
    g.LogEnabled = true;
    g.LogType = type;
    g.LogNextPrefix = g.LogNextSuffix = NULL;
    g.LogDepthRef = window->DC.TreeDepth;
    g.LogDepthToExpand = ((auto_open_depth >= 0) ? auto_open_depth : g.LogDepthToExpandDefault);
    g.LogLinePosY = FLT_MAX;
    g.LogLineFirstItem = true;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiTextBuffer::empty(), GImGui, IM_ASSERT, ImGuiContext::LogBuffer, ImGuiContext::LogDepthRef, ImGuiContext::LogDepthToExpand, ImGuiContext::LogDepthToExpandDefault, ImGuiContext::LogEnabled, ImGuiContext::LogFile, ImGuiContext::LogLineFirstItem, ImGuiContext::LogLinePosY, ImGuiContext::LogNextPrefix, ImGuiContext::LogNextSuffix, ImGuiContext::LogType, and ImGuiWindowTempData::TreeDepth.

Referenced by LogToBuffer(), LogToClipboard(), LogToFile(), and LogToTTY().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogButtons()

void ImGui::LogButtons ( )

{
    ImGuiContext& g = *GImGui;
 
    PushID("LogButtons");
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
    const bool log_to_tty = Button("Log To TTY"); SameLine();
#else
    const bool log_to_tty = false;
#endif
    const bool log_to_file = Button("Log To File"); SameLine();
    const bool log_to_clipboard = Button("Log To Clipboard"); SameLine();
    PushAllowKeyboardFocus(false);
    SetNextItemWidth(80.0f);
    SliderInt("Default Depth", &g.LogDepthToExpandDefault, 0, 9, NULL);
    PopAllowKeyboardFocus();
    PopID();
 
    // Start logging at the end of the function so that the buttons don't appear in the log
    if (log_to_tty)
        LogToTTY();
    if (log_to_file)
        LogToFile();
    if (log_to_clipboard)
        LogToClipboard();
}

References Button(), GImGui, ImGuiContext::LogDepthToExpandDefault, LogToClipboard(), LogToFile(), LogToTTY(), PopAllowKeyboardFocus(), PopID(), PushAllowKeyboardFocus(), PushID(), SameLine(), SetNextItemWidth(), and SliderInt().

Referenced by ShowDemoWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogFinish()

void ImGui::LogFinish ( )

{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;
 
    LogText(IM_NEWLINE);
    switch (g.LogType)
    {
    case ImGuiLogType_TTY:
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
        fflush(g.LogFile);
#endif
        break;
    case ImGuiLogType_File:
        ImFileClose(g.LogFile);
        break;
    case ImGuiLogType_Buffer:
        break;
    case ImGuiLogType_Clipboard:
        if (!g.LogBuffer.empty())
            SetClipboardText(g.LogBuffer.begin());
        break;
    case ImGuiLogType_None:
        IM_ASSERT(0);
        break;
    }
 
    g.LogEnabled = false;
    g.LogType = ImGuiLogType_None;
    g.LogFile = NULL;
    g.LogBuffer.clear();
}

References ImGuiTextBuffer::begin(), ImGuiTextBuffer::clear(), ImGuiTextBuffer::empty(), GImGui, IM_ASSERT, IM_NEWLINE, ImFileClose(), ImGuiLogType_Buffer, ImGuiLogType_Clipboard, ImGuiLogType_File, ImGuiLogType_None, ImGuiLogType_TTY, ImGuiContext::LogBuffer, ImGuiContext::LogEnabled, ImGuiContext::LogFile, LogText(), ImGuiContext::LogType, and SetClipboardText().

Referenced by ExampleAppConsole::Draw(), End(), ShowAboutWindow(), ShowDemoWindow(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogRenderedText()

void ImGui::LogRenderedText	(	const ImVec2 *	ref_pos,
		const char *	text,
		const char *	text_end = `NULL`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    const char* prefix = g.LogNextPrefix;
    const char* suffix = g.LogNextSuffix;
    g.LogNextPrefix = g.LogNextSuffix = NULL;
 
    if (!text_end)
        text_end = FindRenderedTextEnd(text, text_end);
 
    const bool log_new_line = ref_pos && (ref_pos->y > g.LogLinePosY + g.Style.FramePadding.y + 1);
    if (ref_pos)
        g.LogLinePosY = ref_pos->y;
    if (log_new_line)
    {
        LogText(IM_NEWLINE);
        g.LogLineFirstItem = true;
    }
 
    if (prefix)
        LogRenderedText(ref_pos, prefix, prefix + strlen(prefix)); // Calculate end ourself to ensure "##" are included here.
 
    // Re-adjust padding if we have popped out of our starting depth
    if (g.LogDepthRef > window->DC.TreeDepth)
        g.LogDepthRef = window->DC.TreeDepth;
    const int tree_depth = (window->DC.TreeDepth - g.LogDepthRef);
 
    const char* text_remaining = text;
    for (;;)
    {
        // Split the string. Each new line (after a '\n') is followed by indentation corresponding to the current depth of our log entry.
        // We don't add a trailing \n yet to allow a subsequent item on the same line to be captured.
        const char* line_start = text_remaining;
        const char* line_end = ImStreolRange(line_start, text_end);
        const bool is_last_line = (line_end == text_end);
        if (line_start != line_end || !is_last_line)
        {
            const int line_length = (int)(line_end - line_start);
            const int indentation = g.LogLineFirstItem ? tree_depth * 4 : 1;
            LogText("%*s%.*s", indentation, "", line_length, line_start);
            g.LogLineFirstItem = false;
            if (*line_end == '\n')
            {
                LogText(IM_NEWLINE);
                g.LogLineFirstItem = true;
            }
        }
        if (is_last_line)
            break;
        text_remaining = line_end + 1;
    }
 
    if (suffix)
        LogRenderedText(ref_pos, suffix, suffix + strlen(suffix));
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, FindRenderedTextEnd(), ImGuiStyle::FramePadding, GImGui, IM_NEWLINE, ImStreolRange(), ImGuiContext::LogDepthRef, ImGuiContext::LogLineFirstItem, ImGuiContext::LogLinePosY, ImGuiContext::LogNextPrefix, ImGuiContext::LogNextSuffix, LogRenderedText(), LogText(), ImGuiContext::Style, ImGuiWindowTempData::TreeDepth, and ImVec2::y.

Referenced by Checkbox(), InputTextEx(), LogRenderedText(), RadioButton(), RenderText(), RenderTextClipped(), RenderTextEllipsis(), RenderTextWrapped(), SeparatorEx(), TableBeginCell(), and TableEndRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogSetNextTextDecoration()

void ImGui::LogSetNextTextDecoration	(	const char *	prefix,
		const char *	suffix
	)

{
    ImGuiContext& g = *GImGui;
    g.LogNextPrefix = prefix;
    g.LogNextSuffix = suffix;
}

References GImGui, ImGuiContext::LogNextPrefix, and ImGuiContext::LogNextSuffix.

Referenced by BeginCombo(), ButtonEx(), DragScalar(), InputTextEx(), SliderScalar(), and TreeNodeBehavior().

Here is the caller graph for this function:

◆ LogText()

void ImGui::LogText	(	const char *	fmt,
			...
	)

{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;
 
    va_list args;
    va_start(args, fmt);
    LogTextV(g, fmt, args);
    va_end(args);
}

References GImGui, ImGuiContext::LogEnabled, and LogTextV().

Referenced by LogFinish(), LogRenderedText(), SeparatorEx(), ShowAboutWindow(), ShowDemoWindow(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogTextV()

void ImGui::LogTextV	(	const char *	fmt,
		va_list	args
	)

{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;
 
    LogTextV(g, fmt, args);
}

References GImGui, ImGuiContext::LogEnabled, and LogTextV().

Here is the call graph for this function:

◆ LogToBuffer()

void ImGui::LogToBuffer ( int auto_open_depth = -1 )

{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    LogBegin(ImGuiLogType_Buffer, auto_open_depth);
}

References GImGui, ImGuiLogType_Buffer, LogBegin(), and ImGuiContext::LogEnabled.

Here is the call graph for this function:

◆ LogToClipboard()

void ImGui::LogToClipboard ( int auto_open_depth = -1 )

{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    LogBegin(ImGuiLogType_Clipboard, auto_open_depth);
}

References GImGui, ImGuiLogType_Clipboard, LogBegin(), and ImGuiContext::LogEnabled.

Referenced by ExampleAppConsole::Draw(), ExampleAppLog::Draw(), LogButtons(), ShowAboutWindow(), ShowDemoWindow(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogToFile()

void ImGui::LogToFile	(	int	auto_open_depth = `-1`,
		const char *	filename = `NULL`
	)

{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
 
    // FIXME: We could probably open the file in text mode "at", however note that clipboard/buffer logging will still
    // be subject to outputting OS-incompatible carriage return if within strings the user doesn't use IM_NEWLINE.
    // By opening the file in binary mode "ab" we have consistent output everywhere.
    if (!filename)
        filename = g.IO.LogFilename;
    if (!filename || !filename[0])
        return;
    ImFileHandle f = ImFileOpen(filename, "ab");
    if (!f)
    {
        IM_ASSERT(0);
        return;
    }
 
    LogBegin(ImGuiLogType_File, auto_open_depth);
    g.LogFile = f;
}

References GImGui, IM_ASSERT, ImFileOpen(), ImGuiLogType_File, ImGuiContext::IO, LogBegin(), ImGuiContext::LogEnabled, ImGuiContext::LogFile, and ImGuiIO::LogFilename.

Referenced by LogButtons().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogToTTY()

void ImGui::LogToTTY ( int auto_open_depth = -1 )

{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    IM_UNUSED(auto_open_depth);
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
    LogBegin(ImGuiLogType_TTY, auto_open_depth);
    g.LogFile = stdout;
#endif
}

References GImGui, IM_UNUSED, ImGuiLogType_TTY, LogBegin(), ImGuiContext::LogEnabled, and ImGuiContext::LogFile.

Referenced by LogButtons(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MarkIniSettingsDirty() [1/2]

void ImGui::MarkIniSettingsDirty ( )

{
    ImGuiContext& g = *GImGui;
    if (g.SettingsDirtyTimer <= 0.0f)
        g.SettingsDirtyTimer = g.IO.IniSavingRate;
}

References GImGui, ImGuiIO::IniSavingRate, ImGuiContext::IO, and ImGuiContext::SettingsDirtyTimer.

Referenced by Begin(), NavUpdateWindowing(), TabBarProcessReorder(), TableSaveSettings(), UpdateMouseMovingWindowNewFrame(), and UpdateWindowManualResize().

Here is the caller graph for this function:

◆ MarkIniSettingsDirty() [2/2]

void ImGui::MarkIniSettingsDirty ( ImGuiWindow * window )

{
    ImGuiContext& g = *GImGui;
    if (!(window->Flags & ImGuiWindowFlags_NoSavedSettings))
        if (g.SettingsDirtyTimer <= 0.0f)
            g.SettingsDirtyTimer = g.IO.IniSavingRate;
}

References ImGuiWindow::Flags, GImGui, ImGuiWindowFlags_NoSavedSettings, ImGuiIO::IniSavingRate, ImGuiContext::IO, and ImGuiContext::SettingsDirtyTimer.

◆ MarkItemEdited()

void ImGui::MarkItemEdited ( ImGuiID id )

{
    // This marking is solely to be able to provide info for IsItemDeactivatedAfterEdit().
    // ActiveId might have been released by the time we call this (as in the typical press/release button behavior) but still need need to fill the data.
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.ActiveId == id || g.ActiveId == 0 || g.DragDropActive);
    IM_UNUSED(id); // Avoid unused variable warnings when asserts are compiled out.
    //IM_ASSERT(g.CurrentWindow->DC.LastItemId == id);
    g.ActiveIdHasBeenEditedThisFrame = true;
    g.ActiveIdHasBeenEditedBefore = true;
    g.CurrentWindow->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_Edited;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdHasBeenEditedBefore, ImGuiContext::ActiveIdHasBeenEditedThisFrame, ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiContext::DragDropActive, GImGui, IM_ASSERT, IM_UNUSED, ImGuiItemStatusFlags_Edited, and ImGuiWindowTempData::LastItemStatusFlags.

Referenced by Checkbox(), ColorEdit4(), ColorPicker4(), DragScalar(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), InputScalar(), InputTextEx(), RadioButton(), Slic3r::GUI::selectable(), Selectable(), SliderScalar(), SplitterBehavior(), TempInputScalar(), and VSliderScalar().

Here is the caller graph for this function:

◆ MemAlloc()

void * ImGui::MemAlloc ( size_t size )

{
    if (ImGuiContext* ctx = GImGui)
        ctx->IO.MetricsActiveAllocations++;
    return (*GImAllocatorAllocFunc)(size, GImAllocatorUserData);
}

References GImAllocatorAllocFunc, GImAllocatorUserData, and GImGui.

◆ MemFree()

void ImGui::MemFree ( void * ptr )

{
    if (ptr)
        if (ImGuiContext* ctx = GImGui)
            ctx->IO.MetricsActiveAllocations--;
    return (*GImAllocatorFreeFunc)(ptr, GImAllocatorUserData);
}

References GImAllocatorFreeFunc, GImAllocatorUserData, and GImGui.

Referenced by IM_DELETE(), and InputTextEx().

Here is the caller graph for this function:

◆ MenuItem() [1/2]

bool ImGui::MenuItem	(	const char *	label,
		const char *	shortcut,
		bool *	p_selected,
		bool	enabled = `true`
	)

{
    if (MenuItem(label, shortcut, p_selected ? *p_selected : false, enabled))
    {
        if (p_selected)
            *p_selected = !*p_selected;
        return true;
    }
    return false;
}

References MenuItem().

Here is the call graph for this function:

◆ MenuItem() [2/2]

bool ImGui::MenuItem	(	const char *	label,
		const char *	shortcut = `NULL`,
		bool	selected = `false`,
		bool	enabled = `true`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    ImGuiStyle& style = g.Style;
    ImVec2 pos = window->DC.CursorPos;
    ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    // We've been using the equivalent of ImGuiSelectableFlags_SetNavIdOnHover on all Selectable() since early Nav system days (commit 43ee5d73),
    // but I am unsure whether this should be kept at all. For now moved it to be an opt-in feature used by menus only.
    ImGuiSelectableFlags flags = ImGuiSelectableFlags_SelectOnRelease | ImGuiSelectableFlags_SetNavIdOnHover | (enabled ? 0 : ImGuiSelectableFlags_Disabled);
    bool pressed;
    if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)
    {
        // Mimic the exact layout spacing of BeginMenu() to allow MenuItem() inside a menu bar, which is a little misleading but may be useful
        // Note that in this situation: we don't render the shortcut, we render a highlight instead of the selected tick mark.
        float w = label_size.x;
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * 0.5f);
        PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x * 2.0f, style.ItemSpacing.y));
        pressed = Selectable(label, selected, flags, ImVec2(w, 0.0f));
        PopStyleVar();
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * (-1.0f + 0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().
    }
    else
    {
        // Menu item inside a vertical menu
        // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.
        //  Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.
        float shortcut_w = shortcut ? CalcTextSize(shortcut, NULL).x : 0.0f;
        float min_w = window->DC.MenuColumns.DeclColumns(label_size.x, shortcut_w, IM_FLOOR(g.FontSize * 1.20f)); // Feedback for next frame
        float extra_w = ImMax(0.0f, GetContentRegionAvail().x - min_w);
        pressed = Selectable(label, false, flags | ImGuiSelectableFlags_SpanAvailWidth, ImVec2(min_w, 0.0f));
        if (shortcut_w > 0.0f)
        {
            PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
            RenderText(pos + ImVec2(window->DC.MenuColumns.Pos[1] + extra_w, 0.0f), shortcut, NULL, false);
            PopStyleColor();
        }
        if (selected)
            RenderCheckMark(window->DrawList, pos + ImVec2(window->DC.MenuColumns.Pos[2] + extra_w + g.FontSize * 0.40f, g.FontSize * 0.134f * 0.5f), GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled), g.FontSize  * 0.866f);
    }
 
    IMGUI_TEST_ENGINE_ITEM_INFO(window->DC.LastItemId, label, window->DC.LastItemStatusFlags | ImGuiItemStatusFlags_Checkable | (selected ? ImGuiItemStatusFlags_Checked : 0));
    return pressed;
}

References CalcTextSize(), ImGuiStyle::Colors, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiMenuColumns::DeclColumns(), ImGuiWindow::DrawList, ImGuiContext::FontSize, GetColorU32(), GetContentRegionAvail(), GetCurrentWindow(), GImGui, IM_FLOOR, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiLayoutType_Horizontal, ImGuiSelectableFlags_Disabled, ImGuiSelectableFlags_SelectOnRelease, ImGuiSelectableFlags_SetNavIdOnHover, ImGuiSelectableFlags_SpanAvailWidth, ImGuiStyleVar_ItemSpacing, ImMax(), ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemStatusFlags, ImGuiWindowTempData::LayoutType, ImGuiWindowTempData::MenuColumns, PopStyleColor(), PopStyleVar(), ImGuiMenuColumns::Pos, PushStyleColor(), PushStyleVar(), RenderCheckMark(), RenderText(), Selectable(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, and ImVec2::x.

Referenced by MyDocument::DisplayContextMenu(), ExampleAppConsole::Draw(), MenuItem(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindow(), ShowDemoWindowPopups(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppLayout(), ShowExampleAppMainMenuBar(), ShowExampleAppSimpleOverlay(), ShowExampleMenuFile(), and TableDrawContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavApplyItemToResult()

static void ImGui::NavApplyItemToResult	(	ImGuiNavItemData *	result,
		ImGuiWindow *	window,
		ImGuiID	id,
		const ImRect &	nav_bb_rel
	)

static

{
    result->Window = window;
    result->ID = id;
    result->FocusScopeId = window->DC.NavFocusScopeIdCurrent;
    result->RectRel = nav_bb_rel;
}

References ImGuiWindow::DC, ImGuiNavItemData::FocusScopeId, ImGuiNavItemData::ID, ImGuiWindowTempData::NavFocusScopeIdCurrent, ImGuiNavItemData::RectRel, and ImGuiNavItemData::Window.

Referenced by NavProcessItem().

Here is the caller graph for this function:

◆ NavCalcPreferredRefPos()

static ImVec2 ImGui::NavCalcPreferredRefPos ( )

static

{
    ImGuiContext& g = *GImGui;
    if (g.NavDisableHighlight || !g.NavDisableMouseHover || !g.NavWindow)
    {
        // Mouse (we need a fallback in case the mouse becomes invalid after being used)
        if (IsMousePosValid(&g.IO.MousePos))
            return g.IO.MousePos;
        return g.LastValidMousePos;
    }
    else
    {
        // When navigation is active and mouse is disabled, decide on an arbitrary position around the bottom left of the currently navigated item.
        const ImRect& rect_rel = g.NavWindow->NavRectRel[g.NavLayer];
        ImVec2 pos = g.NavWindow->Pos + ImVec2(rect_rel.Min.x + ImMin(g.Style.FramePadding.x * 4, rect_rel.GetWidth()), rect_rel.Max.y - ImMin(g.Style.FramePadding.y, rect_rel.GetHeight()));
        ImGuiViewport* viewport = GetMainViewport();
        return ImFloor(ImClamp(pos, viewport->Pos, viewport->Pos + viewport->Size)); // ImFloor() is important because non-integer mouse position application in backend might be lossy and result in undesirable non-zero delta.
    }
}

References ImGuiStyle::FramePadding, ImRect::GetHeight(), GetMainViewport(), ImRect::GetWidth(), GImGui, ImClamp(), ImFloor(), ImMin(), ImGuiContext::IO, IsMousePosValid(), ImGuiContext::LastValidMousePos, ImRect::Max, ImRect::Min, ImGuiIO::MousePos, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavLayer, ImGuiWindow::NavRectRel, ImGuiContext::NavWindow, ImGuiViewport::Pos, ImGuiWindow::Pos, ImGuiViewport::Size, ImGuiContext::Style, ImVec2::x, and ImVec2::y.

Referenced by FindBestWindowPosForPopup(), NavUpdate(), and OpenPopupEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavEndFrame()

static void ImGui::NavEndFrame ( )

static

{
    ImGuiContext& g = *GImGui;
 
    // Show CTRL+TAB list window
    if (g.NavWindowingTarget != NULL)
        NavUpdateWindowingOverlay();
 
    // Perform wrap-around in menus
    ImGuiWindow* window = g.NavWrapRequestWindow;
    ImGuiNavMoveFlags move_flags = g.NavWrapRequestFlags;
    if (window != NULL && g.NavWindow == window && NavMoveRequestButNoResultYet() && g.NavMoveRequestForward == ImGuiNavForward_None && g.NavLayer == ImGuiNavLayer_Main)
    {
        IM_ASSERT(move_flags != 0); // No points calling this with no wrapping
        ImRect bb_rel = window->NavRectRel[0];
 
        ImGuiDir clip_dir = g.NavMoveDir;
        if (g.NavMoveDir == ImGuiDir_Left && (move_flags & (ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_LoopX)))
        {
            bb_rel.Min.x = bb_rel.Max.x =
                ImMax(window->SizeFull.x, window->ContentSize.x + window->WindowPadding.x * 2.0f) - window->Scroll.x;
            if (move_flags & ImGuiNavMoveFlags_WrapX)
            {
                bb_rel.TranslateY(-bb_rel.GetHeight());
                clip_dir = ImGuiDir_Up;
            }
            NavMoveRequestForward(g.NavMoveDir, clip_dir, bb_rel, move_flags);
        }
        if (g.NavMoveDir == ImGuiDir_Right && (move_flags & (ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_LoopX)))
        {
            bb_rel.Min.x = bb_rel.Max.x = -window->Scroll.x;
            if (move_flags & ImGuiNavMoveFlags_WrapX)
            {
                bb_rel.TranslateY(+bb_rel.GetHeight());
                clip_dir = ImGuiDir_Down;
            }
            NavMoveRequestForward(g.NavMoveDir, clip_dir, bb_rel, move_flags);
        }
        if (g.NavMoveDir == ImGuiDir_Up && (move_flags & (ImGuiNavMoveFlags_WrapY | ImGuiNavMoveFlags_LoopY)))
        {
            bb_rel.Min.y = bb_rel.Max.y =
                ImMax(window->SizeFull.y, window->ContentSize.y + window->WindowPadding.y * 2.0f) - window->Scroll.y;
            if (move_flags & ImGuiNavMoveFlags_WrapY)
            {
                bb_rel.TranslateX(-bb_rel.GetWidth());
                clip_dir = ImGuiDir_Left;
            }
            NavMoveRequestForward(g.NavMoveDir, clip_dir, bb_rel, move_flags);
        }
        if (g.NavMoveDir == ImGuiDir_Down && (move_flags & (ImGuiNavMoveFlags_WrapY | ImGuiNavMoveFlags_LoopY)))
        {
            bb_rel.Min.y = bb_rel.Max.y = -window->Scroll.y;
            if (move_flags & ImGuiNavMoveFlags_WrapY)
            {
                bb_rel.TranslateX(+bb_rel.GetWidth());
                clip_dir = ImGuiDir_Right;
            }
            NavMoveRequestForward(g.NavMoveDir, clip_dir, bb_rel, move_flags);
        }
    }
}

References ImGuiWindow::ContentSize, ImRect::GetHeight(), ImRect::GetWidth(), GImGui, IM_ASSERT, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_Right, ImGuiDir_Up, ImGuiNavForward_None, ImGuiNavLayer_Main, ImGuiNavMoveFlags_LoopX, ImGuiNavMoveFlags_LoopY, ImGuiNavMoveFlags_WrapX, ImGuiNavMoveFlags_WrapY, ImMax(), ImRect::Max, ImRect::Min, ImGuiContext::NavLayer, ImGuiContext::NavMoveDir, NavMoveRequestButNoResultYet(), ImGuiContext::NavMoveRequestForward, NavMoveRequestForward(), ImGuiWindow::NavRectRel, NavUpdateWindowingOverlay(), ImGuiContext::NavWindow, ImGuiContext::NavWindowingTarget, ImGuiContext::NavWrapRequestFlags, ImGuiContext::NavWrapRequestWindow, ImGuiWindow::Scroll, ImGuiWindow::SizeFull, ImRect::TranslateX(), ImRect::TranslateY(), ImGuiWindow::WindowPadding, ImVec2::x, and ImVec2::y.

Referenced by EndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavInitWindow()

void ImGui::NavInitWindow	(	ImGuiWindow *	window,
		bool	force_reinit
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(window == g.NavWindow);
 
    if (window->Flags & ImGuiWindowFlags_NoNavInputs)
    {
        g.NavId = g.NavFocusScopeId = 0;
        return;
    }
 
    bool init_for_nav = false;
    if (window == window->RootWindow || (window->Flags & ImGuiWindowFlags_Popup) || (window->NavLastIds[0] == 0) || force_reinit)
        init_for_nav = true;
    IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: from NavInitWindow(), init_for_nav=%d, window=\"%s\", layer=%d\n", init_for_nav, window->Name, g.NavLayer);
    if (init_for_nav)
    {
        SetNavID(0, g.NavLayer, 0, ImRect());
        g.NavInitRequest = true;
        g.NavInitRequestFromMove = false;
        g.NavInitResultId = 0;
        g.NavInitResultRectRel = ImRect();
        NavUpdateAnyRequestFlag();
    }
    else
    {
        g.NavId = window->NavLastIds[0];
        g.NavFocusScopeId = 0;
    }
}

References ImGuiWindow::Flags, GImGui, IM_ASSERT, IMGUI_DEBUG_LOG_NAV, ImGuiWindowFlags_NoNavInputs, ImGuiWindowFlags_Popup, ImGuiWindow::Name, ImGuiContext::NavFocusScopeId, ImGuiContext::NavId, ImGuiContext::NavInitRequest, ImGuiContext::NavInitRequestFromMove, ImGuiContext::NavInitResultId, ImGuiContext::NavInitResultRectRel, ImGuiWindow::NavLastIds, ImGuiContext::NavLayer, NavUpdateAnyRequestFlag(), ImGuiContext::NavWindow, ImGuiWindow::RootWindow, and SetNavID().

Referenced by Begin(), BeginChildEx(), NavRestoreLayer(), and NavUpdateWindowing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavMoveRequestButNoResultYet()

bool ImGui::NavMoveRequestButNoResultYet ( )

{
    ImGuiContext& g = *GImGui;
    return g.NavMoveRequest && g.NavMoveResultLocal.ID == 0 && g.NavMoveResultOther.ID == 0;
}

References GImGui, ImGuiNavItemData::ID, ImGuiContext::NavMoveRequest, ImGuiContext::NavMoveResultLocal, and ImGuiContext::NavMoveResultOther.

Referenced by EndMenu(), EndMenuBar(), NavEndFrame(), and TreePop().

Here is the caller graph for this function:

◆ NavMoveRequestCancel()

void ImGui::NavMoveRequestCancel ( )

{
    ImGuiContext& g = *GImGui;
    g.NavMoveRequest = false;
    NavUpdateAnyRequestFlag();
}

References GImGui, ImGuiContext::NavMoveRequest, and NavUpdateAnyRequestFlag().

Referenced by BeginMenu(), EndMenu(), EndMenuBar(), NavMoveRequestForward(), TreeNodeBehavior(), and TreePop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavMoveRequestForward()

void ImGui::NavMoveRequestForward	(	ImGuiDir	move_dir,
		ImGuiDir	clip_dir,
		const ImRect &	bb_rel,
		ImGuiNavMoveFlags	move_flags
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavMoveRequestForward == ImGuiNavForward_None);
    NavMoveRequestCancel();
    g.NavMoveDir = move_dir;
    g.NavMoveClipDir = clip_dir;
    g.NavMoveRequestForward = ImGuiNavForward_ForwardQueued;
    g.NavMoveRequestFlags = move_flags;
    g.NavWindow->NavRectRel[g.NavLayer] = bb_rel;
}

References GImGui, IM_ASSERT, ImGuiNavForward_ForwardQueued, ImGuiNavForward_None, ImGuiContext::NavLayer, ImGuiContext::NavMoveClipDir, ImGuiContext::NavMoveDir, NavMoveRequestCancel(), ImGuiContext::NavMoveRequestFlags, ImGuiContext::NavMoveRequestForward, ImGuiWindow::NavRectRel, and ImGuiContext::NavWindow.

Referenced by NavEndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavMoveRequestTryWrapping()

void ImGui::NavMoveRequestTryWrapping	(	ImGuiWindow *	window,
		ImGuiNavMoveFlags	move_flags
	)

{
    ImGuiContext& g = *GImGui;
 
    // Navigation wrap-around logic is delayed to the end of the frame because this operation is only valid after entire
    // popup is assembled and in case of appended popups it is not clear which EndPopup() call is final.
    g.NavWrapRequestWindow = window;
    g.NavWrapRequestFlags = move_flags;
}

References GImGui, ImGuiContext::NavWrapRequestFlags, and ImGuiContext::NavWrapRequestWindow.

Referenced by EndPopup().

Here is the caller graph for this function:

◆ NavProcessItem()

static void ImGui::NavProcessItem	(	ImGuiWindow *	window,
		const ImRect &	nav_bb,
		ImGuiID	id
	)

static

{
    ImGuiContext& g = *GImGui;
    //if (!g.IO.NavActive)  // [2017/10/06] Removed this possibly redundant test but I am not sure of all the side-effects yet. Some of the feature here will need to work regardless of using a _NoNavInputs flag.
    //    return;
 
    const ImGuiItemFlags item_flags = g.CurrentItemFlags;
    const ImRect nav_bb_rel(nav_bb.Min - window->Pos, nav_bb.Max - window->Pos);
 
    // Process Init Request
    if (g.NavInitRequest && g.NavLayer == window->DC.NavLayerCurrent)
    {
        // Even if 'ImGuiItemFlags_NoNavDefaultFocus' is on (typically collapse/close button) we record the first ResultId so they can be used as a fallback
        if (!(item_flags & ImGuiItemFlags_NoNavDefaultFocus) || g.NavInitResultId == 0)
        {
            g.NavInitResultId = id;
            g.NavInitResultRectRel = nav_bb_rel;
        }
        if (!(item_flags & ImGuiItemFlags_NoNavDefaultFocus))
        {
            g.NavInitRequest = false; // Found a match, clear request
            NavUpdateAnyRequestFlag();
        }
    }
 
    // Process Move Request (scoring for navigation)
    // FIXME-NAV: Consider policy for double scoring (scoring from NavScoringRectScreen + scoring from a rect wrapped according to current wrapping policy)
    if ((g.NavId != id || (g.NavMoveRequestFlags & ImGuiNavMoveFlags_AllowCurrentNavId)) && !(item_flags & (ImGuiItemFlags_Disabled | ImGuiItemFlags_NoNav)))
    {
        ImGuiNavItemData* result = (window == g.NavWindow) ? &g.NavMoveResultLocal : &g.NavMoveResultOther;
#if IMGUI_DEBUG_NAV_SCORING
        // [DEBUG] Score all items in NavWindow at all times
        if (!g.NavMoveRequest)
            g.NavMoveDir = g.NavMoveDirLast;
        bool new_best = NavScoreItem(result, nav_bb) && g.NavMoveRequest;
#else
        bool new_best = g.NavMoveRequest && NavScoreItem(result, nav_bb);
#endif
        if (new_best)
            NavApplyItemToResult(result, window, id, nav_bb_rel);
 
        // Features like PageUp/PageDown need to maintain a separate score for the visible set of items.
        const float VISIBLE_RATIO = 0.70f;
        if ((g.NavMoveRequestFlags & ImGuiNavMoveFlags_AlsoScoreVisibleSet) && window->ClipRect.Overlaps(nav_bb))
            if (ImClamp(nav_bb.Max.y, window->ClipRect.Min.y, window->ClipRect.Max.y) - ImClamp(nav_bb.Min.y, window->ClipRect.Min.y, window->ClipRect.Max.y) >= (nav_bb.Max.y - nav_bb.Min.y) * VISIBLE_RATIO)
                if (NavScoreItem(&g.NavMoveResultLocalVisibleSet, nav_bb))
                    NavApplyItemToResult(&g.NavMoveResultLocalVisibleSet, window, id, nav_bb_rel);
    }
 
    // Update window-relative bounding box of navigated item
    if (g.NavId == id)
    {
        g.NavWindow = window;                                           // Always refresh g.NavWindow, because some operations such as FocusItem() don't have a window.
        g.NavLayer = window->DC.NavLayerCurrent;
        g.NavFocusScopeId = window->DC.NavFocusScopeIdCurrent;
        g.NavIdIsAlive = true;
        window->NavRectRel[window->DC.NavLayerCurrent] = nav_bb_rel;    // Store item bounding box (relative to window position)
    }
}

References ImGuiWindow::ClipRect, ImGuiContext::CurrentItemFlags, ImGuiWindow::DC, GImGui, ImClamp(), ImGuiItemFlags_Disabled, ImGuiItemFlags_NoNav, ImGuiItemFlags_NoNavDefaultFocus, ImGuiNavMoveFlags_AllowCurrentNavId, ImGuiNavMoveFlags_AlsoScoreVisibleSet, ImRect::Max, ImRect::Min, NavApplyItemToResult(), ImGuiContext::NavFocusScopeId, ImGuiWindowTempData::NavFocusScopeIdCurrent, ImGuiContext::NavId, ImGuiContext::NavIdIsAlive, ImGuiContext::NavInitRequest, ImGuiContext::NavInitResultId, ImGuiContext::NavInitResultRectRel, ImGuiContext::NavLayer, ImGuiWindowTempData::NavLayerCurrent, ImGuiContext::NavMoveDir, ImGuiContext::NavMoveDirLast, ImGuiContext::NavMoveRequest, ImGuiContext::NavMoveRequestFlags, ImGuiContext::NavMoveResultLocal, ImGuiContext::NavMoveResultLocalVisibleSet, ImGuiContext::NavMoveResultOther, ImGuiWindow::NavRectRel, NavScoreItem(), NavUpdateAnyRequestFlag(), ImGuiContext::NavWindow, ImRect::Overlaps(), ImGuiWindow::Pos, and ImVec2::y.

Referenced by ItemAdd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavRestoreLastChildNavWindow()

static ImGuiWindow * ImGui::NavRestoreLastChildNavWindow ( ImGuiWindow * window )

static

{
    if (window->NavLastChildNavWindow && window->NavLastChildNavWindow->WasActive)
        return window->NavLastChildNavWindow;
    return window;
}

References ImGuiWindow::NavLastChildNavWindow, and ImGuiWindow::WasActive.

Referenced by ClosePopupToLevel(), FocusTopMostWindowUnderOne(), NavRestoreLayer(), and NavUpdateWindowing().

Here is the caller graph for this function:

◆ NavRestoreLayer()

void ImGui::NavRestoreLayer ( ImGuiNavLayer layer )

static

{
    ImGuiContext& g = *GImGui;
    if (layer == ImGuiNavLayer_Main)
        g.NavWindow = NavRestoreLastChildNavWindow(g.NavWindow);
    ImGuiWindow* window = g.NavWindow;
    if (window->NavLastIds[layer] != 0)
    {
        SetNavID(window->NavLastIds[layer], layer, 0, window->NavRectRel[layer]);
        g.NavDisableHighlight = false;
        g.NavDisableMouseHover = g.NavMousePosDirty = true;
    }
    else
    {
        g.NavLayer = layer;
        NavInitWindow(window, true);
    }
}

References GImGui, ImGuiNavLayer_Main, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, NavInitWindow(), ImGuiWindow::NavLastIds, ImGuiContext::NavLayer, ImGuiContext::NavMousePosDirty, ImGuiWindow::NavRectRel, NavRestoreLastChildNavWindow(), ImGuiContext::NavWindow, and SetNavID().

Referenced by NavUpdate(), and NavUpdateWindowing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavSaveLastChildNavWindowIntoParent()

static void ImGui::NavSaveLastChildNavWindowIntoParent ( ImGuiWindow * nav_window )

static

{
    ImGuiWindow* parent = nav_window;
    while (parent && parent->RootWindow != parent && (parent->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu)) == 0)
        parent = parent->ParentWindow;
    if (parent && parent != nav_window)
        parent->NavLastChildNavWindow = nav_window;
}

References ImGuiWindow::Flags, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_Popup, ImGuiWindow::NavLastChildNavWindow, ImGuiWindow::ParentWindow, and ImGuiWindow::RootWindow.

Referenced by NavUpdate().

Here is the caller graph for this function:

◆ NavScoreItem()

static bool ImGui::NavScoreItem	(	ImGuiNavItemData *	result,
		ImRect	cand
	)

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (g.NavLayer != window->DC.NavLayerCurrent)
        return false;
 
    const ImRect& curr = g.NavScoringRect; // Current modified source rect (NB: we've applied Max.x = Min.x in NavUpdate() to inhibit the effect of having varied item width)
    g.NavScoringCount++;
 
    // When entering through a NavFlattened border, we consider child window items as fully clipped for scoring
    if (window->ParentWindow == g.NavWindow)
    {
        IM_ASSERT((window->Flags | g.NavWindow->Flags) & ImGuiWindowFlags_NavFlattened);
        if (!window->ClipRect.Overlaps(cand))
            return false;
        cand.ClipWithFull(window->ClipRect); // This allows the scored item to not overlap other candidates in the parent window
    }
 
    // We perform scoring on items bounding box clipped by the current clipping rectangle on the other axis (clipping on our movement axis would give us equal scores for all clipped items)
    // For example, this ensure that items in one column are not reached when moving vertically from items in another column.
    NavClampRectToVisibleAreaForMoveDir(g.NavMoveClipDir, cand, window->ClipRect);
 
    // Compute distance between boxes
    // FIXME-NAV: Introducing biases for vertical navigation, needs to be removed.
    float dbx = NavScoreItemDistInterval(cand.Min.x, cand.Max.x, curr.Min.x, curr.Max.x);
    float dby = NavScoreItemDistInterval(ImLerp(cand.Min.y, cand.Max.y, 0.2f), ImLerp(cand.Min.y, cand.Max.y, 0.8f), ImLerp(curr.Min.y, curr.Max.y, 0.2f), ImLerp(curr.Min.y, curr.Max.y, 0.8f)); // Scale down on Y to keep using box-distance for vertically touching items
    if (dby != 0.0f && dbx != 0.0f)
        dbx = (dbx / 1000.0f) + ((dbx > 0.0f) ? +1.0f : -1.0f);
    float dist_box = ImFabs(dbx) + ImFabs(dby);
 
    // Compute distance between centers (this is off by a factor of 2, but we only compare center distances with each other so it doesn't matter)
    float dcx = (cand.Min.x + cand.Max.x) - (curr.Min.x + curr.Max.x);
    float dcy = (cand.Min.y + cand.Max.y) - (curr.Min.y + curr.Max.y);
    float dist_center = ImFabs(dcx) + ImFabs(dcy); // L1 metric (need this for our connectedness guarantee)
 
    // Determine which quadrant of 'curr' our candidate item 'cand' lies in based on distance
    ImGuiDir quadrant;
    float dax = 0.0f, day = 0.0f, dist_axial = 0.0f;
    if (dbx != 0.0f || dby != 0.0f)
    {
        // For non-overlapping boxes, use distance between boxes
        dax = dbx;
        day = dby;
        dist_axial = dist_box;
        quadrant = ImGetDirQuadrantFromDelta(dbx, dby);
    }
    else if (dcx != 0.0f || dcy != 0.0f)
    {
        // For overlapping boxes with different centers, use distance between centers
        dax = dcx;
        day = dcy;
        dist_axial = dist_center;
        quadrant = ImGetDirQuadrantFromDelta(dcx, dcy);
    }
    else
    {
        // Degenerate case: two overlapping buttons with same center, break ties arbitrarily (note that LastItemId here is really the _previous_ item order, but it doesn't matter)
        quadrant = (window->DC.LastItemId < g.NavId) ? ImGuiDir_Left : ImGuiDir_Right;
    }
 
#if IMGUI_DEBUG_NAV_SCORING
    char buf[128];
    if (IsMouseHoveringRect(cand.Min, cand.Max))
    {
        ImFormatString(buf, IM_ARRAYSIZE(buf), "dbox (%.2f,%.2f->%.4f)\ndcen (%.2f,%.2f->%.4f)\nd (%.2f,%.2f->%.4f)\nnav %c, quadrant %c", dbx, dby, dist_box, dcx, dcy, dist_center, dax, day, dist_axial, "WENS"[g.NavMoveDir], "WENS"[quadrant]);
        ImDrawList* draw_list = GetForegroundDrawList(window);
        draw_list->AddRect(curr.Min, curr.Max, IM_COL32(255,200,0,100));
        draw_list->AddRect(cand.Min, cand.Max, IM_COL32(255,255,0,200));
        draw_list->AddRectFilled(cand.Max - ImVec2(4, 4), cand.Max + CalcTextSize(buf) + ImVec2(4, 4), IM_COL32(40,0,0,150));
        draw_list->AddText(g.IO.FontDefault, 13.0f, cand.Max, ~0U, buf);
    }
    else if (g.IO.KeyCtrl) // Hold to preview score in matching quadrant. Press C to rotate.
    {
        if (IsKeyPressedMap(ImGuiKey_C)) { g.NavMoveDirLast = (ImGuiDir)((g.NavMoveDirLast + 1) & 3); g.IO.KeysDownDuration[g.IO.KeyMap[ImGuiKey_C]] = 0.01f; }
        if (quadrant == g.NavMoveDir)
        {
            ImFormatString(buf, IM_ARRAYSIZE(buf), "%.0f/%.0f", dist_box, dist_center);
            ImDrawList* draw_list = GetForegroundDrawList(window);
            draw_list->AddRectFilled(cand.Min, cand.Max, IM_COL32(255, 0, 0, 200));
            draw_list->AddText(g.IO.FontDefault, 13.0f, cand.Min, IM_COL32(255, 255, 255, 255), buf);
        }
    }
#endif
 
    // Is it in the quadrant we're interesting in moving to?
    bool new_best = false;
    if (quadrant == g.NavMoveDir)
    {
        // Does it beat the current best candidate?
        if (dist_box < result->DistBox)
        {
            result->DistBox = dist_box;
            result->DistCenter = dist_center;
            return true;
        }
        if (dist_box == result->DistBox)
        {
            // Try using distance between center points to break ties
            if (dist_center < result->DistCenter)
            {
                result->DistCenter = dist_center;
                new_best = true;
            }
            else if (dist_center == result->DistCenter)
            {
                // Still tied! we need to be extra-careful to make sure everything gets linked properly. We consistently break ties by symbolically moving "later" items
                // (with higher index) to the right/downwards by an infinitesimal amount since we the current "best" button already (so it must have a lower index),
                // this is fairly easy. This rule ensures that all buttons with dx==dy==0 will end up being linked in order of appearance along the x axis.
                if (((g.NavMoveDir == ImGuiDir_Up || g.NavMoveDir == ImGuiDir_Down) ? dby : dbx) < 0.0f) // moving bj to the right/down decreases distance
                    new_best = true;
            }
        }
    }
 
    // Axial check: if 'curr' has no link at all in some direction and 'cand' lies roughly in that direction, add a tentative link. This will only be kept if no "real" matches
    // are found, so it only augments the graph produced by the above method using extra links. (important, since it doesn't guarantee strong connectedness)
    // This is just to avoid buttons having no links in a particular direction when there's a suitable neighbor. you get good graphs without this too.
    // 2017/09/29: FIXME: This now currently only enabled inside menu bars, ideally we'd disable it everywhere. Menus in particular need to catch failure. For general navigation it feels awkward.
    // Disabling it may lead to disconnected graphs when nodes are very spaced out on different axis. Perhaps consider offering this as an option?
    if (result->DistBox == FLT_MAX && dist_axial < result->DistAxial)  // Check axial match
        if (g.NavLayer == ImGuiNavLayer_Menu && !(g.NavWindow->Flags & ImGuiWindowFlags_ChildMenu))
            if ((g.NavMoveDir == ImGuiDir_Left && dax < 0.0f) || (g.NavMoveDir == ImGuiDir_Right && dax > 0.0f) || (g.NavMoveDir == ImGuiDir_Up && day < 0.0f) || (g.NavMoveDir == ImGuiDir_Down && day > 0.0f))
            {
                result->DistAxial = dist_axial;
                new_best = true;
            }
 
    return new_best;
}

References ImDrawList::AddRect(), ImDrawList::AddRectFilled(), ImDrawList::AddText(), CalcTextSize(), ImGuiWindow::ClipRect, ImRect::ClipWithFull(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiNavItemData::DistAxial, ImGuiNavItemData::DistBox, ImGuiNavItemData::DistCenter, ImGuiWindow::Flags, ImGuiIO::FontDefault, GetForegroundDrawList(), GImGui, IM_ARRAYSIZE, IM_ASSERT, IM_COL32, ImFabs, ImFormatString(), ImGetDirQuadrantFromDelta(), ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_Right, ImGuiDir_Up, ImGuiKey_C, ImGuiNavLayer_Menu, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_NavFlattened, ImLerp(), ImGuiContext::IO, IsKeyPressedMap(), IsMouseHoveringRect(), ImGuiIO::KeyCtrl, ImGuiIO::KeyMap, ImGuiIO::KeysDownDuration, ImGuiWindowTempData::LastItemId, ImRect::Max, ImRect::Min, NavClampRectToVisibleAreaForMoveDir(), ImGuiContext::NavId, ImGuiContext::NavLayer, ImGuiWindowTempData::NavLayerCurrent, ImGuiContext::NavMoveClipDir, ImGuiContext::NavMoveDir, ImGuiContext::NavMoveDirLast, NavScoreItemDistInterval(), ImGuiContext::NavScoringCount, ImGuiContext::NavScoringRect, ImGuiContext::NavWindow, ImRect::Overlaps(), ImGuiWindow::ParentWindow, ImVec2::x, and ImVec2::y.

Referenced by NavProcessItem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavUpdate()

static void ImGui::NavUpdate ( )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiIO& io = g.IO;
 
    io.WantSetMousePos = false;
    g.NavWrapRequestWindow = NULL;
    g.NavWrapRequestFlags = ImGuiNavMoveFlags_None;
#if 0
    if (g.NavScoringCount > 0) IMGUI_DEBUG_LOG("NavScoringCount %d for '%s' layer %d (Init:%d, Move:%d)\n", g.FrameCount, g.NavScoringCount, g.NavWindow ? g.NavWindow->Name : "NULL", g.NavLayer, g.NavInitRequest || g.NavInitResultId != 0, g.NavMoveRequest);
#endif
 
    // Set input source as Gamepad when buttons are pressed (as some features differs when used with Gamepad vs Keyboard)
    // (do it before we map Keyboard input!)
    bool nav_keyboard_active = (io.ConfigFlags & ImGuiConfigFlags_NavEnableKeyboard) != 0;
    bool nav_gamepad_active = (io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) != 0 && (io.BackendFlags & ImGuiBackendFlags_HasGamepad) != 0;
    if (nav_gamepad_active && g.NavInputSource != ImGuiInputSource_Gamepad)
    {
        if (io.NavInputs[ImGuiNavInput_Activate] > 0.0f || io.NavInputs[ImGuiNavInput_Input] > 0.0f || io.NavInputs[ImGuiNavInput_Cancel] > 0.0f || io.NavInputs[ImGuiNavInput_Menu] > 0.0f
            || io.NavInputs[ImGuiNavInput_DpadLeft] > 0.0f || io.NavInputs[ImGuiNavInput_DpadRight] > 0.0f || io.NavInputs[ImGuiNavInput_DpadUp] > 0.0f || io.NavInputs[ImGuiNavInput_DpadDown] > 0.0f)
            g.NavInputSource = ImGuiInputSource_Gamepad;
    }
 
    // Update Keyboard->Nav inputs mapping
    if (nav_keyboard_active)
    {
        #define NAV_MAP_KEY(_KEY, _NAV_INPUT)  do { if (IsKeyDown(io.KeyMap[_KEY])) { io.NavInputs[_NAV_INPUT] = 1.0f; g.NavInputSource = ImGuiInputSource_Keyboard; } } while (0)
        NAV_MAP_KEY(ImGuiKey_Space,     ImGuiNavInput_Activate );
        NAV_MAP_KEY(ImGuiKey_Enter,     ImGuiNavInput_Input    );
        NAV_MAP_KEY(ImGuiKey_Escape,    ImGuiNavInput_Cancel   );
        NAV_MAP_KEY(ImGuiKey_LeftArrow, ImGuiNavInput_KeyLeft_ );
        NAV_MAP_KEY(ImGuiKey_RightArrow,ImGuiNavInput_KeyRight_);
        NAV_MAP_KEY(ImGuiKey_UpArrow,   ImGuiNavInput_KeyUp_   );
        NAV_MAP_KEY(ImGuiKey_DownArrow, ImGuiNavInput_KeyDown_ );
        if (io.KeyCtrl)
            io.NavInputs[ImGuiNavInput_TweakSlow] = 1.0f;
        if (io.KeyShift)
            io.NavInputs[ImGuiNavInput_TweakFast] = 1.0f;
 
        // AltGR is normally Alt+Ctrl but we can't reliably detect it (not all backends/systems/layout emit it as Alt+Ctrl)
        // But also even on keyboards without AltGR we don't want Alt+Ctrl to open menu anyway.
        if (io.KeyAlt && !io.KeyCtrl)
            io.NavInputs[ImGuiNavInput_KeyMenu_]  = 1.0f;
 
        // We automatically cancel toggling nav layer when any text has been typed while holding Alt. (See #370)
        if (io.KeyAlt && !io.KeyCtrl && g.NavWindowingToggleLayer && io.InputQueueCharacters.Size > 0)
            g.NavWindowingToggleLayer = false;
 
        #undef NAV_MAP_KEY
    }
    memcpy(io.NavInputsDownDurationPrev, io.NavInputsDownDuration, sizeof(io.NavInputsDownDuration));
    for (int i = 0; i < IM_ARRAYSIZE(io.NavInputs); i++)
        io.NavInputsDownDuration[i] = (io.NavInputs[i] > 0.0f) ? (io.NavInputsDownDuration[i] < 0.0f ? 0.0f : io.NavInputsDownDuration[i] + io.DeltaTime) : -1.0f;
 
    // Process navigation init request (select first/default focus)
    if (g.NavInitResultId != 0)
        NavUpdateInitResult();
    g.NavInitRequest = false;
    g.NavInitRequestFromMove = false;
    g.NavInitResultId = 0;
    g.NavJustMovedToId = 0;
 
    // Process navigation move request
    if (g.NavMoveRequest)
        NavUpdateMoveResult();
 
    // When a forwarded move request failed, we restore the highlight that we disabled during the forward frame
    if (g.NavMoveRequestForward == ImGuiNavForward_ForwardActive)
    {
        IM_ASSERT(g.NavMoveRequest);
        if (g.NavMoveResultLocal.ID == 0 && g.NavMoveResultOther.ID == 0)
            g.NavDisableHighlight = false;
        g.NavMoveRequestForward = ImGuiNavForward_None;
    }
 
    // Apply application mouse position movement, after we had a chance to process move request result.
    if (g.NavMousePosDirty && g.NavIdIsAlive)
    {
        // Set mouse position given our knowledge of the navigated item position from last frame
        if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos) && (io.BackendFlags & ImGuiBackendFlags_HasSetMousePos))
            if (!g.NavDisableHighlight && g.NavDisableMouseHover && g.NavWindow)
            {
                io.MousePos = io.MousePosPrev = NavCalcPreferredRefPos();
                io.WantSetMousePos = true;
            }
        g.NavMousePosDirty = false;
    }
    g.NavIdIsAlive = false;
    g.NavJustTabbedId = 0;
    IM_ASSERT(g.NavLayer == 0 || g.NavLayer == 1);
 
    // Store our return window (for returning from Layer 1 to Layer 0) and clear it as soon as we step back in our own Layer 0
    if (g.NavWindow)
        NavSaveLastChildNavWindowIntoParent(g.NavWindow);
    if (g.NavWindow && g.NavWindow->NavLastChildNavWindow != NULL && g.NavLayer == ImGuiNavLayer_Main)
        g.NavWindow->NavLastChildNavWindow = NULL;
 
    // Update CTRL+TAB and Windowing features (hold Square to move/resize/etc.)
    NavUpdateWindowing();
 
    // Set output flags for user application
    io.NavActive = (nav_keyboard_active || nav_gamepad_active) && g.NavWindow && !(g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs);
    io.NavVisible = (io.NavActive && g.NavId != 0 && !g.NavDisableHighlight) || (g.NavWindowingTarget != NULL);
 
    // Process NavCancel input (to close a popup, get back to parent, clear focus)
    if (IsNavInputTest(ImGuiNavInput_Cancel, ImGuiInputReadMode_Pressed))
    {
        IMGUI_DEBUG_LOG_NAV("[nav] ImGuiNavInput_Cancel\n");
        if (g.ActiveId != 0)
        {
            if (!IsActiveIdUsingNavInput(ImGuiNavInput_Cancel))
                ClearActiveID();
        }
        else if (g.NavLayer != ImGuiNavLayer_Main)
        {
            // Leave the "menu" layer
            NavRestoreLayer(ImGuiNavLayer_Main);
        }
        else if (g.NavWindow && g.NavWindow != g.NavWindow->RootWindow && !(g.NavWindow->Flags & ImGuiWindowFlags_Popup) && g.NavWindow->ParentWindow)
        {
            // Exit child window
            ImGuiWindow* child_window = g.NavWindow;
            ImGuiWindow* parent_window = g.NavWindow->ParentWindow;
            IM_ASSERT(child_window->ChildId != 0);
            ImRect child_rect = child_window->Rect();
            FocusWindow(parent_window);
            SetNavID(child_window->ChildId, ImGuiNavLayer_Main, 0, ImRect(child_rect.Min - parent_window->Pos, child_rect.Max - parent_window->Pos));
        }
        else if (g.OpenPopupStack.Size > 0)
        {
            // Close open popup/menu
            if (!(g.OpenPopupStack.back().Window->Flags & ImGuiWindowFlags_Modal))
                ClosePopupToLevel(g.OpenPopupStack.Size - 1, true);
        }
        else
        {
            // Clear NavLastId for popups but keep it for regular child window so we can leave one and come back where we were
            if (g.NavWindow && ((g.NavWindow->Flags & ImGuiWindowFlags_Popup) || !(g.NavWindow->Flags & ImGuiWindowFlags_ChildWindow)))
                g.NavWindow->NavLastIds[0] = 0;
            g.NavId = g.NavFocusScopeId = 0;
        }
    }
 
    // Process manual activation request
    g.NavActivateId = g.NavActivateDownId = g.NavActivatePressedId = g.NavInputId = 0;
    if (g.NavId != 0 && !g.NavDisableHighlight && !g.NavWindowingTarget && g.NavWindow && !(g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs))
    {
        bool activate_down = IsNavInputDown(ImGuiNavInput_Activate);
        bool activate_pressed = activate_down && IsNavInputTest(ImGuiNavInput_Activate, ImGuiInputReadMode_Pressed);
        if (g.ActiveId == 0 && activate_pressed)
            g.NavActivateId = g.NavId;
        if ((g.ActiveId == 0 || g.ActiveId == g.NavId) && activate_down)
            g.NavActivateDownId = g.NavId;
        if ((g.ActiveId == 0 || g.ActiveId == g.NavId) && activate_pressed)
            g.NavActivatePressedId = g.NavId;
        if ((g.ActiveId == 0 || g.ActiveId == g.NavId) && IsNavInputTest(ImGuiNavInput_Input, ImGuiInputReadMode_Pressed))
            g.NavInputId = g.NavId;
    }
    if (g.NavWindow && (g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs))
        g.NavDisableHighlight = true;
    if (g.NavActivateId != 0)
        IM_ASSERT(g.NavActivateDownId == g.NavActivateId);
    g.NavMoveRequest = false;
 
    // Process programmatic activation request
    if (g.NavNextActivateId != 0)
        g.NavActivateId = g.NavActivateDownId = g.NavActivatePressedId = g.NavInputId = g.NavNextActivateId;
    g.NavNextActivateId = 0;
 
    // Initiate directional inputs request
    if (g.NavMoveRequestForward == ImGuiNavForward_None)
    {
        g.NavMoveDir = ImGuiDir_None;
        g.NavMoveRequestFlags = ImGuiNavMoveFlags_None;
        if (g.NavWindow && !g.NavWindowingTarget && !(g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs))
        {
            const ImGuiInputReadMode read_mode = ImGuiInputReadMode_Repeat;
            if (!IsActiveIdUsingNavDir(ImGuiDir_Left)  && (IsNavInputTest(ImGuiNavInput_DpadLeft,  read_mode) || IsNavInputTest(ImGuiNavInput_KeyLeft_,  read_mode))) { g.NavMoveDir = ImGuiDir_Left; }
            if (!IsActiveIdUsingNavDir(ImGuiDir_Right) && (IsNavInputTest(ImGuiNavInput_DpadRight, read_mode) || IsNavInputTest(ImGuiNavInput_KeyRight_, read_mode))) { g.NavMoveDir = ImGuiDir_Right; }
            if (!IsActiveIdUsingNavDir(ImGuiDir_Up)    && (IsNavInputTest(ImGuiNavInput_DpadUp,    read_mode) || IsNavInputTest(ImGuiNavInput_KeyUp_,    read_mode))) { g.NavMoveDir = ImGuiDir_Up; }
            if (!IsActiveIdUsingNavDir(ImGuiDir_Down)  && (IsNavInputTest(ImGuiNavInput_DpadDown,  read_mode) || IsNavInputTest(ImGuiNavInput_KeyDown_,  read_mode))) { g.NavMoveDir = ImGuiDir_Down; }
        }
        g.NavMoveClipDir = g.NavMoveDir;
    }
    else
    {
        // Forwarding previous request (which has been modified, e.g. wrap around menus rewrite the requests with a starting rectangle at the other side of the window)
        // (Preserve g.NavMoveRequestFlags, g.NavMoveClipDir which were set by the NavMoveRequestForward() function)
        IM_ASSERT(g.NavMoveDir != ImGuiDir_None && g.NavMoveClipDir != ImGuiDir_None);
        IM_ASSERT(g.NavMoveRequestForward == ImGuiNavForward_ForwardQueued);
        IMGUI_DEBUG_LOG_NAV("[nav] NavMoveRequestForward %d\n", g.NavMoveDir);
        g.NavMoveRequestForward = ImGuiNavForward_ForwardActive;
    }
 
    // Update PageUp/PageDown/Home/End scroll
    // FIXME-NAV: Consider enabling those keys even without the master ImGuiConfigFlags_NavEnableKeyboard flag?
    float nav_scoring_rect_offset_y = 0.0f;
    if (nav_keyboard_active)
        nav_scoring_rect_offset_y = NavUpdatePageUpPageDown();
 
    // If we initiate a movement request and have no current NavId, we initiate a InitDefautRequest that will be used as a fallback if the direction fails to find a match
    if (g.NavMoveDir != ImGuiDir_None)
    {
        g.NavMoveRequest = true;
        g.NavMoveRequestKeyMods = io.KeyMods;
        g.NavMoveDirLast = g.NavMoveDir;
    }
    if (g.NavMoveRequest && g.NavId == 0)
    {
        IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: from move, window \"%s\", layer=%d\n", g.NavWindow->Name, g.NavLayer);
        g.NavInitRequest = g.NavInitRequestFromMove = true;
        // Reassigning with same value, we're being explicit here.
        g.NavInitResultId = 0;     // -V1048
        g.NavDisableHighlight = false;
    }
    NavUpdateAnyRequestFlag();
 
    // Scrolling
    if (g.NavWindow && !(g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs) && !g.NavWindowingTarget)
    {
        // *Fallback* manual-scroll with Nav directional keys when window has no navigable item
        ImGuiWindow* window = g.NavWindow;
        const float scroll_speed = IM_ROUND(window->CalcFontSize() * 100 * io.DeltaTime); // We need round the scrolling speed because sub-pixel scroll isn't reliably supported.
        if (window->DC.NavLayersActiveMask == 0x00 && window->DC.NavHasScroll && g.NavMoveRequest)
        {
            if (g.NavMoveDir == ImGuiDir_Left || g.NavMoveDir == ImGuiDir_Right)
                SetScrollX(window, ImFloor(window->Scroll.x + ((g.NavMoveDir == ImGuiDir_Left) ? -1.0f : +1.0f) * scroll_speed));
            if (g.NavMoveDir == ImGuiDir_Up || g.NavMoveDir == ImGuiDir_Down)
                SetScrollY(window, ImFloor(window->Scroll.y + ((g.NavMoveDir == ImGuiDir_Up) ? -1.0f : +1.0f) * scroll_speed));
        }
 
        // *Normal* Manual scroll with NavScrollXXX keys
        // Next movement request will clamp the NavId reference rectangle to the visible area, so navigation will resume within those bounds.
        ImVec2 scroll_dir = GetNavInputAmount2d(ImGuiNavDirSourceFlags_PadLStick, ImGuiInputReadMode_Down, 1.0f / 10.0f, 10.0f);
        if (scroll_dir.x != 0.0f && window->ScrollbarX)
            SetScrollX(window, ImFloor(window->Scroll.x + scroll_dir.x * scroll_speed));
        if (scroll_dir.y != 0.0f)
            SetScrollY(window, ImFloor(window->Scroll.y + scroll_dir.y * scroll_speed));
    }
 
    // Reset search results
    g.NavMoveResultLocal.Clear();
    g.NavMoveResultLocalVisibleSet.Clear();
    g.NavMoveResultOther.Clear();
 
    // When using gamepad, we project the reference nav bounding box into window visible area.
    // This is to allow resuming navigation inside the visible area after doing a large amount of scrolling, since with gamepad every movements are relative
    // (can't focus a visible object like we can with the mouse).
    if (g.NavMoveRequest && g.NavInputSource == ImGuiInputSource_Gamepad && g.NavLayer == ImGuiNavLayer_Main)
    {
        ImGuiWindow* window = g.NavWindow;
        ImRect window_rect_rel(window->InnerRect.Min - window->Pos - ImVec2(1, 1), window->InnerRect.Max - window->Pos + ImVec2(1, 1));
        if (!window_rect_rel.Contains(window->NavRectRel[g.NavLayer]))
        {
            IMGUI_DEBUG_LOG_NAV("[nav] NavMoveRequest: clamp NavRectRel\n");
            float pad = window->CalcFontSize() * 0.5f;
            window_rect_rel.Expand(ImVec2(-ImMin(window_rect_rel.GetWidth(), pad), -ImMin(window_rect_rel.GetHeight(), pad))); // Terrible approximation for the intent of starting navigation from first fully visible item
            window->NavRectRel[g.NavLayer].ClipWithFull(window_rect_rel);
            g.NavId = g.NavFocusScopeId = 0;
        }
    }
 
    // For scoring we use a single segment on the left side our current item bounding box (not touching the edge to avoid box overlap with zero-spaced items)
    ImRect nav_rect_rel = g.NavWindow && !g.NavWindow->NavRectRel[g.NavLayer].IsInverted() ? g.NavWindow->NavRectRel[g.NavLayer] : ImRect(0, 0, 0, 0);
    g.NavScoringRect = g.NavWindow ? ImRect(g.NavWindow->Pos + nav_rect_rel.Min, g.NavWindow->Pos + nav_rect_rel.Max) : ImRect(0, 0, 0, 0);
    g.NavScoringRect.TranslateY(nav_scoring_rect_offset_y);
    g.NavScoringRect.Min.x = ImMin(g.NavScoringRect.Min.x + 1.0f, g.NavScoringRect.Max.x);
    g.NavScoringRect.Max.x = g.NavScoringRect.Min.x;
    IM_ASSERT(!g.NavScoringRect.IsInverted()); // Ensure if we have a finite, non-inverted bounding box here will allows us to remove extraneous ImFabs() calls in NavScoreItem().
    //GetForegroundDrawList()->AddRect(g.NavScoringRectScreen.Min, g.NavScoringRectScreen.Max, IM_COL32(255,200,0,255)); // [DEBUG]
    g.NavScoringCount = 0;
#if IMGUI_DEBUG_NAV_RECTS
    if (g.NavWindow)
    {
        ImDrawList* draw_list = GetForegroundDrawList(g.NavWindow);
        if (1) { for (int layer = 0; layer < 2; layer++) draw_list->AddRect(g.NavWindow->Pos + g.NavWindow->NavRectRel[layer].Min, g.NavWindow->Pos + g.NavWindow->NavRectRel[layer].Max, IM_COL32(255,200,0,255)); } // [DEBUG]
        if (1) { ImU32 col = (!g.NavWindow->Hidden) ? IM_COL32(255,0,255,255) : IM_COL32(255,0,0,255); ImVec2 p = NavCalcPreferredRefPos(); char buf[32]; ImFormatString(buf, 32, "%d", g.NavLayer); draw_list->AddCircleFilled(p, 3.0f, col); draw_list->AddText(NULL, 13.0f, p + ImVec2(8,-4), col, buf); }
    }
#endif
}

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavUpdateAnyRequestFlag()

static void ImGui::NavUpdateAnyRequestFlag ( )

inlinestatic

{
    ImGuiContext& g = *GImGui;
    g.NavAnyRequest = g.NavMoveRequest || g.NavInitRequest || (IMGUI_DEBUG_NAV_SCORING && g.NavWindow != NULL);
    if (g.NavAnyRequest)
        IM_ASSERT(g.NavWindow != NULL);
}

References GImGui, IM_ASSERT, IMGUI_DEBUG_NAV_SCORING, ImGuiContext::NavAnyRequest, ImGuiContext::NavInitRequest, ImGuiContext::NavMoveRequest, and ImGuiContext::NavWindow.

Referenced by FocusWindow(), NavInitWindow(), NavMoveRequestCancel(), NavProcessItem(), NavUpdate(), and SetItemDefaultFocus().

Here is the caller graph for this function:

◆ NavUpdateInitResult()

static void ImGui::NavUpdateInitResult ( )

static

{
    // In very rare cases g.NavWindow may be null (e.g. clearing focus after requesting an init request, which does happen when releasing Alt while clicking on void)
    ImGuiContext& g = *GImGui;
    if (!g.NavWindow)
        return;
 
    // Apply result from previous navigation init request (will typically select the first item, unless SetItemDefaultFocus() has been called)
    // FIXME-NAV: On _NavFlattened windows, g.NavWindow will only be updated during subsequent frame. Not a problem currently.
    IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: result NavID 0x%08X in Layer %d Window \"%s\"\n", g.NavInitResultId, g.NavLayer, g.NavWindow->Name);
    SetNavID(g.NavInitResultId, g.NavLayer, 0, g.NavInitResultRectRel);
    if (g.NavInitRequestFromMove)
    {
        g.NavDisableHighlight = false;
        g.NavDisableMouseHover = g.NavMousePosDirty = true;
    }
}

References GImGui, IMGUI_DEBUG_LOG_NAV, ImGuiWindow::Name, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavInitRequestFromMove, ImGuiContext::NavInitResultId, ImGuiContext::NavInitResultRectRel, ImGuiContext::NavLayer, ImGuiContext::NavMousePosDirty, ImGuiContext::NavWindow, and SetNavID().

Referenced by NavUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavUpdateMoveResult()

static void ImGui::NavUpdateMoveResult ( )

static

{
    ImGuiContext& g = *GImGui;
    if (g.NavMoveResultLocal.ID == 0 && g.NavMoveResultOther.ID == 0)
    {
        // In a situation when there is no results but NavId != 0, re-enable the Navigation highlight (because g.NavId is not considered as a possible result)
        if (g.NavId != 0)
        {
            g.NavDisableHighlight = false;
            g.NavDisableMouseHover = true;
        }
        return;
    }
 
    // Select which result to use
    ImGuiNavItemData* result = (g.NavMoveResultLocal.ID != 0) ? &g.NavMoveResultLocal : &g.NavMoveResultOther;
 
    // PageUp/PageDown behavior first jumps to the bottom/top mostly visible item, _otherwise_ use the result from the previous/next page.
    if (g.NavMoveRequestFlags & ImGuiNavMoveFlags_AlsoScoreVisibleSet)
        if (g.NavMoveResultLocalVisibleSet.ID != 0 && g.NavMoveResultLocalVisibleSet.ID != g.NavId)
            result = &g.NavMoveResultLocalVisibleSet;
 
    // Maybe entering a flattened child from the outside? In this case solve the tie using the regular scoring rules.
    if (result != &g.NavMoveResultOther && g.NavMoveResultOther.ID != 0 && g.NavMoveResultOther.Window->ParentWindow == g.NavWindow)
        if ((g.NavMoveResultOther.DistBox < result->DistBox) || (g.NavMoveResultOther.DistBox == result->DistBox && g.NavMoveResultOther.DistCenter < result->DistCenter))
            result = &g.NavMoveResultOther;
    IM_ASSERT(g.NavWindow && result->Window);
 
    // Scroll to keep newly navigated item fully into view.
    if (g.NavLayer == ImGuiNavLayer_Main)
    {
        ImVec2 delta_scroll;
        if (g.NavMoveRequestFlags & ImGuiNavMoveFlags_ScrollToEdge)
        {
            float scroll_target = (g.NavMoveDir == ImGuiDir_Up) ? result->Window->ScrollMax.y : 0.0f;
            delta_scroll.y = result->Window->Scroll.y - scroll_target;
            SetScrollY(result->Window, scroll_target);
        }
        else
        {
            ImRect rect_abs = ImRect(result->RectRel.Min + result->Window->Pos, result->RectRel.Max + result->Window->Pos);
            delta_scroll = ScrollToBringRectIntoView(result->Window, rect_abs);
        }
 
        // Offset our result position so mouse position can be applied immediately after in NavUpdate()
        result->RectRel.TranslateX(-delta_scroll.x);
        result->RectRel.TranslateY(-delta_scroll.y);
    }
 
    ClearActiveID();
    g.NavWindow = result->Window;
    if (g.NavId != result->ID)
    {
        // Don't set NavJustMovedToId if just landed on the same spot (which may happen with ImGuiNavMoveFlags_AllowCurrentNavId)
        g.NavJustMovedToId = result->ID;
        g.NavJustMovedToFocusScopeId = result->FocusScopeId;
        g.NavJustMovedToKeyMods = g.NavMoveRequestKeyMods;
    }
    IMGUI_DEBUG_LOG_NAV("[nav] NavMoveRequest: result NavID 0x%08X in Layer %d Window \"%s\"\n", result->ID, g.NavLayer, g.NavWindow->Name);
    SetNavID(result->ID, g.NavLayer, result->FocusScopeId, result->RectRel);
    g.NavDisableHighlight = false;
    g.NavDisableMouseHover = g.NavMousePosDirty = true;
}

References ClearActiveID(), ImGuiNavItemData::DistBox, ImGuiNavItemData::DistCenter, ImGuiNavItemData::FocusScopeId, GImGui, ImGuiNavItemData::ID, IM_ASSERT, IMGUI_DEBUG_LOG_NAV, ImGuiDir_Up, ImGuiNavLayer_Main, ImGuiNavMoveFlags_AlsoScoreVisibleSet, ImGuiNavMoveFlags_ScrollToEdge, ImRect::Max, ImRect::Min, ImGuiWindow::Name, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavId, ImGuiContext::NavJustMovedToFocusScopeId, ImGuiContext::NavJustMovedToId, ImGuiContext::NavJustMovedToKeyMods, ImGuiContext::NavLayer, ImGuiContext::NavMousePosDirty, ImGuiContext::NavMoveDir, ImGuiContext::NavMoveRequestFlags, ImGuiContext::NavMoveRequestKeyMods, ImGuiContext::NavMoveResultLocal, ImGuiContext::NavMoveResultLocalVisibleSet, ImGuiContext::NavMoveResultOther, ImGuiContext::NavWindow, ImGuiWindow::ParentWindow, ImGuiWindow::Pos, ImGuiNavItemData::RectRel, ImGuiWindow::Scroll, ImGuiWindow::ScrollMax, ScrollToBringRectIntoView(), SetNavID(), SetScrollY(), ImRect::TranslateX(), ImRect::TranslateY(), ImGuiNavItemData::Window, ImVec2::x, and ImVec2::y.

Referenced by NavUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavUpdatePageUpPageDown()

static float ImGui::NavUpdatePageUpPageDown ( )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiIO& io = g.IO;
 
    if (g.NavMoveDir != ImGuiDir_None || g.NavWindow == NULL)
        return 0.0f;
    if ((g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs) || g.NavWindowingTarget != NULL || g.NavLayer != ImGuiNavLayer_Main)
        return 0.0f;
 
    ImGuiWindow* window = g.NavWindow;
    const bool page_up_held = IsKeyDown(io.KeyMap[ImGuiKey_PageUp]) && !IsActiveIdUsingKey(ImGuiKey_PageUp);
    const bool page_down_held = IsKeyDown(io.KeyMap[ImGuiKey_PageDown]) && !IsActiveIdUsingKey(ImGuiKey_PageDown);
    const bool home_pressed = IsKeyPressed(io.KeyMap[ImGuiKey_Home]) && !IsActiveIdUsingKey(ImGuiKey_Home);
    const bool end_pressed = IsKeyPressed(io.KeyMap[ImGuiKey_End]) && !IsActiveIdUsingKey(ImGuiKey_End);
    if (page_up_held != page_down_held || home_pressed != end_pressed) // If either (not both) are pressed
    {
        if (window->DC.NavLayersActiveMask == 0x00 && window->DC.NavHasScroll)
        {
            // Fallback manual-scroll when window has no navigable item
            if (IsKeyPressed(io.KeyMap[ImGuiKey_PageUp], true))
                SetScrollY(window, window->Scroll.y - window->InnerRect.GetHeight());
            else if (IsKeyPressed(io.KeyMap[ImGuiKey_PageDown], true))
                SetScrollY(window, window->Scroll.y + window->InnerRect.GetHeight());
            else if (home_pressed)
                SetScrollY(window, 0.0f);
            else if (end_pressed)
                SetScrollY(window, window->ScrollMax.y);
        }
        else
        {
            ImRect& nav_rect_rel = window->NavRectRel[g.NavLayer];
            const float page_offset_y = ImMax(0.0f, window->InnerRect.GetHeight() - window->CalcFontSize() * 1.0f + nav_rect_rel.GetHeight());
            float nav_scoring_rect_offset_y = 0.0f;
            if (IsKeyPressed(io.KeyMap[ImGuiKey_PageUp], true))
            {
                nav_scoring_rect_offset_y = -page_offset_y;
                g.NavMoveDir = ImGuiDir_Down; // Because our scoring rect is offset up, we request the down direction (so we can always land on the last item)
                g.NavMoveClipDir = ImGuiDir_Up;
                g.NavMoveRequestFlags = ImGuiNavMoveFlags_AllowCurrentNavId | ImGuiNavMoveFlags_AlsoScoreVisibleSet;
            }
            else if (IsKeyPressed(io.KeyMap[ImGuiKey_PageDown], true))
            {
                nav_scoring_rect_offset_y = +page_offset_y;
                g.NavMoveDir = ImGuiDir_Up; // Because our scoring rect is offset down, we request the up direction (so we can always land on the last item)
                g.NavMoveClipDir = ImGuiDir_Down;
                g.NavMoveRequestFlags = ImGuiNavMoveFlags_AllowCurrentNavId | ImGuiNavMoveFlags_AlsoScoreVisibleSet;
            }
            else if (home_pressed)
            {
                // FIXME-NAV: handling of Home/End is assuming that the top/bottom most item will be visible with Scroll.y == 0/ScrollMax.y
                // Scrolling will be handled via the ImGuiNavMoveFlags_ScrollToEdge flag, we don't scroll immediately to avoid scrolling happening before nav result.
                // Preserve current horizontal position if we have any.
                nav_rect_rel.Min.y = nav_rect_rel.Max.y = -window->Scroll.y;
                if (nav_rect_rel.IsInverted())
                    nav_rect_rel.Min.x = nav_rect_rel.Max.x = 0.0f;
                g.NavMoveDir = ImGuiDir_Down;
                g.NavMoveRequestFlags = ImGuiNavMoveFlags_AllowCurrentNavId | ImGuiNavMoveFlags_ScrollToEdge;
            }
            else if (end_pressed)
            {
                nav_rect_rel.Min.y = nav_rect_rel.Max.y = window->ScrollMax.y + window->SizeFull.y - window->Scroll.y;
                if (nav_rect_rel.IsInverted())
                    nav_rect_rel.Min.x = nav_rect_rel.Max.x = 0.0f;
                g.NavMoveDir = ImGuiDir_Up;
                g.NavMoveRequestFlags = ImGuiNavMoveFlags_AllowCurrentNavId | ImGuiNavMoveFlags_ScrollToEdge;
            }
            return nav_scoring_rect_offset_y;
        }
    }
    return 0.0f;
}

References ImGuiWindow::CalcFontSize(), ImGuiWindow::DC, ImGuiWindow::Flags, ImRect::GetHeight(), GImGui, ImGuiDir_Down, ImGuiDir_None, ImGuiDir_Up, ImGuiKey_End, ImGuiKey_Home, ImGuiKey_PageDown, ImGuiKey_PageUp, ImGuiNavLayer_Main, ImGuiNavMoveFlags_AllowCurrentNavId, ImGuiNavMoveFlags_AlsoScoreVisibleSet, ImGuiNavMoveFlags_ScrollToEdge, ImGuiWindowFlags_NoNavInputs, ImMax(), ImGuiWindow::InnerRect, ImGuiContext::IO, IsActiveIdUsingKey(), ImRect::IsInverted(), IsKeyDown(), IsKeyPressed(), ImGuiIO::KeyMap, ImRect::Max, ImRect::Min, ImGuiWindowTempData::NavHasScroll, ImGuiContext::NavLayer, ImGuiWindowTempData::NavLayersActiveMask, ImGuiContext::NavMoveClipDir, ImGuiContext::NavMoveDir, ImGuiContext::NavMoveRequestFlags, ImGuiWindow::NavRectRel, ImGuiContext::NavWindow, ImGuiContext::NavWindowingTarget, ImGuiWindow::Scroll, ImGuiWindow::ScrollMax, SetScrollY(), ImGuiWindow::SizeFull, ImVec2::x, and ImVec2::y.

Referenced by NavUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavUpdateWindowing()

static void ImGui::NavUpdateWindowing ( )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* apply_focus_window = NULL;
    bool apply_toggle_layer = false;
 
    ImGuiWindow* modal_window = GetTopMostPopupModal();
    bool allow_windowing = (modal_window == NULL);
    if (!allow_windowing)
        g.NavWindowingTarget = NULL;
 
    // Fade out
    if (g.NavWindowingTargetAnim && g.NavWindowingTarget == NULL)
    {
        g.NavWindowingHighlightAlpha = ImMax(g.NavWindowingHighlightAlpha - g.IO.DeltaTime * 10.0f, 0.0f);
        if (g.DimBgRatio <= 0.0f && g.NavWindowingHighlightAlpha <= 0.0f)
            g.NavWindowingTargetAnim = NULL;
    }
 
    // Start CTRL-TAB or Square+L/R window selection
    bool start_windowing_with_gamepad = allow_windowing && !g.NavWindowingTarget && IsNavInputTest(ImGuiNavInput_Menu, ImGuiInputReadMode_Pressed);
    bool start_windowing_with_keyboard = allow_windowing && !g.NavWindowingTarget && g.IO.KeyCtrl && IsKeyPressedMap(ImGuiKey_Tab) && (g.IO.ConfigFlags & ImGuiConfigFlags_NavEnableKeyboard);
    if (start_windowing_with_gamepad || start_windowing_with_keyboard)
        if (ImGuiWindow* window = g.NavWindow ? g.NavWindow : FindWindowNavFocusable(g.WindowsFocusOrder.Size - 1, -INT_MAX, -1))
        {
            g.NavWindowingTarget = g.NavWindowingTargetAnim = window->RootWindow; // FIXME-DOCK: Will need to use RootWindowDockStop
            g.NavWindowingTimer = g.NavWindowingHighlightAlpha = 0.0f;
            g.NavWindowingToggleLayer = start_windowing_with_keyboard ? false : true;
            g.NavInputSource = start_windowing_with_keyboard ? ImGuiInputSource_Keyboard : ImGuiInputSource_Gamepad;
        }
 
    // Gamepad update
    g.NavWindowingTimer += g.IO.DeltaTime;
    if (g.NavWindowingTarget && g.NavInputSource == ImGuiInputSource_Gamepad)
    {
        // Highlight only appears after a brief time holding the button, so that a fast tap on PadMenu (to toggle NavLayer) doesn't add visual noise
        g.NavWindowingHighlightAlpha = ImMax(g.NavWindowingHighlightAlpha, ImSaturate((g.NavWindowingTimer - NAV_WINDOWING_HIGHLIGHT_DELAY) / 0.05f));
 
        // Select window to focus
        const int focus_change_dir = (int)IsNavInputTest(ImGuiNavInput_FocusPrev, ImGuiInputReadMode_RepeatSlow) - (int)IsNavInputTest(ImGuiNavInput_FocusNext, ImGuiInputReadMode_RepeatSlow);
        if (focus_change_dir != 0)
        {
            NavUpdateWindowingHighlightWindow(focus_change_dir);
            g.NavWindowingHighlightAlpha = 1.0f;
        }
 
        // Single press toggles NavLayer, long press with L/R apply actual focus on release (until then the window was merely rendered top-most)
        if (!IsNavInputDown(ImGuiNavInput_Menu))
        {
            g.NavWindowingToggleLayer &= (g.NavWindowingHighlightAlpha < 1.0f); // Once button was held long enough we don't consider it a tap-to-toggle-layer press anymore.
            if (g.NavWindowingToggleLayer && g.NavWindow)
                apply_toggle_layer = true;
            else if (!g.NavWindowingToggleLayer)
                apply_focus_window = g.NavWindowingTarget;
            g.NavWindowingTarget = NULL;
        }
    }
 
    // Keyboard: Focus
    if (g.NavWindowingTarget && g.NavInputSource == ImGuiInputSource_Keyboard)
    {
        // Visuals only appears after a brief time after pressing TAB the first time, so that a fast CTRL+TAB doesn't add visual noise
        g.NavWindowingHighlightAlpha = ImMax(g.NavWindowingHighlightAlpha, ImSaturate((g.NavWindowingTimer - NAV_WINDOWING_HIGHLIGHT_DELAY) / 0.05f)); // 1.0f
        if (IsKeyPressedMap(ImGuiKey_Tab, true))
            NavUpdateWindowingHighlightWindow(g.IO.KeyShift ? +1 : -1);
        if (!g.IO.KeyCtrl)
            apply_focus_window = g.NavWindowingTarget;
    }
 
    // Keyboard: Press and Release ALT to toggle menu layer
    // FIXME: We lack an explicit IO variable for "is the imgui window focused", so compare mouse validity to detect the common case of backend clearing releases all keys on ALT-TAB
    if (IsNavInputTest(ImGuiNavInput_KeyMenu_, ImGuiInputReadMode_Pressed))
        g.NavWindowingToggleLayer = true;
    if ((g.ActiveId == 0 || g.ActiveIdAllowOverlap) && g.NavWindowingToggleLayer && IsNavInputTest(ImGuiNavInput_KeyMenu_, ImGuiInputReadMode_Released))
        if (IsMousePosValid(&g.IO.MousePos) == IsMousePosValid(&g.IO.MousePosPrev))
            apply_toggle_layer = true;
 
    // Move window
    if (g.NavWindowingTarget && !(g.NavWindowingTarget->Flags & ImGuiWindowFlags_NoMove))
    {
        ImVec2 move_delta;
        if (g.NavInputSource == ImGuiInputSource_Keyboard && !g.IO.KeyShift)
            move_delta = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard, ImGuiInputReadMode_Down);
        if (g.NavInputSource == ImGuiInputSource_Gamepad)
            move_delta = GetNavInputAmount2d(ImGuiNavDirSourceFlags_PadLStick, ImGuiInputReadMode_Down);
        if (move_delta.x != 0.0f || move_delta.y != 0.0f)
        {
            const float NAV_MOVE_SPEED = 800.0f;
            const float move_speed = ImFloor(NAV_MOVE_SPEED * g.IO.DeltaTime * ImMin(g.IO.DisplayFramebufferScale.x, g.IO.DisplayFramebufferScale.y)); // FIXME: Doesn't handle variable framerate very well
            ImGuiWindow* moving_window = g.NavWindowingTarget->RootWindow;
            SetWindowPos(moving_window, moving_window->Pos + move_delta * move_speed, ImGuiCond_Always);
            MarkIniSettingsDirty(moving_window);
            g.NavDisableMouseHover = true;
        }
    }
 
    // Apply final focus
    if (apply_focus_window && (g.NavWindow == NULL || apply_focus_window != g.NavWindow->RootWindow))
    {
        ClearActiveID();
        g.NavDisableHighlight = false;
        g.NavDisableMouseHover = true;
        apply_focus_window = NavRestoreLastChildNavWindow(apply_focus_window);
        ClosePopupsOverWindow(apply_focus_window, false);
        FocusWindow(apply_focus_window);
        if (apply_focus_window->NavLastIds[0] == 0)
            NavInitWindow(apply_focus_window, false);
 
        // If the window has ONLY a menu layer (no main layer), select it directly
        // Use NavLayersActiveMaskNext since windows didn't have a chance to be Begin()-ed on this frame,
        // so CTRL+Tab where the keys are only held for 1 frame will be able to use correct layers mask since
        // the target window as already been previewed once.
        // FIXME-NAV: This should be done in NavInit.. or in FocusWindow... However in both of those cases,
        // we won't have a guarantee that windows has been visible before and therefore NavLayersActiveMask*
        // won't be valid.
        if (apply_focus_window->DC.NavLayersActiveMaskNext == (1 << ImGuiNavLayer_Menu))
            g.NavLayer = ImGuiNavLayer_Menu;
    }
    if (apply_focus_window)
        g.NavWindowingTarget = NULL;
 
    // Apply menu/layer toggle
    if (apply_toggle_layer && g.NavWindow)
    {
        ClearActiveID();
 
        // Move to parent menu if necessary
        ImGuiWindow* new_nav_window = g.NavWindow;
        while (new_nav_window->ParentWindow
            && (new_nav_window->DC.NavLayersActiveMask & (1 << ImGuiNavLayer_Menu)) == 0
            && (new_nav_window->Flags & ImGuiWindowFlags_ChildWindow) != 0
            && (new_nav_window->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu)) == 0)
            new_nav_window = new_nav_window->ParentWindow;
        if (new_nav_window != g.NavWindow)
        {
            ImGuiWindow* old_nav_window = g.NavWindow;
            FocusWindow(new_nav_window);
            new_nav_window->NavLastChildNavWindow = old_nav_window;
        }
        g.NavDisableHighlight = false;
        g.NavDisableMouseHover = true;
 
        // Reinitialize navigation when entering menu bar with the Alt key.
        const ImGuiNavLayer new_nav_layer = (g.NavWindow->DC.NavLayersActiveMask & (1 << ImGuiNavLayer_Menu)) ? (ImGuiNavLayer)((int)g.NavLayer ^ 1) : ImGuiNavLayer_Main;
        if (new_nav_layer == ImGuiNavLayer_Menu)
            g.NavWindow->NavLastIds[new_nav_layer] = 0;
        NavRestoreLayer(new_nav_layer);
    }
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdAllowOverlap, ClearActiveID(), ClosePopupsOverWindow(), ImGuiIO::ConfigFlags, ImGuiWindow::DC, ImGuiIO::DeltaTime, ImGuiContext::DimBgRatio, ImGuiIO::DisplayFramebufferScale, FindWindowNavFocusable(), ImGuiWindow::Flags, FocusWindow(), GetNavInputAmount2d(), GetTopMostPopupModal(), GImGui, ImFloor(), ImGuiCond_Always, ImGuiConfigFlags_NavEnableKeyboard, ImGuiInputReadMode_Down, ImGuiInputReadMode_Pressed, ImGuiInputReadMode_Released, ImGuiInputReadMode_RepeatSlow, ImGuiInputSource_Gamepad, ImGuiInputSource_Keyboard, ImGuiKey_Tab, ImGuiNavDirSourceFlags_Keyboard, ImGuiNavDirSourceFlags_PadLStick, ImGuiNavInput_FocusNext, ImGuiNavInput_FocusPrev, ImGuiNavInput_KeyMenu_, ImGuiNavInput_Menu, ImGuiNavLayer_Main, ImGuiNavLayer_Menu, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_Popup, ImMax(), ImMin(), ImSaturate(), ImGuiContext::IO, IsKeyPressedMap(), IsMousePosValid(), IsNavInputDown(), IsNavInputTest(), ImGuiIO::KeyCtrl, ImGuiIO::KeyShift, MarkIniSettingsDirty(), ImGuiIO::MousePos, ImGuiIO::MousePosPrev, NAV_WINDOWING_HIGHLIGHT_DELAY, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, NavInitWindow(), ImGuiContext::NavInputSource, ImGuiWindow::NavLastChildNavWindow, ImGuiWindow::NavLastIds, ImGuiContext::NavLayer, ImGuiWindowTempData::NavLayersActiveMask, ImGuiWindowTempData::NavLayersActiveMaskNext, NavRestoreLastChildNavWindow(), NavRestoreLayer(), NavUpdateWindowingHighlightWindow(), ImGuiContext::NavWindow, ImGuiContext::NavWindowingHighlightAlpha, ImGuiContext::NavWindowingTarget, ImGuiContext::NavWindowingTargetAnim, ImGuiContext::NavWindowingTimer, ImGuiContext::NavWindowingToggleLayer, ImGuiWindow::ParentWindow, ImGuiWindow::Pos, ImGuiWindow::RootWindow, SetWindowPos(), ImVector< T >::Size, ImGuiContext::WindowsFocusOrder, ImVec2::x, and ImVec2::y.

Referenced by NavUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NavUpdateWindowingOverlay()

void ImGui::NavUpdateWindowingOverlay ( )

static

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavWindowingTarget != NULL);
 
    if (g.NavWindowingTimer < NAV_WINDOWING_LIST_APPEAR_DELAY)
        return;
 
    if (g.NavWindowingListWindow == NULL)
        g.NavWindowingListWindow = FindWindowByName("###NavWindowingList");
    const ImGuiViewport* viewport = GetMainViewport();
    SetNextWindowSizeConstraints(ImVec2(viewport->Size.x * 0.20f, viewport->Size.y * 0.20f), ImVec2(FLT_MAX, FLT_MAX));
    SetNextWindowPos(viewport->GetCenter(), ImGuiCond_Always, ImVec2(0.5f, 0.5f));
    PushStyleVar(ImGuiStyleVar_WindowPadding, g.Style.WindowPadding * 2.0f);
    Begin("###NavWindowingList", NULL, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings);
    for (int n = g.WindowsFocusOrder.Size - 1; n >= 0; n--)
    {
        ImGuiWindow* window = g.WindowsFocusOrder[n];
        IM_ASSERT(window != NULL); // Fix static analyzers
        if (!IsWindowNavFocusable(window))
            continue;
        const char* label = window->Name;
        if (label == FindRenderedTextEnd(label))
            label = GetFallbackWindowNameForWindowingList(window);
        Selectable(label, g.NavWindowingTarget == window);
    }
    End();
    PopStyleVar();
}

References Begin(), End(), FindRenderedTextEnd(), FindWindowByName(), ImGuiViewport::GetCenter(), GetFallbackWindowNameForWindowingList(), GetMainViewport(), GImGui, IM_ASSERT, ImGuiCond_Always, ImGuiStyleVar_WindowPadding, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoFocusOnAppearing, ImGuiWindowFlags_NoInputs, ImGuiWindowFlags_NoMove, ImGuiWindowFlags_NoResize, ImGuiWindowFlags_NoSavedSettings, ImGuiWindowFlags_NoTitleBar, IsWindowNavFocusable(), ImGuiWindow::Name, NAV_WINDOWING_LIST_APPEAR_DELAY, ImGuiContext::NavWindowingListWindow, ImGuiContext::NavWindowingTarget, ImGuiContext::NavWindowingTimer, PopStyleVar(), PushStyleVar(), Selectable(), SetNextWindowPos(), SetNextWindowSizeConstraints(), ImVector< T >::Size, ImGuiViewport::Size, ImGuiContext::Style, ImGuiStyle::WindowPadding, ImGuiContext::WindowsFocusOrder, ImVec2::x, and ImVec2::y.

Referenced by NavEndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewFrame()

void ImGui::NewFrame ( )

{
    IM_ASSERT(GImGui != NULL && "No current context. Did you call ImGui::CreateContext() and ImGui::SetCurrentContext() ?");
    ImGuiContext& g = *GImGui;
 
    // Remove pending delete hooks before frame start.
    // This deferred removal avoid issues of removal while iterating the hook vector
    for (int n = g.Hooks.Size - 1; n >= 0; n--)
        if (g.Hooks[n].Type == ImGuiContextHookType_PendingRemoval_)
            g.Hooks.erase(&g.Hooks[n]);
 
    CallContextHooks(&g, ImGuiContextHookType_NewFramePre);
 
    // Check and assert for various common IO and Configuration mistakes
    ErrorCheckNewFrameSanityChecks();
 
    // Load settings on first frame, save settings when modified (after a delay)
    UpdateSettings();
 
    g.Time += g.IO.DeltaTime;
    g.WithinFrameScope = true;
    g.FrameCount += 1;
    g.TooltipOverrideCount = 0;
    g.WindowsActiveCount = 0;
    g.MenusIdSubmittedThisFrame.resize(0);
 
    // Calculate frame-rate for the user, as a purely luxurious feature
    g.FramerateSecPerFrameAccum += g.IO.DeltaTime - g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx];
    g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx] = g.IO.DeltaTime;
    g.FramerateSecPerFrameIdx = (g.FramerateSecPerFrameIdx + 1) % IM_ARRAYSIZE(g.FramerateSecPerFrame);
    g.FramerateSecPerFrameCount = ImMin(g.FramerateSecPerFrameCount + 1, IM_ARRAYSIZE(g.FramerateSecPerFrame));
    g.IO.Framerate = (g.FramerateSecPerFrameAccum > 0.0f) ? (1.0f / (g.FramerateSecPerFrameAccum / (float)g.FramerateSecPerFrameCount)) : FLT_MAX;
 
    UpdateViewportsNewFrame();
 
    // Setup current font and draw list shared data
    g.IO.Fonts->Locked = true;
    SetCurrentFont(GetDefaultFont());
    IM_ASSERT(g.Font->IsLoaded());
    ImRect virtual_space(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
    for (int n = 0; n < g.Viewports.Size; n++)
        virtual_space.Add(g.Viewports[n]->GetMainRect());
    g.DrawListSharedData.ClipRectFullscreen = virtual_space.ToVec4();
    g.DrawListSharedData.CurveTessellationTol = g.Style.CurveTessellationTol;
    g.DrawListSharedData.SetCircleTessellationMaxError(g.Style.CircleTessellationMaxError);
    g.DrawListSharedData.InitialFlags = ImDrawListFlags_None;
    if (g.Style.AntiAliasedLines)
        g.DrawListSharedData.InitialFlags |= ImDrawListFlags_AntiAliasedLines;
    if (g.Style.AntiAliasedLinesUseTex && !(g.Font->ContainerAtlas->Flags & ImFontAtlasFlags_NoBakedLines))
        g.DrawListSharedData.InitialFlags |= ImDrawListFlags_AntiAliasedLinesUseTex;
    if (g.Style.AntiAliasedFill)
        g.DrawListSharedData.InitialFlags |= ImDrawListFlags_AntiAliasedFill;
    if (g.IO.BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset)
        g.DrawListSharedData.InitialFlags |= ImDrawListFlags_AllowVtxOffset;
 
    // Mark rendering data as invalid to prevent user who may have a handle on it to use it.
    for (int n = 0; n < g.Viewports.Size; n++)
    {
        ImGuiViewportP* viewport = g.Viewports[n];
        viewport->DrawDataP.Clear();
    }
 
    // Drag and drop keep the source ID alive so even if the source disappear our state is consistent
    if (g.DragDropActive && g.DragDropPayload.SourceId == g.ActiveId)
        KeepAliveID(g.DragDropPayload.SourceId);
 
    // Update HoveredId data
    if (!g.HoveredIdPreviousFrame)
        g.HoveredIdTimer = 0.0f;
    if (!g.HoveredIdPreviousFrame || (g.HoveredId && g.ActiveId == g.HoveredId))
        g.HoveredIdNotActiveTimer = 0.0f;
    if (g.HoveredId)
        g.HoveredIdTimer += g.IO.DeltaTime;
    if (g.HoveredId && g.ActiveId != g.HoveredId)
        g.HoveredIdNotActiveTimer += g.IO.DeltaTime;
    g.HoveredIdPreviousFrame = g.HoveredId;
    g.HoveredIdPreviousFrameUsingMouseWheel = g.HoveredIdUsingMouseWheel;
    g.HoveredId = 0;
    g.HoveredIdAllowOverlap = false;
    g.HoveredIdUsingMouseWheel = false;
    g.HoveredIdDisabled = false;
 
    // Update ActiveId data (clear reference to active widget if the widget isn't alive anymore)
    if (g.ActiveIdIsAlive != g.ActiveId && g.ActiveIdPreviousFrame == g.ActiveId && g.ActiveId != 0)
        ClearActiveID();
    if (g.ActiveId)
        g.ActiveIdTimer += g.IO.DeltaTime;
    g.LastActiveIdTimer += g.IO.DeltaTime;
    g.ActiveIdPreviousFrame = g.ActiveId;
    g.ActiveIdPreviousFrameWindow = g.ActiveIdWindow;
    g.ActiveIdPreviousFrameHasBeenEditedBefore = g.ActiveIdHasBeenEditedBefore;
    g.ActiveIdIsAlive = 0;
    g.ActiveIdHasBeenEditedThisFrame = false;
    g.ActiveIdPreviousFrameIsAlive = false;
    g.ActiveIdIsJustActivated = false;
    if (g.TempInputId != 0 && g.ActiveId != g.TempInputId)
        g.TempInputId = 0;
    if (g.ActiveId == 0)
    {
        g.ActiveIdUsingNavDirMask = 0x00;
        g.ActiveIdUsingNavInputMask = 0x00;
        g.ActiveIdUsingKeyInputMask = 0x00;
    }
 
    // Drag and drop
    g.DragDropAcceptIdPrev = g.DragDropAcceptIdCurr;
    g.DragDropAcceptIdCurr = 0;
    g.DragDropAcceptIdCurrRectSurface = FLT_MAX;
    g.DragDropWithinSource = false;
    g.DragDropWithinTarget = false;
    g.DragDropHoldJustPressedId = 0;
 
    // Update keyboard input state
    // Synchronize io.KeyMods with individual modifiers io.KeyXXX bools
    g.IO.KeyMods = GetMergedKeyModFlags();
    memcpy(g.IO.KeysDownDurationPrev, g.IO.KeysDownDuration, sizeof(g.IO.KeysDownDuration));
    for (int i = 0; i < IM_ARRAYSIZE(g.IO.KeysDown); i++)
        g.IO.KeysDownDuration[i] = g.IO.KeysDown[i] ? (g.IO.KeysDownDuration[i] < 0.0f ? 0.0f : g.IO.KeysDownDuration[i] + g.IO.DeltaTime) : -1.0f;
 
    // Update gamepad/keyboard navigation
    NavUpdate();
 
    // Update mouse input state
    UpdateMouseInputs();
 
    // Find hovered window
    // (needs to be before UpdateMouseMovingWindowNewFrame so we fill g.HoveredWindowUnderMovingWindow on the mouse release frame)
    UpdateHoveredWindowAndCaptureFlags();
 
    // Handle user moving window with mouse (at the beginning of the frame to avoid input lag or sheering)
    UpdateMouseMovingWindowNewFrame();
 
    // Background darkening/whitening
    if (GetTopMostPopupModal() != NULL || (g.NavWindowingTarget != NULL && g.NavWindowingHighlightAlpha > 0.0f))
        g.DimBgRatio = ImMin(g.DimBgRatio + g.IO.DeltaTime * 6.0f, 1.0f);
    else
        g.DimBgRatio = ImMax(g.DimBgRatio - g.IO.DeltaTime * 10.0f, 0.0f);
 
    g.MouseCursor = ImGuiMouseCursor_Arrow;
    g.WantCaptureMouseNextFrame = g.WantCaptureKeyboardNextFrame = g.WantTextInputNextFrame = -1;
    g.PlatformImePos = ImVec2(1.0f, 1.0f); // OS Input Method Editor showing on top-left of our window by default
 
    // Mouse wheel scrolling, scale
    UpdateMouseWheel();
 
    // Update legacy TAB focus
    UpdateTabFocus();
 
    // Mark all windows as not visible and compact unused memory.
    IM_ASSERT(g.WindowsFocusOrder.Size <= g.Windows.Size);
    const float memory_compact_start_time = (g.GcCompactAll || g.IO.ConfigMemoryCompactTimer < 0.0f) ? FLT_MAX : (float)g.Time - g.IO.ConfigMemoryCompactTimer;
    for (int i = 0; i != g.Windows.Size; i++)
    {
        ImGuiWindow* window = g.Windows[i];
        window->WasActive = window->Active;
        window->BeginCount = 0;
        window->Active = false;
        window->WriteAccessed = false;
 
        // Garbage collect transient buffers of recently unused windows
        if (!window->WasActive && !window->MemoryCompacted && window->LastTimeActive < memory_compact_start_time)
            GcCompactTransientWindowBuffers(window);
    }
 
    // Garbage collect transient buffers of recently unused tables
    for (int i = 0; i < g.TablesLastTimeActive.Size; i++)
        if (g.TablesLastTimeActive[i] >= 0.0f && g.TablesLastTimeActive[i] < memory_compact_start_time)
            TableGcCompactTransientBuffers(g.Tables.GetByIndex(i));
    for (int i = 0; i < g.TablesTempDataStack.Size; i++)
        if (g.TablesTempDataStack[i].LastTimeActive >= 0.0f && g.TablesTempDataStack[i].LastTimeActive < memory_compact_start_time)
            TableGcCompactTransientBuffers(&g.TablesTempDataStack[i]);
    if (g.GcCompactAll)
        GcCompactTransientMiscBuffers();
    g.GcCompactAll = false;
 
    // Closing the focused window restore focus to the first active root window in descending z-order
    if (g.NavWindow && !g.NavWindow->WasActive)
        FocusTopMostWindowUnderOne(NULL, NULL);
 
    // No window should be open at the beginning of the frame.
    // But in order to allow the user to call NewFrame() multiple times without calling Render(), we are doing an explicit clear.
    g.CurrentWindowStack.resize(0);
    g.BeginPopupStack.resize(0);
    g.ItemFlagsStack.resize(0);
    g.ItemFlagsStack.push_back(ImGuiItemFlags_None);
    g.GroupStack.resize(0);
    ClosePopupsOverWindow(g.NavWindow, false);
 
    // [DEBUG] Item picker tool - start with DebugStartItemPicker() - useful to visually select an item and break into its call-stack.
    UpdateDebugToolItemPicker();
 
    // Create implicit/fallback window - which we will only render it if the user has added something to it.
    // We don't use "Debug" to avoid colliding with user trying to create a "Debug" window with custom flags.
    // This fallback is particularly important as it avoid ImGui:: calls from crashing.
    g.WithinFrameScopeWithImplicitWindow = true;
    SetNextWindowSize(ImVec2(400, 400), ImGuiCond_FirstUseEver);
    Begin("Debug##Default");
    IM_ASSERT(g.CurrentWindow->IsFallbackWindow == true);
 
    CallContextHooks(&g, ImGuiContextHookType_NewFramePost);
}

Referenced by Slic3r::GUI::ImGuiWrapper::new_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewLine()

void ImGui::NewLine ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    const ImGuiLayoutType backup_layout_type = window->DC.LayoutType;
    window->DC.LayoutType = ImGuiLayoutType_Vertical;
    if (window->DC.CurrLineSize.y > 0.0f)     // In the event that we are on a line with items that is smaller that FontSize high, we will preserve its height.
        ItemSize(ImVec2(0, 0));
    else
        ItemSize(ImVec2(0.0f, g.FontSize));
    window->DC.LayoutType = backup_layout_type;
}

References ImGuiWindowTempData::CurrLineSize, ImGuiWindow::DC, ImGuiContext::FontSize, GetCurrentWindow(), GImGui, ImGuiLayoutType_Vertical, ItemSize(), ImGuiWindowTempData::LayoutType, ImGuiWindow::SkipItems, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NextColumn()

void ImGui::NextColumn ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems || window->DC.CurrentColumns == NULL)
        return;
 
    ImGuiContext& g = *GImGui;
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
 
    if (columns->Count == 1)
    {
        window->DC.CursorPos.x = IM_FLOOR(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
        IM_ASSERT(columns->Current == 0);
        return;
    }
 
    // Next column
    if (++columns->Current == columns->Count)
        columns->Current = 0;
 
    PopItemWidth();
 
    // Optimization: avoid PopClipRect() + SetCurrentChannel() + PushClipRect()
    // (which would needlessly attempt to update commands in the wrong channel, then pop or overwrite them),
    ImGuiOldColumnData* column = &columns->Columns[columns->Current];
    SetWindowClipRectBeforeSetChannel(window, column->ClipRect);
    columns->Splitter.SetCurrentChannel(window->DrawList, columns->Current + 1);
 
    const float column_padding = g.Style.ItemSpacing.x;
    columns->LineMaxY = ImMax(columns->LineMaxY, window->DC.CursorPos.y);
    if (columns->Current > 0)
    {
        // Columns 1+ ignore IndentX (by canceling it out)
        // FIXME-COLUMNS: Unnecessary, could be locked?
        window->DC.ColumnsOffset.x = GetColumnOffset(columns->Current) - window->DC.Indent.x + column_padding;
    }
    else
    {
        // New row/line: column 0 honor IndentX.
        window->DC.ColumnsOffset.x = ImMax(column_padding - window->WindowPadding.x, 0.0f);
        columns->LineMinY = columns->LineMaxY;
    }
    window->DC.CursorPos.x = IM_FLOOR(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
    window->DC.CursorPos.y = columns->LineMinY;
    window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
    window->DC.CurrLineTextBaseOffset = 0.0f;
 
    // FIXME-COLUMNS: Share code with BeginColumns() - move code on columns setup.
    float offset_0 = GetColumnOffset(columns->Current);
    float offset_1 = GetColumnOffset(columns->Current + 1);
    float width = offset_1 - offset_0;
    PushItemWidth(width * 0.65f);
    window->WorkRect.Max.x = window->Pos.x + offset_1 - column_padding;
}

References ImGuiOldColumnData::ClipRect, ImGuiOldColumns::Columns, ImGuiWindowTempData::ColumnsOffset, ImGuiOldColumns::Count, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindowTempData::CurrLineSize, ImGuiWindowTempData::CurrLineTextBaseOffset, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, GetColumnOffset(), GetCurrentWindow(), GImGui, IM_ASSERT, IM_FLOOR, ImMax(), ImGuiWindowTempData::Indent, ImGuiStyle::ItemSpacing, ImGuiOldColumns::LineMaxY, ImGuiOldColumns::LineMinY, ImRect::Max, PopItemWidth(), ImGuiWindow::Pos, PushItemWidth(), ImDrawListSplitter::SetCurrentChannel(), SetWindowClipRectBeforeSetChannel(), ImGuiWindow::SkipItems, ImGuiOldColumns::Splitter, ImGuiContext::Style, ImGuiWindow::WindowPadding, ImGuiWindow::WorkRect, ImVec2::x, ImVec1::x, and ImVec2::y.

Referenced by ShowDemoWindowColumns(), ShowDemoWindowLayout(), and ShowPlaceholderObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OpenPopup() [1/2]

void ImGui::OpenPopup	(	const char *	str_id,
		ImGuiPopupFlags	popup_flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    OpenPopupEx(g.CurrentWindow->GetID(str_id), popup_flags);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetID(), GImGui, and OpenPopupEx().

Referenced by BeginMenu(), ColorEdit4(), ColorEditOptionsPopup(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_add_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_button(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppDocuments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OpenPopup() [2/2]

void ImGui::OpenPopup	(	ImGuiID	id,
		ImGuiPopupFlags	popup_flags = `0`
	)

{
    OpenPopupEx(id, popup_flags);
}

References OpenPopupEx().

Here is the call graph for this function:

◆ OpenPopupContextItem()

static void ImGui::OpenPopupContextItem	(	const char *	str_id = `NULL`,
		ImGuiMouseButton	mb = `1`
	)

inlinestatic

2789{ OpenPopupOnItemClick(str_id, mb); } // Bool return value removed. Use IsWindowAppearing() in BeginPopup() instead. Renamed in 1.77, renamed back in 1.79. Sorry!

References OpenPopupContextItem(), and OpenPopupOnItemClick().

Referenced by OpenPopupContextItem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OpenPopupEx()

void ImGui::OpenPopupEx	(	ImGuiID	id,
		ImGuiPopupFlags	popup_flags = `ImGuiPopupFlags_None`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* parent_window = g.CurrentWindow;
    const int current_stack_size = g.BeginPopupStack.Size;
 
    if (popup_flags & ImGuiPopupFlags_NoOpenOverExistingPopup)
        if (IsPopupOpen(0u, ImGuiPopupFlags_AnyPopupId))
            return;
 
    ImGuiPopupData popup_ref; // Tagged as new ref as Window will be set back to NULL if we write this into OpenPopupStack.
    popup_ref.PopupId = id;
    popup_ref.Window = NULL;
    popup_ref.SourceWindow = g.NavWindow;
    popup_ref.OpenFrameCount = g.FrameCount;
    popup_ref.OpenParentId = parent_window->IDStack.back();
    popup_ref.OpenPopupPos = NavCalcPreferredRefPos();
    popup_ref.OpenMousePos = IsMousePosValid(&g.IO.MousePos) ? g.IO.MousePos : popup_ref.OpenPopupPos;
 
    IMGUI_DEBUG_LOG_POPUP("OpenPopupEx(0x%08X)\n", id);
    if (g.OpenPopupStack.Size < current_stack_size + 1)
    {
        g.OpenPopupStack.push_back(popup_ref);
    }
    else
    {
        // Gently handle the user mistakenly calling OpenPopup() every frame. It is a programming mistake! However, if we were to run the regular code path, the ui
        // would become completely unusable because the popup will always be in hidden-while-calculating-size state _while_ claiming focus. Which would be a very confusing
        // situation for the programmer. Instead, we silently allow the popup to proceed, it will keep reappearing and the programming error will be more obvious to understand.
        if (g.OpenPopupStack[current_stack_size].PopupId == id && g.OpenPopupStack[current_stack_size].OpenFrameCount == g.FrameCount - 1)
        {
            g.OpenPopupStack[current_stack_size].OpenFrameCount = popup_ref.OpenFrameCount;
        }
        else
        {
            // Close child popups if any, then flag popup for open/reopen
            ClosePopupToLevel(current_stack_size, false);
            g.OpenPopupStack.push_back(popup_ref);
        }
 
        // When reopening a popup we first refocus its parent, otherwise if its parent is itself a popup it would get closed by ClosePopupsOverWindow().
        // This is equivalent to what ClosePopupToLevel() does.
        //if (g.OpenPopupStack[current_stack_size].PopupId == id)
        //    FocusWindow(parent_window);
    }
}

References ImVector< T >::back(), ImGuiContext::BeginPopupStack, ClosePopupToLevel(), ImGuiContext::CurrentWindow, ImGuiContext::FrameCount, GImGui, ImGuiWindow::IDStack, IMGUI_DEBUG_LOG_POPUP, ImGuiPopupFlags_AnyPopupId, ImGuiPopupFlags_NoOpenOverExistingPopup, ImGuiContext::IO, IsMousePosValid(), IsPopupOpen(), ImGuiIO::MousePos, NavCalcPreferredRefPos(), ImGuiContext::NavWindow, ImGuiPopupData::OpenFrameCount, ImGuiPopupData::OpenMousePos, ImGuiPopupData::OpenParentId, ImGuiPopupData::OpenPopupPos, ImGuiContext::OpenPopupStack, ImGuiPopupData::PopupId, ImVector< T >::push_back(), ImVector< T >::Size, ImGuiPopupData::SourceWindow, and ImGuiPopupData::Window.

Referenced by BeginCombo(), BeginPopupContextItem(), BeginPopupContextVoid(), BeginPopupContextWindow(), OpenPopup(), OpenPopup(), OpenPopupOnItemClick(), and TableOpenContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OpenPopupOnItemClick()

void ImGui::OpenPopupOnItemClick	(	const char *	str_id = `NULL`,
		ImGuiPopupFlags	popup_flags = `1`
	)

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
    {
        ImGuiID id = str_id ? window->GetID(str_id) : window->DC.LastItemId; // If user hasn't passed an ID, we can use the LastItemID. Using LastItemID as a Popup ID won't conflict!
        IM_ASSERT(id != 0);                                                  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a Text() item)
        OpenPopupEx(id, popup_flags);
    }
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiWindow::GetID(), GImGui, IM_ASSERT, ImGuiHoveredFlags_AllowWhenBlockedByPopup, ImGuiPopupFlags_MouseButtonMask_, IsItemHovered(), IsMouseReleased(), ImGuiWindowTempData::LastItemId, and OpenPopupEx().

Referenced by ColorEdit4(), ColorPicker4(), OpenPopupContextItem(), ShowDemoWindowPopups(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlotEx()

int ImGui::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,
		ImVec2	frame_size
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return -1;
 
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
 
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
    if (frame_size.x == 0.0f)
        frame_size.x = CalcItemWidth();
    if (frame_size.y == 0.0f)
        frame_size.y = label_size.y + (style.FramePadding.y * 2);
 
    const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);
    const ImRect inner_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
    const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, 0, &frame_bb))
        return -1;
    const bool hovered = ItemHoverable(frame_bb, id);
 
    // Determine scale from values if not specified
    if (scale_min == FLT_MAX || scale_max == FLT_MAX)
    {
        float v_min = FLT_MAX;
        float v_max = -FLT_MAX;
        for (int i = 0; i < values_count; i++)
        {
            const float v = values_getter(data, i);
            if (v != v) // Ignore NaN values
                continue;
            v_min = ImMin(v_min, v);
            v_max = ImMax(v_max, v);
        }
        if (scale_min == FLT_MAX)
            scale_min = v_min;
        if (scale_max == FLT_MAX)
            scale_max = v_max;
    }
 
    RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
 
    const int values_count_min = (plot_type == ImGuiPlotType_Lines) ? 2 : 1;
    int idx_hovered = -1;
    if (values_count >= values_count_min)
    {
        int res_w = ImMin((int)frame_size.x, values_count) + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
        int item_count = values_count + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
 
        // Tooltip on hover
        if (hovered && inner_bb.Contains(g.IO.MousePos))
        {
            const float t = ImClamp((g.IO.MousePos.x - inner_bb.Min.x) / (inner_bb.Max.x - inner_bb.Min.x), 0.0f, 0.9999f);
            const int v_idx = (int)(t * item_count);
            IM_ASSERT(v_idx >= 0 && v_idx < values_count);
 
            const float v0 = values_getter(data, (v_idx + values_offset) % values_count);
            const float v1 = values_getter(data, (v_idx + 1 + values_offset) % values_count);
            if (plot_type == ImGuiPlotType_Lines)
                SetTooltip("%d: %8.4g\n%d: %8.4g", v_idx, v0, v_idx + 1, v1);
            else if (plot_type == ImGuiPlotType_Histogram)
                SetTooltip("%d: %8.4g", v_idx, v0);
            idx_hovered = v_idx;
        }
 
        const float t_step = 1.0f / (float)res_w;
        const float inv_scale = (scale_min == scale_max) ? 0.0f : (1.0f / (scale_max - scale_min));
 
        float v0 = values_getter(data, (0 + values_offset) % values_count);
        float t0 = 0.0f;
        ImVec2 tp0 = ImVec2( t0, 1.0f - ImSaturate((v0 - scale_min) * inv_scale) );                       // Point in the normalized space of our target rectangle
        float histogram_zero_line_t = (scale_min * scale_max < 0.0f) ? (-scale_min * inv_scale) : (scale_min < 0.0f ? 0.0f : 1.0f);   // Where does the zero line stands
 
        const ImU32 col_base = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLines : ImGuiCol_PlotHistogram);
        const ImU32 col_hovered = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLinesHovered : ImGuiCol_PlotHistogramHovered);
 
        for (int n = 0; n < res_w; n++)
        {
            const float t1 = t0 + t_step;
            const int v1_idx = (int)(t0 * item_count + 0.5f);
            IM_ASSERT(v1_idx >= 0 && v1_idx < values_count);
            const float v1 = values_getter(data, (v1_idx + values_offset + 1) % values_count);
            const ImVec2 tp1 = ImVec2( t1, 1.0f - ImSaturate((v1 - scale_min) * inv_scale) );
 
            // NB: Draw calls are merged together by the DrawList system. Still, we should render our batch are lower level to save a bit of CPU.
            ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, tp0);
            ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, (plot_type == ImGuiPlotType_Lines) ? tp1 : ImVec2(tp1.x, histogram_zero_line_t));
            if (plot_type == ImGuiPlotType_Lines)
            {
                window->DrawList->AddLine(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base);
            }
            else if (plot_type == ImGuiPlotType_Histogram)
            {
                if (pos1.x >= pos0.x + 2.0f)
                    pos1.x -= 1.0f;
                window->DrawList->AddRectFilled(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base);
            }
 
            t0 = t1;
            tp0 = tp1;
        }
    }
 
    // Text overlay
    if (overlay_text)
        RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, overlay_text, NULL, NULL, ImVec2(0.5f, 0.0f));
 
    if (label_size.x > 0.0f)
        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, inner_bb.Min.y), label);
 
    // Return hovered index or -1 if none are hovered.
    // This is currently not exposed in the public API because we need a larger redesign of the whole thing, but in the short-term we are making it available in PlotEx().
    return idx_hovered;
}

References ImDrawList::AddLine(), ImDrawList::AddRectFilled(), CalcItemWidth(), CalcTextSize(), ImRect::Contains(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, GetColorU32(), GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, IM_ASSERT, ImClamp(), ImGuiCol_FrameBg, ImGuiCol_PlotHistogram, ImGuiCol_PlotHistogramHovered, ImGuiCol_PlotLines, ImGuiCol_PlotLinesHovered, ImGuiPlotType_Histogram, ImGuiPlotType_Lines, ImLerp(), ImMax(), ImMin(), ImSaturate(), ImGuiContext::IO, ItemAdd(), ItemHoverable(), ItemSize(), ImRect::Max, ImRect::Min, ImGuiIO::MousePos, RenderFrame(), RenderText(), RenderTextClipped(), SetTooltip(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by PlotHistogram(), PlotHistogram(), PlotLines(), and PlotLines().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlotHistogram() [1/2]

void ImGui::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)`
	)

{
    ImGuiPlotArrayGetterData data(values, stride);
    PlotEx(ImGuiPlotType_Histogram, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}

References ImGuiPlotType_Histogram, Plot_ArrayGetter(), and PlotEx().

Referenced by ShowDemoWindowLayout(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlotHistogram() [2/2]

void ImGui::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)`
	)

{
    PlotEx(ImGuiPlotType_Histogram, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}

References ImGuiPlotType_Histogram, and PlotEx().

Here is the call graph for this function:

◆ PlotLines() [1/2]

void ImGui::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)`
	)

{
    ImGuiPlotArrayGetterData data(values, stride);
    PlotEx(ImGuiPlotType_Lines, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}

References ImGuiPlotType_Lines, Plot_ArrayGetter(), and PlotEx().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlotLines() [2/2]

void ImGui::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)`
	)

{
    PlotEx(ImGuiPlotType_Lines, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}

References ImGuiPlotType_Lines, and PlotEx().

Here is the call graph for this function:

◆ PopAllowKeyboardFocus()

void ImGui::PopAllowKeyboardFocus ( )

{
    PopItemFlag();
}

References PopItemFlag().

Referenced by LogButtons(), and ShowDemoWindowMisc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopButtonRepeat()

void ImGui::PopButtonRepeat ( )

{
    PopItemFlag();
}

References PopItemFlag().

Referenced by ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopClipRect()

void ImGui::PopClipRect ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DrawList->PopClipRect();
    window->ClipRect = window->DrawList->_ClipRectStack.back();
}

References ImDrawList::_ClipRectStack, ImVector< T >::back(), ImGuiWindow::ClipRect, ImGuiWindow::DrawList, GetCurrentWindow(), and ImDrawList::PopClipRect().

Referenced by End(), EndColumns(), EndMenuBar(), ShowDemoWindowLayout(), and TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopColumnsBackground()

void ImGui::PopColumnsBackground ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns->Count == 1)
        return;
 
    // Optimization: avoid PopClipRect() + SetCurrentChannel()
    SetWindowClipRectBeforeSetChannel(window, columns->HostBackupClipRect);
    columns->Splitter.SetCurrentChannel(window->DrawList, columns->Current + 1);
}

References ImGuiOldColumns::Count, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, ImGuiWindow::DrawList, GetCurrentWindowRead(), ImGuiOldColumns::HostBackupClipRect, ImDrawListSplitter::SetCurrentChannel(), SetWindowClipRectBeforeSetChannel(), and ImGuiOldColumns::Splitter.

Referenced by Slic3r::GUI::selectable(), Selectable(), and SeparatorEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopFocusScope()

void ImGui::PopFocusScope ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.FocusScopeStack.Size > 0); // Too many PopFocusScope() ?
    window->DC.NavFocusScopeIdCurrent = g.FocusScopeStack.back();
    g.FocusScopeStack.pop_back();
}

References ImVector< T >::back(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiContext::FocusScopeStack, GImGui, IM_ASSERT, ImGuiWindowTempData::NavFocusScopeIdCurrent, ImVector< T >::pop_back(), and ImVector< T >::Size.

Referenced by ErrorCheckEndFrameRecover().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopFont()

void ImGui::PopFont ( )

{
    ImGuiContext& g = *GImGui;
    g.CurrentWindow->DrawList->PopTextureID();
    g.FontStack.pop_back();
    SetCurrentFont(g.FontStack.empty() ? GetDefaultFont() : g.FontStack.back());
}

References ImVector< T >::back(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImVector< T >::empty(), ImGuiContext::FontStack, GetDefaultFont(), GImGui, ImVector< T >::pop_back(), ImDrawList::PopTextureID(), and SetCurrentFont().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input(), InputTextEx(), and ShowFont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopID()

void ImGui::PopID ( )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    IM_ASSERT(window->IDStack.Size > 1); // Too many PopID(), or could be popping in a wrong/different window?
    window->IDStack.pop_back();
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::IDStack, IM_ASSERT, ImVector< T >::pop_back(), and ImVector< T >::Size.

Referenced by ColorEdit4(), ColorPicker4(), ColorPickerOptionsPopup(), DebugNodeTabBar(), DebugNodeWindowsList(), MyDocument::DisplayContents(), DragFloatRange2(), DragIntRange2(), DragScalarN(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), EndMenuBar(), EndTabBar(), EndTabItem(), EndTable(), ErrorCheckEndFrameRecover(), GetColumnsID(), Slic3r::GUI::ImGuiWrapper::image_button(), ImageButton(), InputScalar(), InputScalarN(), LogButtons(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::render_extruders_combo(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppDocuments(), ShowFontAtlas(), ShowFontSelector(), ShowPlaceholderObject(), ShowStyleEditor(), SliderScalarN(), TableHeadersRow(), TreePop(), and UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopItemFlag()

void ImGui::PopItemFlag ( )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.ItemFlagsStack.Size > 1); // Too many calls to PopItemFlag() - we always leave a 0 at the bottom of the stack.
    g.ItemFlagsStack.pop_back();
    g.CurrentItemFlags = g.ItemFlagsStack.back();
}

References ImVector< T >::back(), ImGuiContext::CurrentItemFlags, GImGui, IM_ASSERT, ImGuiContext::ItemFlagsStack, ImVector< T >::pop_back(), and ImVector< T >::Size.

Referenced by ColorPicker4(), Slic3r::GUI::ImGuiWrapper::disabled_end(), PopAllowKeyboardFocus(), PopButtonRepeat(), TabItemEx(), and TableDrawContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopItemWidth()

void ImGui::PopItemWidth ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.ItemWidth = window->DC.ItemWidthStack.back();
    window->DC.ItemWidthStack.pop_back();
}

References ImVector< T >::back(), ImGuiWindow::DC, GetCurrentWindow(), ImGuiWindowTempData::ItemWidth, ImGuiWindowTempData::ItemWidthStack, and ImVector< T >::pop_back().

Referenced by ColorPicker4(), ColorPickerOptionsPopup(), DragFloatRange2(), DragIntRange2(), DragScalarN(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), EndColumns(), InputScalarN(), NextColumn(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowExampleAppCustomRendering(), ShowStyleEditor(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopStyleColor()

void ImGui::PopStyleColor ( int count = 1 )

{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        ImGuiColorMod& backup = g.ColorStack.back();
        g.Style.Colors[backup.Col] = backup.BackupValue;
        g.ColorStack.pop_back();
        count--;
    }
}

References ImVector< T >::back(), ImGuiColorMod::BackupValue, ImGuiColorMod::Col, ImGuiStyle::Colors, ImGuiContext::ColorStack, GImGui, ImVector< T >::pop_back(), and ImGuiContext::Style.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopStyleVar()

void ImGui::PopStyleVar ( int count = 1 )

{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        // We avoid a generic memcpy(data, &backup.Backup.., GDataTypeSize[info->Type] * info->Count), the overhead in Debug is not worth it.
        ImGuiStyleMod& backup = g.StyleVarStack.back();
        const ImGuiStyleVarInfo* info = GetStyleVarInfo(backup.VarIdx);
        void* data = info->GetVarPtr(&g.Style);
        if (info->Type == ImGuiDataType_Float && info->Count == 1)      { ((float*)data)[0] = backup.BackupFloat[0]; }
        else if (info->Type == ImGuiDataType_Float && info->Count == 2) { ((float*)data)[0] = backup.BackupFloat[0]; ((float*)data)[1] = backup.BackupFloat[1]; }
        g.StyleVarStack.pop_back();
        count--;
    }
}

References ImVector< T >::back(), ImGuiStyleVarInfo::Count, GetStyleVarInfo(), ImGuiStyleVarInfo::GetVarPtr(), GImGui, ImGuiDataType_Float, ImVector< T >::pop_back(), ImGuiContext::Style, ImGuiContext::StyleVarStack, ImGuiStyleVarInfo::Type, and ImGuiStyleMod::VarIdx.

Referenced by BeginChildFrame(), BeginCombo(), BeginMenu(), BeginViewportSideBar(), Slic3r::GUI::ImGuiWrapper::disabled_end(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), Slic3r::GUI::GLGizmoEmboss::draw_window(), ErrorCheckEndFrameRecover(), InputTextEx(), MenuItem(), NavUpdateWindowingOverlay(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), PopStyleCompact(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GLGizmoCut3D::render_reset_button(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppLongText(), ShowExampleAppPropertyEditor(), Slic3r::GUI::ImGuiWrapper::slider_float(), TabItemLabelAndCloseButton(), and Slic3r::GUI::ImGuiWrapper::tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopTextWrapPos()

void ImGui::PopTextWrapPos ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.TextWrapPos = window->DC.TextWrapPosStack.back();
    window->DC.TextWrapPosStack.pop_back();
}

References ImVector< T >::back(), ImGuiWindow::DC, GetCurrentWindow(), ImVector< T >::pop_back(), ImGuiWindowTempData::TextWrapPos, and ImGuiWindowTempData::TextWrapPosStack.

Referenced by EditTableSizingFlags(), HelpMarker(), MetricsHelpMarker(), ShowDemoWindowWidgets(), Slic3r::GUI::ImGuiWrapper::text_wrapped(), TextWrappedV(), and Slic3r::GUI::ImGuiWrapper::tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProgressBar()

void ImGui::ProgressBar	(	float	fraction,
		const ImVec2 &	size_arg = `ImVec2(-FLT_MIN, 0)`,
		const char *	overlay = `NULL`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
 
    ImVec2 pos = window->DC.CursorPos;
    ImVec2 size = CalcItemSize(size_arg, CalcItemWidth(), g.FontSize + style.FramePadding.y * 2.0f);
    ImRect bb(pos, pos + size);
    ItemSize(size, style.FramePadding.y);
    if (!ItemAdd(bb, 0))
        return;
 
    // Render
    fraction = ImSaturate(fraction);
    RenderFrame(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
    bb.Expand(ImVec2(-style.FrameBorderSize, -style.FrameBorderSize));
    const ImVec2 fill_br = ImVec2(ImLerp(bb.Min.x, bb.Max.x, fraction), bb.Max.y);
    RenderRectFilledRangeH(window->DrawList, bb, GetColorU32(ImGuiCol_PlotHistogram), 0.0f, fraction, style.FrameRounding);
 
    // Default displaying the fraction as percentage string, but user can override it
    char overlay_buf[32];
    if (!overlay)
    {
        ImFormatString(overlay_buf, IM_ARRAYSIZE(overlay_buf), "%.0f%%", fraction * 100 + 0.01f);
        overlay = overlay_buf;
    }
 
    ImVec2 overlay_size = CalcTextSize(overlay, NULL);
    if (overlay_size.x > 0.0f)
        RenderTextClipped(ImVec2(ImClamp(fill_br.x + style.ItemSpacing.x, bb.Min.x, bb.Max.x - overlay_size.x - style.ItemInnerSpacing.x), bb.Min.y), bb.Max, overlay, NULL, &overlay_size, ImVec2(0.0f, 0.5f), &bb);
}

References CalcItemSize(), CalcItemWidth(), CalcTextSize(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImRect::Expand(), ImGuiContext::FontSize, GetColorU32(), GetCurrentWindow(), GImGui, IM_ARRAYSIZE, ImClamp(), ImFormatString(), ImGuiCol_FrameBg, ImGuiCol_PlotHistogram, ImLerp(), ImSaturate(), ItemAdd(), ItemSize(), ImRect::Max, ImRect::Min, RenderFrame(), RenderRectFilledRangeH(), RenderTextClipped(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushAllowKeyboardFocus()

void ImGui::PushAllowKeyboardFocus ( bool allow_keyboard_focus )

{
    PushItemFlag(ImGuiItemFlags_NoTabStop, !allow_keyboard_focus);
}

References ImGuiItemFlags_NoTabStop, and PushItemFlag().

Referenced by LogButtons(), and ShowDemoWindowMisc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushButtonRepeat()

void ImGui::PushButtonRepeat ( bool repeat )

{
    PushItemFlag(ImGuiItemFlags_ButtonRepeat, repeat);
}

References ImGuiItemFlags_ButtonRepeat, and PushItemFlag().

Referenced by ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushClipRect()

void ImGui::PushClipRect	(	const ImVec2 &	clip_rect_min,
		const ImVec2 &	clip_rect_max,
		bool	intersect_with_current_clip_rect
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DrawList->PushClipRect(clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
    window->ClipRect = window->DrawList->_ClipRectStack.back();
}

References ImDrawList::_ClipRectStack, ImVector< T >::back(), ImGuiWindow::ClipRect, ImGuiWindow::DrawList, GetCurrentWindow(), and ImDrawList::PushClipRect().

Referenced by Begin(), BeginMenuBar(), PushColumnClipRect(), ShowDemoWindowLayout(), and TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushColumnClipRect()

void ImGui::PushColumnClipRect ( int column_index )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (column_index < 0)
        column_index = columns->Current;
 
    ImGuiOldColumnData* column = &columns->Columns[column_index];
    PushClipRect(column->ClipRect.Min, column->ClipRect.Max, false);
}

References ImGuiOldColumnData::ClipRect, ImGuiOldColumns::Columns, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, GetCurrentWindowRead(), ImRect::Max, ImRect::Min, and PushClipRect().

Referenced by BeginColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushColumnsBackground()

void ImGui::PushColumnsBackground ( )

{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns->Count == 1)
        return;
 
    // Optimization: avoid SetCurrentChannel() + PushClipRect()
    columns->HostBackupClipRect = window->ClipRect;
    SetWindowClipRectBeforeSetChannel(window, columns->HostInitialClipRect);
    columns->Splitter.SetCurrentChannel(window->DrawList, 0);
}

References ImGuiWindow::ClipRect, ImGuiOldColumns::Count, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, ImGuiWindow::DrawList, GetCurrentWindowRead(), ImGuiOldColumns::HostBackupClipRect, ImGuiOldColumns::HostInitialClipRect, ImDrawListSplitter::SetCurrentChannel(), SetWindowClipRectBeforeSetChannel(), and ImGuiOldColumns::Splitter.

Referenced by Slic3r::GUI::selectable(), Selectable(), and SeparatorEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushFocusScope()

void ImGui::PushFocusScope ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    g.FocusScopeStack.push_back(window->DC.NavFocusScopeIdCurrent);
    window->DC.NavFocusScopeIdCurrent = id;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiContext::FocusScopeStack, GImGui, ImGuiWindowTempData::NavFocusScopeIdCurrent, and ImVector< T >::push_back().

Here is the call graph for this function:

◆ PushFont()

void ImGui::PushFont ( ImFont * font )

{
    ImGuiContext& g = *GImGui;
    if (!font)
        font = GetDefaultFont();
    SetCurrentFont(font);
    g.FontStack.push_back(font);
    g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}

References ImFont::ContainerAtlas, ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImGuiContext::FontStack, GetDefaultFont(), GImGui, ImVector< T >::push_back(), ImDrawList::PushTextureID(), SetCurrentFont(), and ImFontAtlas::TexID.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input(), InputTextEx(), and ShowFont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushID() [1/4]

void ImGui::PushID ( const char * str_id )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(str_id);
    window->IDStack.push_back(id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetIDNoKeepAlive(), GImGui, ImGuiWindow::IDStack, and ImVector< T >::push_back().

Referenced by BeginMenuBar(), ColorEdit4(), ColorPicker4(), ColorPickerOptionsPopup(), DebugNodeTabBar(), DebugNodeWindowsList(), MyDocument::DisplayContents(), DragFloatRange2(), DragIntRange2(), DragScalarN(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), GetColumnsID(), Slic3r::GUI::ImGuiWrapper::image_button(), ImageButton(), InputScalar(), InputScalarN(), LogButtons(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::render_extruders_combo(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppDocuments(), ShowFontAtlas(), ShowFontSelector(), ShowPlaceholderObject(), ShowStyleEditor(), SliderScalarN(), TableHeadersRow(), TreePush(), TreePush(), and UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushID() [2/4]

void ImGui::PushID	(	const char *	str_id_begin,
		const char *	str_id_end
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(str_id_begin, str_id_end);
    window->IDStack.push_back(id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetIDNoKeepAlive(), GImGui, ImGuiWindow::IDStack, and ImVector< T >::push_back().

Here is the call graph for this function:

◆ PushID() [3/4]

void ImGui::PushID ( const void * ptr_id )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(ptr_id);
    window->IDStack.push_back(id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetIDNoKeepAlive(), GImGui, ImGuiWindow::IDStack, and ImVector< T >::push_back().

Here is the call graph for this function:

◆ PushID() [4/4]

void ImGui::PushID ( int int_id )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(int_id);
    window->IDStack.push_back(id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::GetIDNoKeepAlive(), GImGui, ImGuiWindow::IDStack, and ImVector< T >::push_back().

Here is the call graph for this function:

◆ PushItemFlag()

void ImGui::PushItemFlag	(	ImGuiItemFlags	option,
		bool	enabled
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiItemFlags item_flags = g.CurrentItemFlags;
    IM_ASSERT(item_flags == g.ItemFlagsStack.back());
    if (enabled)
        item_flags |= option;
    else
        item_flags &= ~option;
    g.CurrentItemFlags = item_flags;
    g.ItemFlagsStack.push_back(item_flags);
}

References ImVector< T >::back(), ImGuiContext::CurrentItemFlags, GImGui, IM_ASSERT, ImGuiContext::ItemFlagsStack, and ImVector< T >::push_back().

Referenced by ColorPicker4(), Slic3r::GUI::ImGuiWrapper::disabled_begin(), PushAllowKeyboardFocus(), PushButtonRepeat(), TabItemEx(), and TableDrawContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushItemWidth()

void ImGui::PushItemWidth ( float item_width )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->DC.ItemWidthStack.push_back(window->DC.ItemWidth); // Backup current width
    window->DC.ItemWidth = (item_width == 0.0f ? window->ItemWidthDefault : item_width);
    g.NextItemData.Flags &= ~ImGuiNextItemDataFlags_HasWidth;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiNextItemData::Flags, GImGui, ImGuiWindowTempData::ItemWidth, ImGuiWindow::ItemWidthDefault, ImGuiWindowTempData::ItemWidthStack, ImGuiContext::NextItemData, and ImVector< T >::push_back().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushMultiItemsWidths()

void ImGui::PushMultiItemsWidths	(	int	components,
		float	width_full
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiStyle& style = g.Style;
    const float w_item_one  = ImMax(1.0f, IM_FLOOR((w_full - (style.ItemInnerSpacing.x) * (components - 1)) / (float)components));
    const float w_item_last = ImMax(1.0f, IM_FLOOR(w_full - (w_item_one + style.ItemInnerSpacing.x) * (components - 1)));
    window->DC.ItemWidthStack.push_back(window->DC.ItemWidth); // Backup current width
    window->DC.ItemWidthStack.push_back(w_item_last);
    for (int i = 0; i < components - 2; i++)
        window->DC.ItemWidthStack.push_back(w_item_one);
    window->DC.ItemWidth = (components == 1) ? w_item_last : w_item_one;
    g.NextItemData.Flags &= ~ImGuiNextItemDataFlags_HasWidth;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiNextItemData::Flags, GImGui, IM_FLOOR, ImMax(), ImGuiWindowTempData::ItemWidth, ImGuiWindowTempData::ItemWidthStack, ImGuiContext::NextItemData, ImVector< T >::push_back(), ImGuiContext::Style, and style.

Referenced by DragFloatRange2(), DragIntRange2(), DragScalarN(), InputScalarN(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushOverrideID()

void ImGui::PushOverrideID ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->IDStack.push_back(id);
}

References ImGuiContext::CurrentWindow, GImGui, ImGuiWindow::IDStack, and ImVector< T >::push_back().

Referenced by BeginTabBarEx(), BeginTabItem(), and BeginTableEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushStyleColor() [1/2]

void ImGui::PushStyleColor	(	ImGuiCol	idx,
		const ImVec4 &	col
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiColorMod backup;
    backup.Col = idx;
    backup.BackupValue = g.Style.Colors[idx];
    g.ColorStack.push_back(backup);
    g.Style.Colors[idx] = col;
}

References ImGuiColorMod::BackupValue, col(), ImGuiColorMod::Col, ImGuiStyle::Colors, ImGuiContext::ColorStack, GImGui, ImVector< T >::push_back(), and ImGuiContext::Style.

Here is the call graph for this function:

◆ PushStyleColor() [2/2]

void ImGui::PushStyleColor	(	ImGuiCol	idx,
		ImU32	col
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiColorMod backup;
    backup.Col = idx;
    backup.BackupValue = g.Style.Colors[idx];
    g.ColorStack.push_back(backup);
    g.Style.Colors[idx] = ColorConvertU32ToFloat4(col);
}

References ImGuiColorMod::BackupValue, col(), ImGuiColorMod::Col, ColorConvertU32ToFloat4(), ImGuiStyle::Colors, ImGuiContext::ColorStack, GImGui, ImVector< T >::push_back(), and ImGuiContext::Style.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushStyleVar() [1/2]

void ImGui::PushStyleVar	(	ImGuiStyleVar	idx,
		const ImVec2 &	val
	)

{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
    {
        ImGuiContext& g = *GImGui;
        ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
}

References ImGuiStyleVarInfo::Count, GetStyleVarInfo(), ImGuiStyleVarInfo::GetVarPtr(), GImGui, IM_ASSERT, ImGuiDataType_Float, ImVector< T >::push_back(), ImGuiContext::Style, ImGuiContext::StyleVarStack, and ImGuiStyleVarInfo::Type.

Here is the call graph for this function:

◆ PushStyleVar() [2/2]

void ImGui::PushStyleVar	(	ImGuiStyleVar	idx,
		float	val
	)

{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1)
    {
        ImGuiContext& g = *GImGui;
        float* pvar = (float*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
}

References ImGuiStyleVarInfo::Count, GetStyleVarInfo(), ImGuiStyleVarInfo::GetVarPtr(), GImGui, IM_ASSERT, ImGuiDataType_Float, ImVector< T >::push_back(), ImGuiContext::Style, ImGuiContext::StyleVarStack, and ImGuiStyleVarInfo::Type.

Referenced by BeginChildFrame(), BeginCombo(), BeginMenu(), BeginViewportSideBar(), Slic3r::GUI::ImGuiWrapper::disabled_begin(), ExampleAppConsole::Draw(), ExampleAppLog::Draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), Slic3r::GUI::GLGizmoEmboss::draw_window(), InputTextEx(), MenuItem(), NavUpdateWindowingOverlay(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), PushStyleCompact(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GLGizmoCut3D::render_reset_button(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppLongText(), ShowExampleAppPropertyEditor(), Slic3r::GUI::ImGuiWrapper::slider_float(), TabItemLabelAndCloseButton(), and Slic3r::GUI::ImGuiWrapper::tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushTextWrapPos()

void ImGui::PushTextWrapPos ( float wrap_local_pos_x = 0.0f )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.TextWrapPosStack.push_back(window->DC.TextWrapPos);
    window->DC.TextWrapPos = wrap_pos_x;
}

References ImGuiWindow::DC, GetCurrentWindow(), ImVector< T >::push_back(), ImGuiWindowTempData::TextWrapPos, and ImGuiWindowTempData::TextWrapPosStack.

Referenced by EditTableSizingFlags(), HelpMarker(), MetricsHelpMarker(), ShowDemoWindowWidgets(), Slic3r::GUI::ImGuiWrapper::text_wrapped(), TextWrappedV(), and Slic3r::GUI::ImGuiWrapper::tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RadioButton() [1/2]

bool ImGui::RadioButton	(	const char *	label,
		bool	active
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    const float square_sz = GetFrameHeight();
    const ImVec2 pos = window->DC.CursorPos;
    const ImRect check_bb(pos, pos + ImVec2(square_sz, square_sz));
    const ImRect total_bb(pos, pos + ImVec2(square_sz + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), label_size.y + style.FramePadding.y * 2.0f));
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, id))
        return false;
 
    ImVec2 center = check_bb.GetCenter();
    center.x = IM_ROUND(center.x);
    center.y = IM_ROUND(center.y);
    const float radius = (square_sz - 1.0f) * 0.5f;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(total_bb, id, &hovered, &held);
    if (pressed)
        MarkItemEdited(id);
 
    RenderNavHighlight(total_bb, id);
    window->DrawList->AddCircleFilled(center, radius, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), 16);
    if (active)
    {
        const float pad = ImMax(1.0f, IM_FLOOR(square_sz / 6.0f));
        window->DrawList->AddCircleFilled(center, radius - pad, GetColorU32(ImGuiCol_CheckMark), 16);
    }
 
    if (style.FrameBorderSize > 0.0f)
    {
        window->DrawList->AddCircle(center + ImVec2(1, 1), radius, GetColorU32(ImGuiCol_BorderShadow), 16, style.FrameBorderSize);
        window->DrawList->AddCircle(center, radius, GetColorU32(ImGuiCol_Border), 16, style.FrameBorderSize);
    }
 
    ImVec2 label_pos = ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y);
    if (g.LogEnabled)
        LogRenderedText(&label_pos, active ? "(x)" : "( )");
    if (label_size.x > 0.0f)
        RenderText(label_pos, label);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    return pressed;
}

References ImDrawList::AddCircle(), ImDrawList::AddCircleFilled(), ButtonBehavior(), CalcTextSize(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImRect::GetCenter(), GetColorU32(), GetCurrentWindow(), GetFrameHeight(), ImGuiWindow::GetID(), GImGui, IM_FLOOR, IM_ROUND, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiCol_Border, ImGuiCol_BorderShadow, ImGuiCol_CheckMark, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImMax(), ItemAdd(), ItemSize(), ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::LogEnabled, LogRenderedText(), MarkItemEdited(), ImRect::Max, ImRect::Min, RenderNavHighlight(), RenderText(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by ColorEditOptionsPopup(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::ImGuiWrapper::radio_button(), RadioButton(), Slic3r::GUI::GLGizmoCut3D::render_connect_mode_radio_button(), Slic3r::GUI::GLGizmoCut3D::render_connect_type_radio_button(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RadioButton() [2/2]

bool ImGui::RadioButton	(	const char *	label,
		int *	v,
		int	v_button
	)

{
    const bool pressed = RadioButton(label, *v == v_button);
    if (pressed)
        *v = v_button;
    return pressed;
}

References RadioButton().

Here is the call graph for this function:

◆ RemoveContextHook()

void ImGui::RemoveContextHook	(	ImGuiContext *	context,
		ImGuiID	hook_to_remove
	)

{
    ImGuiContext& g = *ctx;
    IM_ASSERT(hook_id != 0);
    for (int n = 0; n < g.Hooks.Size; n++)
        if (g.Hooks[n].HookId == hook_id)
            g.Hooks[n].Type = ImGuiContextHookType_PendingRemoval_;
}

References ImGuiContext::Hooks, IM_ASSERT, ImGuiContextHookType_PendingRemoval_, and ImVector< T >::Size.

◆ Render()

void ImGui::Render ( )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.Initialized);
 
    if (g.FrameCountEnded != g.FrameCount)
        EndFrame();
    g.FrameCountRendered = g.FrameCount;
    g.IO.MetricsRenderWindows = 0;
 
    CallContextHooks(&g, ImGuiContextHookType_RenderPre);
 
    // Add background ImDrawList (for each active viewport)
    for (int n = 0; n != g.Viewports.Size; n++)
    {
        ImGuiViewportP* viewport = g.Viewports[n];
        viewport->DrawDataBuilder.Clear();
        if (viewport->DrawLists[0] != NULL)
            AddDrawListToDrawData(&viewport->DrawDataBuilder.Layers[0], GetBackgroundDrawList(viewport));
    }
 
    // Add ImDrawList to render
    ImGuiWindow* windows_to_render_top_most[2];
    windows_to_render_top_most[0] = (g.NavWindowingTarget && !(g.NavWindowingTarget->Flags & ImGuiWindowFlags_NoBringToFrontOnFocus)) ? g.NavWindowingTarget->RootWindow : NULL;
    windows_to_render_top_most[1] = (g.NavWindowingTarget ? g.NavWindowingListWindow : NULL);
    for (int n = 0; n != g.Windows.Size; n++)
    {
        ImGuiWindow* window = g.Windows[n];
        IM_MSVC_WARNING_SUPPRESS(6011); // Static Analysis false positive "warning C6011: Dereferencing NULL pointer 'window'"
        if (IsWindowActiveAndVisible(window) && (window->Flags & ImGuiWindowFlags_ChildWindow) == 0 && window != windows_to_render_top_most[0] && window != windows_to_render_top_most[1])
            AddRootWindowToDrawData(window);
    }
    for (int n = 0; n < IM_ARRAYSIZE(windows_to_render_top_most); n++)
        if (windows_to_render_top_most[n] && IsWindowActiveAndVisible(windows_to_render_top_most[n])) // NavWindowingTarget is always temporarily displayed as the top-most window
            AddRootWindowToDrawData(windows_to_render_top_most[n]);
 
    // Setup ImDrawData structures for end-user
    g.IO.MetricsRenderVertices = g.IO.MetricsRenderIndices = 0;
    for (int n = 0; n < g.Viewports.Size; n++)
    {
        ImGuiViewportP* viewport = g.Viewports[n];
        viewport->DrawDataBuilder.FlattenIntoSingleLayer();
 
        // Draw software mouse cursor if requested by io.MouseDrawCursor flag
        if (g.IO.MouseDrawCursor)
            RenderMouseCursor(GetForegroundDrawList(viewport), g.IO.MousePos, g.Style.MouseCursorScale, g.MouseCursor, IM_COL32_WHITE, IM_COL32_BLACK, IM_COL32(0, 0, 0, 48));
 
        // Add foreground ImDrawList (for each active viewport)
        if (viewport->DrawLists[1] != NULL)
            AddDrawListToDrawData(&viewport->DrawDataBuilder.Layers[0], GetForegroundDrawList(viewport));
 
        SetupViewportDrawData(viewport, &viewport->DrawDataBuilder.Layers[0]);
        ImDrawData* draw_data = &viewport->DrawDataP;
        g.IO.MetricsRenderVertices += draw_data->TotalVtxCount;
        g.IO.MetricsRenderIndices += draw_data->TotalIdxCount;
    }
 
    CallContextHooks(&g, ImGuiContextHookType_RenderPost);
}

References AddDrawListToDrawData(), AddRootWindowToDrawData(), CallContextHooks(), ImDrawDataBuilder::Clear(), ImGuiViewportP::DrawDataBuilder, ImGuiViewportP::DrawDataP, ImGuiViewportP::DrawLists, EndFrame(), ImGuiWindow::Flags, ImDrawDataBuilder::FlattenIntoSingleLayer(), ImGuiContext::FrameCount, ImGuiContext::FrameCountEnded, ImGuiContext::FrameCountRendered, GetBackgroundDrawList(), GetForegroundDrawList(), GImGui, IM_ARRAYSIZE, IM_ASSERT, IM_COL32, IM_COL32_BLACK, IM_COL32_WHITE, IM_MSVC_WARNING_SUPPRESS, ImGuiContextHookType_RenderPost, ImGuiContextHookType_RenderPre, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NoBringToFrontOnFocus, ImGuiContext::Initialized, ImGuiContext::IO, IsWindowActiveAndVisible(), ImDrawDataBuilder::Layers, ImGuiIO::MetricsRenderIndices, ImGuiIO::MetricsRenderVertices, ImGuiIO::MetricsRenderWindows, ImGuiContext::MouseCursor, ImGuiStyle::MouseCursorScale, ImGuiIO::MouseDrawCursor, ImGuiIO::MousePos, ImGuiContext::NavWindowingListWindow, ImGuiContext::NavWindowingTarget, RenderMouseCursor(), ImGuiWindow::RootWindow, SetupViewportDrawData(), ImVector< T >::Size, ImGuiContext::Style, ImDrawData::TotalIdxCount, ImDrawData::TotalVtxCount, ImGuiContext::Viewports, and ImGuiContext::Windows.

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::post_draw(), and Slic3r::GUI::ImGuiWrapper::render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderArrow() [1/2]

void ImGui::RenderArrow	(	ImDrawList *	draw_list,
		ImVec2	pos,
		ImU32	col,
		ImGuiDir	dir,
		float	scale = `1.0f`
	)

{
    const float h = draw_list->_Data->FontSize * 1.00f;
    float r = h * 0.40f * scale;
    ImVec2 center = pos + ImVec2(h * 0.50f, h * 0.50f * scale);
 
    ImVec2 a, b, c;
    switch (dir)
    {
    case ImGuiDir_Up:
    case ImGuiDir_Down:
        if (dir == ImGuiDir_Up) r = -r;
        a = ImVec2(+0.000f, +0.750f) * r;
        b = ImVec2(-0.866f, -0.750f) * r;
        c = ImVec2(+0.866f, -0.750f) * r;
        break;
    case ImGuiDir_Left:
    case ImGuiDir_Right:
        if (dir == ImGuiDir_Left) r = -r;
        a = ImVec2(+0.750f, +0.000f) * r;
        b = ImVec2(-0.750f, +0.866f) * r;
        c = ImVec2(-0.750f, -0.866f) * r;
        break;
    case ImGuiDir_None:
    case ImGuiDir_COUNT:
        IM_ASSERT(0);
        break;
    }
    draw_list->AddTriangleFilled(center + a, center + b, center + c, col);
}

References ImDrawList::_Data, ImDrawList::AddTriangleFilled(), col(), ImDrawListSharedData::FontSize, IM_ASSERT, ImGuiDir_COUNT, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_None, ImGuiDir_Right, ImGuiDir_Up, and scale().

Referenced by ArrowButtonEx(), BeginCombo(), BeginMenu(), CollapseButton(), RenderArrow(), TableHeader(), and TreeNodeBehavior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderArrow() [2/2]

void ImGui::RenderArrow	(	ImVec2	pos,
		ImGuiDir	dir,
		float	scale = `1.0f`
	)

inline

2539{ ImGuiWindow* window = GetCurrentWindow(); RenderArrow(window->DrawList, pos, GetColorU32(ImGuiCol_Text), dir, scale); }

References ImGuiWindow::DrawList, GetColorU32(), GetCurrentWindow(), ImGuiCol_Text, RenderArrow(), and scale().

Here is the call graph for this function:

◆ RenderArrowPointingAt()

void ImGui::RenderArrowPointingAt	(	ImDrawList *	draw_list,
		ImVec2	pos,
		ImVec2	half_sz,
		ImGuiDir	direction,
		ImU32	col
	)

{
    switch (direction)
    {
    case ImGuiDir_Left:  draw_list->AddTriangleFilled(ImVec2(pos.x + half_sz.x, pos.y - half_sz.y), ImVec2(pos.x + half_sz.x, pos.y + half_sz.y), pos, col); return;
    case ImGuiDir_Right: draw_list->AddTriangleFilled(ImVec2(pos.x - half_sz.x, pos.y + half_sz.y), ImVec2(pos.x - half_sz.x, pos.y - half_sz.y), pos, col); return;
    case ImGuiDir_Up:    draw_list->AddTriangleFilled(ImVec2(pos.x + half_sz.x, pos.y + half_sz.y), ImVec2(pos.x - half_sz.x, pos.y + half_sz.y), pos, col); return;
    case ImGuiDir_Down:  draw_list->AddTriangleFilled(ImVec2(pos.x - half_sz.x, pos.y - half_sz.y), ImVec2(pos.x + half_sz.x, pos.y - half_sz.y), pos, col); return;
    case ImGuiDir_None: case ImGuiDir_COUNT: break; // Fix warnings
    }
}

References ImDrawList::AddTriangleFilled(), col(), ImGuiDir_COUNT, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_None, ImGuiDir_Right, ImGuiDir_Up, ImVec2::x, and ImVec2::y.

Referenced by RenderArrowsForVerticalBar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderBullet() [1/2]

void ImGui::RenderBullet	(	ImDrawList *	draw_list,
		ImVec2	pos,
		ImU32	col
	)

{
    draw_list->AddCircleFilled(pos, draw_list->_Data->FontSize * 0.20f, col, 8);
}

References ImDrawList::_Data, ImDrawList::AddCircleFilled(), col(), and ImDrawListSharedData::FontSize.

Referenced by Bullet(), BulletTextV(), RenderBullet(), and TreeNodeBehavior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderBullet() [2/2]

void ImGui::RenderBullet ( ImVec2 pos )

inline

2540{ ImGuiWindow* window = GetCurrentWindow(); RenderBullet(window->DrawList, pos, GetColorU32(ImGuiCol_Text)); }

References ImGuiWindow::DrawList, GetColorU32(), GetCurrentWindow(), ImGuiCol_Text, and RenderBullet().

Here is the call graph for this function:

◆ RenderCheckMark()

void ImGui::RenderCheckMark	(	ImDrawList *	draw_list,
		ImVec2	pos,
		ImU32	col,
		float	sz
	)

{
    float thickness = ImMax(sz / 5.0f, 1.0f);
    sz -= thickness * 0.5f;
    pos += ImVec2(thickness * 0.25f, thickness * 0.25f);
 
    float third = sz / 3.0f;
    float bx = pos.x + third;
    float by = pos.y + sz - third * 0.5f;
    draw_list->PathLineTo(ImVec2(bx - third, by - third));
    draw_list->PathLineTo(ImVec2(bx, by));
    draw_list->PathLineTo(ImVec2(bx + third * 2.0f, by - third * 2.0f));
    draw_list->PathStroke(col, 0, thickness);
}

References col(), ImMax(), ImDrawList::PathLineTo(), and ImDrawList::PathStroke().

Referenced by Checkbox(), and MenuItem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderColorRectWithAlphaCheckerboard()

void ImGui::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`
	)

{
    if ((flags & ImDrawFlags_RoundCornersMask_) == 0)
        flags = ImDrawFlags_RoundCornersDefault_;
    if (((col & IM_COL32_A_MASK) >> IM_COL32_A_SHIFT) < 0xFF)
    {
        ImU32 col_bg1 = GetColorU32(ImAlphaBlendColors(IM_COL32(204, 204, 204, 255), col));
        ImU32 col_bg2 = GetColorU32(ImAlphaBlendColors(IM_COL32(128, 128, 128, 255), col));
        draw_list->AddRectFilled(p_min, p_max, col_bg1, rounding, flags);
 
        int yi = 0;
        for (float y = p_min.y + grid_off.y; y < p_max.y; y += grid_step, yi++)
        {
            float y1 = ImClamp(y, p_min.y, p_max.y), y2 = ImMin(y + grid_step, p_max.y);
            if (y2 <= y1)
                continue;
            for (float x = p_min.x + grid_off.x + (yi & 1) * grid_step; x < p_max.x; x += grid_step * 2.0f)
            {
                float x1 = ImClamp(x, p_min.x, p_max.x), x2 = ImMin(x + grid_step, p_max.x);
                if (x2 <= x1)
                    continue;
                ImDrawFlags cell_flags = ImDrawFlags_RoundCornersNone;
                if (y1 <= p_min.y) { if (x1 <= p_min.x) cell_flags |= ImDrawFlags_RoundCornersTopLeft; if (x2 >= p_max.x) cell_flags |= ImDrawFlags_RoundCornersTopRight; }
                if (y2 >= p_max.y) { if (x1 <= p_min.x) cell_flags |= ImDrawFlags_RoundCornersBottomLeft; if (x2 >= p_max.x) cell_flags |= ImDrawFlags_RoundCornersBottomRight; }
 
                // Combine flags
                cell_flags = (flags == ImDrawFlags_RoundCornersNone || cell_flags == ImDrawFlags_RoundCornersNone) ? ImDrawFlags_RoundCornersNone : (cell_flags & flags);
                draw_list->AddRectFilled(ImVec2(x1, y1), ImVec2(x2, y2), col_bg2, rounding, cell_flags);
            }
        }
    }
    else
    {
        draw_list->AddRectFilled(p_min, p_max, col, rounding, flags);
    }
}

References ImDrawList::AddRectFilled(), col(), GetColorU32(), IM_COL32, IM_COL32_A_MASK, IM_COL32_A_SHIFT, ImAlphaBlendColors(), ImClamp(), ImDrawFlags_RoundCornersBottomLeft, ImDrawFlags_RoundCornersBottomRight, ImDrawFlags_RoundCornersDefault_, ImDrawFlags_RoundCornersMask_, ImDrawFlags_RoundCornersNone, ImDrawFlags_RoundCornersTopLeft, ImDrawFlags_RoundCornersTopRight, ImMin(), ImVec2::x, and ImVec2::y.

Referenced by ColorButton(), and ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderFrame()

void ImGui::RenderFrame	(	ImVec2	p_min,
		ImVec2	p_max,
		ImU32	fill_col,
		bool	border = `true`,
		float	rounding = `0.0f`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
    const float border_size = g.Style.FrameBorderSize;
    if (border && border_size > 0.0f)
    {
        window->DrawList->AddRect(p_min + ImVec2(1, 1), p_max + ImVec2(1, 1), GetColorU32(ImGuiCol_BorderShadow), rounding, 0, border_size);
        window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, 0, border_size);
    }
}

References ImDrawList::AddRect(), ImDrawList::AddRectFilled(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImGuiStyle::FrameBorderSize, GetColorU32(), GImGui, ImGuiCol_Border, ImGuiCol_BorderShadow, and ImGuiContext::Style.

Referenced by ArrowButtonEx(), ButtonEx(), Checkbox(), DragScalar(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), InputTextEx(), PlotEx(), ProgressBar(), RenderWindowDecorations(), Slic3r::GUI::selectable(), Selectable(), SliderScalar(), TreeNodeBehavior(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderFrameBorder()

void ImGui::RenderFrameBorder	(	ImVec2	p_min,
		ImVec2	p_max,
		float	rounding = `0.0f`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const float border_size = g.Style.FrameBorderSize;
    if (border_size > 0.0f)
    {
        window->DrawList->AddRect(p_min + ImVec2(1, 1), p_max + ImVec2(1, 1), GetColorU32(ImGuiCol_BorderShadow), rounding, 0, border_size);
        window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, 0, border_size);
    }
}

References ImDrawList::AddRect(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImGuiStyle::FrameBorderSize, GetColorU32(), GImGui, ImGuiCol_Border, ImGuiCol_BorderShadow, and ImGuiContext::Style.

Referenced by BeginCombo(), ColorButton(), and ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderMouseCursor()

void ImGui::RenderMouseCursor	(	ImDrawList *	draw_list,
		ImVec2	pos,
		float	scale,
		ImGuiMouseCursor	mouse_cursor,
		ImU32	col_fill,
		ImU32	col_border,
		ImU32	col_shadow
	)

{
    if (mouse_cursor == ImGuiMouseCursor_None)
        return;
    IM_ASSERT(mouse_cursor > ImGuiMouseCursor_None && mouse_cursor < ImGuiMouseCursor_COUNT);
 
    ImFontAtlas* font_atlas = draw_list->_Data->Font->ContainerAtlas;
    ImVec2 offset, size, uv[4];
    if (font_atlas->GetMouseCursorTexData(mouse_cursor, &offset, &size, &uv[0], &uv[2]))
    {
        pos -= offset;
        ImTextureID tex_id = font_atlas->TexID;
        draw_list->PushTextureID(tex_id);
        draw_list->AddImage(tex_id, pos + ImVec2(1, 0) * scale, pos + (ImVec2(1, 0) + size) * scale,    uv[2], uv[3], col_shadow);
        draw_list->AddImage(tex_id, pos + ImVec2(2, 0) * scale, pos + (ImVec2(2, 0) + size) * scale,    uv[2], uv[3], col_shadow);
        draw_list->AddImage(tex_id, pos,                        pos + size * scale,                     uv[2], uv[3], col_border);
        draw_list->AddImage(tex_id, pos,                        pos + size * scale,                     uv[0], uv[1], col_fill);
        draw_list->PopTextureID();
    }
}

References ImDrawList::_Data, ImDrawList::AddImage(), ImFont::ContainerAtlas, ImDrawListSharedData::Font, ImFontAtlas::GetMouseCursorTexData(), IM_ASSERT, ImGuiMouseCursor_COUNT, ImGuiMouseCursor_None, ImDrawList::PopTextureID(), ImDrawList::PushTextureID(), scale(), and ImFontAtlas::TexID.

Referenced by Render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderNavHighlight()

void ImGui::RenderNavHighlight	(	const ImRect &	bb,
		ImGuiID	id,
		ImGuiNavHighlightFlags	flags = `ImGuiNavHighlightFlags_TypeDefault`
	)

{
    ImGuiContext& g = *GImGui;
    if (id != g.NavId)
        return;
    if (g.NavDisableHighlight && !(flags & ImGuiNavHighlightFlags_AlwaysDraw))
        return;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->DC.NavHideHighlightOneFrame)
        return;
 
    float rounding = (flags & ImGuiNavHighlightFlags_NoRounding) ? 0.0f : g.Style.FrameRounding;
    ImRect display_rect = bb;
    display_rect.ClipWith(window->ClipRect);
    if (flags & ImGuiNavHighlightFlags_TypeDefault)
    {
        const float THICKNESS = 2.0f;
        const float DISTANCE = 3.0f + THICKNESS * 0.5f;
        display_rect.Expand(ImVec2(DISTANCE, DISTANCE));
        bool fully_visible = window->ClipRect.Contains(display_rect);
        if (!fully_visible)
            window->DrawList->PushClipRect(display_rect.Min, display_rect.Max);
        window->DrawList->AddRect(display_rect.Min + ImVec2(THICKNESS * 0.5f, THICKNESS * 0.5f), display_rect.Max - ImVec2(THICKNESS * 0.5f, THICKNESS * 0.5f), GetColorU32(ImGuiCol_NavHighlight), rounding, 0, THICKNESS);
        if (!fully_visible)
            window->DrawList->PopClipRect();
    }
    if (flags & ImGuiNavHighlightFlags_TypeThin)
    {
        window->DrawList->AddRect(display_rect.Min, display_rect.Max, GetColorU32(ImGuiCol_NavHighlight), rounding, 0, 1.0f);
    }
}

References ImDrawList::AddRect(), ImGuiWindow::ClipRect, ImRect::ClipWith(), ImRect::Contains(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiWindow::DrawList, ImRect::Expand(), ImGuiStyle::FrameRounding, GetColorU32(), GImGui, ImGuiCol_NavHighlight, ImGuiNavHighlightFlags_AlwaysDraw, ImGuiNavHighlightFlags_NoRounding, ImGuiNavHighlightFlags_TypeDefault, ImGuiNavHighlightFlags_TypeThin, ImRect::Max, ImRect::Min, ImGuiContext::NavDisableHighlight, ImGuiWindowTempData::NavHideHighlightOneFrame, ImGuiContext::NavId, ImDrawList::PopClipRect(), ImDrawList::PushClipRect(), and ImGuiContext::Style.

Referenced by ArrowButtonEx(), BeginCombo(), ButtonEx(), Checkbox(), ColorButton(), DragScalar(), EndChild(), Slic3r::GUI::image_button_ex(), ImageButtonEx(), InputTextEx(), RadioButton(), Slic3r::GUI::selectable(), Selectable(), SliderScalar(), TabItemEx(), TableHeader(), TreeNodeBehavior(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderRectFilledRangeH()

void ImGui::RenderRectFilledRangeH	(	ImDrawList *	draw_list,
		const ImRect &	rect,
		ImU32	col,
		float	x_start_norm,
		float	x_end_norm,
		float	rounding
	)

{
    if (x_end_norm == x_start_norm)
        return;
    if (x_start_norm > x_end_norm)
        ImSwap(x_start_norm, x_end_norm);
 
    ImVec2 p0 = ImVec2(ImLerp(rect.Min.x, rect.Max.x, x_start_norm), rect.Min.y);
    ImVec2 p1 = ImVec2(ImLerp(rect.Min.x, rect.Max.x, x_end_norm), rect.Max.y);
    if (rounding == 0.0f)
    {
        draw_list->AddRectFilled(p0, p1, col, 0.0f);
        return;
    }
 
    rounding = ImClamp(ImMin((rect.Max.x - rect.Min.x) * 0.5f, (rect.Max.y - rect.Min.y) * 0.5f) - 1.0f, 0.0f, rounding);
    const float inv_rounding = 1.0f / rounding;
    const float arc0_b = ImAcos01(1.0f - (p0.x - rect.Min.x) * inv_rounding);
    const float arc0_e = ImAcos01(1.0f - (p1.x - rect.Min.x) * inv_rounding);
    const float half_pi = IM_PI * 0.5f; // We will == compare to this because we know this is the exact value ImAcos01 can return.
    const float x0 = ImMax(p0.x, rect.Min.x + rounding);
    if (arc0_b == arc0_e)
    {
        draw_list->PathLineTo(ImVec2(x0, p1.y));
        draw_list->PathLineTo(ImVec2(x0, p0.y));
    }
    else if (arc0_b == 0.0f && arc0_e == half_pi)
    {
        draw_list->PathArcToFast(ImVec2(x0, p1.y - rounding), rounding, 3, 6); // BL
        draw_list->PathArcToFast(ImVec2(x0, p0.y + rounding), rounding, 6, 9); // TR
    }
    else
    {
        draw_list->PathArcTo(ImVec2(x0, p1.y - rounding), rounding, IM_PI - arc0_e, IM_PI - arc0_b, 3); // BL
        draw_list->PathArcTo(ImVec2(x0, p0.y + rounding), rounding, IM_PI + arc0_b, IM_PI + arc0_e, 3); // TR
    }
    if (p1.x > rect.Min.x + rounding)
    {
        const float arc1_b = ImAcos01(1.0f - (rect.Max.x - p1.x) * inv_rounding);
        const float arc1_e = ImAcos01(1.0f - (rect.Max.x - p0.x) * inv_rounding);
        const float x1 = ImMin(p1.x, rect.Max.x - rounding);
        if (arc1_b == arc1_e)
        {
            draw_list->PathLineTo(ImVec2(x1, p0.y));
            draw_list->PathLineTo(ImVec2(x1, p1.y));
        }
        else if (arc1_b == 0.0f && arc1_e == half_pi)
        {
            draw_list->PathArcToFast(ImVec2(x1, p0.y + rounding), rounding, 9, 12); // TR
            draw_list->PathArcToFast(ImVec2(x1, p1.y - rounding), rounding, 0, 3);  // BR
        }
        else
        {
            draw_list->PathArcTo(ImVec2(x1, p0.y + rounding), rounding, -arc1_e, -arc1_b, 3); // TR
            draw_list->PathArcTo(ImVec2(x1, p1.y - rounding), rounding, +arc1_b, +arc1_e, 3); // BR
        }
    }
    draw_list->PathFillConvex(col);
}

References ImDrawList::AddRectFilled(), col(), IM_PI, ImAcos01(), ImClamp(), ImLerp(), ImMax(), ImMin(), ImSwap(), ImRect::Max, ImRect::Min, ImDrawList::PathArcTo(), ImDrawList::PathArcToFast(), ImDrawList::PathFillConvex(), ImDrawList::PathLineTo(), ImVec2::x, and ImVec2::y.

Referenced by ProgressBar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderRectFilledWithHole()

void ImGui::RenderRectFilledWithHole	(	ImDrawList *	draw_list,
		ImRect	outer,
		ImRect	inner,
		ImU32	col,
		float	rounding
	)

{
    const bool fill_L = (inner.Min.x > outer.Min.x);
    const bool fill_R = (inner.Max.x < outer.Max.x);
    const bool fill_U = (inner.Min.y > outer.Min.y);
    const bool fill_D = (inner.Max.y < outer.Max.y);
    if (fill_L) draw_list->AddRectFilled(ImVec2(outer.Min.x, inner.Min.y), ImVec2(inner.Min.x, inner.Max.y), col, rounding, (fill_U ? 0 : ImDrawFlags_RoundCornersTopLeft)  | (fill_D ? 0 : ImDrawFlags_RoundCornersBottomLeft));
    if (fill_R) draw_list->AddRectFilled(ImVec2(inner.Max.x, inner.Min.y), ImVec2(outer.Max.x, inner.Max.y), col, rounding, (fill_U ? 0 : ImDrawFlags_RoundCornersTopRight) | (fill_D ? 0 : ImDrawFlags_RoundCornersBottomRight));
    if (fill_U) draw_list->AddRectFilled(ImVec2(inner.Min.x, outer.Min.y), ImVec2(inner.Max.x, inner.Min.y), col, rounding, (fill_L ? 0 : ImDrawFlags_RoundCornersTopLeft)  | (fill_R ? 0 : ImDrawFlags_RoundCornersTopRight));
    if (fill_D) draw_list->AddRectFilled(ImVec2(inner.Min.x, inner.Max.y), ImVec2(inner.Max.x, outer.Max.y), col, rounding, (fill_L ? 0 : ImDrawFlags_RoundCornersBottomLeft)  | (fill_R ? 0 : ImDrawFlags_RoundCornersBottomRight));
    if (fill_L && fill_U) draw_list->AddRectFilled(ImVec2(outer.Min.x, outer.Min.y), ImVec2(inner.Min.x, inner.Min.y), col, rounding, ImDrawFlags_RoundCornersTopLeft);
    if (fill_R && fill_U) draw_list->AddRectFilled(ImVec2(inner.Max.x, outer.Min.y), ImVec2(outer.Max.x, inner.Min.y), col, rounding, ImDrawFlags_RoundCornersTopRight);
    if (fill_L && fill_D) draw_list->AddRectFilled(ImVec2(outer.Min.x, inner.Max.y), ImVec2(inner.Min.x, outer.Max.y), col, rounding, ImDrawFlags_RoundCornersBottomLeft);
    if (fill_R && fill_D) draw_list->AddRectFilled(ImVec2(inner.Max.x, inner.Max.y), ImVec2(outer.Max.x, outer.Max.y), col, rounding, ImDrawFlags_RoundCornersBottomRight);
}

References ImDrawList::AddRectFilled(), col(), ImDrawFlags_RoundCornersBottomLeft, ImDrawFlags_RoundCornersBottomRight, ImDrawFlags_RoundCornersTopLeft, ImDrawFlags_RoundCornersTopRight, ImRect::Max, ImRect::Min, ImVec2::x, and ImVec2::y.

Here is the call graph for this function:

◆ RenderText()

void ImGui::RenderText	(	ImVec2	pos,
		const char *	text,
		const char *	text_end = `NULL`,
		bool	hide_text_after_hash = `true`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    // Hide anything after a '##' string
    const char* text_display_end;
    if (hide_text_after_hash)
    {
        text_display_end = FindRenderedTextEnd(text, text_end);
    }
    else
    {
        if (!text_end)
            text_end = text + strlen(text); // FIXME-OPT
        text_display_end = text_end;
    }
 
    if (text != text_display_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_display_end);
    }
}

References ImDrawList::AddText(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, FindRenderedTextEnd(), ImGuiContext::Font, ImGuiContext::FontSize, GetColorU32(), GImGui, ImGuiCol_Text, ImGuiContext::LogEnabled, and LogRenderedText().

Referenced by BeginCombo(), BeginListBox(), BulletTextV(), Checkbox(), DragScalar(), InputTextEx(), LabelTextV(), MenuItem(), PlotEx(), RadioButton(), SliderScalar(), TableHeader(), TextEx(), TreeNodeBehavior(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderTextClipped()

void ImGui::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`
	)

{
    // Hide anything after a '##' string
    const char* text_display_end = FindRenderedTextEnd(text, text_end);
    const int text_len = (int)(text_display_end - text);
    if (text_len == 0)
        return;
 
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    RenderTextClippedEx(window->DrawList, pos_min, pos_max, text, text_display_end, text_size_if_known, align, clip_rect);
    if (g.LogEnabled)
        LogRenderedText(&pos_min, text, text_display_end);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, FindRenderedTextEnd(), GImGui, ImGuiContext::LogEnabled, LogRenderedText(), and RenderTextClippedEx().

Referenced by BeginCombo(), ButtonEx(), DragScalar(), LabelTextV(), PlotEx(), ProgressBar(), RenderWindowTitleBarContents(), Slic3r::GUI::selectable(), Selectable(), SliderScalar(), TreeNodeBehavior(), and VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderTextClippedEx()

void ImGui::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`
	)

{
    // Perform CPU side clipping for single clipped element to avoid using scissor state
    ImVec2 pos = pos_min;
    const ImVec2 text_size = text_size_if_known ? *text_size_if_known : CalcTextSize(text, text_display_end, false, 0.0f);
 
    const ImVec2* clip_min = clip_rect ? &clip_rect->Min : &pos_min;
    const ImVec2* clip_max = clip_rect ? &clip_rect->Max : &pos_max;
    bool need_clipping = (pos.x + text_size.x >= clip_max->x) || (pos.y + text_size.y >= clip_max->y);
    if (clip_rect) // If we had no explicit clipping rectangle then pos==clip_min
        need_clipping |= (pos.x < clip_min->x) || (pos.y < clip_min->y);
 
    // Align whole block. We should defer that to the better rendering function when we'll have support for individual line alignment.
    if (align.x > 0.0f) pos.x = ImMax(pos.x, pos.x + (pos_max.x - pos.x - text_size.x) * align.x);
    if (align.y > 0.0f) pos.y = ImMax(pos.y, pos.y + (pos_max.y - pos.y - text_size.y) * align.y);
 
    // Render
    if (need_clipping)
    {
        ImVec4 fine_clip_rect(clip_min->x, clip_min->y, clip_max->x, clip_max->y);
        draw_list->AddText(NULL, 0.0f, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, &fine_clip_rect);
    }
    else
    {
        draw_list->AddText(NULL, 0.0f, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, NULL);
    }
}

References ImDrawList::AddText(), CalcTextSize(), GetColorU32(), ImGuiCol_Text, ImMax(), ImRect::Max, ImRect::Min, ImVec2::x, and ImVec2::y.

Referenced by RenderTextClipped(), RenderTextEllipsis(), and TabItemLabelAndCloseButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderTextEllipsis()

void ImGui::RenderTextEllipsis	(	ImDrawList *	draw_list,
		const ImVec2 &	pos_min,
		const ImVec2 &	pos_max,
		float	clip_max_x,
		float	ellipsis_max_x,
		const char *	text,
		const char *	text_end,
		const ImVec2 *	text_size_if_known
	)

{
    ImGuiContext& g = *GImGui;
    if (text_end_full == NULL)
        text_end_full = FindRenderedTextEnd(text);
    const ImVec2 text_size = text_size_if_known ? *text_size_if_known : CalcTextSize(text, text_end_full, false, 0.0f);
 
    //draw_list->AddLine(ImVec2(pos_max.x, pos_min.y - 4), ImVec2(pos_max.x, pos_max.y + 4), IM_COL32(0, 0, 255, 255));
    //draw_list->AddLine(ImVec2(ellipsis_max_x, pos_min.y-2), ImVec2(ellipsis_max_x, pos_max.y+2), IM_COL32(0, 255, 0, 255));
    //draw_list->AddLine(ImVec2(clip_max_x, pos_min.y), ImVec2(clip_max_x, pos_max.y), IM_COL32(255, 0, 0, 255));
    // FIXME: We could technically remove (last_glyph->AdvanceX - last_glyph->X1) from text_size.x here and save a few pixels.
    if (text_size.x > pos_max.x - pos_min.x)
    {
        // Hello wo...
        // |       |   |
        // min   max   ellipsis_max
        //          <-> this is generally some padding value
 
        const ImFont* font = draw_list->_Data->Font;
        const float font_size = draw_list->_Data->FontSize;
        const char* text_end_ellipsis = NULL;
 
        ImWchar ellipsis_char = font->EllipsisChar;
        int ellipsis_char_count = 1;
        if (ellipsis_char == (ImWchar)-1)
        {
            ellipsis_char = (ImWchar)'.';
            ellipsis_char_count = 3;
        }
        const ImFontGlyph* glyph = font->FindGlyph(ellipsis_char);
 
        float ellipsis_glyph_width = glyph->X1;                 // Width of the glyph with no padding on either side
        float ellipsis_total_width = ellipsis_glyph_width;      // Full width of entire ellipsis
 
        if (ellipsis_char_count > 1)
        {
            // Full ellipsis size without free spacing after it.
            const float spacing_between_dots = 1.0f * (draw_list->_Data->FontSize / font->FontSize);
            ellipsis_glyph_width = glyph->X1 - glyph->X0 + spacing_between_dots;
            ellipsis_total_width = ellipsis_glyph_width * (float)ellipsis_char_count - spacing_between_dots;
        }
 
        // We can now claim the space between pos_max.x and ellipsis_max.x
        const float text_avail_width = ImMax((ImMax(pos_max.x, ellipsis_max_x) - ellipsis_total_width) - pos_min.x, 1.0f);
        float text_size_clipped_x = font->CalcTextSizeA(font_size, text_avail_width, 0.0f, text, text_end_full, &text_end_ellipsis).x;
        if (text == text_end_ellipsis && text_end_ellipsis < text_end_full)
        {
            // Always display at least 1 character if there's no room for character + ellipsis
            text_end_ellipsis = text + ImTextCountUtf8BytesFromChar(text, text_end_full);
            text_size_clipped_x = font->CalcTextSizeA(font_size, FLT_MAX, 0.0f, text, text_end_ellipsis).x;
        }
        while (text_end_ellipsis > text && ImCharIsBlankA(text_end_ellipsis[-1]))
        {
            // Trim trailing space before ellipsis (FIXME: Supporting non-ascii blanks would be nice, for this we need a function to backtrack in UTF-8 text)
            text_end_ellipsis--;
            text_size_clipped_x -= font->CalcTextSizeA(font_size, FLT_MAX, 0.0f, text_end_ellipsis, text_end_ellipsis + 1).x; // Ascii blanks are always 1 byte
        }
 
        // Render text, render ellipsis
        RenderTextClippedEx(draw_list, pos_min, ImVec2(clip_max_x, pos_max.y), text, text_end_ellipsis, &text_size, ImVec2(0.0f, 0.0f));
        float ellipsis_x = pos_min.x + text_size_clipped_x;
        if (ellipsis_x + ellipsis_total_width <= ellipsis_max_x)
            for (int i = 0; i < ellipsis_char_count; i++)
            {
                font->RenderChar(draw_list, font_size, ImVec2(ellipsis_x, pos_min.y), GetColorU32(ImGuiCol_Text), ellipsis_char);
                ellipsis_x += ellipsis_glyph_width;
            }
    }
    else
    {
        RenderTextClippedEx(draw_list, pos_min, ImVec2(clip_max_x, pos_max.y), text, text_end_full, &text_size, ImVec2(0.0f, 0.0f));
    }
 
    if (g.LogEnabled)
        LogRenderedText(&pos_min, text, text_end_full);
}

References ImDrawList::_Data, CalcTextSize(), ImFont::CalcTextSizeA(), ImFont::EllipsisChar, ImFont::FindGlyph(), FindRenderedTextEnd(), ImDrawListSharedData::Font, ImFont::FontSize, ImDrawListSharedData::FontSize, GetColorU32(), GImGui, ImCharIsBlankA(), ImGuiCol_Text, ImMax(), ImTextCountUtf8BytesFromChar(), ImGuiContext::LogEnabled, LogRenderedText(), ImFont::RenderChar(), RenderTextClippedEx(), ImVec2::x, ImFontGlyph::X0, ImFontGlyph::X1, and ImVec2::y.

Referenced by TabItemLabelAndCloseButton(), and TableHeader().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderTextWrapped()

void ImGui::RenderTextWrapped	(	ImVec2	pos,
		const char *	text,
		const char *	text_end,
		float	wrap_width
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    if (!text_end)
        text_end = text + strlen(text); // FIXME-OPT
 
    if (text != text_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_end, wrap_width);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_end);
    }
}

References ImDrawList::AddText(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImGuiContext::Font, ImGuiContext::FontSize, GetColorU32(), GImGui, ImGuiCol_Text, ImGuiContext::LogEnabled, and LogRenderedText().

Referenced by TextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderWindowDecorations()

void ImGui::RenderWindowDecorations	(	ImGuiWindow *	window,
		const ImRect &	title_bar_rect,
		bool	title_bar_is_highlight,
		int	resize_grip_count,
		const ImU32	resize_grip_col[4],
		float	resize_grip_draw_size
	)

static

{
    ImGuiContext& g = *GImGui;
    ImGuiStyle& style = g.Style;
    ImGuiWindowFlags flags = window->Flags;
 
    // Ensure that ScrollBar doesn't read last frame's SkipItems
    IM_ASSERT(window->BeginCount == 0);
    window->SkipItems = false;
 
    // Draw window + handle manual resize
    // As we highlight the title bar when want_focus is set, multiple reappearing windows will have have their title bar highlighted on their reappearing frame.
    const float window_rounding = window->WindowRounding;
    const float window_border_size = window->WindowBorderSize;
    if (window->Collapsed)
    {
        // Title bar only
        float backup_border_size = style.FrameBorderSize;
        g.Style.FrameBorderSize = window->WindowBorderSize;
        ImU32 title_bar_col = GetColorU32((title_bar_is_highlight && !g.NavDisableHighlight) ? ImGuiCol_TitleBgActive : ImGuiCol_TitleBgCollapsed);
        RenderFrame(title_bar_rect.Min, title_bar_rect.Max, title_bar_col, true, window_rounding);
        g.Style.FrameBorderSize = backup_border_size;
    }
    else
    {
        // Window background
        if (!(flags & ImGuiWindowFlags_NoBackground))
        {
            ImU32 bg_col = GetColorU32(GetWindowBgColorIdxFromFlags(flags));
            bool override_alpha = false;
            float alpha = 1.0f;
            if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasBgAlpha)
            {
                alpha = g.NextWindowData.BgAlphaVal;
                override_alpha = true;
            }
            if (override_alpha)
                bg_col = (bg_col & ~IM_COL32_A_MASK) | (IM_F32_TO_INT8_SAT(alpha) << IM_COL32_A_SHIFT);
            window->DrawList->AddRectFilled(window->Pos + ImVec2(0, window->TitleBarHeight()), window->Pos + window->Size, bg_col, window_rounding, (flags & ImGuiWindowFlags_NoTitleBar) ? 0 : ImDrawFlags_RoundCornersBottom);
        }
 
        // Title bar
        if (!(flags & ImGuiWindowFlags_NoTitleBar))
        {
            ImU32 title_bar_col = GetColorU32(title_bar_is_highlight ? ImGuiCol_TitleBgActive : ImGuiCol_TitleBg);
            window->DrawList->AddRectFilled(title_bar_rect.Min, title_bar_rect.Max, title_bar_col, window_rounding, ImDrawFlags_RoundCornersTop);
        }
 
        // Menu bar
        if (flags & ImGuiWindowFlags_MenuBar)
        {
            ImRect menu_bar_rect = window->MenuBarRect();
            menu_bar_rect.ClipWith(window->Rect());  // Soft clipping, in particular child window don't have minimum size covering the menu bar so this is useful for them.
            window->DrawList->AddRectFilled(menu_bar_rect.Min + ImVec2(window_border_size, 0), menu_bar_rect.Max - ImVec2(window_border_size, 0), GetColorU32(ImGuiCol_MenuBarBg), (flags & ImGuiWindowFlags_NoTitleBar) ? window_rounding : 0.0f, ImDrawFlags_RoundCornersTop);
            if (style.FrameBorderSize > 0.0f && menu_bar_rect.Max.y < window->Pos.y + window->Size.y)
                window->DrawList->AddLine(menu_bar_rect.GetBL(), menu_bar_rect.GetBR(), GetColorU32(ImGuiCol_Border), style.FrameBorderSize);
        }
 
        // Scrollbars
        if (window->ScrollbarX)
            Scrollbar(ImGuiAxis_X);
        if (window->ScrollbarY)
            Scrollbar(ImGuiAxis_Y);
 
        // Render resize grips (after their input handling so we don't have a frame of latency)
        if (!(flags & ImGuiWindowFlags_NoResize))
        {
            for (int resize_grip_n = 0; resize_grip_n < resize_grip_count; resize_grip_n++)
            {
                const ImGuiResizeGripDef& grip = resize_grip_def[resize_grip_n];
                const ImVec2 corner = ImLerp(window->Pos, window->Pos + window->Size, grip.CornerPosN);
                window->DrawList->PathLineTo(corner + grip.InnerDir * ((resize_grip_n & 1) ? ImVec2(window_border_size, resize_grip_draw_size) : ImVec2(resize_grip_draw_size, window_border_size)));
                window->DrawList->PathLineTo(corner + grip.InnerDir * ((resize_grip_n & 1) ? ImVec2(resize_grip_draw_size, window_border_size) : ImVec2(window_border_size, resize_grip_draw_size)));
                window->DrawList->PathArcToFast(ImVec2(corner.x + grip.InnerDir.x * (window_rounding + window_border_size), corner.y + grip.InnerDir.y * (window_rounding + window_border_size)), window_rounding, grip.AngleMin12, grip.AngleMax12);
                window->DrawList->PathFillConvex(resize_grip_col[resize_grip_n]);
            }
        }
 
        // Borders
        RenderWindowOuterBorders(window);
    }
}

References ImDrawList::AddLine(), ImDrawList::AddRectFilled(), ImGuiResizeGripDef::AngleMax12, ImGuiResizeGripDef::AngleMin12, ImGuiWindow::BeginCount, ImGuiNextWindowData::BgAlphaVal, ImRect::ClipWith(), ImGuiWindow::Collapsed, ImGuiResizeGripDef::CornerPosN, ImGuiWindow::DrawList, ImGuiNextWindowData::Flags, ImGuiWindow::Flags, ImGuiStyle::FrameBorderSize, ImRect::GetBL(), ImRect::GetBR(), GetColorU32(), GetWindowBgColorIdxFromFlags(), GImGui, IM_ASSERT, IM_COL32_A_SHIFT, IM_F32_TO_INT8_SAT, ImDrawFlags_RoundCornersBottom, ImDrawFlags_RoundCornersTop, ImGuiAxis_X, ImGuiAxis_Y, ImGuiCol_Border, ImGuiCol_MenuBarBg, ImGuiCol_TitleBg, ImGuiCol_TitleBgActive, ImGuiCol_TitleBgCollapsed, ImGuiNextWindowDataFlags_HasBgAlpha, ImGuiWindowFlags_MenuBar, ImGuiWindowFlags_NoBackground, ImGuiWindowFlags_NoResize, ImGuiWindowFlags_NoTitleBar, ImLerp(), ImGuiResizeGripDef::InnerDir, ImRect::Max, ImGuiWindow::MenuBarRect(), ImRect::Min, ImGuiContext::NavDisableHighlight, ImGuiContext::NextWindowData, ImDrawList::PathArcToFast(), ImDrawList::PathFillConvex(), ImDrawList::PathLineTo(), ImGuiWindow::Pos, ImGuiWindow::Rect(), RenderFrame(), RenderWindowOuterBorders(), resize_grip_def, Scrollbar(), ImGuiWindow::ScrollbarX, ImGuiWindow::ScrollbarY, ImGuiWindow::Size, ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImGuiWindow::TitleBarHeight(), ImGuiWindow::WindowBorderSize, ImGuiWindow::WindowRounding, ImVec2::x, and ImVec2::y.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderWindowOuterBorders()

static void ImGui::RenderWindowOuterBorders ( ImGuiWindow * window )

static

{
    ImGuiContext& g = *GImGui;
    float rounding = window->WindowRounding;
    float border_size = window->WindowBorderSize;
    if (border_size > 0.0f && !(window->Flags & ImGuiWindowFlags_NoBackground))
        window->DrawList->AddRect(window->Pos, window->Pos + window->Size, GetColorU32(ImGuiCol_Border), rounding, 0, border_size);
 
    int border_held = window->ResizeBorderHeld;
    if (border_held != -1)
    {
        const ImGuiResizeBorderDef& def = resize_border_def[border_held];
        ImRect border_r = GetResizeBorderRect(window, border_held, rounding, 0.0f);
        window->DrawList->PathArcTo(ImLerp(border_r.Min, border_r.Max, def.SegmentN1) + ImVec2(0.5f, 0.5f) + def.InnerDir * rounding, rounding, def.OuterAngle - IM_PI * 0.25f, def.OuterAngle);
        window->DrawList->PathArcTo(ImLerp(border_r.Min, border_r.Max, def.SegmentN2) + ImVec2(0.5f, 0.5f) + def.InnerDir * rounding, rounding, def.OuterAngle, def.OuterAngle + IM_PI * 0.25f);
        window->DrawList->PathStroke(GetColorU32(ImGuiCol_SeparatorActive), 0, ImMax(2.0f, border_size)); // Thicker than usual
    }
    if (g.Style.FrameBorderSize > 0 && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
    {
        float y = window->Pos.y + window->TitleBarHeight() - 1;
        window->DrawList->AddLine(ImVec2(window->Pos.x + border_size, y), ImVec2(window->Pos.x + window->Size.x - border_size, y), GetColorU32(ImGuiCol_Border), g.Style.FrameBorderSize);
    }
}

References ImDrawList::AddLine(), ImDrawList::AddRect(), ImGuiWindow::DrawList, ImGuiWindow::Flags, ImGuiStyle::FrameBorderSize, GetColorU32(), GetResizeBorderRect(), GImGui, IM_PI, ImGuiCol_Border, ImGuiCol_SeparatorActive, ImGuiWindowFlags_NoBackground, ImGuiWindowFlags_NoTitleBar, ImLerp(), ImMax(), ImGuiResizeBorderDef::InnerDir, ImRect::Max, ImRect::Min, ImGuiResizeBorderDef::OuterAngle, ImDrawList::PathArcTo(), ImDrawList::PathStroke(), ImGuiWindow::Pos, resize_border_def, ImGuiWindow::ResizeBorderHeld, ImGuiResizeBorderDef::SegmentN1, ImGuiResizeBorderDef::SegmentN2, ImGuiWindow::Size, ImGuiContext::Style, ImGuiWindow::TitleBarHeight(), ImGuiWindow::WindowBorderSize, ImGuiWindow::WindowRounding, ImVec2::x, and ImVec2::y.

Referenced by RenderWindowDecorations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RenderWindowTitleBarContents()

void ImGui::RenderWindowTitleBarContents	(	ImGuiWindow *	window,
		const ImRect &	title_bar_rect,
		const char *	name,
		bool *	p_open
	)

static

{
    ImGuiContext& g = *GImGui;
    ImGuiStyle& style = g.Style;
    ImGuiWindowFlags flags = window->Flags;
 
    const bool has_close_button = (p_open != NULL);
    const bool has_collapse_button = !(flags & ImGuiWindowFlags_NoCollapse) && (style.WindowMenuButtonPosition != ImGuiDir_None);
 
    // Close & Collapse button are on the Menu NavLayer and don't default focus (unless there's nothing else on that layer)
    const ImGuiItemFlags item_flags_backup = g.CurrentItemFlags;
    g.CurrentItemFlags |= ImGuiItemFlags_NoNavDefaultFocus;
    window->DC.NavLayerCurrent = ImGuiNavLayer_Menu;
 
    // Layout buttons
    // FIXME: Would be nice to generalize the subtleties expressed here into reusable code.
    float pad_l = style.FramePadding.x;
    float pad_r = style.FramePadding.x;
    float button_sz = g.FontSize;
    ImVec2 close_button_pos;
    ImVec2 collapse_button_pos;
    if (has_close_button)
    {
        pad_r += button_sz;
        close_button_pos = ImVec2(title_bar_rect.Max.x - pad_r - style.FramePadding.x, title_bar_rect.Min.y);
    }
    if (has_collapse_button && style.WindowMenuButtonPosition == ImGuiDir_Right)
    {
        pad_r += button_sz;
        collapse_button_pos = ImVec2(title_bar_rect.Max.x - pad_r - style.FramePadding.x, title_bar_rect.Min.y);
    }
    if (has_collapse_button && style.WindowMenuButtonPosition == ImGuiDir_Left)
    {
        collapse_button_pos = ImVec2(title_bar_rect.Min.x + pad_l - style.FramePadding.x, title_bar_rect.Min.y);
        pad_l += button_sz;
    }
 
    // Collapse button (submitting first so it gets priority when choosing a navigation init fallback)
    if (has_collapse_button)
        if (CollapseButton(window->GetID("#COLLAPSE"), collapse_button_pos))
            window->WantCollapseToggle = true; // Defer actual collapsing to next frame as we are too far in the Begin() function
 
    // Close button
    if (has_close_button)
        if (CloseButton(window->GetID("#CLOSE"), close_button_pos))
            *p_open = false;
 
    window->DC.NavLayerCurrent = ImGuiNavLayer_Main;
    g.CurrentItemFlags = item_flags_backup;
 
    // Title bar text (with: horizontal alignment, avoiding collapse/close button, optional "unsaved document" marker)
    // FIXME: Refactor text alignment facilities along with RenderText helpers, this is WAY too much messy code..
    const char* UNSAVED_DOCUMENT_MARKER = "*";
    const float marker_size_x = (flags & ImGuiWindowFlags_UnsavedDocument) ? CalcTextSize(UNSAVED_DOCUMENT_MARKER, NULL, false).x : 0.0f;
    const ImVec2 text_size = CalcTextSize(name, NULL, true) + ImVec2(marker_size_x, 0.0f);
 
    // As a nice touch we try to ensure that centered title text doesn't get affected by visibility of Close/Collapse button,
    // while uncentered title text will still reach edges correctly.
    if (pad_l > style.FramePadding.x)
        pad_l += g.Style.ItemInnerSpacing.x;
    if (pad_r > style.FramePadding.x)
        pad_r += g.Style.ItemInnerSpacing.x;
    if (style.WindowTitleAlign.x > 0.0f && style.WindowTitleAlign.x < 1.0f)
    {
        float centerness = ImSaturate(1.0f - ImFabs(style.WindowTitleAlign.x - 0.5f) * 2.0f); // 0.0f on either edges, 1.0f on center
        float pad_extend = ImMin(ImMax(pad_l, pad_r), title_bar_rect.GetWidth() - pad_l - pad_r - text_size.x);
        pad_l = ImMax(pad_l, pad_extend * centerness);
        pad_r = ImMax(pad_r, pad_extend * centerness);
    }
 
    ImRect layout_r(title_bar_rect.Min.x + pad_l, title_bar_rect.Min.y, title_bar_rect.Max.x - pad_r, title_bar_rect.Max.y);
    ImRect clip_r(layout_r.Min.x, layout_r.Min.y, ImMin(layout_r.Max.x + g.Style.ItemInnerSpacing.x, title_bar_rect.Max.x), layout_r.Max.y);
    //if (g.IO.KeyShift) window->DrawList->AddRect(layout_r.Min, layout_r.Max, IM_COL32(255, 128, 0, 255)); // [DEBUG]
    //if (g.IO.KeyCtrl) window->DrawList->AddRect(clip_r.Min, clip_r.Max, IM_COL32(255, 128, 0, 255)); // [DEBUG]
    RenderTextClipped(layout_r.Min, layout_r.Max, name, NULL, &text_size, style.WindowTitleAlign, &clip_r);
    if (flags & ImGuiWindowFlags_UnsavedDocument)
    {
        ImVec2 marker_pos = ImVec2(ImMax(layout_r.Min.x, layout_r.Min.x + (layout_r.GetWidth() - text_size.x) * style.WindowTitleAlign.x) + text_size.x, layout_r.Min.y) + ImVec2(2 - marker_size_x, 0.0f);
        ImVec2 off = ImVec2(0.0f, IM_FLOOR(-g.FontSize * 0.25f));
        RenderTextClipped(marker_pos + off, layout_r.Max + off, UNSAVED_DOCUMENT_MARKER, NULL, NULL, ImVec2(0, style.WindowTitleAlign.y), &clip_r);
    }
}

References CalcTextSize(), CloseButton(), CollapseButton(), ImGuiContext::CurrentItemFlags, ImGuiWindow::DC, ImGuiWindow::Flags, ImGuiContext::FontSize, ImGuiWindow::GetID(), ImRect::GetWidth(), GImGui, IM_FLOOR, ImFabs, ImGuiDir_Left, ImGuiDir_None, ImGuiDir_Right, ImGuiItemFlags_NoNavDefaultFocus, ImGuiNavLayer_Main, ImGuiNavLayer_Menu, ImGuiWindowFlags_NoCollapse, ImGuiWindowFlags_UnsavedDocument, ImMax(), ImMin(), ImSaturate(), ImGuiStyle::ItemInnerSpacing, ImRect::Max, ImRect::Min, ImGuiWindowTempData::NavLayerCurrent, RenderTextClipped(), ImGuiContext::Style, style, ImGuiWindow::WantCollapseToggle, ImVec2::x, and ImVec2::y.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetMouseDragDelta()

void ImGui::ResetMouseDragDelta ( ImGuiMouseButton button = 0 )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    // NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
    g.IO.MouseClickedPos[button] = g.IO.MousePos;
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiContext::IO, ImGuiIO::MouseClickedPos, ImGuiIO::MouseDown, and ImGuiIO::MousePos.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_style_list(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ RoundScalarWithFormatT()

template<typename T , typename SIGNED_T >

IMGUI_API T ImGui::RoundScalarWithFormatT	(	const char *	format,
		ImGuiDataType	data_type,
		T	v
	)

◆ SameLine()

void ImGui::SameLine	(	float	offset_from_start_x = `0.0f`,
		float	spacing = `-1.0f`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    if (offset_from_start_x != 0.0f)
    {
        if (spacing_w < 0.0f) spacing_w = 0.0f;
        window->DC.CursorPos.x = window->Pos.x - window->Scroll.x + offset_from_start_x + spacing_w + window->DC.GroupOffset.x + window->DC.ColumnsOffset.x;
        window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
    }
    else
    {
        if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
        window->DC.CursorPos.x = window->DC.CursorPosPrevLine.x + spacing_w;
        window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
    }
    window->DC.CurrLineSize = window->DC.PrevLineSize;
    window->DC.CurrLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
}

Here is the call graph for this function:

◆ SaveIniSettingsToDisk()

void ImGui::SaveIniSettingsToDisk ( const char * ini_filename )

{
    ImGuiContext& g = *GImGui;
    g.SettingsDirtyTimer = 0.0f;
    if (!ini_filename)
        return;
 
    size_t ini_data_size = 0;
    const char* ini_data = SaveIniSettingsToMemory(&ini_data_size);
    ImFileHandle f = ImFileOpen(ini_filename, "wt");
    if (!f)
        return;
    ImFileWrite(ini_data, sizeof(char), ini_data_size, f);
    ImFileClose(f);
}

References GImGui, ImFileClose(), ImFileOpen(), ImFileWrite(), SaveIniSettingsToMemory(), and ImGuiContext::SettingsDirtyTimer.

Referenced by ShowMetricsWindow(), Shutdown(), and UpdateSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveIniSettingsToMemory()

const char * ImGui::SaveIniSettingsToMemory ( size_t * out_ini_size = NULL )

{
    ImGuiContext& g = *GImGui;
    g.SettingsDirtyTimer = 0.0f;
    g.SettingsIniData.Buf.resize(0);
    g.SettingsIniData.Buf.push_back(0);
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
    {
        ImGuiSettingsHandler* handler = &g.SettingsHandlers[handler_n];
        handler->WriteAllFn(&g, handler, &g.SettingsIniData);
    }
    if (out_size)
        *out_size = (size_t)g.SettingsIniData.size();
    return g.SettingsIniData.c_str();
}

References ImGuiTextBuffer::Buf, ImGuiTextBuffer::c_str(), GImGui, ImVector< T >::push_back(), ImVector< T >::resize(), ImGuiContext::SettingsDirtyTimer, ImGuiContext::SettingsHandlers, ImGuiContext::SettingsIniData, ImVector< T >::Size, ImGuiTextBuffer::size(), and ImGuiSettingsHandler::WriteAllFn.

Referenced by SaveIniSettingsToDisk(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScaleRatioFromValueT()

template<typename T , typename SIGNED_T , typename FLOAT_T >

IMGUI_API float ImGui::ScaleRatioFromValueT	(	ImGuiDataType	data_type,
		T	v,
		T	v_min,
		T	v_max,
		bool	is_logarithmic,
		float	logarithmic_zero_epsilon,
		float	zero_deadzone_size
	)

◆ ScaleValueFromRatioT()

template<typename T , typename SIGNED_T , typename FLOAT_T >

IMGUI_API T ImGui::ScaleValueFromRatioT	(	ImGuiDataType	data_type,
		float	t,
		T	v_min,
		T	v_max,
		bool	is_logarithmic,
		float	logarithmic_zero_epsilon,
		float	zero_deadzone_size
	)

◆ Scrollbar()

void ImGui::Scrollbar ( ImGuiAxis axis )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    const ImGuiID id = GetWindowScrollbarID(window, axis);
    KeepAliveID(id);
 
    // Calculate scrollbar bounding box
    ImRect bb = GetWindowScrollbarRect(window, axis);
    ImDrawFlags rounding_corners = ImDrawFlags_RoundCornersNone;
    if (axis == ImGuiAxis_X)
    {
        rounding_corners |= ImDrawFlags_RoundCornersBottomLeft;
        if (!window->ScrollbarY)
            rounding_corners |= ImDrawFlags_RoundCornersBottomRight;
    }
    else
    {
        if ((window->Flags & ImGuiWindowFlags_NoTitleBar) && !(window->Flags & ImGuiWindowFlags_MenuBar))
            rounding_corners |= ImDrawFlags_RoundCornersTopRight;
        if (!window->ScrollbarX)
            rounding_corners |= ImDrawFlags_RoundCornersBottomRight;
    }
    float size_avail = window->InnerRect.Max[axis] - window->InnerRect.Min[axis];
    float size_contents = window->ContentSize[axis] + window->WindowPadding[axis] * 2.0f;
    ScrollbarEx(bb, id, axis, &window->Scroll[axis], size_avail, size_contents, rounding_corners);
}

References ImGuiWindow::ContentSize, ImGuiContext::CurrentWindow, ImGuiWindow::Flags, GetWindowScrollbarID(), GetWindowScrollbarRect(), GImGui, ImDrawFlags_RoundCornersBottomLeft, ImDrawFlags_RoundCornersBottomRight, ImDrawFlags_RoundCornersNone, ImDrawFlags_RoundCornersTopRight, ImGuiAxis_X, ImGuiWindowFlags_MenuBar, ImGuiWindowFlags_NoTitleBar, ImGuiWindow::InnerRect, KeepAliveID(), ImRect::Max, ImRect::Min, ImGuiWindow::Scroll, ScrollbarEx(), ImGuiWindow::ScrollbarX, ImGuiWindow::ScrollbarY, and ImGuiWindow::WindowPadding.

Referenced by RenderWindowDecorations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScrollbarEx()

bool ImGui::ScrollbarEx	(	const ImRect &	bb,
		ImGuiID	id,
		ImGuiAxis	axis,
		float *	p_scroll_v,
		float	avail_v,
		float	contents_v,
		ImDrawFlags	flags
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    const float bb_frame_width = bb_frame.GetWidth();
    const float bb_frame_height = bb_frame.GetHeight();
    if (bb_frame_width <= 0.0f || bb_frame_height <= 0.0f)
        return false;
 
    // When we are too small, start hiding and disabling the grab (this reduce visual noise on very small window and facilitate using the window resize grab)
    float alpha = 1.0f;
    if ((axis == ImGuiAxis_Y) && bb_frame_height < g.FontSize + g.Style.FramePadding.y * 2.0f)
        alpha = ImSaturate((bb_frame_height - g.FontSize) / (g.Style.FramePadding.y * 2.0f));
    if (alpha <= 0.0f)
        return false;
 
    const ImGuiStyle& style = g.Style;
    const bool allow_interaction = (alpha >= 1.0f);
 
    ImRect bb = bb_frame;
    bb.Expand(ImVec2(-ImClamp(IM_FLOOR((bb_frame_width - 2.0f) * 0.5f), 0.0f, 3.0f), -ImClamp(IM_FLOOR((bb_frame_height - 2.0f) * 0.5f), 0.0f, 3.0f)));
 
    // V denote the main, longer axis of the scrollbar (= height for a vertical scrollbar)
    const float scrollbar_size_v = (axis == ImGuiAxis_X) ? bb.GetWidth() : bb.GetHeight();
 
    // Calculate the height of our grabbable box. It generally represent the amount visible (vs the total scrollable amount)
    // But we maintain a minimum size in pixel to allow for the user to still aim inside.
    IM_ASSERT(ImMax(size_contents_v, size_avail_v) > 0.0f); // Adding this assert to check if the ImMax(XXX,1.0f) is still needed. PLEASE CONTACT ME if this triggers.
    const float win_size_v = ImMax(ImMax(size_contents_v, size_avail_v), 1.0f);
    const float grab_h_pixels = ImClamp(scrollbar_size_v * (size_avail_v / win_size_v), style.GrabMinSize, scrollbar_size_v);
    const float grab_h_norm = grab_h_pixels / scrollbar_size_v;
 
    // Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().
    bool held = false;
    bool hovered = false;
    ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_NoNavFocus);
 
    float scroll_max = ImMax(1.0f, size_contents_v - size_avail_v);
    float scroll_ratio = ImSaturate(*p_scroll_v / scroll_max);
    float grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v; // Grab position in normalized space
    if (held && allow_interaction && grab_h_norm < 1.0f)
    {
        float scrollbar_pos_v = bb.Min[axis];
        float mouse_pos_v = g.IO.MousePos[axis];
 
        // Click position in scrollbar normalized space (0.0f->1.0f)
        const float clicked_v_norm = ImSaturate((mouse_pos_v - scrollbar_pos_v) / scrollbar_size_v);
        SetHoveredID(id);
 
        bool seek_absolute = false;
        if (g.ActiveIdIsJustActivated)
        {
            // On initial click calculate the distance between mouse and the center of the grab
            seek_absolute = (clicked_v_norm < grab_v_norm || clicked_v_norm > grab_v_norm + grab_h_norm);
            if (seek_absolute)
                g.ScrollbarClickDeltaToGrabCenter = 0.0f;
            else
                g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;
        }
 
        // Apply scroll (p_scroll_v will generally point on one member of window->Scroll)
        // It is ok to modify Scroll here because we are being called in Begin() after the calculation of ContentSize and before setting up our starting position
        const float scroll_v_norm = ImSaturate((clicked_v_norm - g.ScrollbarClickDeltaToGrabCenter - grab_h_norm * 0.5f) / (1.0f - grab_h_norm));
        *p_scroll_v = IM_ROUND(scroll_v_norm * scroll_max);//(win_size_contents_v - win_size_v));
 
        // Update values for rendering
        scroll_ratio = ImSaturate(*p_scroll_v / scroll_max);
        grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;
 
        // Update distance to grab now that we have seeked and saturated
        if (seek_absolute)
            g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;
    }
 
    // Render
    const ImU32 bg_col = GetColorU32(ImGuiCol_ScrollbarBg);
    const ImU32 grab_col = GetColorU32(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab, alpha);
    window->DrawList->AddRectFilled(bb_frame.Min, bb_frame.Max, bg_col, window->WindowRounding, flags);
    ImRect grab_rect;
    if (axis == ImGuiAxis_X)
        grab_rect = ImRect(ImLerp(bb.Min.x, bb.Max.x, grab_v_norm), bb.Min.y, ImLerp(bb.Min.x, bb.Max.x, grab_v_norm) + grab_h_pixels, bb.Max.y);
    else
        grab_rect = ImRect(bb.Min.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm), bb.Max.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm) + grab_h_pixels);
    window->DrawList->AddRectFilled(grab_rect.Min, grab_rect.Max, grab_col, style.ScrollbarRounding);
 
    return held;
}

References ImGuiContext::ActiveIdIsJustActivated, ImDrawList::AddRectFilled(), ButtonBehavior(), ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImRect::Expand(), ImGuiContext::FontSize, ImGuiStyle::FramePadding, GetColorU32(), ImRect::GetHeight(), ImRect::GetWidth(), GImGui, IM_ASSERT, IM_FLOOR, IM_ROUND, ImClamp(), ImGuiAxis_X, ImGuiAxis_Y, ImGuiButtonFlags_NoNavFocus, ImGuiCol_ScrollbarBg, ImGuiCol_ScrollbarGrab, ImGuiCol_ScrollbarGrabActive, ImGuiCol_ScrollbarGrabHovered, ImLerp(), ImMax(), ImSaturate(), ImGuiContext::IO, ImRect::Max, ImRect::Min, ImGuiIO::MousePos, ImGuiContext::ScrollbarClickDeltaToGrabCenter, SetHoveredID(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, ImGuiWindow::WindowRounding, ImVec2::x, and ImVec2::y.

Referenced by Scrollbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScrollToBringRectIntoView()

ImVec2 ImGui::ScrollToBringRectIntoView	(	ImGuiWindow *	window,
		const ImRect &	item_rect
	)

{
    ImGuiContext& g = *GImGui;
    ImRect window_rect(window->InnerRect.Min - ImVec2(1, 1), window->InnerRect.Max + ImVec2(1, 1));
    //GetForegroundDrawList(window)->AddRect(window_rect.Min, window_rect.Max, IM_COL32_WHITE); // [DEBUG]
 
    ImVec2 delta_scroll;
    if (!window_rect.Contains(item_rect))
    {
        if (window->ScrollbarX && item_rect.Min.x < window_rect.Min.x)
            SetScrollFromPosX(window, item_rect.Min.x - window->Pos.x - g.Style.ItemSpacing.x, 0.0f);
        else if (window->ScrollbarX && item_rect.Max.x >= window_rect.Max.x)
            SetScrollFromPosX(window, item_rect.Max.x - window->Pos.x + g.Style.ItemSpacing.x, 1.0f);
        if (item_rect.Min.y < window_rect.Min.y)
            SetScrollFromPosY(window, item_rect.Min.y - window->Pos.y - g.Style.ItemSpacing.y, 0.0f);
        else if (item_rect.Max.y >= window_rect.Max.y)
            SetScrollFromPosY(window, item_rect.Max.y - window->Pos.y + g.Style.ItemSpacing.y, 1.0f);
 
        ImVec2 next_scroll = CalcNextScrollFromScrollTargetAndClamp(window);
        delta_scroll = next_scroll - window->Scroll;
    }
 
    // Also scroll parent window to keep us into view if necessary
    if (window->Flags & ImGuiWindowFlags_ChildWindow)
        delta_scroll += ScrollToBringRectIntoView(window->ParentWindow, ImRect(item_rect.Min - delta_scroll, item_rect.Max - delta_scroll));
 
    return delta_scroll;
}

References CalcNextScrollFromScrollTargetAndClamp(), ImRect::Contains(), ImGuiWindow::Flags, GImGui, ImGuiWindowFlags_ChildWindow, ImGuiWindow::InnerRect, ImGuiStyle::ItemSpacing, ImRect::Max, ImRect::Min, ImGuiWindow::ParentWindow, ImGuiWindow::Pos, ImGuiWindow::Scroll, ImGuiWindow::ScrollbarX, ScrollToBringRectIntoView(), SetScrollFromPosX(), SetScrollFromPosY(), ImGuiContext::Style, ImVec2::x, and ImVec2::y.

Referenced by NavUpdateMoveResult(), and ScrollToBringRectIntoView().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Selectable() [1/2]

bool ImGui::Selectable	(	const char *	label,
		bool *	p_selected,
		ImGuiSelectableFlags	flags = `0`,
		const ImVec2 &	size = `ImVec2(0, 0)`
	)

{
    if (Selectable(label, *p_selected, flags, size_arg))
    {
        *p_selected = !*p_selected;
        return true;
    }
    return false;
}

References Selectable().

Here is the call graph for this function:

◆ Selectable() [2/2]

bool ImGui::Selectable	(	const char *	label,
		bool	selected = `false`,
		ImGuiSelectableFlags	flags = `0`,
		const ImVec2 &	size = `ImVec2(0, 0)`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
 
    // Submit label or explicit size to ItemSize(), whereas ItemAdd() will submit a larger/spanning rectangle.
    ImGuiID id = window->GetID(label);
    ImVec2 label_size = CalcTextSize(label, NULL, true);
    ImVec2 size(size_arg.x != 0.0f ? size_arg.x : label_size.x, size_arg.y != 0.0f ? size_arg.y : label_size.y);
    ImVec2 pos = window->DC.CursorPos;
    pos.y += window->DC.CurrLineTextBaseOffset;
    ItemSize(size, 0.0f);
 
    // Fill horizontal space
    // We don't support (size < 0.0f) in Selectable() because the ItemSpacing extension would make explicitly right-aligned sizes not visibly match other widgets.
    const bool span_all_columns = (flags & ImGuiSelectableFlags_SpanAllColumns) != 0;
    const float min_x = span_all_columns ? window->ParentWorkRect.Min.x : pos.x;
    const float max_x = span_all_columns ? window->ParentWorkRect.Max.x : window->WorkRect.Max.x;
    if (size_arg.x == 0.0f || (flags & ImGuiSelectableFlags_SpanAvailWidth))
        size.x = ImMax(label_size.x, max_x - min_x);
 
    // Text stays at the submission position, but bounding box may be extended on both sides
    const ImVec2 text_min = pos;
    const ImVec2 text_max(min_x + size.x, pos.y + size.y);
 
    // Selectables are meant to be tightly packed together with no click-gap, so we extend their box to cover spacing between selectable.
    ImRect bb(min_x, pos.y, text_max.x, text_max.y);
    if ((flags & ImGuiSelectableFlags_NoPadWithHalfSpacing) == 0)
    {
        const float spacing_x = span_all_columns ? 0.0f : style.ItemSpacing.x;
        const float spacing_y = style.ItemSpacing.y;
        const float spacing_L = IM_FLOOR(spacing_x * 0.50f);
        const float spacing_U = IM_FLOOR(spacing_y * 0.50f);
        bb.Min.x -= spacing_L;
        bb.Min.y -= spacing_U;
        bb.Max.x += (spacing_x - spacing_L);
        bb.Max.y += (spacing_y - spacing_U);
    }
    //if (g.IO.KeyCtrl) { GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(0, 255, 0, 255)); }
 
    // Modify ClipRect for the ItemAdd(), faster than doing a PushColumnsBackground/PushTableBackground for every Selectable..
    const float backup_clip_rect_min_x = window->ClipRect.Min.x;
    const float backup_clip_rect_max_x = window->ClipRect.Max.x;
    if (span_all_columns)
    {
        window->ClipRect.Min.x = window->ParentWorkRect.Min.x;
        window->ClipRect.Max.x = window->ParentWorkRect.Max.x;
    }
 
    bool item_add;
    if (flags & ImGuiSelectableFlags_Disabled)
    {
        ImGuiItemFlags backup_item_flags = g.CurrentItemFlags;
        g.CurrentItemFlags |= ImGuiItemFlags_Disabled | ImGuiItemFlags_NoNavDefaultFocus;
        item_add = ItemAdd(bb, id);
        g.CurrentItemFlags = backup_item_flags;
    }
    else
    {
        item_add = ItemAdd(bb, id);
    }
 
    if (span_all_columns)
    {
        window->ClipRect.Min.x = backup_clip_rect_min_x;
        window->ClipRect.Max.x = backup_clip_rect_max_x;
    }
 
    if (!item_add)
        return false;
 
    // FIXME: We can standardize the behavior of those two, we could also keep the fast path of override ClipRect + full push on render only,
    // which would be advantageous since most selectable are not selected.
    if (span_all_columns && window->DC.CurrentColumns)
        PushColumnsBackground();
    else if (span_all_columns && g.CurrentTable)
        TablePushBackgroundChannel();
 
    // We use NoHoldingActiveID on menus so user can click and _hold_ on a menu then drag to browse child entries
    ImGuiButtonFlags button_flags = 0;
    if (flags & ImGuiSelectableFlags_NoHoldingActiveID) { button_flags |= ImGuiButtonFlags_NoHoldingActiveId; }
    if (flags & ImGuiSelectableFlags_SelectOnClick)     { button_flags |= ImGuiButtonFlags_PressedOnClick; }
    if (flags & ImGuiSelectableFlags_SelectOnRelease)   { button_flags |= ImGuiButtonFlags_PressedOnRelease; }
    if (flags & ImGuiSelectableFlags_Disabled)          { button_flags |= ImGuiButtonFlags_Disabled; }
    if (flags & ImGuiSelectableFlags_AllowDoubleClick)  { button_flags |= ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnDoubleClick; }
    if (flags & ImGuiSelectableFlags_AllowItemOverlap)  { button_flags |= ImGuiButtonFlags_AllowItemOverlap; }
 
    if (flags & ImGuiSelectableFlags_Disabled)
        selected = false;
 
    const bool was_selected = selected;
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, button_flags);
 
    // Update NavId when clicking or when Hovering (this doesn't happen on most widgets), so navigation can be resumed with gamepad/keyboard
    if (pressed || (hovered && (flags & ImGuiSelectableFlags_SetNavIdOnHover)))
    {
        if (!g.NavDisableMouseHover && g.NavWindow == window && g.NavLayer == window->DC.NavLayerCurrent)
        {
            SetNavID(id, window->DC.NavLayerCurrent, window->DC.NavFocusScopeIdCurrent, ImRect(bb.Min - window->Pos, bb.Max - window->Pos));
            g.NavDisableHighlight = true;
        }
    }
    if (pressed)
        MarkItemEdited(id);
 
    if (flags & ImGuiSelectableFlags_AllowItemOverlap)
        SetItemAllowOverlap();
 
    // In this branch, Selectable() cannot toggle the selection so this will never trigger.
    if (selected != was_selected) //-V547
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_ToggledSelection;
 
    // Render
    if (held && (flags & ImGuiSelectableFlags_DrawHoveredWhenHeld))
        hovered = true;
    if (hovered || selected)
    {
        const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
        RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
        RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
    }
 
    if (span_all_columns && window->DC.CurrentColumns)
        PopColumnsBackground();
    else if (span_all_columns && g.CurrentTable)
        TablePopBackgroundChannel();
 
    if (flags & ImGuiSelectableFlags_Disabled) PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]);
    RenderTextClipped(text_min, text_max, label, NULL, &label_size, style.SelectableTextAlign, &bb);
    if (flags & ImGuiSelectableFlags_Disabled) PopStyleColor();
 
    // Automatically close popups
    if (pressed && (window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiSelectableFlags_DontClosePopups) && !(g.CurrentItemFlags & ImGuiItemFlags_SelectableDontClosePopup))
        CloseCurrentPopup();
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    return pressed;
}

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), BeginMenu(), ColorEditOptionsPopup(), ColorPickerOptionsPopup(), Slic3r::GUI::ImGuiWrapper::combo(), DebugNodeDrawList(), DebugNodeTable(), ExampleAppConsole::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), EditTableSizingFlags(), MenuItem(), NavUpdateWindowingOverlay(), Slic3r::GUI::render_extruders_combo(), Selectable(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppLayout(), ShowFontSelector(), ShowMetricsWindow(), TabBarTabListPopupButton(), and Slic3r::GUI::ImGuiWrapper::undo_redo_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Separator()

void ImGui::Separator ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;
 
    // Those flags should eventually be overridable by the user
    ImGuiSeparatorFlags flags = (window->DC.LayoutType == ImGuiLayoutType_Horizontal) ? ImGuiSeparatorFlags_Vertical : ImGuiSeparatorFlags_Horizontal;
    flags |= ImGuiSeparatorFlags_SpanAllColumns;
    SeparatorEx(flags);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiLayoutType_Horizontal, ImGuiSeparatorFlags_Horizontal, ImGuiSeparatorFlags_SpanAllColumns, ImGuiSeparatorFlags_Vertical, ImGuiWindowTempData::LayoutType, SeparatorEx(), and ImGuiWindow::SkipItems.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SeparatorEx()

void ImGui::SeparatorEx ( ImGuiSeparatorFlags flags )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    IM_ASSERT(ImIsPowerOfTwo(flags & (ImGuiSeparatorFlags_Horizontal | ImGuiSeparatorFlags_Vertical)));   // Check that only 1 option is selected
 
    float thickness_draw = 1.0f;
    float thickness_layout = 0.0f;
    if (flags & ImGuiSeparatorFlags_Vertical)
    {
        // Vertical separator, for menu bars (use current line height). Not exposed because it is misleading and it doesn't have an effect on regular layout.
        float y1 = window->DC.CursorPos.y;
        float y2 = window->DC.CursorPos.y + window->DC.CurrLineSize.y;
        const ImRect bb(ImVec2(window->DC.CursorPos.x, y1), ImVec2(window->DC.CursorPos.x + thickness_draw, y2));
        ItemSize(ImVec2(thickness_layout, 0.0f));
        if (!ItemAdd(bb, 0))
            return;
 
        // Draw
        window->DrawList->AddLine(ImVec2(bb.Min.x, bb.Min.y), ImVec2(bb.Min.x, bb.Max.y), GetColorU32(ImGuiCol_Separator));
        if (g.LogEnabled)
            LogText(" |");
    }
    else if (flags & ImGuiSeparatorFlags_Horizontal)
    {
        // Horizontal Separator
        float x1 = window->Pos.x;
        float x2 = window->Pos.x + window->Size.x;
 
        // FIXME-WORKRECT: old hack (#205) until we decide of consistent behavior with WorkRect/Indent and Separator
        if (g.GroupStack.Size > 0 && g.GroupStack.back().WindowID == window->ID)
            x1 += window->DC.Indent.x;
 
        ImGuiOldColumns* columns = (flags & ImGuiSeparatorFlags_SpanAllColumns) ? window->DC.CurrentColumns : NULL;
        if (columns)
            PushColumnsBackground();
 
        // We don't provide our width to the layout so that it doesn't get feed back into AutoFit
        const ImRect bb(ImVec2(x1, window->DC.CursorPos.y), ImVec2(x2, window->DC.CursorPos.y + thickness_draw));
        ItemSize(ImVec2(0.0f, thickness_layout));
        const bool item_visible = ItemAdd(bb, 0);
        if (item_visible)
        {
            // Draw
            window->DrawList->AddLine(bb.Min, ImVec2(bb.Max.x, bb.Min.y), GetColorU32(ImGuiCol_Separator));
            if (g.LogEnabled)
                LogRenderedText(&bb.Min, "--------------------------------\n");
 
        }
        if (columns)
        {
            PopColumnsBackground();
            columns->LineMinY = window->DC.CursorPos.y;
        }
    }
}

References ImDrawList::AddLine(), ImVector< T >::back(), ImGuiWindowTempData::CurrentColumns, ImGuiWindowTempData::CurrLineSize, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, GetColorU32(), GetCurrentWindow(), GImGui, ImGuiContext::GroupStack, ImGuiWindow::ID, IM_ASSERT, ImGuiCol_Separator, ImGuiSeparatorFlags_Horizontal, ImGuiSeparatorFlags_SpanAllColumns, ImGuiSeparatorFlags_Vertical, ImIsPowerOfTwo(), ImGuiWindowTempData::Indent, ItemAdd(), ItemSize(), ImGuiOldColumns::LineMinY, ImGuiContext::LogEnabled, LogRenderedText(), LogText(), ImRect::Max, ImRect::Min, PopColumnsBackground(), ImGuiWindow::Pos, PushColumnsBackground(), ImVector< T >::Size, ImGuiWindow::Size, ImGuiWindow::SkipItems, ImGuiGroupData::WindowID, ImVec2::x, ImVec1::x, and ImVec2::y.

Referenced by Separator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetActiveID()

void ImGui::SetActiveID	(	ImGuiID	id,
		ImGuiWindow *	window
	)

{
    ImGuiContext& g = *GImGui;
    g.ActiveIdIsJustActivated = (g.ActiveId != id);
    if (g.ActiveIdIsJustActivated)
    {
        g.ActiveIdTimer = 0.0f;
        g.ActiveIdHasBeenPressedBefore = false;
        g.ActiveIdHasBeenEditedBefore = false;
        g.ActiveIdMouseButton = -1;
        if (id != 0)
        {
            g.LastActiveId = id;
            g.LastActiveIdTimer = 0.0f;
        }
    }
    g.ActiveId = id;
    g.ActiveIdAllowOverlap = false;
    g.ActiveIdNoClearOnFocusLoss = false;
    g.ActiveIdWindow = window;
    g.ActiveIdHasBeenEditedThisFrame = false;
    if (id)
    {
        g.ActiveIdIsAlive = id;
        g.ActiveIdSource = (g.NavActivateId == id || g.NavInputId == id || g.NavJustTabbedId == id || g.NavJustMovedToId == id) ? ImGuiInputSource_Nav : ImGuiInputSource_Mouse;
    }
 
    // Clear declaration of inputs claimed by the widget
    // (Please note that this is WIP and not all keys/inputs are thoroughly declared by all widgets yet)
    g.ActiveIdUsingMouseWheel = false;
    g.ActiveIdUsingNavDirMask = 0x00;
    g.ActiveIdUsingNavInputMask = 0x00;
    g.ActiveIdUsingKeyInputMask = 0x00;
}

Referenced by BeginChildEx(), BeginDragDropSource(), ButtonBehavior(), ClearActiveID(), DragScalar(), InputTextEx(), SliderScalar(), StartMouseMovingWindow(), and VSliderScalar().

Here is the caller graph for this function:

◆ SetAllocatorFunctions()

void ImGui::SetAllocatorFunctions	(	ImGuiMemAllocFunc	alloc_func,
		ImGuiMemFreeFunc	free_func,
		void *	user_data = `NULL`
	)

{
    GImAllocatorAllocFunc = alloc_func;
    GImAllocatorFreeFunc = free_func;
    GImAllocatorUserData = user_data;
}

References alloc_func, free_func, GImAllocatorAllocFunc, GImAllocatorFreeFunc, and GImAllocatorUserData.

◆ SetClipboardText()

void ImGui::SetClipboardText ( const char * text )

{
    ImGuiContext& g = *GImGui;
    if (g.IO.SetClipboardTextFn)
        g.IO.SetClipboardTextFn(g.IO.ClipboardUserData, text);
}

References ImGuiIO::ClipboardUserData, GImGui, ImGuiContext::IO, and ImGuiIO::SetClipboardTextFn.

Referenced by ColorEditOptionsPopup(), InputTextEx(), and LogFinish().

Here is the caller graph for this function:

◆ SetColorEditOptions()

void ImGui::SetColorEditOptions ( ImGuiColorEditFlags flags )

{
    ImGuiContext& g = *GImGui;
    if ((flags & ImGuiColorEditFlags__DisplayMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DisplayMask;
    if ((flags & ImGuiColorEditFlags__DataTypeMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DataTypeMask;
    if ((flags & ImGuiColorEditFlags__PickerMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__PickerMask;
    if ((flags & ImGuiColorEditFlags__InputMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__InputMask;
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__DisplayMask));    // Check only 1 option is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__DataTypeMask));   // Check only 1 option is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__PickerMask));     // Check only 1 option is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__InputMask));      // Check only 1 option is selected
    g.ColorEditOptions = flags;
}

References ImGuiContext::ColorEditOptions, GImGui, IM_ASSERT, ImGuiColorEditFlags__DataTypeMask, ImGuiColorEditFlags__DisplayMask, ImGuiColorEditFlags__InputMask, ImGuiColorEditFlags__OptionsDefault, ImGuiColorEditFlags__PickerMask, and ImIsPowerOfTwo().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetColumnOffset()

void ImGui::SetColumnOffset	(	int	column_index,
		float	offset_x
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    IM_ASSERT(columns != NULL);
 
    if (column_index < 0)
        column_index = columns->Current;
    IM_ASSERT(column_index < columns->Columns.Size);
 
    const bool preserve_width = !(columns->Flags & ImGuiOldColumnFlags_NoPreserveWidths) && (column_index < columns->Count - 1);
    const float width = preserve_width ? GetColumnWidthEx(columns, column_index, columns->IsBeingResized) : 0.0f;
 
    if (!(columns->Flags & ImGuiOldColumnFlags_NoForceWithinWindow))
        offset = ImMin(offset, columns->OffMaxX - g.Style.ColumnsMinSpacing * (columns->Count - column_index));
    columns->Columns[column_index].OffsetNorm = GetColumnNormFromOffset(columns, offset - columns->OffMinX);
 
    if (preserve_width)
        SetColumnOffset(column_index + 1, offset + ImMax(g.Style.ColumnsMinSpacing, width));
}

References Columns(), ImGuiOldColumns::Columns, ImGuiStyle::ColumnsMinSpacing, ImGuiOldColumns::Count, ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiOldColumns::Flags, GetColumnNormFromOffset(), GetColumnWidthEx(), GImGui, IM_ASSERT, ImGuiOldColumnFlags_NoForceWithinWindow, ImGuiOldColumnFlags_NoPreserveWidths, ImMax(), ImMin(), ImGuiOldColumns::IsBeingResized, ImGuiOldColumns::OffMaxX, ImGuiOldColumns::OffMinX, SetColumnOffset(), and ImGuiContext::Style.

Referenced by EndColumns(), SetColumnOffset(), and SetColumnWidth().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetColumnWidth()

void ImGui::SetColumnWidth	(	int	column_index,
		float	width
	)

{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    IM_ASSERT(columns != NULL);
 
    if (column_index < 0)
        column_index = columns->Current;
    SetColumnOffset(column_index + 1, GetColumnOffset(column_index) + width);
}

References ImGuiOldColumns::Current, ImGuiWindowTempData::CurrentColumns, ImGuiWindow::DC, GetColumnOffset(), GetCurrentWindowRead(), IM_ASSERT, and SetColumnOffset().

Here is the call graph for this function:

◆ SetCurrentContext()

void ImGui::SetCurrentContext ( ImGuiContext * ctx )

{
#ifdef IMGUI_SET_CURRENT_CONTEXT_FUNC
    IMGUI_SET_CURRENT_CONTEXT_FUNC(ctx); // For custom thread-based hackery you may want to have control over this.
#else
    GImGui = ctx;
#endif
}

References GImGui.

Referenced by CreateContext(), DestroyContext(), and Shutdown().

Here is the caller graph for this function:

◆ SetCurrentFont()

void ImGui::SetCurrentFont ( ImFont * font )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(font && font->IsLoaded());    // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
    IM_ASSERT(font->Scale > 0.0f);
    g.Font = font;
    g.FontBaseSize = ImMax(1.0f, g.IO.FontGlobalScale * g.Font->FontSize * g.Font->Scale);
    g.FontSize = g.CurrentWindow ? g.CurrentWindow->CalcFontSize() : 0.0f;
 
    ImFontAtlas* atlas = g.Font->ContainerAtlas;
    g.DrawListSharedData.TexUvWhitePixel = atlas->TexUvWhitePixel;
    g.DrawListSharedData.TexUvLines = atlas->TexUvLines;
    g.DrawListSharedData.Font = g.Font;
    g.DrawListSharedData.FontSize = g.FontSize;
}

References ImGuiWindow::CalcFontSize(), ImFont::ContainerAtlas, ImGuiContext::CurrentWindow, ImGuiContext::DrawListSharedData, ImDrawListSharedData::Font, ImGuiContext::Font, ImGuiContext::FontBaseSize, ImGuiIO::FontGlobalScale, ImFont::FontSize, ImDrawListSharedData::FontSize, ImGuiContext::FontSize, GImGui, IM_ASSERT, ImMax(), ImGuiContext::IO, ImFont::IsLoaded(), ImFont::Scale, ImFontAtlas::TexUvLines, ImDrawListSharedData::TexUvLines, ImFontAtlas::TexUvWhitePixel, and ImDrawListSharedData::TexUvWhitePixel.

Referenced by NewFrame(), PopFont(), and PushFont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCursorPos()

void ImGui::SetCursorPos ( const ImVec2 & local_pos )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.CursorPos = window->Pos - window->Scroll + local_pos;
    window->DC.CursorMaxPos = ImMax(window->DC.CursorMaxPos, window->DC.CursorPos);
}

References ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), ImMax(), ImGuiWindow::Pos, and ImGuiWindow::Scroll.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCursorPosX()

void ImGui::SetCursorPosX ( float local_x )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.CursorPos.x = window->Pos.x - window->Scroll.x + x;
    window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, window->DC.CursorPos.x);
}

References ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), ImMax(), ImGuiWindow::Pos, ImGuiWindow::Scroll, and ImVec2::x.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCursorPosY()

void ImGui::SetCursorPosY ( float local_y )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.CursorPos.y = window->Pos.y - window->Scroll.y + y;
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, window->DC.CursorPos.y);
}

References ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), ImMax(), ImGuiWindow::Pos, ImGuiWindow::Scroll, and ImVec2::y.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCursorScreenPos()

void ImGui::SetCursorScreenPos ( const ImVec2 & pos )

{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.CursorPos = pos;
    window->DC.CursorMaxPos = ImMax(window->DC.CursorMaxPos, window->DC.CursorPos);
}

References ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), and ImMax().

Referenced by ColorPicker4(), ColorPickerOptionsPopup(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), and Slic3r::GUI::render_extruders_combo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDragDropPayload()

bool ImGui::SetDragDropPayload	(	const char *	type,
		const void *	data,
		size_t	sz,
		ImGuiCond	cond = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiPayload& payload = g.DragDropPayload;
    if (cond == 0)
        cond = ImGuiCond_Always;
 
    IM_ASSERT(type != NULL);
    IM_ASSERT(strlen(type) < IM_ARRAYSIZE(payload.DataType) && "Payload type can be at most 32 characters long");
    IM_ASSERT((data != NULL && data_size > 0) || (data == NULL && data_size == 0));
    IM_ASSERT(cond == ImGuiCond_Always || cond == ImGuiCond_Once);
    IM_ASSERT(payload.SourceId != 0);                               // Not called between BeginDragDropSource() and EndDragDropSource()
 
    if (cond == ImGuiCond_Always || payload.DataFrameCount == -1)
    {
        // Copy payload
        ImStrncpy(payload.DataType, type, IM_ARRAYSIZE(payload.DataType));
        g.DragDropPayloadBufHeap.resize(0);
        if (data_size > sizeof(g.DragDropPayloadBufLocal))
        {
            // Store in heap
            g.DragDropPayloadBufHeap.resize((int)data_size);
            payload.Data = g.DragDropPayloadBufHeap.Data;
            memcpy(payload.Data, data, data_size);
        }
        else if (data_size > 0)
        {
            // Store locally
            memset(&g.DragDropPayloadBufLocal, 0, sizeof(g.DragDropPayloadBufLocal));
            payload.Data = g.DragDropPayloadBufLocal;
            memcpy(payload.Data, data, data_size);
        }
        else
        {
            payload.Data = NULL;
        }
        payload.DataSize = (int)data_size;
    }
    payload.DataFrameCount = g.FrameCount;
 
    return (g.DragDropAcceptFrameCount == g.FrameCount) || (g.DragDropAcceptFrameCount == g.FrameCount - 1);
}

References ImVector< T >::Data, ImGuiPayload::Data, ImGuiPayload::DataFrameCount, ImGuiPayload::DataSize, ImGuiPayload::DataType, ImGuiContext::DragDropAcceptFrameCount, ImGuiContext::DragDropPayload, ImGuiContext::DragDropPayloadBufHeap, ImGuiContext::DragDropPayloadBufLocal, ImGuiContext::FrameCount, GImGui, IM_ARRAYSIZE, IM_ASSERT, ImGuiCond_Always, ImGuiCond_Once, ImStrncpy(), ImVector< T >::resize(), and ImGuiPayload::SourceId.

Referenced by ColorButton(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFocusID()

void ImGui::SetFocusID	(	ImGuiID	id,
		ImGuiWindow *	window
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(id != 0);
 
    // Assume that SetFocusID() is called in the context where its window->DC.NavLayerCurrent and window->DC.NavFocusScopeIdCurrent are valid.
    // Note that window may be != g.CurrentWindow (e.g. SetFocusID call in InputTextEx for multi-line text)
    const ImGuiNavLayer nav_layer = window->DC.NavLayerCurrent;
    if (g.NavWindow != window)
        g.NavInitRequest = false;
    g.NavWindow = window;
    g.NavId = id;
    g.NavLayer = nav_layer;
    g.NavFocusScopeId = window->DC.NavFocusScopeIdCurrent;
    window->NavLastIds[nav_layer] = id;
    if (window->DC.LastItemId == id)
        window->NavRectRel[nav_layer] = ImRect(window->DC.LastItemRect.Min - window->Pos, window->DC.LastItemRect.Max - window->Pos);
 
    if (g.ActiveIdSource == ImGuiInputSource_Nav)
        g.NavDisableMouseHover = true;
    else
        g.NavDisableHighlight = true;
}

References ImGuiContext::ActiveIdSource, ImGuiWindow::DC, GImGui, IM_ASSERT, ImGuiInputSource_Nav, ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemRect, ImRect::Max, ImRect::Min, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavFocusScopeId, ImGuiWindowTempData::NavFocusScopeIdCurrent, ImGuiContext::NavId, ImGuiContext::NavInitRequest, ImGuiWindow::NavLastIds, ImGuiContext::NavLayer, ImGuiWindowTempData::NavLayerCurrent, ImGuiWindow::NavRectRel, ImGuiContext::NavWindow, and ImGuiWindow::Pos.

Referenced by ButtonBehavior(), DragScalar(), InputTextEx(), SliderScalar(), and VSliderScalar().

Here is the caller graph for this function:

◆ SetHoveredID()

void ImGui::SetHoveredID ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    g.HoveredId = id;
    g.HoveredIdAllowOverlap = false;
    g.HoveredIdUsingMouseWheel = false;
    if (id != 0 && g.HoveredIdPreviousFrame != id)
        g.HoveredIdTimer = g.HoveredIdNotActiveTimer = 0.0f;
}

References GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdAllowOverlap, ImGuiContext::HoveredIdNotActiveTimer, ImGuiContext::HoveredIdPreviousFrame, ImGuiContext::HoveredIdTimer, and ImGuiContext::HoveredIdUsingMouseWheel.

Referenced by ButtonBehavior(), ItemHoverable(), and ScrollbarEx().

Here is the caller graph for this function:

◆ SetItemAllowOverlap()

void ImGui::SetItemAllowOverlap ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiID id = g.CurrentWindow->DC.LastItemId;
    if (g.HoveredId == id)
        g.HoveredIdAllowOverlap = true;
    if (g.ActiveId == id)
        g.ActiveIdAllowOverlap = true;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdAllowOverlap, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdAllowOverlap, and ImGuiWindowTempData::LastItemId.

Referenced by Slic3r::GUI::selectable(), Selectable(), SplitterBehavior(), TabItemEx(), TableHeader(), and TreeNodeBehavior().

Here is the caller graph for this function:

◆ SetItemDefaultFocus()

void ImGui::SetItemDefaultFocus ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (!window->Appearing)
        return;
    if (g.NavWindow == window->RootWindowForNav && (g.NavInitRequest || g.NavInitResultId != 0) && g.NavLayer == window->DC.NavLayerCurrent)
    {
        g.NavInitRequest = false;
        g.NavInitResultId = window->DC.LastItemId;
        g.NavInitResultRectRel = ImRect(window->DC.LastItemRect.Min - window->Pos, window->DC.LastItemRect.Max - window->Pos);
        NavUpdateAnyRequestFlag();
        if (!IsItemVisible())
            SetScrollHereY();
    }
}

References ImGuiWindow::Appearing, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, IsItemVisible(), ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemRect, ImRect::Max, ImRect::Min, ImGuiContext::NavInitRequest, ImGuiContext::NavInitResultId, ImGuiContext::NavInitResultRectRel, ImGuiContext::NavLayer, ImGuiWindowTempData::NavLayerCurrent, NavUpdateAnyRequestFlag(), ImGuiContext::NavWindow, ImGuiWindow::Pos, ImGuiWindow::RootWindowForNav, and SetScrollHereY().

Referenced by ExampleAppConsole::Draw(), ShowDemoWindowPopups(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetItemUsingMouseWheel()

void ImGui::SetItemUsingMouseWheel ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiID id = g.CurrentWindow->DC.LastItemId;
    if (g.HoveredId == id)
        g.HoveredIdUsingMouseWheel = true;
    if (g.ActiveId == id)
        g.ActiveIdUsingMouseWheel = true;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdUsingMouseWheel, ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdUsingMouseWheel, and ImGuiWindowTempData::LastItemId.

◆ SetKeyboardFocusHere()

void ImGui::SetKeyboardFocusHere ( int offset = 0 )

{
    IM_ASSERT(offset >= -1);    // -1 is allowed but not below
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    g.TabFocusRequestNextWindow = window;
    g.TabFocusRequestNextCounterRegular = window->DC.FocusCounterRegular + 1 + offset;
    g.TabFocusRequestNextCounterTabStop = INT_MAX;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiWindowTempData::FocusCounterRegular, GImGui, IM_ASSERT, ImGuiContext::TabFocusRequestNextCounterRegular, ImGuiContext::TabFocusRequestNextCounterTabStop, and ImGuiContext::TabFocusRequestNextWindow.

Referenced by ExampleAppConsole::Draw(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::ImGuiWrapper::search_list(), ShowDemoWindowMisc(), and Slic3r::GUI::ImGuiWrapper::slider_float().

Here is the caller graph for this function:

◆ SetLastItemData()

void ImGui::SetLastItemData	(	ImGuiWindow *	window,
		ImGuiID	item_id,
		ImGuiItemStatusFlags	status_flags,
		const ImRect &	item_rect
	)

{
    window->DC.LastItemId = item_id;
    window->DC.LastItemStatusFlags = item_flags;
    window->DC.LastItemRect = item_rect;
}

References ImGuiWindow::DC, ImGuiWindowTempData::LastItemId, ImGuiWindowTempData::LastItemRect, and ImGuiWindowTempData::LastItemStatusFlags.

Referenced by Begin().

Here is the caller graph for this function:

◆ SetMouseCursor()

void ImGui::SetMouseCursor ( ImGuiMouseCursor cursor_type )

{
    GImGui->MouseCursor = cursor_type;
}

References GImGui, and ImGuiContext::MouseCursor.

Referenced by ShowDemoWindowMisc(), SplitterBehavior(), TableUpdateBorders(), and UpdateDebugToolItemPicker().

Here is the caller graph for this function:

◆ SetNavID()

void ImGui::SetNavID	(	ImGuiID	id,
		ImGuiNavLayer	nav_layer,
		ImGuiID	focus_scope_id,
		const ImRect &	rect_rel
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavWindow != NULL);
    IM_ASSERT(nav_layer == ImGuiNavLayer_Main || nav_layer == ImGuiNavLayer_Menu);
    g.NavId = id;
    g.NavLayer = nav_layer;
    g.NavFocusScopeId = focus_scope_id;
    g.NavWindow->NavLastIds[nav_layer] = id;
    g.NavWindow->NavRectRel[nav_layer] = rect_rel;
    //g.NavDisableHighlight = false;
    //g.NavDisableMouseHover = g.NavMousePosDirty = true;
}

References GImGui, IM_ASSERT, ImGuiNavLayer_Main, ImGuiNavLayer_Menu, ImGuiContext::NavFocusScopeId, ImGuiContext::NavId, ImGuiWindow::NavLastIds, ImGuiContext::NavLayer, ImGuiWindow::NavRectRel, and ImGuiContext::NavWindow.

Referenced by EndMenuBar(), NavInitWindow(), NavRestoreLayer(), NavUpdate(), NavUpdateInitResult(), NavUpdateMoveResult(), Slic3r::GUI::selectable(), Selectable(), and TreePop().

Here is the caller graph for this function:

◆ SetNextItemOpen()

void ImGui::SetNextItemOpen	(	bool	is_open,
		ImGuiCond	cond = `0`
	)

{
    ImGuiContext& g = *GImGui;
    if (g.CurrentWindow->SkipItems)
        return;
    g.NextItemData.Flags |= ImGuiNextItemDataFlags_HasOpen;
    g.NextItemData.OpenVal = is_open;
    g.NextItemData.OpenCond = cond ? cond : ImGuiCond_Always;
}

References ImGuiContext::CurrentWindow, ImGuiNextItemData::Flags, GImGui, ImGuiCond_Always, ImGuiNextItemDataFlags_HasOpen, ImGuiContext::NextItemData, ImGuiNextItemData::OpenCond, ImGuiNextItemData::OpenVal, and ImGuiWindow::SkipItems.

Referenced by DebugNodeViewport(), SetNextTreeNodeOpen(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the caller graph for this function:

◆ SetNextItemWidth()

void ImGui::SetNextItemWidth ( float item_width )

{
    ImGuiContext& g = *GImGui;
    g.NextItemData.Flags |= ImGuiNextItemDataFlags_HasWidth;
    g.NextItemData.Width = item_width;
}

References ImGuiNextItemData::Flags, GImGui, ImGuiNextItemDataFlags_HasWidth, ImGuiContext::NextItemData, and ImGuiNextItemData::Width.

Here is the caller graph for this function:

◆ SetNextTreeNodeOpen()

static void ImGui::SetNextTreeNodeOpen	(	bool	open,
		ImGuiCond	cond = `0`
	)

inlinestatic

2810{ SetNextItemOpen(open, cond); }

References SetNextItemOpen(), and SetNextTreeNodeOpen().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_window(), and SetNextTreeNodeOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetNextWindowBgAlpha()

void ImGui::SetNextWindowBgAlpha ( float alpha )

{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasBgAlpha;
    g.NextWindowData.BgAlphaVal = alpha;
}

References ImGuiNextWindowData::BgAlphaVal, ImGuiNextWindowData::Flags, GImGui, ImGuiNextWindowDataFlags_HasBgAlpha, and ImGuiContext::NextWindowData.

Referenced by BeginTooltipEx(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::ImGuiWrapper::set_next_window_bg_alpha(), ShowExampleAppSimpleOverlay(), and UpdateDebugToolItemPicker().

Here is the caller graph for this function:

◆ SetNextWindowCollapsed()

void ImGui::SetNextWindowCollapsed	(	bool	collapsed,
		ImGuiCond	cond = `0`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasCollapsed;
    g.NextWindowData.CollapsedVal = collapsed;
    g.NextWindowData.CollapsedCond = cond ? cond : ImGuiCond_Always;
}

References ImGuiNextWindowData::CollapsedCond, ImGuiNextWindowData::CollapsedVal, ImGuiNextWindowData::Flags, GImGui, IM_ASSERT, ImGuiCond_Always, ImGuiNextWindowDataFlags_HasCollapsed, ImIsPowerOfTwo(), and ImGuiContext::NextWindowData.

Here is the call graph for this function:

◆ SetNextWindowContentSize()

void ImGui::SetNextWindowContentSize ( const ImVec2 & size )

{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasContentSize;
    g.NextWindowData.ContentSizeVal = ImFloor(size);
}

References ImGuiNextWindowData::ContentSizeVal, ImGuiNextWindowData::Flags, GImGui, ImFloor(), ImGuiNextWindowDataFlags_HasContentSize, and ImGuiContext::NextWindowData.

Referenced by BeginTableEx(), ShowDemoWindowColumns(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetNextWindowFocus()

void ImGui::SetNextWindowFocus ( )

{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasFocus;
}

References ImGuiNextWindowData::Flags, GImGui, ImGuiNextWindowDataFlags_HasFocus, and ImGuiContext::NextWindowData.

◆ SetNextWindowPos()

void ImGui::SetNextWindowPos	(	const ImVec2 &	pos,
		ImGuiCond	cond = `0`,
		const ImVec2 &	pivot = `ImVec2(0, 0)`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasPos;
    g.NextWindowData.PosVal = pos;
    g.NextWindowData.PosPivotVal = pivot;
    g.NextWindowData.PosCond = cond ? cond : ImGuiCond_Always;
}

References ImGuiNextWindowData::Flags, GImGui, IM_ASSERT, ImGuiCond_Always, ImGuiNextWindowDataFlags_HasPos, ImIsPowerOfTwo(), ImGuiContext::NextWindowData, ImGuiNextWindowData::PosCond, ImGuiNextWindowData::PosPivotVal, and ImGuiNextWindowData::PosVal.

Referenced by BeginCombo(), BeginMenu(), BeginPopupModal(), BeginTooltipEx(), BeginViewportSideBar(), ColorEdit4(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), NavUpdateWindowingOverlay(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), ShowDemoWindow(), ShowDemoWindowPopups(), ShowExampleAppFullscreen(), ShowExampleAppSimpleOverlay(), ShowExampleAppWindowTitles(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetNextWindowScroll()

void ImGui::SetNextWindowScroll ( const ImVec2 & scroll )

{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasScroll;
    g.NextWindowData.ScrollVal = scroll;
}

References ImGuiNextWindowData::Flags, GImGui, ImGuiNextWindowDataFlags_HasScroll, ImGuiContext::NextWindowData, and ImGuiNextWindowData::ScrollVal.

Referenced by BeginTableEx().

Here is the caller graph for this function:

◆ SetNextWindowSize()

void ImGui::SetNextWindowSize	(	const ImVec2 &	size,
		ImGuiCond	cond = `0`
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSize;
    g.NextWindowData.SizeVal = size;
    g.NextWindowData.SizeCond = cond ? cond : ImGuiCond_Always;
}

References ImGuiNextWindowData::Flags, GImGui, IM_ASSERT, ImGuiCond_Always, ImGuiNextWindowDataFlags_HasSize, ImIsPowerOfTwo(), ImGuiContext::NextWindowData, ImGuiNextWindowData::SizeCond, and ImGuiNextWindowData::SizeVal.

Referenced by BeginChildEx(), BeginViewportSideBar(), ExampleAppConsole::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), NewFrame(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::set_next_window_size(), ShowDemoWindow(), ShowExampleAppFullscreen(), ShowExampleAppLayout(), ShowExampleAppLog(), ShowExampleAppLongText(), and ShowExampleAppPropertyEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetNextWindowSizeConstraints()

void ImGui::SetNextWindowSizeConstraints	(	const ImVec2 &	size_min,
		const ImVec2 &	size_max,
		ImGuiSizeCallback	custom_callback = `NULL`,
		void *	custom_callback_data = `NULL`
	)

{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSizeConstraint;
    g.NextWindowData.SizeConstraintRect = ImRect(size_min, size_max);
    g.NextWindowData.SizeCallback = custom_callback;
    g.NextWindowData.SizeCallbackUserData = custom_callback_user_data;
}

References ImGuiNextWindowData::Flags, GImGui, ImGuiNextWindowDataFlags_HasSizeConstraint, ImGuiContext::NextWindowData, ImGuiNextWindowData::SizeCallback, ImGuiNextWindowData::SizeCallbackUserData, and ImGuiNextWindowData::SizeConstraintRect.

Referenced by BeginCombo(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_window(), NavUpdateWindowingOverlay(), Slic3r::GUI::GCodeViewer::render_legend(), and ShowExampleAppConstrainedResize().

Here is the caller graph for this function:

◆ SetScrollFromPosX() [1/2]

void ImGui::SetScrollFromPosX	(	float	local_x,
		float	center_x_ratio = `0.5f`
	)

{
    ImGuiContext& g = *GImGui;
    SetScrollFromPosX(g.CurrentWindow, local_x, center_x_ratio);
}

References ImGuiContext::CurrentWindow, GImGui, and SetScrollFromPosX().

Referenced by EndTable(), ScrollToBringRectIntoView(), SetScrollFromPosX(), SetScrollHereX(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScrollFromPosX() [2/2]

void ImGui::SetScrollFromPosX	(	ImGuiWindow *	window,
		float	local_x,
		float	center_x_ratio
	)

{
    IM_ASSERT(center_x_ratio >= 0.0f && center_x_ratio <= 1.0f);
    window->ScrollTarget.x = IM_FLOOR(local_x + window->Scroll.x); // Convert local position to scroll offset
    window->ScrollTargetCenterRatio.x = center_x_ratio;
    window->ScrollTargetEdgeSnapDist.x = 0.0f;
}

References IM_ASSERT, IM_FLOOR, ImGuiWindow::Scroll, ImGuiWindow::ScrollTarget, ImGuiWindow::ScrollTargetCenterRatio, ImGuiWindow::ScrollTargetEdgeSnapDist, and ImVec2::x.

◆ SetScrollFromPosY() [1/2]

void ImGui::SetScrollFromPosY	(	float	local_y,
		float	center_y_ratio = `0.5f`
	)

{
    ImGuiContext& g = *GImGui;
    SetScrollFromPosY(g.CurrentWindow, local_y, center_y_ratio);
}

References ImGuiContext::CurrentWindow, GImGui, and SetScrollFromPosY().

Referenced by ScrollToBringRectIntoView(), SetScrollFromPosY(), SetScrollHereY(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScrollFromPosY() [2/2]

void ImGui::SetScrollFromPosY	(	ImGuiWindow *	window,
		float	local_y,
		float	center_y_ratio
	)

{
    IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
    const float decoration_up_height = window->TitleBarHeight() + window->MenuBarHeight(); // FIXME: Would be nice to have a more standardized access to our scrollable/client rect;
    local_y -= decoration_up_height;
    window->ScrollTarget.y = IM_FLOOR(local_y + window->Scroll.y); // Convert local position to scroll offset
    window->ScrollTargetCenterRatio.y = center_y_ratio;
    window->ScrollTargetEdgeSnapDist.y = 0.0f;
}

References IM_ASSERT, IM_FLOOR, ImGuiWindow::MenuBarHeight(), ImGuiWindow::Scroll, ImGuiWindow::ScrollTarget, ImGuiWindow::ScrollTargetCenterRatio, ImGuiWindow::ScrollTargetEdgeSnapDist, ImGuiWindow::TitleBarHeight(), and ImVec2::y.

Here is the call graph for this function:

◆ SetScrollHereX()

void ImGui::SetScrollHereX ( float center_x_ratio = 0.5f )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float spacing_x = ImMax(window->WindowPadding.x, g.Style.ItemSpacing.x);
    float target_pos_x = ImLerp(window->DC.LastItemRect.Min.x - spacing_x, window->DC.LastItemRect.Max.x + spacing_x, center_x_ratio);
    SetScrollFromPosX(window, target_pos_x - window->Pos.x, center_x_ratio); // Convert from absolute to local pos
 
    // Tweak: snap on edges when aiming at an item very close to the edge
    window->ScrollTargetEdgeSnapDist.x = ImMax(0.0f, window->WindowPadding.x - spacing_x);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImLerp(), ImMax(), ImGuiStyle::ItemSpacing, ImGuiWindowTempData::LastItemRect, ImRect::Max, ImRect::Min, ImGuiWindow::Pos, ImGuiWindow::ScrollTargetEdgeSnapDist, SetScrollFromPosX(), ImGuiContext::Style, ImGuiWindow::WindowPadding, and ImVec2::x.

Referenced by ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScrollHereY()

void ImGui::SetScrollHereY ( float center_y_ratio = 0.5f )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float spacing_y = ImMax(window->WindowPadding.y, g.Style.ItemSpacing.y);
    float target_pos_y = ImLerp(window->DC.CursorPosPrevLine.y - spacing_y, window->DC.CursorPosPrevLine.y + window->DC.PrevLineSize.y + spacing_y, center_y_ratio);
    SetScrollFromPosY(window, target_pos_y - window->Pos.y, center_y_ratio); // Convert from absolute to local pos
 
    // Tweak: snap on edges when aiming at an item very close to the edge
    window->ScrollTargetEdgeSnapDist.y = ImMax(0.0f, window->WindowPadding.y - spacing_y);
}

References ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPosPrevLine, ImGuiWindow::DC, GImGui, ImLerp(), ImMax(), ImGuiStyle::ItemSpacing, ImGuiWindow::Pos, ImGuiWindowTempData::PrevLineSize, ImGuiWindow::ScrollTargetEdgeSnapDist, SetScrollFromPosY(), ImGuiContext::Style, ImGuiWindow::WindowPadding, and ImVec2::y.

Referenced by ExampleAppConsole::Draw(), ExampleAppLog::Draw(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), SetItemDefaultFocus(), and ShowDemoWindowLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScrollX() [1/2]

void ImGui::SetScrollX ( float scroll_x )

{
    ImGuiContext& g = *GImGui;
    SetScrollX(g.CurrentWindow, scroll_x);
}

References ImGuiContext::CurrentWindow, GImGui, scroll_x, and SetScrollX().

Referenced by NavUpdate(), SetScrollX(), ShowDemoWindowLayout(), and UpdateMouseWheel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScrollX() [2/2]

void ImGui::SetScrollX	(	ImGuiWindow *	window,
		float	scroll_x
	)

{
    window->ScrollTarget.x = scroll_x;
    window->ScrollTargetCenterRatio.x = 0.0f;
    window->ScrollTargetEdgeSnapDist.x = 0.0f;
}

References scroll_x, ImGuiWindow::ScrollTarget, ImGuiWindow::ScrollTargetCenterRatio, ImGuiWindow::ScrollTargetEdgeSnapDist, and ImVec2::x.

◆ SetScrollY() [1/2]

void ImGui::SetScrollY ( float scroll_y )

{
    ImGuiContext& g = *GImGui;
    SetScrollY(g.CurrentWindow, scroll_y);
}

References ImGuiContext::CurrentWindow, GImGui, scroll_y, and SetScrollY().

Referenced by InputTextEx(), NavUpdate(), NavUpdateMoveResult(), NavUpdatePageUpPageDown(), Slic3r::GUI::scroll_down(), Slic3r::GUI::scroll_up(), Slic3r::GUI::scroll_y(), SetScrollY(), ShowDemoWindowLayout(), and UpdateMouseWheel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScrollY() [2/2]

void ImGui::SetScrollY	(	ImGuiWindow *	window,
		float	scroll_y
	)

{
    window->ScrollTarget.y = scroll_y;
    window->ScrollTargetCenterRatio.y = 0.0f;
    window->ScrollTargetEdgeSnapDist.y = 0.0f;
}

References scroll_y, ImGuiWindow::ScrollTarget, ImGuiWindow::ScrollTargetCenterRatio, ImGuiWindow::ScrollTargetEdgeSnapDist, and ImVec2::y.

◆ SetStateStorage()

void ImGui::SetStateStorage ( ImGuiStorage * storage )

{
    ImGuiWindow* window = GImGui->CurrentWindow;
    window->DC.StateStorage = tree ? tree : &window->StateStorage;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiWindowTempData::StateStorage, and ImGuiWindow::StateStorage.

◆ SetTabItemClosed()

void ImGui::SetTabItemClosed ( const char * tab_or_docked_window_label )

{
    ImGuiContext& g = *GImGui;
    bool is_within_manual_tab_bar = g.CurrentTabBar && !(g.CurrentTabBar->Flags & ImGuiTabBarFlags_DockNode);
    if (is_within_manual_tab_bar)
    {
        ImGuiTabBar* tab_bar = g.CurrentTabBar;
        ImGuiID tab_id = TabBarCalcTabID(tab_bar, label);
        if (ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id))
            tab->WantClose = true; // Will be processed by next call to TabBarLayout()
    }
}

References ImGuiContext::CurrentTabBar, ImGuiTabBar::Flags, GImGui, ImGuiTabBarFlags_DockNode, TabBarCalcTabID(), and TabBarFindTabByID().

Referenced by NotifyOfDocumentsClosedElsewhere().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetTooltip()

void ImGui::SetTooltip	(	const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    SetTooltipV(fmt, args);
    va_end(args);
}

References SetTooltipV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetTooltipV()

void ImGui::SetTooltipV	(	const char *	fmt,
		va_list	args
	)

{
    BeginTooltipEx(0, ImGuiTooltipFlags_OverridePreviousTooltip);
    TextV(fmt, args);
    EndTooltip();
}

References BeginTooltipEx(), EndTooltip(), ImGuiTooltipFlags_OverridePreviousTooltip, and TextV().

Referenced by SetTooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWindowClipRectBeforeSetChannel()

void ImGui::SetWindowClipRectBeforeSetChannel	(	ImGuiWindow *	window,
		const ImRect &	clip_rect
	)

{
    ImVec4 clip_rect_vec4 = clip_rect.ToVec4();
    window->ClipRect = clip_rect;
    window->DrawList->_CmdHeader.ClipRect = clip_rect_vec4;
    window->DrawList->_ClipRectStack.Data[window->DrawList->_ClipRectStack.Size - 1] = clip_rect_vec4;
}

References ImDrawList::_ClipRectStack, ImDrawList::_CmdHeader, ImDrawCmdHeader::ClipRect, ImGuiWindow::ClipRect, ImVector< T >::Data, ImGuiWindow::DrawList, ImVector< T >::Size, and ImRect::ToVec4().

Referenced by NextColumn(), PopColumnsBackground(), PushColumnsBackground(), TableBeginCell(), TableEndRow(), TablePopBackgroundChannel(), and TablePushBackgroundChannel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWindowCollapsed() [1/3]

void ImGui::SetWindowCollapsed	(	bool	collapsed,
		ImGuiCond	cond = `0`
	)

{
    SetWindowCollapsed(GImGui->CurrentWindow, collapsed, cond);
}

References ImGuiContext::CurrentWindow, GImGui, and SetWindowCollapsed().

Referenced by Begin(), SetWindowCollapsed(), and SetWindowCollapsed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWindowCollapsed() [2/3]

void ImGui::SetWindowCollapsed	(	const char *	name,
		bool	collapsed,
		ImGuiCond	cond = `0`
	)

{
    if (ImGuiWindow* window = FindWindowByName(name))
        SetWindowCollapsed(window, collapsed, cond);
}

References FindWindowByName(), and SetWindowCollapsed().

Here is the call graph for this function:

◆ SetWindowCollapsed() [3/3]

void ImGui::SetWindowCollapsed	(	ImGuiWindow *	window,
		bool	collapsed,
		ImGuiCond	cond = `0`
	)

{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowCollapsedAllowFlags & cond) == 0)
        return;
    window->SetWindowCollapsedAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);
 
    // Set
    window->Collapsed = collapsed;
}

References ImGuiWindow::Collapsed, ImGuiCond_Appearing, ImGuiCond_FirstUseEver, ImGuiCond_Once, and ImGuiWindow::SetWindowCollapsedAllowFlags.

◆ SetWindowFocus() [1/2]

void ImGui::SetWindowFocus ( )

{
    FocusWindow(GImGui->CurrentWindow);
}

References ImGuiContext::CurrentWindow, FocusWindow(), and GImGui.

Here is the call graph for this function:

◆ SetWindowFocus() [2/2]

void ImGui::SetWindowFocus ( const char * name )

{
    if (name)
    {
        if (ImGuiWindow* window = FindWindowByName(name))
            FocusWindow(window);
    }
    else
    {
        FocusWindow(NULL);
    }
}

References FindWindowByName(), and FocusWindow().

Here is the call graph for this function:

◆ SetWindowFontScale()

void ImGui::SetWindowFontScale ( float scale )

{
    IM_ASSERT(scale > 0.0f);
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->FontWindowScale = scale;
    g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
}

References ImGuiWindow::CalcFontSize(), ImGuiContext::DrawListSharedData, ImDrawListSharedData::FontSize, ImGuiContext::FontSize, ImGuiWindow::FontWindowScale, GetCurrentWindow(), GImGui, IM_ASSERT, and scale().

Referenced by ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWindowHitTestHole()

void ImGui::SetWindowHitTestHole	(	ImGuiWindow *	window,
		const ImVec2 &	pos,
		const ImVec2 &	size
	)

{
    IM_ASSERT(window->HitTestHoleSize.x == 0);     // We don't support multiple holes/hit test filters
    window->HitTestHoleSize = ImVec2ih(size);
    window->HitTestHoleOffset = ImVec2ih(pos - window->Pos);
}

References ImGuiWindow::HitTestHoleOffset, ImGuiWindow::HitTestHoleSize, IM_ASSERT, ImGuiWindow::Pos, and ImVec2ih::x.

◆ SetWindowPos() [1/3]

void ImGui::SetWindowPos	(	const char *	name,
		const ImVec2 &	pos,
		ImGuiCond	cond = `0`
	)

{
    if (ImGuiWindow* window = FindWindowByName(name))
        SetWindowPos(window, pos, cond);
}

References FindWindowByName(), and SetWindowPos().

Here is the call graph for this function:

◆ SetWindowPos() [2/3]

void ImGui::SetWindowPos	(	const ImVec2 &	pos,
		ImGuiCond	cond = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindowRead();
    SetWindowPos(window, pos, cond);
}

References GetCurrentWindowRead(), and SetWindowPos().

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::GLGizmoCut3D::adjust_window_position(), Begin(), NavUpdateWindowing(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoSlaSupports::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::render_debug_input_window(), SetWindowPos(), SetWindowPos(), UpdateMouseMovingWindowNewFrame(), and UpdateMouseWheel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWindowPos() [3/3]

void ImGui::SetWindowPos	(	ImGuiWindow *	window,
		const ImVec2 &	pos,
		ImGuiCond	cond = `0`
	)

{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
        return;
 
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    window->SetWindowPosAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);
    window->SetWindowPosVal = ImVec2(FLT_MAX, FLT_MAX);
 
    // Set
    const ImVec2 old_pos = window->Pos;
    window->Pos = ImFloor(pos);
    ImVec2 offset = window->Pos - old_pos;
    window->DC.CursorPos += offset;         // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
    window->DC.CursorMaxPos += offset;      // And more importantly we need to offset CursorMaxPos/CursorStartPos this so ContentSize calculation doesn't get affected.
    window->DC.IdealMaxPos += offset;
    window->DC.CursorStartPos += offset;
}

References ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindowTempData::CursorStartPos, ImGuiWindow::DC, ImGuiWindowTempData::IdealMaxPos, IM_ASSERT, ImFloor(), ImGuiCond_Appearing, ImGuiCond_FirstUseEver, ImGuiCond_Once, ImIsPowerOfTwo(), ImGuiWindow::Pos, ImGuiWindow::SetWindowPosAllowFlags, and ImGuiWindow::SetWindowPosVal.

Here is the call graph for this function:

◆ SetWindowSize() [1/3]

void ImGui::SetWindowSize	(	const char *	name,
		const ImVec2 &	size,
		ImGuiCond	cond = `0`
	)

{
    if (ImGuiWindow* window = FindWindowByName(name))
        SetWindowSize(window, size, cond);
}

References FindWindowByName(), and SetWindowSize().

Here is the call graph for this function:

◆ SetWindowSize() [2/3]

void ImGui::SetWindowSize	(	const ImVec2 &	size,
		ImGuiCond	cond = `0`
	)

{
    SetWindowSize(GImGui->CurrentWindow, size, cond);
}

References ImGuiContext::CurrentWindow, GImGui, and SetWindowSize().

Referenced by Begin(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::set_minimal_window_size(), SetWindowSize(), SetWindowSize(), and ShowExampleAppConstrainedResize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWindowSize() [3/3]

void ImGui::SetWindowSize	(	ImGuiWindow *	window,
		const ImVec2 &	size,
		ImGuiCond	cond = `0`
	)

{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
        return;
 
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    window->SetWindowSizeAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);
 
    // Set
    if (size.x > 0.0f)
    {
        window->AutoFitFramesX = 0;
        window->SizeFull.x = IM_FLOOR(size.x);
    }
    else
    {
        window->AutoFitFramesX = 2;
        window->AutoFitOnlyGrows = false;
    }
    if (size.y > 0.0f)
    {
        window->AutoFitFramesY = 0;
        window->SizeFull.y = IM_FLOOR(size.y);
    }
    else
    {
        window->AutoFitFramesY = 2;
        window->AutoFitOnlyGrows = false;
    }
}

References ImGuiWindow::AutoFitFramesX, ImGuiWindow::AutoFitFramesY, ImGuiWindow::AutoFitOnlyGrows, IM_ASSERT, IM_FLOOR, ImGuiCond_Appearing, ImGuiCond_FirstUseEver, ImGuiCond_Once, ImIsPowerOfTwo(), ImGuiWindow::SetWindowSizeAllowFlags, ImGuiWindow::SizeFull, ImVec2::x, and ImVec2::y.

Here is the call graph for this function:

◆ ShadeVertsLinearColorGradientKeepAlpha()

void ImGui::ShadeVertsLinearColorGradientKeepAlpha	(	ImDrawList *	draw_list,
		int	vert_start_idx,
		int	vert_end_idx,
		ImVec2	gradient_p0,
		ImVec2	gradient_p1,
		ImU32	col0,
		ImU32	col1
	)

{
    ImVec2 gradient_extent = gradient_p1 - gradient_p0;
    float gradient_inv_length2 = 1.0f / ImLengthSqr(gradient_extent);
    ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx;
    ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx;
    const int col0_r = (int)(col0 >> IM_COL32_R_SHIFT) & 0xFF;
    const int col0_g = (int)(col0 >> IM_COL32_G_SHIFT) & 0xFF;
    const int col0_b = (int)(col0 >> IM_COL32_B_SHIFT) & 0xFF;
    const int col_delta_r = ((int)(col1 >> IM_COL32_R_SHIFT) & 0xFF) - col0_r;
    const int col_delta_g = ((int)(col1 >> IM_COL32_G_SHIFT) & 0xFF) - col0_g;
    const int col_delta_b = ((int)(col1 >> IM_COL32_B_SHIFT) & 0xFF) - col0_b;
    for (ImDrawVert* vert = vert_start; vert < vert_end; vert++)
    {
        float d = ImDot(vert->pos - gradient_p0, gradient_extent);
        float t = ImClamp(d * gradient_inv_length2, 0.0f, 1.0f);
        int r = (int)(col0_r + col_delta_r * t);
        int g = (int)(col0_g + col_delta_g * t);
        int b = (int)(col0_b + col_delta_b * t);
        vert->col = (r << IM_COL32_R_SHIFT) | (g << IM_COL32_G_SHIFT) | (b << IM_COL32_B_SHIFT) | (vert->col & IM_COL32_A_MASK);
    }
}

References ImVector< T >::Data, IM_COL32_A_MASK, IM_COL32_B_SHIFT, IM_COL32_G_SHIFT, IM_COL32_R_SHIFT, ImClamp(), ImDot(), ImLengthSqr(), and ImDrawList::VtxBuffer.

Referenced by ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShadeVertsLinearUV()

void ImGui::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
	)

{
    const ImVec2 size = b - a;
    const ImVec2 uv_size = uv_b - uv_a;
    const ImVec2 scale = ImVec2(
        size.x != 0.0f ? (uv_size.x / size.x) : 0.0f,
        size.y != 0.0f ? (uv_size.y / size.y) : 0.0f);
 
    ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx;
    ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx;
    if (clamp)
    {
        const ImVec2 min = ImMin(uv_a, uv_b);
        const ImVec2 max = ImMax(uv_a, uv_b);
        for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
            vertex->uv = ImClamp(uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale), min, max);
    }
    else
    {
        for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
            vertex->uv = uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale);
    }
}

References ImVector< T >::Data, ImClamp(), ImMax(), ImMin(), ImMul(), scale(), ImDrawList::VtxBuffer, ImVec2::x, and ImVec2::y.

Referenced by ImDrawList::AddImageRounded().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowAboutWindow()

void ImGui::ShowAboutWindow ( bool * p_open = NULL )

{
    if (!ImGui::Begin("About Dear ImGui", p_open, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::End();
        return;
    }
    ImGui::Text("Dear ImGui %s", ImGui::GetVersion());
    ImGui::Separator();
    ImGui::Text("By Omar Cornut and all Dear ImGui contributors.");
    ImGui::Text("Dear ImGui is licensed under the MIT License, see LICENSE for more information.");
 
    static bool show_config_info = false;
    ImGui::Checkbox("Config/Build Information", &show_config_info);
    if (show_config_info)
    {
        ImGuiIO& io = ImGui::GetIO();
        ImGuiStyle& style = ImGui::GetStyle();
 
        bool copy_to_clipboard = ImGui::Button("Copy to clipboard");
        ImVec2 child_size = ImVec2(0, ImGui::GetTextLineHeightWithSpacing() * 18);
        ImGui::BeginChildFrame(ImGui::GetID("cfg_infos"), child_size, ImGuiWindowFlags_NoMove);
        if (copy_to_clipboard)
        {
            ImGui::LogToClipboard();
            ImGui::LogText("```\n"); // Back quotes will make text appears without formatting when pasting on GitHub
        }
 
        ImGui::Text("Dear ImGui %s (%d)", IMGUI_VERSION, IMGUI_VERSION_NUM);
        ImGui::Separator();
        ImGui::Text("sizeof(size_t): %d, sizeof(ImDrawIdx): %d, sizeof(ImDrawVert): %d", (int)sizeof(size_t), (int)sizeof(ImDrawIdx), (int)sizeof(ImDrawVert));
        ImGui::Text("define: __cplusplus=%d", (int)__cplusplus);
#ifdef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_OBSOLETE_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_WIN32_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_WIN32_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_FILE_FUNCTIONS
        ImGui::Text("define: IMGUI_DISABLE_FILE_FUNCTIONS");
#endif
#ifdef IMGUI_DISABLE_DEFAULT_ALLOCATORS
        ImGui::Text("define: IMGUI_DISABLE_DEFAULT_ALLOCATORS");
#endif
#ifdef IMGUI_USE_BGRA_PACKED_COLOR
        ImGui::Text("define: IMGUI_USE_BGRA_PACKED_COLOR");
#endif
#ifdef _WIN32
        ImGui::Text("define: _WIN32");
#endif
#ifdef _WIN64
        ImGui::Text("define: _WIN64");
#endif
#ifdef __linux__
        ImGui::Text("define: __linux__");
#endif
#ifdef __APPLE__
        ImGui::Text("define: __APPLE__");
#endif
#ifdef _MSC_VER
        ImGui::Text("define: _MSC_VER=%d", _MSC_VER);
#endif
#ifdef _MSVC_LANG
        ImGui::Text("define: _MSVC_LANG=%d", (int)_MSVC_LANG);
#endif
#ifdef __MINGW32__
        ImGui::Text("define: __MINGW32__");
#endif
#ifdef __MINGW64__
        ImGui::Text("define: __MINGW64__");
#endif
#ifdef __GNUC__
        ImGui::Text("define: __GNUC__=%d", (int)__GNUC__);
#endif
#ifdef __clang_version__
        ImGui::Text("define: __clang_version__=%s", __clang_version__);
#endif
        ImGui::Separator();
        ImGui::Text("io.BackendPlatformName: %s", io.BackendPlatformName ? io.BackendPlatformName : "NULL");
        ImGui::Text("io.BackendRendererName: %s", io.BackendRendererName ? io.BackendRendererName : "NULL");
        ImGui::Text("io.ConfigFlags: 0x%08X", io.ConfigFlags);
        if (io.ConfigFlags & ImGuiConfigFlags_NavEnableKeyboard)        ImGui::Text(" NavEnableKeyboard");
        if (io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad)         ImGui::Text(" NavEnableGamepad");
        if (io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos)     ImGui::Text(" NavEnableSetMousePos");
        if (io.ConfigFlags & ImGuiConfigFlags_NavNoCaptureKeyboard)     ImGui::Text(" NavNoCaptureKeyboard");
        if (io.ConfigFlags & ImGuiConfigFlags_NoMouse)                  ImGui::Text(" NoMouse");
        if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)      ImGui::Text(" NoMouseCursorChange");
        if (io.MouseDrawCursor)                                         ImGui::Text("io.MouseDrawCursor");
        if (io.ConfigMacOSXBehaviors)                                   ImGui::Text("io.ConfigMacOSXBehaviors");
        if (io.ConfigInputTextCursorBlink)                              ImGui::Text("io.ConfigInputTextCursorBlink");
        if (io.ConfigWindowsResizeFromEdges)                            ImGui::Text("io.ConfigWindowsResizeFromEdges");
        if (io.ConfigWindowsMoveFromTitleBarOnly)                       ImGui::Text("io.ConfigWindowsMoveFromTitleBarOnly");
        if (io.ConfigMemoryCompactTimer >= 0.0f)                        ImGui::Text("io.ConfigMemoryCompactTimer = %.1f", io.ConfigMemoryCompactTimer);
        ImGui::Text("io.BackendFlags: 0x%08X", io.BackendFlags);
        if (io.BackendFlags & ImGuiBackendFlags_HasGamepad)             ImGui::Text(" HasGamepad");
        if (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors)        ImGui::Text(" HasMouseCursors");
        if (io.BackendFlags & ImGuiBackendFlags_HasSetMousePos)         ImGui::Text(" HasSetMousePos");
        if (io.BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset)   ImGui::Text(" RendererHasVtxOffset");
        ImGui::Separator();
        ImGui::Text("io.Fonts: %d fonts, Flags: 0x%08X, TexSize: %d,%d", io.Fonts->Fonts.Size, io.Fonts->Flags, io.Fonts->TexWidth, io.Fonts->TexHeight);
        ImGui::Text("io.DisplaySize: %.2f,%.2f", io.DisplaySize.x, io.DisplaySize.y);
        ImGui::Text("io.DisplayFramebufferScale: %.2f,%.2f", io.DisplayFramebufferScale.x, io.DisplayFramebufferScale.y);
        ImGui::Separator();
        ImGui::Text("style.WindowPadding: %.2f,%.2f", style.WindowPadding.x, style.WindowPadding.y);
        ImGui::Text("style.WindowBorderSize: %.2f", style.WindowBorderSize);
        ImGui::Text("style.FramePadding: %.2f,%.2f", style.FramePadding.x, style.FramePadding.y);
        ImGui::Text("style.FrameRounding: %.2f", style.FrameRounding);
        ImGui::Text("style.FrameBorderSize: %.2f", style.FrameBorderSize);
        ImGui::Text("style.ItemSpacing: %.2f,%.2f", style.ItemSpacing.x, style.ItemSpacing.y);
        ImGui::Text("style.ItemInnerSpacing: %.2f,%.2f", style.ItemInnerSpacing.x, style.ItemInnerSpacing.y);
 
        if (copy_to_clipboard)
        {
            ImGui::LogText("\n```\n");
            ImGui::LogFinish();
        }
        ImGui::EndChildFrame();
    }
    ImGui::End();
}

References ImGuiIO::BackendFlags, ImGuiIO::BackendPlatformName, ImGuiIO::BackendRendererName, Begin(), BeginChildFrame(), Button(), Checkbox(), ImGuiIO::ConfigFlags, ImGuiIO::ConfigInputTextCursorBlink, ImGuiIO::ConfigMacOSXBehaviors, ImGuiIO::ConfigMemoryCompactTimer, ImGuiIO::ConfigWindowsMoveFromTitleBarOnly, ImGuiIO::ConfigWindowsResizeFromEdges, ImGuiIO::DisplayFramebufferScale, ImGuiIO::DisplaySize, End(), EndChildFrame(), ImFontAtlas::Flags, ImGuiIO::Fonts, ImFontAtlas::Fonts, GetID(), GetIO(), GetStyle(), GetTextLineHeightWithSpacing(), GetVersion(), IMGUI_VERSION, IMGUI_VERSION_NUM, ImGuiBackendFlags_HasGamepad, ImGuiBackendFlags_HasMouseCursors, ImGuiBackendFlags_HasSetMousePos, ImGuiBackendFlags_RendererHasVtxOffset, ImGuiConfigFlags_NavEnableGamepad, ImGuiConfigFlags_NavEnableKeyboard, ImGuiConfigFlags_NavEnableSetMousePos, ImGuiConfigFlags_NavNoCaptureKeyboard, ImGuiConfigFlags_NoMouse, ImGuiConfigFlags_NoMouseCursorChange, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoMove, LogFinish(), LogText(), LogToClipboard(), ImGuiIO::MouseDrawCursor, Separator(), ImVector< T >::Size, style, ImFontAtlas::TexHeight, Text(), ImFontAtlas::TexWidth, ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowDemoWindow()

void ImGui::ShowDemoWindow ( bool * p_open = NULL )

{
    // Exceptionally add an extra assert here for people confused about initial Dear ImGui setup
    // Most ImGui functions would normally just crash if the context is missing.
    IM_ASSERT(ImGui::GetCurrentContext() != NULL && "Missing dear imgui context. Refer to examples app!");
 
    // Examples Apps (accessible from the "Examples" menu)
    static bool show_app_main_menu_bar = false;
    static bool show_app_documents = false;
 
    static bool show_app_console = false;
    static bool show_app_log = false;
    static bool show_app_layout = false;
    static bool show_app_property_editor = false;
    static bool show_app_long_text = false;
    static bool show_app_auto_resize = false;
    static bool show_app_constrained_resize = false;
    static bool show_app_simple_overlay = false;
    static bool show_app_fullscreen = false;
    static bool show_app_window_titles = false;
    static bool show_app_custom_rendering = false;
 
    if (show_app_main_menu_bar)       ShowExampleAppMainMenuBar();
    if (show_app_documents)           ShowExampleAppDocuments(&show_app_documents);
 
    if (show_app_console)             ShowExampleAppConsole(&show_app_console);
    if (show_app_log)                 ShowExampleAppLog(&show_app_log);
    if (show_app_layout)              ShowExampleAppLayout(&show_app_layout);
    if (show_app_property_editor)     ShowExampleAppPropertyEditor(&show_app_property_editor);
    if (show_app_long_text)           ShowExampleAppLongText(&show_app_long_text);
    if (show_app_auto_resize)         ShowExampleAppAutoResize(&show_app_auto_resize);
    if (show_app_constrained_resize)  ShowExampleAppConstrainedResize(&show_app_constrained_resize);
    if (show_app_simple_overlay)      ShowExampleAppSimpleOverlay(&show_app_simple_overlay);
    if (show_app_fullscreen)          ShowExampleAppFullscreen(&show_app_fullscreen);
    if (show_app_window_titles)       ShowExampleAppWindowTitles(&show_app_window_titles);
    if (show_app_custom_rendering)    ShowExampleAppCustomRendering(&show_app_custom_rendering);
 
    // Dear ImGui Apps (accessible from the "Tools" menu)
    static bool show_app_metrics = false;
    static bool show_app_style_editor = false;
    static bool show_app_about = false;
 
    if (show_app_metrics)       { ImGui::ShowMetricsWindow(&show_app_metrics); }
    if (show_app_about)         { ImGui::ShowAboutWindow(&show_app_about); }
    if (show_app_style_editor)
    {
        ImGui::Begin("Dear ImGui Style Editor", &show_app_style_editor);
        ImGui::ShowStyleEditor();
        ImGui::End();
    }
 
    // Demonstrate the various window flags. Typically you would just use the default!
    static bool no_titlebar = false;
    static bool no_scrollbar = false;
    static bool no_menu = false;
    static bool no_move = false;
    static bool no_resize = false;
    static bool no_collapse = false;
    static bool no_close = false;
    static bool no_nav = false;
    static bool no_background = false;
    static bool no_bring_to_front = false;
 
    ImGuiWindowFlags window_flags = 0;
    if (no_titlebar)        window_flags |= ImGuiWindowFlags_NoTitleBar;
    if (no_scrollbar)       window_flags |= ImGuiWindowFlags_NoScrollbar;
    if (!no_menu)           window_flags |= ImGuiWindowFlags_MenuBar;
    if (no_move)            window_flags |= ImGuiWindowFlags_NoMove;
    if (no_resize)          window_flags |= ImGuiWindowFlags_NoResize;
    if (no_collapse)        window_flags |= ImGuiWindowFlags_NoCollapse;
    if (no_nav)             window_flags |= ImGuiWindowFlags_NoNav;
    if (no_background)      window_flags |= ImGuiWindowFlags_NoBackground;
    if (no_bring_to_front)  window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus;
    if (no_close)           p_open = NULL; // Don't pass our bool* to Begin
 
    // We specify a default position/size in case there's no data in the .ini file.
    // We only do it to make the demo applications a little more welcoming, but typically this isn't required.
    const ImGuiViewport* main_viewport = ImGui::GetMainViewport();
    ImGui::SetNextWindowPos(ImVec2(main_viewport->WorkPos.x + 650, main_viewport->WorkPos.y + 20), ImGuiCond_FirstUseEver);
    ImGui::SetNextWindowSize(ImVec2(550, 680), ImGuiCond_FirstUseEver);
 
    // Main body of the Demo window starts here.
    if (!ImGui::Begin("Dear ImGui Demo", p_open, window_flags))
    {
        // Early out if the window is collapsed, as an optimization.
        ImGui::End();
        return;
    }
 
    // Most "big" widgets share a common width settings by default. See 'Demo->Layout->Widgets Width' for details.
 
    // e.g. Use 2/3 of the space for widgets and 1/3 for labels (right align)
    //ImGui::PushItemWidth(-ImGui::GetWindowWidth() * 0.35f);
 
    // e.g. Leave a fixed amount of width for labels (by passing a negative value), the rest goes to widgets.
    ImGui::PushItemWidth(ImGui::GetFontSize() * -12);
 
    // Menu Bar
    if (ImGui::BeginMenuBar())
    {
        if (ImGui::BeginMenu("Menu"))
        {
            ShowExampleMenuFile();
            ImGui::EndMenu();
        }
        if (ImGui::BeginMenu("Examples"))
        {
            ImGui::MenuItem("Main menu bar", NULL, &show_app_main_menu_bar);
            ImGui::MenuItem("Console", NULL, &show_app_console);
            ImGui::MenuItem("Log", NULL, &show_app_log);
            ImGui::MenuItem("Simple layout", NULL, &show_app_layout);
            ImGui::MenuItem("Property editor", NULL, &show_app_property_editor);
            ImGui::MenuItem("Long text display", NULL, &show_app_long_text);
            ImGui::MenuItem("Auto-resizing window", NULL, &show_app_auto_resize);
            ImGui::MenuItem("Constrained-resizing window", NULL, &show_app_constrained_resize);
            ImGui::MenuItem("Simple overlay", NULL, &show_app_simple_overlay);
            ImGui::MenuItem("Fullscreen window", NULL, &show_app_fullscreen);
            ImGui::MenuItem("Manipulating window titles", NULL, &show_app_window_titles);
            ImGui::MenuItem("Custom rendering", NULL, &show_app_custom_rendering);
            ImGui::MenuItem("Documents", NULL, &show_app_documents);
            ImGui::EndMenu();
        }
        if (ImGui::BeginMenu("Tools"))
        {
            ImGui::MenuItem("Metrics/Debugger", NULL, &show_app_metrics);
            ImGui::MenuItem("Style Editor", NULL, &show_app_style_editor);
            ImGui::MenuItem("About Dear ImGui", NULL, &show_app_about);
            ImGui::EndMenu();
        }
        ImGui::EndMenuBar();
    }
 
    ImGui::Text("dear imgui says hello. (%s)", IMGUI_VERSION);
    ImGui::Spacing();
 
    if (ImGui::CollapsingHeader("Help"))
    {
        ImGui::Text("ABOUT THIS DEMO:");
        ImGui::BulletText("Sections below are demonstrating many aspects of the library.");
        ImGui::BulletText("The \"Examples\" menu above leads to more demo contents.");
        ImGui::BulletText("The \"Tools\" menu above gives access to: About Box, Style Editor,\n"
                          "and Metrics/Debugger (general purpose Dear ImGui debugging tool).");
        ImGui::Separator();
 
        ImGui::Text("PROGRAMMER GUIDE:");
        ImGui::BulletText("See the ShowDemoWindow() code in imgui_demo.cpp. <- you are here!");
        ImGui::BulletText("See comments in imgui.cpp.");
        ImGui::BulletText("See example applications in the examples/ folder.");
        ImGui::BulletText("Read the FAQ at http://www.dearimgui.org/faq/");
        ImGui::BulletText("Set 'io.ConfigFlags |= NavEnableKeyboard' for keyboard controls.");
        ImGui::BulletText("Set 'io.ConfigFlags |= NavEnableGamepad' for gamepad controls.");
        ImGui::Separator();
 
        ImGui::Text("USER GUIDE:");
        ImGui::ShowUserGuide();
    }
 
    if (ImGui::CollapsingHeader("Configuration"))
    {
        ImGuiIO& io = ImGui::GetIO();
 
        if (ImGui::TreeNode("Configuration##2"))
        {
            ImGui::CheckboxFlags("io.ConfigFlags: NavEnableKeyboard",    &io.ConfigFlags, ImGuiConfigFlags_NavEnableKeyboard);
            ImGui::SameLine(); HelpMarker("Enable keyboard controls.");
            ImGui::CheckboxFlags("io.ConfigFlags: NavEnableGamepad",     &io.ConfigFlags, ImGuiConfigFlags_NavEnableGamepad);
            ImGui::SameLine(); HelpMarker("Enable gamepad controls. Require backend to set io.BackendFlags |= ImGuiBackendFlags_HasGamepad.\n\nRead instructions in imgui.cpp for details.");
            ImGui::CheckboxFlags("io.ConfigFlags: NavEnableSetMousePos", &io.ConfigFlags, ImGuiConfigFlags_NavEnableSetMousePos);
            ImGui::SameLine(); HelpMarker("Instruct navigation to move the mouse cursor. See comment for ImGuiConfigFlags_NavEnableSetMousePos.");
            ImGui::CheckboxFlags("io.ConfigFlags: NoMouse",              &io.ConfigFlags, ImGuiConfigFlags_NoMouse);
            if (io.ConfigFlags & ImGuiConfigFlags_NoMouse)
            {
                // The "NoMouse" option can get us stuck with a disabled mouse! Let's provide an alternative way to fix it:
                if (fmodf((float)ImGui::GetTime(), 0.40f) < 0.20f)
                {
                    ImGui::SameLine();
                    ImGui::Text("<<PRESS SPACE TO DISABLE>>");
                }
                if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Space)))
                    io.ConfigFlags &= ~ImGuiConfigFlags_NoMouse;
            }
            ImGui::CheckboxFlags("io.ConfigFlags: NoMouseCursorChange", &io.ConfigFlags, ImGuiConfigFlags_NoMouseCursorChange);
            ImGui::SameLine(); HelpMarker("Instruct backend to not alter mouse cursor shape and visibility.");
            ImGui::Checkbox("io.ConfigInputTextCursorBlink", &io.ConfigInputTextCursorBlink);
            ImGui::SameLine(); HelpMarker("Enable blinking cursor (optional as some users consider it to be distracting)");
            ImGui::Checkbox("io.ConfigDragClickToInputText", &io.ConfigDragClickToInputText);
            ImGui::SameLine(); HelpMarker("Enable turning DragXXX widgets into text input with a simple mouse click-release (without moving).");
            ImGui::Checkbox("io.ConfigWindowsResizeFromEdges", &io.ConfigWindowsResizeFromEdges);
            ImGui::SameLine(); HelpMarker("Enable resizing of windows from their edges and from the lower-left corner.\nThis requires (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors) because it needs mouse cursor feedback.");
            ImGui::Checkbox("io.ConfigWindowsMoveFromTitleBarOnly", &io.ConfigWindowsMoveFromTitleBarOnly);
            ImGui::Checkbox("io.MouseDrawCursor", &io.MouseDrawCursor);
            ImGui::SameLine(); HelpMarker("Instruct Dear ImGui to render a mouse cursor itself. Note that a mouse cursor rendered via your application GPU rendering path will feel more laggy than hardware cursor, but will be more in sync with your other visuals.\n\nSome desktop applications may use both kinds of cursors (e.g. enable software cursor only when resizing/dragging something).");
            ImGui::Text("Also see Style->Rendering for rendering options.");
            ImGui::TreePop();
            ImGui::Separator();
        }
 
        if (ImGui::TreeNode("Backend Flags"))
        {
            HelpMarker(
                "Those flags are set by the backends (imgui_impl_xxx files) to specify their capabilities.\n"
                "Here we expose then as read-only fields to avoid breaking interactions with your backend.");
 
            // Make a local copy to avoid modifying actual backend flags.
            ImGuiBackendFlags backend_flags = io.BackendFlags;
            ImGui::CheckboxFlags("io.BackendFlags: HasGamepad",           &backend_flags, ImGuiBackendFlags_HasGamepad);
            ImGui::CheckboxFlags("io.BackendFlags: HasMouseCursors",      &backend_flags, ImGuiBackendFlags_HasMouseCursors);
            ImGui::CheckboxFlags("io.BackendFlags: HasSetMousePos",       &backend_flags, ImGuiBackendFlags_HasSetMousePos);
            ImGui::CheckboxFlags("io.BackendFlags: RendererHasVtxOffset", &backend_flags, ImGuiBackendFlags_RendererHasVtxOffset);
            ImGui::TreePop();
            ImGui::Separator();
        }
 
        if (ImGui::TreeNode("Style"))
        {
            HelpMarker("The same contents can be accessed in 'Tools->Style Editor' or by calling the ShowStyleEditor() function.");
            ImGui::ShowStyleEditor();
            ImGui::TreePop();
            ImGui::Separator();
        }
 
        if (ImGui::TreeNode("Capture/Logging"))
        {
            HelpMarker(
                "The logging API redirects all text output so you can easily capture the content of "
                "a window or a block. Tree nodes can be automatically expanded.\n"
                "Try opening any of the contents below in this window and then click one of the \"Log To\" button.");
            ImGui::LogButtons();
 
            HelpMarker("You can also call ImGui::LogText() to output directly to the log without a visual output.");
            if (ImGui::Button("Copy \"Hello, world!\" to clipboard"))
            {
                ImGui::LogToClipboard();
                ImGui::LogText("Hello, world!");
                ImGui::LogFinish();
            }
            ImGui::TreePop();
        }
    }
 
    if (ImGui::CollapsingHeader("Window options"))
    {
        if (ImGui::BeginTable("split", 3))
        {
            ImGui::TableNextColumn(); ImGui::Checkbox("No titlebar", &no_titlebar);
            ImGui::TableNextColumn(); ImGui::Checkbox("No scrollbar", &no_scrollbar);
            ImGui::TableNextColumn(); ImGui::Checkbox("No menu", &no_menu);
            ImGui::TableNextColumn(); ImGui::Checkbox("No move", &no_move);
            ImGui::TableNextColumn(); ImGui::Checkbox("No resize", &no_resize);
            ImGui::TableNextColumn(); ImGui::Checkbox("No collapse", &no_collapse);
            ImGui::TableNextColumn(); ImGui::Checkbox("No close", &no_close);
            ImGui::TableNextColumn(); ImGui::Checkbox("No nav", &no_nav);
            ImGui::TableNextColumn(); ImGui::Checkbox("No background", &no_background);
            ImGui::TableNextColumn(); ImGui::Checkbox("No bring to front", &no_bring_to_front);
            ImGui::EndTable();
        }
    }
 
    // All demo contents
    ShowDemoWindowWidgets();
    ShowDemoWindowLayout();
    ShowDemoWindowPopups();
    ShowDemoWindowTables();
    ShowDemoWindowMisc();
 
    // End of ShowDemoWindow()
    ImGui::PopItemWidth();
    ImGui::End();
}

Referenced by Slic3r::GUI::GLCanvas3D::render().

Here is the caller graph for this function:

◆ ShowFontAtlas()

void ImGui::ShowFontAtlas ( ImFontAtlas * atlas )

{
    for (int i = 0; i < atlas->Fonts.Size; i++)
    {
        ImFont* font = atlas->Fonts[i];
        ImGui::PushID(font);
        ShowFont(font);
        ImGui::PopID();
    }
    if (ImGui::TreeNode("Atlas texture", "Atlas texture (%dx%d pixels)", atlas->TexWidth, atlas->TexHeight))
    {
        ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
        ImVec4 border_col = ImVec4(1.0f, 1.0f, 1.0f, 0.5f);
        ImGui::Image(atlas->TexID, ImVec2((float)atlas->TexWidth, (float)atlas->TexHeight), ImVec2(0, 0), ImVec2(1, 1), tint_col, border_col);
        ImGui::TreePop();
    }
}

References ImFontAtlas::Fonts, Image(), PopID(), PushID(), ShowFont(), ImVector< T >::Size, ImFontAtlas::TexHeight, ImFontAtlas::TexID, ImFontAtlas::TexWidth, TreeNode(), and TreePop().

Referenced by ShowMetricsWindow(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowFontSelector()

void ImGui::ShowFontSelector ( const char * label )

{
    ImGuiIO& io = ImGui::GetIO();
    ImFont* font_current = ImGui::GetFont();
    if (ImGui::BeginCombo(label, font_current->GetDebugName()))
    {
        for (int n = 0; n < io.Fonts->Fonts.Size; n++)
        {
            ImFont* font = io.Fonts->Fonts[n];
            ImGui::PushID((void*)font);
            if (ImGui::Selectable(font->GetDebugName(), font == font_current))
                io.FontDefault = font;
            ImGui::PopID();
        }
        ImGui::EndCombo();
    }
    ImGui::SameLine();
    HelpMarker(
        "- Load additional fonts with io.Fonts->AddFontFromFileTTF().\n"
        "- The font atlas is built when calling io.Fonts->GetTexDataAsXXXX() or io.Fonts->Build().\n"
        "- Read FAQ and docs/FONTS.md for more details.\n"
        "- If you need to add/remove fonts at runtime (e.g. for DPI change), do it before calling NewFrame().");
}

References BeginCombo(), EndCombo(), ImGuiIO::FontDefault, ImGuiIO::Fonts, ImFontAtlas::Fonts, ImFont::GetDebugName(), GetFont(), GetIO(), HelpMarker(), PopID(), PushID(), SameLine(), Selectable(), and ImVector< T >::Size.

Referenced by ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowMetricsWindow()

void ImGui::ShowMetricsWindow ( bool * p_open = NULL )

{
    if (!Begin("Dear ImGui Metrics/Debugger", p_open))
    {
        End();
        return;
    }
 
    ImGuiContext& g = *GImGui;
    ImGuiIO& io = g.IO;
    ImGuiMetricsConfig* cfg = &g.DebugMetricsConfig;
 
    // Basic info
    Text("Dear ImGui %s", GetVersion());
    Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
    Text("%d vertices, %d indices (%d triangles)", io.MetricsRenderVertices, io.MetricsRenderIndices, io.MetricsRenderIndices / 3);
    Text("%d active windows (%d visible)", io.MetricsActiveWindows, io.MetricsRenderWindows);
    Text("%d active allocations", io.MetricsActiveAllocations);
    //SameLine(); if (SmallButton("GC")) { g.GcCompactAll = true; }
 
    Separator();
 
    // Debugging enums
    enum { WRT_OuterRect, WRT_OuterRectClipped, WRT_InnerRect, WRT_InnerClipRect, WRT_WorkRect, WRT_Content, WRT_ContentIdeal, WRT_ContentRegionRect, WRT_Count }; // Windows Rect Type
    const char* wrt_rects_names[WRT_Count] = { "OuterRect", "OuterRectClipped", "InnerRect", "InnerClipRect", "WorkRect", "Content", "ContentIdeal", "ContentRegionRect" };
    enum { TRT_OuterRect, TRT_InnerRect, TRT_WorkRect, TRT_HostClipRect, TRT_InnerClipRect, TRT_BackgroundClipRect, TRT_ColumnsRect, TRT_ColumnsWorkRect, TRT_ColumnsClipRect, TRT_ColumnsContentHeadersUsed, TRT_ColumnsContentHeadersIdeal, TRT_ColumnsContentFrozen, TRT_ColumnsContentUnfrozen, TRT_Count }; // Tables Rect Type
    const char* trt_rects_names[TRT_Count] = { "OuterRect", "InnerRect", "WorkRect", "HostClipRect", "InnerClipRect", "BackgroundClipRect", "ColumnsRect", "ColumnsWorkRect", "ColumnsClipRect", "ColumnsContentHeadersUsed", "ColumnsContentHeadersIdeal", "ColumnsContentFrozen", "ColumnsContentUnfrozen" };
    if (cfg->ShowWindowsRectsType < 0)
        cfg->ShowWindowsRectsType = WRT_WorkRect;
    if (cfg->ShowTablesRectsType < 0)
        cfg->ShowTablesRectsType = TRT_WorkRect;
 
    struct Funcs
    {
        static ImRect GetTableRect(ImGuiTable* table, int rect_type, int n)
        {
            if (rect_type == TRT_OuterRect)                     { return table->OuterRect; }
            else if (rect_type == TRT_InnerRect)                { return table->InnerRect; }
            else if (rect_type == TRT_WorkRect)                 { return table->WorkRect; }
            else if (rect_type == TRT_HostClipRect)             { return table->HostClipRect; }
            else if (rect_type == TRT_InnerClipRect)            { return table->InnerClipRect; }
            else if (rect_type == TRT_BackgroundClipRect)       { return table->BgClipRect; }
            else if (rect_type == TRT_ColumnsRect)              { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->MinX, table->InnerClipRect.Min.y, c->MaxX, table->InnerClipRect.Min.y + table->LastOuterHeight); }
            else if (rect_type == TRT_ColumnsWorkRect)          { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->WorkRect.Min.y, c->WorkMaxX, table->WorkRect.Max.y); }
            else if (rect_type == TRT_ColumnsClipRect)          { ImGuiTableColumn* c = &table->Columns[n]; return c->ClipRect; }
            else if (rect_type == TRT_ColumnsContentHeadersUsed){ ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y, c->ContentMaxXHeadersUsed, table->InnerClipRect.Min.y + table->LastFirstRowHeight); } // Note: y1/y2 not always accurate
            else if (rect_type == TRT_ColumnsContentHeadersIdeal){ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y, c->ContentMaxXHeadersIdeal, table->InnerClipRect.Min.y + table->LastFirstRowHeight); }
            else if (rect_type == TRT_ColumnsContentFrozen)     { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y, c->ContentMaxXFrozen, table->InnerClipRect.Min.y + table->LastFirstRowHeight); }
            else if (rect_type == TRT_ColumnsContentUnfrozen)   { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y + table->LastFirstRowHeight, c->ContentMaxXUnfrozen, table->InnerClipRect.Max.y); }
            IM_ASSERT(0);
            return ImRect();
        }
 
        static ImRect GetWindowRect(ImGuiWindow* window, int rect_type)
        {
            if (rect_type == WRT_OuterRect)                 { return window->Rect(); }
            else if (rect_type == WRT_OuterRectClipped)     { return window->OuterRectClipped; }
            else if (rect_type == WRT_InnerRect)            { return window->InnerRect; }
            else if (rect_type == WRT_InnerClipRect)        { return window->InnerClipRect; }
            else if (rect_type == WRT_WorkRect)             { return window->WorkRect; }
            else if (rect_type == WRT_Content)       { ImVec2 min = window->InnerRect.Min - window->Scroll + window->WindowPadding; return ImRect(min, min + window->ContentSize); }
            else if (rect_type == WRT_ContentIdeal)         { ImVec2 min = window->InnerRect.Min - window->Scroll + window->WindowPadding; return ImRect(min, min + window->ContentSizeIdeal); }
            else if (rect_type == WRT_ContentRegionRect)    { return window->ContentRegionRect; }
            IM_ASSERT(0);
            return ImRect();
        }
    };
 
    // Tools
    if (TreeNode("Tools"))
    {
        // The Item Picker tool is super useful to visually select an item and break into the call-stack of where it was submitted.
        if (Button("Item Picker.."))
            DebugStartItemPicker();
        SameLine();
        MetricsHelpMarker("Will call the IM_DEBUG_BREAK() macro to break in debugger.\nWarning: If you don't have a debugger attached, this will probably crash.");
 
        Checkbox("Show windows begin order", &cfg->ShowWindowsBeginOrder);
        Checkbox("Show windows rectangles", &cfg->ShowWindowsRects);
        SameLine();
        SetNextItemWidth(GetFontSize() * 12);
        cfg->ShowWindowsRects |= Combo("##show_windows_rect_type", &cfg->ShowWindowsRectsType, wrt_rects_names, WRT_Count, WRT_Count);
        if (cfg->ShowWindowsRects && g.NavWindow != NULL)
        {
            BulletText("'%s':", g.NavWindow->Name);
            Indent();
            for (int rect_n = 0; rect_n < WRT_Count; rect_n++)
            {
                ImRect r = Funcs::GetWindowRect(g.NavWindow, rect_n);
                Text("(%6.1f,%6.1f) (%6.1f,%6.1f) Size (%6.1f,%6.1f) %s", r.Min.x, r.Min.y, r.Max.x, r.Max.y, r.GetWidth(), r.GetHeight(), wrt_rects_names[rect_n]);
            }
            Unindent();
        }
        Checkbox("Show ImDrawCmd mesh when hovering", &cfg->ShowDrawCmdMesh);
        Checkbox("Show ImDrawCmd bounding boxes when hovering", &cfg->ShowDrawCmdBoundingBoxes);
 
        Checkbox("Show tables rectangles", &cfg->ShowTablesRects);
        SameLine();
        SetNextItemWidth(GetFontSize() * 12);
        cfg->ShowTablesRects |= Combo("##show_table_rects_type", &cfg->ShowTablesRectsType, trt_rects_names, TRT_Count, TRT_Count);
        if (cfg->ShowTablesRects && g.NavWindow != NULL)
        {
            for (int table_n = 0; table_n < g.Tables.GetSize(); table_n++)
            {
                ImGuiTable* table = g.Tables.GetByIndex(table_n);
                if (table->LastFrameActive < g.FrameCount - 1 || (table->OuterWindow != g.NavWindow && table->InnerWindow != g.NavWindow))
                    continue;
 
                BulletText("Table 0x%08X (%d columns, in '%s')", table->ID, table->ColumnsCount, table->OuterWindow->Name);
                if (IsItemHovered())
                    GetForegroundDrawList()->AddRect(table->OuterRect.Min - ImVec2(1, 1), table->OuterRect.Max + ImVec2(1, 1), IM_COL32(255, 255, 0, 255), 0.0f, 0, 2.0f);
                Indent();
                char buf[128];
                for (int rect_n = 0; rect_n < TRT_Count; rect_n++)
                {
                    if (rect_n >= TRT_ColumnsRect)
                    {
                        if (rect_n != TRT_ColumnsRect && rect_n != TRT_ColumnsClipRect)
                            continue;
                        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                        {
                            ImRect r = Funcs::GetTableRect(table, rect_n, column_n);
                            ImFormatString(buf, IM_ARRAYSIZE(buf), "(%6.1f,%6.1f) (%6.1f,%6.1f) Size (%6.1f,%6.1f) Col %d %s", r.Min.x, r.Min.y, r.Max.x, r.Max.y, r.GetWidth(), r.GetHeight(), column_n, trt_rects_names[rect_n]);
                            Selectable(buf);
                            if (IsItemHovered())
                                GetForegroundDrawList()->AddRect(r.Min - ImVec2(1, 1), r.Max + ImVec2(1, 1), IM_COL32(255, 255, 0, 255), 0.0f, 0, 2.0f);
                        }
                    }
                    else
                    {
                        ImRect r = Funcs::GetTableRect(table, rect_n, -1);
                        ImFormatString(buf, IM_ARRAYSIZE(buf), "(%6.1f,%6.1f) (%6.1f,%6.1f) Size (%6.1f,%6.1f) %s", r.Min.x, r.Min.y, r.Max.x, r.Max.y, r.GetWidth(), r.GetHeight(), trt_rects_names[rect_n]);
                        Selectable(buf);
                        if (IsItemHovered())
                            GetForegroundDrawList()->AddRect(r.Min - ImVec2(1, 1), r.Max + ImVec2(1, 1), IM_COL32(255, 255, 0, 255), 0.0f, 0, 2.0f);
                    }
                }
                Unindent();
            }
        }
 
        TreePop();
    }
 
    // Windows
    DebugNodeWindowsList(&g.Windows, "Windows");
    //DebugNodeWindowsList(&g.WindowsFocusOrder, "WindowsFocusOrder");
 
    // DrawLists
    int drawlist_count = 0;
    for (int viewport_i = 0; viewport_i < g.Viewports.Size; viewport_i++)
        drawlist_count += g.Viewports[viewport_i]->DrawDataBuilder.GetDrawListCount();
    if (TreeNode("DrawLists", "DrawLists (%d)", drawlist_count))
    {
        for (int viewport_i = 0; viewport_i < g.Viewports.Size; viewport_i++)
        {
            ImGuiViewportP* viewport = g.Viewports[viewport_i];
            for (int layer_i = 0; layer_i < IM_ARRAYSIZE(viewport->DrawDataBuilder.Layers); layer_i++)
                for (int draw_list_i = 0; draw_list_i < viewport->DrawDataBuilder.Layers[layer_i].Size; draw_list_i++)
                    DebugNodeDrawList(NULL, viewport->DrawDataBuilder.Layers[layer_i][draw_list_i], "DrawList");
        }
        TreePop();
    }
 
    // Viewports
    if (TreeNode("Viewports", "Viewports (%d)", g.Viewports.Size))
    {
        Indent(GetTreeNodeToLabelSpacing());
        RenderViewportsThumbnails();
        Unindent(GetTreeNodeToLabelSpacing());
        for (int i = 0; i < g.Viewports.Size; i++)
            DebugNodeViewport(g.Viewports[i]);
        TreePop();
    }
 
    // Details for Popups
    if (TreeNode("Popups", "Popups (%d)", g.OpenPopupStack.Size))
    {
        for (int i = 0; i < g.OpenPopupStack.Size; i++)
        {
            ImGuiWindow* window = g.OpenPopupStack[i].Window;
            BulletText("PopupID: %08x, Window: '%s'%s%s", g.OpenPopupStack[i].PopupId, window ? window->Name : "NULL", window && (window->Flags & ImGuiWindowFlags_ChildWindow) ? " ChildWindow" : "", window && (window->Flags & ImGuiWindowFlags_ChildMenu) ? " ChildMenu" : "");
        }
        TreePop();
    }
 
    // Details for TabBars
    if (TreeNode("TabBars", "Tab Bars (%d)", g.TabBars.GetSize()))
    {
        for (int n = 0; n < g.TabBars.GetSize(); n++)
            DebugNodeTabBar(g.TabBars.GetByIndex(n), "TabBar");
        TreePop();
    }
 
    // Details for Tables
    if (TreeNode("Tables", "Tables (%d)", g.Tables.GetSize()))
    {
        for (int n = 0; n < g.Tables.GetSize(); n++)
            DebugNodeTable(g.Tables.GetByIndex(n));
        TreePop();
    }
 
    // Details for Fonts
#ifndef IMGUI_DISABLE_DEMO_WINDOWS
    ImFontAtlas* atlas = g.IO.Fonts;
    if (TreeNode("Fonts", "Fonts (%d)", atlas->Fonts.Size))
    {
        ShowFontAtlas(atlas);
        TreePop();
    }
#endif
 
    // Details for Docking
#ifdef IMGUI_HAS_DOCK
    if (TreeNode("Docking"))
    {
        TreePop();
    }
#endif // #ifdef IMGUI_HAS_DOCK
 
    // Settings
    if (TreeNode("Settings"))
    {
        if (SmallButton("Clear"))
            ClearIniSettings();
        SameLine();
        if (SmallButton("Save to memory"))
            SaveIniSettingsToMemory();
        SameLine();
        if (SmallButton("Save to disk"))
            SaveIniSettingsToDisk(g.IO.IniFilename);
        SameLine();
        if (g.IO.IniFilename)
            Text("\"%s\"", g.IO.IniFilename);
        else
            TextUnformatted("<NULL>");
        Text("SettingsDirtyTimer %.2f", g.SettingsDirtyTimer);
        if (TreeNode("SettingsHandlers", "Settings handlers: (%d)", g.SettingsHandlers.Size))
        {
            for (int n = 0; n < g.SettingsHandlers.Size; n++)
                BulletText("%s", g.SettingsHandlers[n].TypeName);
            TreePop();
        }
        if (TreeNode("SettingsWindows", "Settings packed data: Windows: %d bytes", g.SettingsWindows.size()))
        {
            for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
                DebugNodeWindowSettings(settings);
            TreePop();
        }
 
        if (TreeNode("SettingsTables", "Settings packed data: Tables: %d bytes", g.SettingsTables.size()))
        {
            for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
                DebugNodeTableSettings(settings);
            TreePop();
        }
 
#ifdef IMGUI_HAS_DOCK
#endif // #ifdef IMGUI_HAS_DOCK
 
        if (TreeNode("SettingsIniData", "Settings unpacked data (.ini): %d bytes", g.SettingsIniData.size()))
        {
            InputTextMultiline("##Ini", (char*)(void*)g.SettingsIniData.c_str(), g.SettingsIniData.Buf.Size, ImVec2(-FLT_MIN, GetTextLineHeight() * 20), ImGuiInputTextFlags_ReadOnly);
            TreePop();
        }
        TreePop();
    }
 
    // Misc Details
    if (TreeNode("Internal state"))
    {
        const char* input_source_names[] = { "None", "Mouse", "Keyboard", "Gamepad", "Nav", "Clipboard" }; IM_ASSERT(IM_ARRAYSIZE(input_source_names) == ImGuiInputSource_COUNT);
 
        Text("WINDOWING");
        Indent();
        Text("HoveredWindow: '%s'", g.HoveredWindow ? g.HoveredWindow->Name : "NULL");
        Text("HoveredWindow->Root: '%s'", g.HoveredWindow ? g.HoveredWindow->RootWindow->Name : "NULL");
        Text("HoveredWindowUnderMovingWindow: '%s'", g.HoveredWindowUnderMovingWindow ? g.HoveredWindowUnderMovingWindow->Name : "NULL");
        Text("MovingWindow: '%s'", g.MovingWindow ? g.MovingWindow->Name : "NULL");
        Unindent();
 
        Text("ITEMS");
        Indent();
        Text("ActiveId: 0x%08X/0x%08X (%.2f sec), AllowOverlap: %d, Source: %s", g.ActiveId, g.ActiveIdPreviousFrame, g.ActiveIdTimer, g.ActiveIdAllowOverlap, input_source_names[g.ActiveIdSource]);
        Text("ActiveIdWindow: '%s'", g.ActiveIdWindow ? g.ActiveIdWindow->Name : "NULL");
        Text("HoveredId: 0x%08X/0x%08X (%.2f sec), AllowOverlap: %d", g.HoveredId, g.HoveredIdPreviousFrame, g.HoveredIdTimer, g.HoveredIdAllowOverlap); // Data is "in-flight" so depending on when the Metrics window is called we may see current frame information or not
        Text("DragDrop: %d, SourceId = 0x%08X, Payload \"%s\" (%d bytes)", g.DragDropActive, g.DragDropPayload.SourceId, g.DragDropPayload.DataType, g.DragDropPayload.DataSize);
        Unindent();
 
        Text("NAV,FOCUS");
        Indent();
        Text("NavWindow: '%s'", g.NavWindow ? g.NavWindow->Name : "NULL");
        Text("NavId: 0x%08X, NavLayer: %d", g.NavId, g.NavLayer);
        Text("NavInputSource: %s", input_source_names[g.NavInputSource]);
        Text("NavActive: %d, NavVisible: %d", g.IO.NavActive, g.IO.NavVisible);
        Text("NavActivateId: 0x%08X, NavInputId: 0x%08X", g.NavActivateId, g.NavInputId);
        Text("NavDisableHighlight: %d, NavDisableMouseHover: %d", g.NavDisableHighlight, g.NavDisableMouseHover);
        Text("NavFocusScopeId = 0x%08X", g.NavFocusScopeId);
        Text("NavWindowingTarget: '%s'", g.NavWindowingTarget ? g.NavWindowingTarget->Name : "NULL");
        Unindent();
 
        TreePop();
    }
 
    // Overlay: Display windows Rectangles and Begin Order
    if (cfg->ShowWindowsRects || cfg->ShowWindowsBeginOrder)
    {
        for (int n = 0; n < g.Windows.Size; n++)
        {
            ImGuiWindow* window = g.Windows[n];
            if (!window->WasActive)
                continue;
            ImDrawList* draw_list = GetForegroundDrawList(window);
            if (cfg->ShowWindowsRects)
            {
                ImRect r = Funcs::GetWindowRect(window, cfg->ShowWindowsRectsType);
                draw_list->AddRect(r.Min, r.Max, IM_COL32(255, 0, 128, 255));
            }
            if (cfg->ShowWindowsBeginOrder && !(window->Flags & ImGuiWindowFlags_ChildWindow))
            {
                char buf[32];
                ImFormatString(buf, IM_ARRAYSIZE(buf), "%d", window->BeginOrderWithinContext);
                float font_size = GetFontSize();
                draw_list->AddRectFilled(window->Pos, window->Pos + ImVec2(font_size, font_size), IM_COL32(200, 100, 100, 255));
                draw_list->AddText(window->Pos, IM_COL32(255, 255, 255, 255), buf);
            }
        }
    }
 
    // Overlay: Display Tables Rectangles
    if (cfg->ShowTablesRects)
    {
        for (int table_n = 0; table_n < g.Tables.GetSize(); table_n++)
        {
            ImGuiTable* table = g.Tables.GetByIndex(table_n);
            if (table->LastFrameActive < g.FrameCount - 1)
                continue;
            ImDrawList* draw_list = GetForegroundDrawList(table->OuterWindow);
            if (cfg->ShowTablesRectsType >= TRT_ColumnsRect)
            {
                for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                {
                    ImRect r = Funcs::GetTableRect(table, cfg->ShowTablesRectsType, column_n);
                    ImU32 col = (table->HoveredColumnBody == column_n) ? IM_COL32(255, 255, 128, 255) : IM_COL32(255, 0, 128, 255);
                    float thickness = (table->HoveredColumnBody == column_n) ? 3.0f : 1.0f;
                    draw_list->AddRect(r.Min, r.Max, col, 0.0f, 0, thickness);
                }
            }
            else
            {
                ImRect r = Funcs::GetTableRect(table, cfg->ShowTablesRectsType, -1);
                draw_list->AddRect(r.Min, r.Max, IM_COL32(255, 0, 128, 255));
            }
        }
    }
 
#ifdef IMGUI_HAS_DOCK
    // Overlay: Display Docking info
    if (show_docking_nodes && g.IO.KeyCtrl)
    {
    }
#endif // #ifdef IMGUI_HAS_DOCK
 
    End();
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdAllowOverlap, ImGuiContext::ActiveIdPreviousFrame, ImGuiContext::ActiveIdSource, ImGuiContext::ActiveIdTimer, ImGuiContext::ActiveIdWindow, ImDrawList::AddRect(), ImDrawList::AddRectFilled(), ImDrawList::AddText(), ImChunkStream< T >::begin(), Begin(), ImGuiWindow::BeginOrderWithinContext, ImGuiTable::BgClipRect, ImGuiTextBuffer::Buf, BulletText(), Button(), ImGuiTextBuffer::c_str(), Checkbox(), ClearIniSettings(), col(), ImGuiTable::Columns, ImGuiTable::ColumnsCount, Combo(), ImGuiWindow::ContentRegionRect, ImGuiWindow::ContentSize, ImGuiWindow::ContentSizeIdeal, ImGuiPayload::DataSize, ImGuiPayload::DataType, ImGuiContext::DebugMetricsConfig, DebugNodeDrawList(), DebugNodeTabBar(), DebugNodeTable(), DebugNodeTableSettings(), DebugNodeViewport(), DebugNodeWindowSettings(), DebugNodeWindowsList(), DebugStartItemPicker(), ImGuiContext::DragDropActive, ImGuiContext::DragDropPayload, ImGuiViewportP::DrawDataBuilder, End(), ImGuiWindow::Flags, ImGuiIO::Fonts, ImFontAtlas::Fonts, ImGuiContext::FrameCount, ImGuiIO::Framerate, ImPool< T >::GetByIndex(), GetFontSize(), GetForegroundDrawList(), ImRect::GetHeight(), ImPool< T >::GetSize(), GetTextLineHeight(), GetTreeNodeToLabelSpacing(), GetVersion(), ImRect::GetWidth(), GImGui, ImGuiTable::HostClipRect, ImGuiTable::HoveredColumnBody, ImGuiContext::HoveredId, ImGuiContext::HoveredIdAllowOverlap, ImGuiContext::HoveredIdPreviousFrame, ImGuiContext::HoveredIdTimer, ImGuiContext::HoveredWindow, ImGuiContext::HoveredWindowUnderMovingWindow, ImGuiTable::ID, IM_ARRAYSIZE, IM_ASSERT, IM_COL32, ImFormatString(), ImGuiInputSource_COUNT, ImGuiInputTextFlags_ReadOnly, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_ChildWindow, Indent(), ImGuiIO::IniFilename, ImGuiWindow::InnerClipRect, ImGuiTable::InnerClipRect, ImGuiWindow::InnerRect, ImGuiTable::InnerRect, ImGuiTable::InnerWindow, InputTextMultiline(), ImGuiContext::IO, IsItemHovered(), ImGuiIO::KeyCtrl, ImGuiTable::LastFirstRowHeight, ImGuiTable::LastFrameActive, ImGuiTable::LastOuterHeight, ImDrawDataBuilder::Layers, ImRect::Max, ImGuiIO::MetricsActiveAllocations, ImGuiIO::MetricsActiveWindows, MetricsHelpMarker(), ImGuiIO::MetricsRenderIndices, ImGuiIO::MetricsRenderVertices, ImGuiIO::MetricsRenderWindows, ImRect::Min, ImGuiContext::MovingWindow, ImGuiWindow::Name, ImGuiContext::NavActivateId, ImGuiIO::NavActive, ImGuiContext::NavDisableHighlight, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavFocusScopeId, ImGuiContext::NavId, ImGuiContext::NavInputId, ImGuiContext::NavInputSource, ImGuiContext::NavLayer, ImGuiIO::NavVisible, ImGuiContext::NavWindow, ImGuiContext::NavWindowingTarget, ImChunkStream< T >::next_chunk(), ImGuiContext::OpenPopupStack, ImGuiTable::OuterRect, ImGuiWindow::OuterRectClipped, ImGuiTable::OuterWindow, ImGuiWindow::Pos, ImGuiWindow::Rect(), RenderViewportsThumbnails(), ImGuiWindow::RootWindow, SameLine(), SaveIniSettingsToDisk(), SaveIniSettingsToMemory(), ImGuiWindow::Scroll, Selectable(), Separator(), SetNextItemWidth(), ImGuiContext::SettingsDirtyTimer, ImGuiContext::SettingsHandlers, ImGuiContext::SettingsIniData, ImGuiContext::SettingsTables, ImGuiContext::SettingsWindows, ImGuiMetricsConfig::ShowDrawCmdBoundingBoxes, ImGuiMetricsConfig::ShowDrawCmdMesh, ShowFontAtlas(), ImGuiMetricsConfig::ShowTablesRects, ImGuiMetricsConfig::ShowTablesRectsType, ImGuiMetricsConfig::ShowWindowsBeginOrder, ImGuiMetricsConfig::ShowWindowsRects, ImGuiMetricsConfig::ShowWindowsRectsType, ImVector< T >::Size, ImGuiTextBuffer::size(), ImChunkStream< T >::size(), SmallButton(), ImGuiPayload::SourceId, ImGuiContext::TabBars, ImGuiContext::Tables, Text(), TextUnformatted(), TreeNode(), TreePop(), Unindent(), ImGuiContext::Viewports, ImGuiWindow::WasActive, ImGuiWindow::WindowPadding, ImGuiContext::Windows, ImGuiWindow::WorkRect, ImGuiTable::WorkRect, ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindow().

Here is the caller graph for this function:

◆ ShowStyleEditor()

void ImGui::ShowStyleEditor ( ImGuiStyle * ref = NULL )

{
    // You can pass in a reference ImGuiStyle structure to compare to, revert to and save to
    // (without a reference style pointer, we will use one compared locally as a reference)
    ImGuiStyle& style = ImGui::GetStyle();
    static ImGuiStyle ref_saved_style;
 
    // Default to using internal storage as reference
    static bool init = true;
    if (init && ref == NULL)
        ref_saved_style = style;
    init = false;
    if (ref == NULL)
        ref = &ref_saved_style;
 
    ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.50f);
 
    if (ImGui::ShowStyleSelector("Colors##Selector"))
        ref_saved_style = style;
    ImGui::ShowFontSelector("Fonts##Selector");
 
    // Simplified Settings (expose floating-pointer border sizes as boolean representing 0.0f or 1.0f)
    if (ImGui::SliderFloat("FrameRounding", &style.FrameRounding, 0.0f, 12.0f, "%.0f"))
        style.GrabRounding = style.FrameRounding; // Make GrabRounding always the same value as FrameRounding
    { bool border = (style.WindowBorderSize > 0.0f); if (ImGui::Checkbox("WindowBorder", &border)) { style.WindowBorderSize = border ? 1.0f : 0.0f; } }
    ImGui::SameLine();
    { bool border = (style.FrameBorderSize > 0.0f);  if (ImGui::Checkbox("FrameBorder",  &border)) { style.FrameBorderSize  = border ? 1.0f : 0.0f; } }
    ImGui::SameLine();
    { bool border = (style.PopupBorderSize > 0.0f);  if (ImGui::Checkbox("PopupBorder",  &border)) { style.PopupBorderSize  = border ? 1.0f : 0.0f; } }
 
    // Save/Revert button
    if (ImGui::Button("Save Ref"))
        *ref = ref_saved_style = style;
    ImGui::SameLine();
    if (ImGui::Button("Revert Ref"))
        style = *ref;
    ImGui::SameLine();
    HelpMarker(
        "Save/Revert in local non-persistent storage. Default Colors definition are not affected. "
        "Use \"Export\" below to save them somewhere.");
 
    ImGui::Separator();
 
    if (ImGui::BeginTabBar("##tabs", ImGuiTabBarFlags_None))
    {
        if (ImGui::BeginTabItem("Sizes"))
        {
            ImGui::Text("Main");
            ImGui::SliderFloat2("WindowPadding", (float*)&style.WindowPadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("FramePadding", (float*)&style.FramePadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("CellPadding", (float*)&style.CellPadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("ItemSpacing", (float*)&style.ItemSpacing, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("ItemInnerSpacing", (float*)&style.ItemInnerSpacing, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("TouchExtraPadding", (float*)&style.TouchExtraPadding, 0.0f, 10.0f, "%.0f");
            ImGui::SliderFloat("IndentSpacing", &style.IndentSpacing, 0.0f, 30.0f, "%.0f");
            ImGui::SliderFloat("ScrollbarSize", &style.ScrollbarSize, 1.0f, 20.0f, "%.0f");
            ImGui::SliderFloat("GrabMinSize", &style.GrabMinSize, 1.0f, 20.0f, "%.0f");
            ImGui::Text("Borders");
            ImGui::SliderFloat("WindowBorderSize", &style.WindowBorderSize, 0.0f, 1.0f, "%.0f");
            ImGui::SliderFloat("ChildBorderSize", &style.ChildBorderSize, 0.0f, 1.0f, "%.0f");
            ImGui::SliderFloat("PopupBorderSize", &style.PopupBorderSize, 0.0f, 1.0f, "%.0f");
            ImGui::SliderFloat("FrameBorderSize", &style.FrameBorderSize, 0.0f, 1.0f, "%.0f");
            ImGui::SliderFloat("TabBorderSize", &style.TabBorderSize, 0.0f, 1.0f, "%.0f");
            ImGui::Text("Rounding");
            ImGui::SliderFloat("WindowRounding", &style.WindowRounding, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("ChildRounding", &style.ChildRounding, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("FrameRounding", &style.FrameRounding, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("PopupRounding", &style.PopupRounding, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("ScrollbarRounding", &style.ScrollbarRounding, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("GrabRounding", &style.GrabRounding, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("LogSliderDeadzone", &style.LogSliderDeadzone, 0.0f, 12.0f, "%.0f");
            ImGui::SliderFloat("TabRounding", &style.TabRounding, 0.0f, 12.0f, "%.0f");
            ImGui::Text("Alignment");
            ImGui::SliderFloat2("WindowTitleAlign", (float*)&style.WindowTitleAlign, 0.0f, 1.0f, "%.2f");
            int window_menu_button_position = style.WindowMenuButtonPosition + 1;
            if (ImGui::Combo("WindowMenuButtonPosition", (int*)&window_menu_button_position, "None\0Left\0Right\0"))
                style.WindowMenuButtonPosition = window_menu_button_position - 1;
            ImGui::Combo("ColorButtonPosition", (int*)&style.ColorButtonPosition, "Left\0Right\0");
            ImGui::SliderFloat2("ButtonTextAlign", (float*)&style.ButtonTextAlign, 0.0f, 1.0f, "%.2f");
            ImGui::SameLine(); HelpMarker("Alignment applies when a button is larger than its text content.");
            ImGui::SliderFloat2("SelectableTextAlign", (float*)&style.SelectableTextAlign, 0.0f, 1.0f, "%.2f");
            ImGui::SameLine(); HelpMarker("Alignment applies when a selectable is larger than its text content.");
            ImGui::Text("Safe Area Padding");
            ImGui::SameLine(); HelpMarker("Adjust if you cannot see the edges of your screen (e.g. on a TV where scaling has not been configured).");
            ImGui::SliderFloat2("DisplaySafeAreaPadding", (float*)&style.DisplaySafeAreaPadding, 0.0f, 30.0f, "%.0f");
            ImGui::EndTabItem();
        }
 
        if (ImGui::BeginTabItem("Colors"))
        {
            static int output_dest = 0;
            static bool output_only_modified = true;
            if (ImGui::Button("Export"))
            {
                if (output_dest == 0)
                    ImGui::LogToClipboard();
                else
                    ImGui::LogToTTY();
                ImGui::LogText("ImVec4* colors = ImGui::GetStyle().Colors;" IM_NEWLINE);
                for (int i = 0; i < ImGuiCol_COUNT; i++)
                {
                    const ImVec4& col = style.Colors[i];
                    const char* name = ImGui::GetStyleColorName(i);
                    if (!output_only_modified || memcmp(&col, &ref->Colors[i], sizeof(ImVec4)) != 0)
                        ImGui::LogText("colors[ImGuiCol_%s]%*s= ImVec4(%.2ff, %.2ff, %.2ff, %.2ff);" IM_NEWLINE,
                            name, 23 - (int)strlen(name), "", col.x, col.y, col.z, col.w);
                }
                ImGui::LogFinish();
            }
            ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
            ImGui::SameLine(); ImGui::Checkbox("Only Modified Colors", &output_only_modified);
 
            static ImGuiTextFilter filter;
            filter.Draw("Filter colors", ImGui::GetFontSize() * 16);
 
            static ImGuiColorEditFlags alpha_flags = 0;
            if (ImGui::RadioButton("Opaque", alpha_flags == ImGuiColorEditFlags_None))             { alpha_flags = ImGuiColorEditFlags_None; } ImGui::SameLine();
            if (ImGui::RadioButton("Alpha",  alpha_flags == ImGuiColorEditFlags_AlphaPreview))     { alpha_flags = ImGuiColorEditFlags_AlphaPreview; } ImGui::SameLine();
            if (ImGui::RadioButton("Both",   alpha_flags == ImGuiColorEditFlags_AlphaPreviewHalf)) { alpha_flags = ImGuiColorEditFlags_AlphaPreviewHalf; } ImGui::SameLine();
            HelpMarker(
                "In the color list:\n"
                "Left-click on color square to open color picker,\n"
                "Right-click to open edit options menu.");
 
            ImGui::BeginChild("##colors", ImVec2(0, 0), true, ImGuiWindowFlags_AlwaysVerticalScrollbar | ImGuiWindowFlags_AlwaysHorizontalScrollbar | ImGuiWindowFlags_NavFlattened);
            ImGui::PushItemWidth(-160);
            for (int i = 0; i < ImGuiCol_COUNT; i++)
            {
                const char* name = ImGui::GetStyleColorName(i);
                if (!filter.PassFilter(name))
                    continue;
                ImGui::PushID(i);
                ImGui::ColorEdit4("##color", (float*)&style.Colors[i], ImGuiColorEditFlags_AlphaBar | alpha_flags);
                if (memcmp(&style.Colors[i], &ref->Colors[i], sizeof(ImVec4)) != 0)
                {
                    // Tips: in a real user application, you may want to merge and use an icon font into the main font,
                    // so instead of "Save"/"Revert" you'd use icons!
                    // Read the FAQ and docs/FONTS.md about using icon fonts. It's really easy and super convenient!
                    ImGui::SameLine(0.0f, style.ItemInnerSpacing.x); if (ImGui::Button("Save")) { ref->Colors[i] = style.Colors[i]; }
                    ImGui::SameLine(0.0f, style.ItemInnerSpacing.x); if (ImGui::Button("Revert")) { style.Colors[i] = ref->Colors[i]; }
                }
                ImGui::SameLine(0.0f, style.ItemInnerSpacing.x);
                ImGui::TextUnformatted(name);
                ImGui::PopID();
            }
            ImGui::PopItemWidth();
            ImGui::EndChild();
 
            ImGui::EndTabItem();
        }
 
        if (ImGui::BeginTabItem("Fonts"))
        {
            ImGuiIO& io = ImGui::GetIO();
            ImFontAtlas* atlas = io.Fonts;
            HelpMarker("Read FAQ and docs/FONTS.md for details on font loading.");
            ImGui::ShowFontAtlas(atlas);
 
            // Post-baking font scaling. Note that this is NOT the nice way of scaling fonts, read below.
            // (we enforce hard clamping manually as by default DragFloat/SliderFloat allows CTRL+Click text to get out of bounds).
            const float MIN_SCALE = 0.3f;
            const float MAX_SCALE = 2.0f;
            HelpMarker(
                "Those are old settings provided for convenience.\n"
                "However, the _correct_ way of scaling your UI is currently to reload your font at the designed size, "
                "rebuild the font atlas, and call style.ScaleAllSizes() on a reference ImGuiStyle structure.\n"
                "Using those settings here will give you poor quality results.");
            static float window_scale = 1.0f;
            ImGui::PushItemWidth(ImGui::GetFontSize() * 8);
            if (ImGui::DragFloat("window scale", &window_scale, 0.005f, MIN_SCALE, MAX_SCALE, "%.2f", ImGuiSliderFlags_AlwaysClamp)) // Scale only this window
                ImGui::SetWindowFontScale(window_scale);
            ImGui::DragFloat("global scale", &io.FontGlobalScale, 0.005f, MIN_SCALE, MAX_SCALE, "%.2f", ImGuiSliderFlags_AlwaysClamp); // Scale everything
            ImGui::PopItemWidth();
 
            ImGui::EndTabItem();
        }
 
        if (ImGui::BeginTabItem("Rendering"))
        {
            ImGui::Checkbox("Anti-aliased lines", &style.AntiAliasedLines);
            ImGui::SameLine();
            HelpMarker("When disabling anti-aliasing lines, you'll probably want to disable borders in your style as well.");
 
            ImGui::Checkbox("Anti-aliased lines use texture", &style.AntiAliasedLinesUseTex);
            ImGui::SameLine();
            HelpMarker("Faster lines using texture data. Require backend to render with bilinear filtering (not point/nearest filtering).");
 
            ImGui::Checkbox("Anti-aliased fill", &style.AntiAliasedFill);
            ImGui::PushItemWidth(ImGui::GetFontSize() * 8);
            ImGui::DragFloat("Curve Tessellation Tolerance", &style.CurveTessellationTol, 0.02f, 0.10f, 10.0f, "%.2f");
            if (style.CurveTessellationTol < 0.10f) style.CurveTessellationTol = 0.10f;
 
            // When editing the "Circle Segment Max Error" value, draw a preview of its effect on auto-tessellated circles.
            ImGui::DragFloat("Circle Tessellation Max Error", &style.CircleTessellationMaxError , 0.005f, 0.10f, 5.0f, "%.2f", ImGuiSliderFlags_AlwaysClamp);
            if (ImGui::IsItemActive())
            {
                ImGui::SetNextWindowPos(ImGui::GetCursorScreenPos());
                ImGui::BeginTooltip();
                ImGui::TextUnformatted("(R = radius, N = number of segments)");
                ImGui::Spacing();
                ImDrawList* draw_list = ImGui::GetWindowDrawList();
                const float min_widget_width = ImGui::CalcTextSize("N: MMM\nR: MMM").x;
                for (int n = 0; n < 8; n++)
                {
                    const float RAD_MIN = 5.0f;
                    const float RAD_MAX = 70.0f;
                    const float rad = RAD_MIN + (RAD_MAX - RAD_MIN) * (float)n / (8.0f - 1.0f);
 
                    ImGui::BeginGroup();
 
                    ImGui::Text("R: %.f\nN: %d", rad, draw_list->_CalcCircleAutoSegmentCount(rad));
 
                    const float canvas_width = IM_MAX(min_widget_width, rad * 2.0f);
                    const float offset_x     = floorf(canvas_width * 0.5f);
                    const float offset_y     = floorf(RAD_MAX);
 
                    const ImVec2 p1 = ImGui::GetCursorScreenPos();
                    draw_list->AddCircle(ImVec2(p1.x + offset_x, p1.y + offset_y), rad, ImGui::GetColorU32(ImGuiCol_Text));
                    ImGui::Dummy(ImVec2(canvas_width, RAD_MAX * 2));
 
                    /*
                    const ImVec2 p2 = ImGui::GetCursorScreenPos();
                    draw_list->AddCircleFilled(ImVec2(p2.x + offset_x, p2.y + offset_y), rad, ImGui::GetColorU32(ImGuiCol_Text));
                    ImGui::Dummy(ImVec2(canvas_width, RAD_MAX * 2));
                    */
 
                    ImGui::EndGroup();
                    ImGui::SameLine();
                }
                ImGui::EndTooltip();
            }
            ImGui::SameLine();
            HelpMarker("When drawing circle primitives with \"num_segments == 0\" tesselation will be calculated automatically.");
 
            ImGui::DragFloat("Global Alpha", &style.Alpha, 0.005f, 0.20f, 1.0f, "%.2f"); // Not exposing zero here so user doesn't "lose" the UI (zero alpha clips all widgets). But application code could have a toggle to switch between zero and non-zero.
            ImGui::PopItemWidth();
 
            ImGui::EndTabItem();
        }
 
        ImGui::EndTabBar();
    }
 
    ImGui::PopItemWidth();
}

References ImDrawList::_CalcCircleAutoSegmentCount(), ImDrawList::AddCircle(), BeginChild(), BeginGroup(), BeginTabBar(), BeginTabItem(), BeginTooltip(), Button(), CalcTextSize(), Checkbox(), col(), ColorEdit4(), ImGuiStyle::Colors, Combo(), DragFloat(), ImGuiTextFilter::Draw(), Dummy(), EndChild(), EndGroup(), EndTabBar(), EndTabItem(), EndTooltip(), ImGuiIO::FontGlobalScale, ImGuiIO::Fonts, GetColorU32(), GetCursorScreenPos(), GetFontSize(), GetIO(), GetStyle(), GetStyleColorName(), GetWindowDrawList(), GetWindowWidth(), HelpMarker(), IM_MAX, IM_NEWLINE, ImGuiCol_COUNT, ImGuiCol_Text, ImGuiColorEditFlags_AlphaBar, ImGuiColorEditFlags_AlphaPreview, ImGuiColorEditFlags_AlphaPreviewHalf, ImGuiColorEditFlags_None, ImGuiSliderFlags_AlwaysClamp, ImGuiTabBarFlags_None, ImGuiWindowFlags_AlwaysHorizontalScrollbar, ImGuiWindowFlags_AlwaysVerticalScrollbar, ImGuiWindowFlags_NavFlattened, IsItemActive(), LogFinish(), LogText(), LogToClipboard(), LogToTTY(), ImGuiTextFilter::PassFilter(), PopID(), PopItemWidth(), PushID(), PushItemWidth(), RadioButton(), SameLine(), Separator(), SetNextItemWidth(), SetNextWindowPos(), SetWindowFontScale(), ShowFontAtlas(), ShowFontSelector(), ShowStyleSelector(), SliderFloat(), SliderFloat2(), Spacing(), style, Text(), TextUnformatted(), ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindow().

Here is the caller graph for this function:

◆ ShowStyleSelector()

bool ImGui::ShowStyleSelector ( const char * label )

{
    static int style_idx = -1;
    if (ImGui::Combo(label, &style_idx, "Dark\0Light\0Classic\0"))
    {
        switch (style_idx)
        {
        case 0: ImGui::StyleColorsDark(); break;
        case 1: ImGui::StyleColorsLight(); break;
        case 2: ImGui::StyleColorsClassic(); break;
        }
        return true;
    }
    return false;
}

References Combo(), StyleColorsClassic(), StyleColorsDark(), and StyleColorsLight().

Referenced by ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowUserGuide()

void ImGui::ShowUserGuide ( )

{
    ImGuiIO& io = ImGui::GetIO();
    ImGui::BulletText("Double-click on title bar to collapse window.");
    ImGui::BulletText(
        "Click and drag on lower corner to resize window\n"
        "(double-click to auto fit window to its contents).");
    ImGui::BulletText("CTRL+Click on a slider or drag box to input value as text.");
    ImGui::BulletText("TAB/SHIFT+TAB to cycle through keyboard editable fields.");
    if (io.FontAllowUserScaling)
        ImGui::BulletText("CTRL+Mouse Wheel to zoom window contents.");
    ImGui::BulletText("While inputing text:\n");
    ImGui::Indent();
    ImGui::BulletText("CTRL+Left/Right to word jump.");
    ImGui::BulletText("CTRL+A or double-click to select all.");
    ImGui::BulletText("CTRL+X/C/V to use clipboard cut/copy/paste.");
    ImGui::BulletText("CTRL+Z,CTRL+Y to undo/redo.");
    ImGui::BulletText("ESCAPE to revert.");
    ImGui::BulletText("You can apply arithmetic operators +,*,/ on numerical values.\nUse +- to subtract.");
    ImGui::Unindent();
    ImGui::BulletText("With keyboard navigation enabled:");
    ImGui::Indent();
    ImGui::BulletText("Arrow keys to navigate.");
    ImGui::BulletText("Space to activate a widget.");
    ImGui::BulletText("Return to input text into a widget.");
    ImGui::BulletText("Escape to deactivate a widget, close popup, exit child window.");
    ImGui::BulletText("Alt to jump to the menu layer of a window.");
    ImGui::BulletText("CTRL+Tab to select a window.");
    ImGui::Unindent();
}

References BulletText(), ImGuiIO::FontAllowUserScaling, GetIO(), Indent(), and Unindent().

Referenced by ShowDemoWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShrinkWidths()

void ImGui::ShrinkWidths	(	ImGuiShrinkWidthItem *	items,
		int	count,
		float	width_excess
	)

{
    if (count == 1)
    {
        if (items[0].Width >= 0.0f)
            items[0].Width = ImMax(items[0].Width - width_excess, 1.0f);
        return;
    }
    ImQsort(items, (size_t)count, sizeof(ImGuiShrinkWidthItem), ShrinkWidthItemComparer);
    int count_same_width = 1;
    while (width_excess > 0.0f && count_same_width < count)
    {
        while (count_same_width < count && items[0].Width <= items[count_same_width].Width)
            count_same_width++;
        float max_width_to_remove_per_item = (count_same_width < count && items[count_same_width].Width >= 0.0f) ? (items[0].Width - items[count_same_width].Width) : (items[0].Width - 1.0f);
        if (max_width_to_remove_per_item <= 0.0f)
            break;
        float width_to_remove_per_item = ImMin(width_excess / count_same_width, max_width_to_remove_per_item);
        for (int item_n = 0; item_n < count_same_width; item_n++)
            items[item_n].Width -= width_to_remove_per_item;
        width_excess -= width_to_remove_per_item * count_same_width;
    }
 
    // Round width and redistribute remainder left-to-right (could make it an option of the function?)
    // Ensure that e.g. the right-most tab of a shrunk tab-bar always reaches exactly at the same distance from the right-most edge of the tab bar separator.
    width_excess = 0.0f;
    for (int n = 0; n < count; n++)
    {
        float width_rounded = ImFloor(items[n].Width);
        width_excess += items[n].Width - width_rounded;
        items[n].Width = width_rounded;
    }
    if (width_excess > 0.0f)
        for (int n = 0; n < count; n++)
            if (items[n].Index < (int)(width_excess + 0.01f))
                items[n].Width += 1.0f;
}

References ImFloor(), ImMax(), ImMin(), ImQsort, ShrinkWidthItemComparer(), and ImGuiShrinkWidthItem::Width.

Referenced by TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Shutdown()

void ImGui::Shutdown ( ImGuiContext * context )

{
    // The fonts atlas can be used prior to calling NewFrame(), so we clear it even if g.Initialized is FALSE (which would happen if we never called NewFrame)
    ImGuiContext& g = *context;
    if (g.IO.Fonts && g.FontAtlasOwnedByContext)
    {
        g.IO.Fonts->Locked = false;
        IM_DELETE(g.IO.Fonts);
    }
    g.IO.Fonts = NULL;
 
    // Cleanup of other data are conditional on actually having initialized Dear ImGui.
    if (!g.Initialized)
        return;
 
    // Save settings (unless we haven't attempted to load them: CreateContext/DestroyContext without a call to NewFrame shouldn't save an empty file)
    if (g.SettingsLoaded && g.IO.IniFilename != NULL)
    {
        ImGuiContext* backup_context = GImGui;
        SetCurrentContext(&g);
        SaveIniSettingsToDisk(g.IO.IniFilename);
        SetCurrentContext(backup_context);
    }
 
    CallContextHooks(&g, ImGuiContextHookType_Shutdown);
 
    // Clear everything else
    for (int i = 0; i < g.Windows.Size; i++)
        IM_DELETE(g.Windows[i]);
    g.Windows.clear();
    g.WindowsFocusOrder.clear();
    g.WindowsTempSortBuffer.clear();
    g.CurrentWindow = NULL;
    g.CurrentWindowStack.clear();
    g.WindowsById.Clear();
    g.NavWindow = NULL;
    g.HoveredWindow = g.HoveredWindowUnderMovingWindow = NULL;
    g.ActiveIdWindow = g.ActiveIdPreviousFrameWindow = NULL;
    g.MovingWindow = NULL;
    g.ColorStack.clear();
    g.StyleVarStack.clear();
    g.FontStack.clear();
    g.OpenPopupStack.clear();
    g.BeginPopupStack.clear();
 
    for (int i = 0; i < g.Viewports.Size; i++)
        IM_DELETE(g.Viewports[i]);
    g.Viewports.clear();
 
    g.TabBars.Clear();
    g.CurrentTabBarStack.clear();
    g.ShrinkWidthBuffer.clear();
 
    g.Tables.Clear();
    for (int i = 0; i < g.TablesTempDataStack.Size; i++)
        g.TablesTempDataStack[i].~ImGuiTableTempData();
    g.TablesTempDataStack.clear();
    g.DrawChannelsTempMergeBuffer.clear();
 
    g.ClipboardHandlerData.clear();
    g.MenusIdSubmittedThisFrame.clear();
    g.InputTextState.ClearFreeMemory();
 
    g.SettingsWindows.clear();
    g.SettingsHandlers.clear();
 
    if (g.LogFile)
    {
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
        if (g.LogFile != stdout)
#endif
            ImFileClose(g.LogFile);
        g.LogFile = NULL;
    }
    g.LogBuffer.clear();
 
    g.Initialized = false;
}

References ImGuiContext::ActiveIdPreviousFrameWindow, ImGuiContext::ActiveIdWindow, ImGuiContext::BeginPopupStack, CallContextHooks(), ImVector< T >::clear(), ImGuiTextBuffer::clear(), ImGuiStorage::Clear(), ImPool< T >::Clear(), ImChunkStream< T >::clear(), ImGuiInputTextState::ClearFreeMemory(), ImGuiContext::ClipboardHandlerData, ImGuiContext::ColorStack, ImGuiContext::CurrentTabBarStack, ImGuiContext::CurrentWindow, ImGuiContext::CurrentWindowStack, ImGuiContext::DrawChannelsTempMergeBuffer, ImGuiContext::FontAtlasOwnedByContext, ImGuiIO::Fonts, ImGuiContext::FontStack, GImGui, ImGuiContext::HoveredWindow, ImGuiContext::HoveredWindowUnderMovingWindow, IM_DELETE(), ImFileClose(), ImGuiContextHookType_Shutdown, ImGuiIO::IniFilename, ImGuiContext::Initialized, ImGuiContext::InputTextState, ImGuiContext::IO, ImFontAtlas::Locked, ImGuiContext::LogBuffer, ImGuiContext::LogFile, ImGuiContext::MenusIdSubmittedThisFrame, ImGuiContext::MovingWindow, ImGuiContext::NavWindow, ImGuiContext::OpenPopupStack, SaveIniSettingsToDisk(), SetCurrentContext(), ImGuiContext::SettingsHandlers, ImGuiContext::SettingsLoaded, ImGuiContext::SettingsWindows, ImGuiContext::ShrinkWidthBuffer, ImVector< T >::Size, ImGuiContext::StyleVarStack, ImGuiContext::TabBars, ImGuiContext::Tables, ImGuiContext::TablesTempDataStack, ImGuiContext::Viewports, ImGuiContext::Windows, ImGuiContext::WindowsById, ImGuiContext::WindowsFocusOrder, and ImGuiContext::WindowsTempSortBuffer.

Referenced by DestroyContext().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderAngle()

bool ImGui::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`
	)

{
    if (format == NULL)
        format = "%.0f deg";
    float v_deg = (*v_rad) * 360.0f / (2 * IM_PI);
    bool value_changed = SliderFloat(label, &v_deg, v_degrees_min, v_degrees_max, format, flags);
    *v_rad = v_deg * (2 * IM_PI) / 360.0f;
    return value_changed;
}

References IM_PI, and SliderFloat().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderBehavior()

bool ImGui::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
	)

{
    // Read imgui.cpp "API BREAKING CHANGES" section for 1.78 if you hit this assert.
    IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_InvalidMask_) == 0) && "Invalid ImGuiSliderFlags flag!  Has the 'float power' argument been mistakenly cast to flags? Call function with ImGuiSliderFlags_Logarithmic flags instead.");
 
    ImGuiContext& g = *GImGui;
    if ((g.CurrentItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly))
        return false;
 
    switch (data_type)
    {
    case ImGuiDataType_S8:  { ImS32 v32 = (ImS32)*(ImS8*)p_v;  bool r = SliderBehaviorT<ImS32, ImS32, float>(bb, id, ImGuiDataType_S32, &v32, *(const ImS8*)p_min,  *(const ImS8*)p_max,  format, flags, out_grab_bb); if (r) *(ImS8*)p_v  = (ImS8)v32;  return r; }
    case ImGuiDataType_U8:  { ImU32 v32 = (ImU32)*(ImU8*)p_v;  bool r = SliderBehaviorT<ImU32, ImS32, float>(bb, id, ImGuiDataType_U32, &v32, *(const ImU8*)p_min,  *(const ImU8*)p_max,  format, flags, out_grab_bb); if (r) *(ImU8*)p_v  = (ImU8)v32;  return r; }
    case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)p_v; bool r = SliderBehaviorT<ImS32, ImS32, float>(bb, id, ImGuiDataType_S32, &v32, *(const ImS16*)p_min, *(const ImS16*)p_max, format, flags, out_grab_bb); if (r) *(ImS16*)p_v = (ImS16)v32; return r; }
    case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)p_v; bool r = SliderBehaviorT<ImU32, ImS32, float>(bb, id, ImGuiDataType_U32, &v32, *(const ImU16*)p_min, *(const ImU16*)p_max, format, flags, out_grab_bb); if (r) *(ImU16*)p_v = (ImU16)v32; return r; }
    case ImGuiDataType_S32:
        IM_ASSERT(*(const ImS32*)p_min >= IM_S32_MIN / 2 && *(const ImS32*)p_max <= IM_S32_MAX / 2);
        return SliderBehaviorT<ImS32, ImS32, float >(bb, id, data_type, (ImS32*)p_v,  *(const ImS32*)p_min,  *(const ImS32*)p_max,  format, flags, out_grab_bb);
    case ImGuiDataType_U32:
        IM_ASSERT(*(const ImU32*)p_max <= IM_U32_MAX / 2);
        return SliderBehaviorT<ImU32, ImS32, float >(bb, id, data_type, (ImU32*)p_v,  *(const ImU32*)p_min,  *(const ImU32*)p_max,  format, flags, out_grab_bb);
    case ImGuiDataType_S64:
        IM_ASSERT(*(const ImS64*)p_min >= IM_S64_MIN / 2 && *(const ImS64*)p_max <= IM_S64_MAX / 2);
        return SliderBehaviorT<ImS64, ImS64, double>(bb, id, data_type, (ImS64*)p_v,  *(const ImS64*)p_min,  *(const ImS64*)p_max,  format, flags, out_grab_bb);
    case ImGuiDataType_U64:
        IM_ASSERT(*(const ImU64*)p_max <= IM_U64_MAX / 2);
        return SliderBehaviorT<ImU64, ImS64, double>(bb, id, data_type, (ImU64*)p_v,  *(const ImU64*)p_min,  *(const ImU64*)p_max,  format, flags, out_grab_bb);
    case ImGuiDataType_Float:
        IM_ASSERT(*(const float*)p_min >= -FLT_MAX / 2.0f && *(const float*)p_max <= FLT_MAX / 2.0f);
        return SliderBehaviorT<float, float, float >(bb, id, data_type, (float*)p_v,  *(const float*)p_min,  *(const float*)p_max,  format, flags, out_grab_bb);
    case ImGuiDataType_Double:
        IM_ASSERT(*(const double*)p_min >= -DBL_MAX / 2.0f && *(const double*)p_max <= DBL_MAX / 2.0f);
        return SliderBehaviorT<double, double, double>(bb, id, data_type, (double*)p_v, *(const double*)p_min, *(const double*)p_max, format, flags, out_grab_bb);
    case ImGuiDataType_COUNT: break;
    }
    IM_ASSERT(0);
    return false;
}

References ImGuiContext::CurrentItemFlags, GImGui, IM_ASSERT, IM_S32_MAX, IM_S32_MIN, IM_S64_MAX, IM_S64_MIN, IM_U32_MAX, IM_U64_MAX, ImGuiDataType_COUNT, ImGuiDataType_Double, ImGuiDataType_Float, ImGuiDataType_S16, ImGuiDataType_S32, ImGuiDataType_S64, ImGuiDataType_S8, ImGuiDataType_U16, ImGuiDataType_U32, ImGuiDataType_U64, ImGuiDataType_U8, ImGuiItemFlags_ReadOnly, ImGuiSliderFlags_InvalidMask_, and ImGuiSliderFlags_ReadOnly.

Referenced by SliderScalar(), and VSliderScalar().

Here is the caller graph for this function:

◆ SliderBehaviorT()

template<typename T , typename SIGNED_T , typename FLOAT_T >

IMGUI_API bool ImGui::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
	)

◆ SliderFloat() [1/2]

static bool ImGui::SliderFloat	(	const char *	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2801{ return SliderScalar(label, ImGuiDataType_Float, v, &v_min, &v_max, format, power); }

ImGui::SliderScalar

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)

Definition imgui_widgets.cpp:2922

References ImGuiDataType_Float, SliderFloat(), and SliderScalar().

Here is the call graph for this function:

◆ SliderFloat() [2/2]

bool ImGui::SliderFloat	(	const char *	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = `"%.3f"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalar(label, ImGuiDataType_Float, v, &v_min, &v_max, format, flags);
}

References ImGuiDataType_Float, and SliderScalar().

Referenced by ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleMenuFile(), ShowStyleEditor(), Slic3r::GUI::ImGuiWrapper::slider_float(), SliderAngle(), and SliderFloat().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderFloat2() [1/2]

static bool ImGui::SliderFloat2	(	const char *	label,
		float	v[2],
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2802{ return SliderScalarN(label, ImGuiDataType_Float, v, 2, &v_min, &v_max, format, power); }

ImGui::SliderScalarN

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)

Definition imgui_widgets.cpp:3003

References ImGuiDataType_Float, SliderFloat2(), and SliderScalarN().

Here is the call graph for this function:

◆ SliderFloat2() [2/2]

bool ImGui::SliderFloat2	(	const char *	label,
		float	v[2],
		float	v_min,
		float	v_max,
		const char *	format = `"%.3f"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalarN(label, ImGuiDataType_Float, v, 2, &v_min, &v_max, format, flags);
}

References ImGuiDataType_Float, and SliderScalarN().

Referenced by ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowStyleEditor(), and SliderFloat2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderFloat3() [1/2]

static bool ImGui::SliderFloat3	(	const char *	label,
		float	v[3],
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2803{ return SliderScalarN(label, ImGuiDataType_Float, v, 3, &v_min, &v_max, format, power); }

References ImGuiDataType_Float, SliderFloat3(), and SliderScalarN().

Here is the call graph for this function:

◆ SliderFloat3() [2/2]

bool ImGui::SliderFloat3	(	const char *	label,
		float	v[3],
		float	v_min,
		float	v_max,
		const char *	format = `"%.3f"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalarN(label, ImGuiDataType_Float, v, 3, &v_min, &v_max, format, flags);
}

References ImGuiDataType_Float, and SliderScalarN().

Referenced by ShowDemoWindowMisc(), ShowDemoWindowWidgets(), and SliderFloat3().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderFloat4() [1/2]

static bool ImGui::SliderFloat4	(	const char *	label,
		float	v[4],
		float	v_min,
		float	v_max,
		const char *	format,
		float	power
	)

inlinestatic

2804{ return SliderScalarN(label, ImGuiDataType_Float, v, 4, &v_min, &v_max, format, power); }

References ImGuiDataType_Float, SliderFloat4(), and SliderScalarN().

Here is the call graph for this function:

◆ SliderFloat4() [2/2]

bool ImGui::SliderFloat4	(	const char *	label,
		float	v[4],
		float	v_min,
		float	v_max,
		const char *	format = `"%.3f"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalarN(label, ImGuiDataType_Float, v, 4, &v_min, &v_max, format, flags);
}

References ImGuiDataType_Float, and SliderScalarN().

Referenced by ShowDemoWindowWidgets(), and SliderFloat4().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderInt()

bool ImGui::SliderInt	(	const char *	label,
		int *	v,
		int	v_min,
		int	v_max,
		const char *	format = `"%d"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalar(label, ImGuiDataType_S32, v, &v_min, &v_max, format, flags);
}

References ImGuiDataType_S32, and SliderScalar().

Referenced by LogButtons(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppAutoResize(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderInt2()

bool ImGui::SliderInt2	(	const char *	label,
		int	v[2],
		int	v_min,
		int	v_max,
		const char *	format = `"%d"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalarN(label, ImGuiDataType_S32, v, 2, &v_min, &v_max, format, flags);
}

References ImGuiDataType_S32, and SliderScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderInt3()

bool ImGui::SliderInt3	(	const char *	label,
		int	v[3],
		int	v_min,
		int	v_max,
		const char *	format = `"%d"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalarN(label, ImGuiDataType_S32, v, 3, &v_min, &v_max, format, flags);
}

References ImGuiDataType_S32, and SliderScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderInt4()

bool ImGui::SliderInt4	(	const char *	label,
		int	v[4],
		int	v_min,
		int	v_max,
		const char *	format = `"%d"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return SliderScalarN(label, ImGuiDataType_S32, v, 4, &v_min, &v_max, format, flags);
}

References ImGuiDataType_S32, and SliderScalarN().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderScalar() [1/2]

bool ImGui::SliderScalar	(	const char *	label,
		ImGuiDataType	data_type,
		void *	p_data,
		const void *	p_min,
		const void *	p_max,
		const char *	format,
		float	power
	)

{
    ImGuiSliderFlags slider_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        slider_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return SliderScalar(label, data_type, p_data, p_min, p_max, format, slider_flags);
}

References IM_ASSERT, ImGuiSliderFlags_Logarithmic, ImGuiSliderFlags_None, and SliderScalar().

Here is the call graph for this function:

◆ SliderScalar() [2/2]

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    const float w = CalcItemWidth();
 
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
    const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y * 2.0f));
    const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
 
    const bool temp_input_allowed = (flags & ImGuiSliderFlags_NoInput) == 0;
    ItemSize(total_bb, style.FramePadding.y);
    if (!ItemAdd(total_bb, id, &frame_bb, temp_input_allowed ? ImGuiItemAddFlags_Focusable : 0))
        return false;
 
    // Default format string when passing NULL
    if (format == NULL)
        format = DataTypeGetInfo(data_type)->PrintFmt;
    else if (data_type == ImGuiDataType_S32 && strcmp(format, "%d") != 0) // (FIXME-LEGACY: Patch old "%.0f" format string to use "%d", read function more details.)
        format = PatchFormatStringFloatToInt(format);
 
    // Tabbing or CTRL-clicking on Slider turns it into an input box
    const bool hovered = ItemHoverable(frame_bb, id);
    bool temp_input_is_active = temp_input_allowed && TempInputIsActive(id);
    if (!temp_input_is_active)
    {
        const bool focus_requested = temp_input_allowed && (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_Focused) != 0;
        const bool clicked = (hovered && g.IO.MouseClicked[0]);
        if (focus_requested || clicked || g.NavActivateId == id || g.NavInputId == id)
        {
            SetActiveID(id, window);
            SetFocusID(id, window);
            FocusWindow(window);
            g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Left) | (1 << ImGuiDir_Right);
            if (temp_input_allowed && (focus_requested || (clicked && g.IO.KeyCtrl) || g.NavInputId == id))
                temp_input_is_active = true;
        }
    }
 
    if (temp_input_is_active)
    {
        // Only clamp CTRL+Click input when ImGuiSliderFlags_AlwaysClamp is set
        const bool is_clamp_input = (flags & ImGuiSliderFlags_AlwaysClamp) != 0;
        return TempInputScalar(frame_bb, id, label, data_type, p_data, format, is_clamp_input ? p_min : NULL, is_clamp_input ? p_max : NULL);
    }
 
    // Draw frame
    const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : g.HoveredId == id ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
    RenderNavHighlight(frame_bb, id);
    RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, true, g.Style.FrameRounding);
 
    // Slider behavior
    ImRect grab_bb;
    const bool value_changed = SliderBehavior(frame_bb, id, data_type, p_data, p_min, p_max, format, flags, &grab_bb);
    if (value_changed)
        MarkItemEdited(id);
 
    // Render grab
    if (grab_bb.Max.x > grab_bb.Min.x)
        window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, GetColorU32(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), style.GrabRounding);
 
    // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
    char value_buf[64];
    const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_ARRAYSIZE(value_buf), data_type, p_data, format);
    if (g.LogEnabled)
        LogSetNextTextDecoration("{", "}");
    RenderTextClipped(frame_bb.Min, frame_bb.Max, value_buf, value_buf_end, NULL, ImVec2(0.5f, 0.5f));
 
    if (label_size.x > 0.0f)
        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    return value_changed;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdUsingNavDirMask, ImDrawList::AddRectFilled(), CalcItemWidth(), CalcTextSize(), ImGuiWindowTempData::CursorPos, DataTypeFormatString(), DataTypeGetInfo(), ImGuiWindow::DC, ImGuiWindow::DrawList, FocusWindow(), ImGuiStyle::FrameRounding, GetColorU32(), GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, ImGuiContext::HoveredId, IM_ARRAYSIZE, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiCol_SliderGrab, ImGuiCol_SliderGrabActive, ImGuiDataType_S32, ImGuiDir_Left, ImGuiDir_Right, ImGuiItemAddFlags_Focusable, ImGuiItemStatusFlags_Focused, ImGuiSliderFlags_AlwaysClamp, ImGuiSliderFlags_NoInput, ImGuiContext::IO, ItemAdd(), ItemHoverable(), ItemSize(), ImGuiIO::KeyCtrl, ImGuiWindowTempData::LastItemStatusFlags, ImGuiContext::LogEnabled, LogSetNextTextDecoration(), MarkItemEdited(), ImRect::Max, ImRect::Min, ImGuiIO::MouseClicked, ImGuiContext::NavActivateId, ImGuiContext::NavInputId, PatchFormatStringFloatToInt(), ImGuiDataTypeInfo::PrintFmt, RenderFrame(), RenderNavHighlight(), RenderText(), RenderTextClipped(), SetActiveID(), SetFocusID(), ImGuiWindow::SkipItems, SliderBehavior(), ImGuiContext::Style, style, TempInputIsActive(), TempInputScalar(), ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindowWidgets(), SliderFloat(), SliderFloat(), SliderInt(), SliderScalar(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SliderScalarN() [1/2]

bool ImGui::SliderScalarN	(	const char *	label,
		ImGuiDataType	data_type,
		void *	p_data,
		int	components,
		const void *	p_min,
		const void *	p_max,
		const char *	format,
		float	power
	)

{
    ImGuiSliderFlags slider_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        slider_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return SliderScalarN(label, data_type, v, components, v_min, v_max, format, slider_flags);
}

References IM_ASSERT, ImGuiSliderFlags_Logarithmic, ImGuiSliderFlags_None, and SliderScalarN().

Here is the call graph for this function:

◆ SliderScalarN() [2/2]

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    bool value_changed = false;
    BeginGroup();
    PushID(label);
    PushMultiItemsWidths(components, CalcItemWidth());
    size_t type_size = GDataTypeInfo[data_type].Size;
    for (int i = 0; i < components; i++)
    {
        PushID(i);
        if (i > 0)
            SameLine(0, g.Style.ItemInnerSpacing.x);
        value_changed |= SliderScalar("", data_type, v, v_min, v_max, format, flags);
        PopID();
        PopItemWidth();
        v = (void*)((char*)v + type_size);
    }
    PopID();
 
    const char* label_end = FindRenderedTextEnd(label);
    if (label != label_end)
    {
        SameLine(0, g.Style.ItemInnerSpacing.x);
        TextEx(label, label_end);
    }
 
    EndGroup();
    return value_changed;
}

References BeginGroup(), CalcItemWidth(), EndGroup(), FindRenderedTextEnd(), GDataTypeInfo, GetCurrentWindow(), GImGui, ImGuiStyle::ItemInnerSpacing, PopID(), PopItemWidth(), PushID(), PushMultiItemsWidths(), SameLine(), ImGuiDataTypeInfo::Size, ImGuiWindow::SkipItems, SliderScalar(), ImGuiContext::Style, TextEx(), and ImVec2::x.

Referenced by SliderFloat2(), SliderFloat2(), SliderFloat3(), SliderFloat3(), SliderFloat4(), SliderFloat4(), SliderInt2(), SliderInt3(), SliderInt4(), and SliderScalarN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SmallButton()

bool ImGui::SmallButton ( const char * label )

{
    ImGuiContext& g = *GImGui;
    float backup_padding_y = g.Style.FramePadding.y;
    g.Style.FramePadding.y = 0.0f;
    bool pressed = ButtonEx(label, ImVec2(0, 0), ImGuiButtonFlags_AlignTextBaseLine);
    g.Style.FramePadding.y = backup_padding_y;
    return pressed;
}

References ButtonEx(), ImGuiStyle::FramePadding, GImGui, ImGuiButtonFlags_AlignTextBaseLine, ImGuiContext::Style, and ImVec2::y.

Referenced by DebugNodeTabBar(), DebugNodeTable(), ExampleAppConsole::Draw(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppLog(), ShowFont(), and ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Spacing()

void ImGui::Spacing ( )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
    ItemSize(ImVec2(0, 0));
}

References GetCurrentWindow(), ItemSize(), and ImGuiWindow::SkipItems.

Referenced by ColorEdit4(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitterBehavior()

bool ImGui::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`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    const ImGuiItemFlags item_flags_backup = g.CurrentItemFlags;
    g.CurrentItemFlags |= ImGuiItemFlags_NoNav | ImGuiItemFlags_NoNavDefaultFocus;
    bool item_add = ItemAdd(bb, id);
    g.CurrentItemFlags = item_flags_backup;
    if (!item_add)
        return false;
 
    bool hovered, held;
    ImRect bb_interact = bb;
    bb_interact.Expand(axis == ImGuiAxis_Y ? ImVec2(0.0f, hover_extend) : ImVec2(hover_extend, 0.0f));
    ButtonBehavior(bb_interact, id, &hovered, &held, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_AllowItemOverlap);
    if (g.ActiveId != id)
        SetItemAllowOverlap();
 
    if (held || (g.HoveredId == id && g.HoveredIdPreviousFrame == id && g.HoveredIdTimer >= hover_visibility_delay))
        SetMouseCursor(axis == ImGuiAxis_Y ? ImGuiMouseCursor_ResizeNS : ImGuiMouseCursor_ResizeEW);
 
    ImRect bb_render = bb;
    if (held)
    {
        ImVec2 mouse_delta_2d = g.IO.MousePos - g.ActiveIdClickOffset - bb_interact.Min;
        float mouse_delta = (axis == ImGuiAxis_Y) ? mouse_delta_2d.y : mouse_delta_2d.x;
 
        // Minimum pane size
        float size_1_maximum_delta = ImMax(0.0f, *size1 - min_size1);
        float size_2_maximum_delta = ImMax(0.0f, *size2 - min_size2);
        if (mouse_delta < -size_1_maximum_delta)
            mouse_delta = -size_1_maximum_delta;
        if (mouse_delta > size_2_maximum_delta)
            mouse_delta = size_2_maximum_delta;
 
        // Apply resize
        if (mouse_delta != 0.0f)
        {
            if (mouse_delta < 0.0f)
                IM_ASSERT(*size1 + mouse_delta >= min_size1);
            if (mouse_delta > 0.0f)
                IM_ASSERT(*size2 - mouse_delta >= min_size2);
            *size1 += mouse_delta;
            *size2 -= mouse_delta;
            bb_render.Translate((axis == ImGuiAxis_X) ? ImVec2(mouse_delta, 0.0f) : ImVec2(0.0f, mouse_delta));
            MarkItemEdited(id);
        }
    }
 
    // Render
    const ImU32 col = GetColorU32(held ? ImGuiCol_SeparatorActive : (hovered && g.HoveredIdTimer >= hover_visibility_delay) ? ImGuiCol_SeparatorHovered : ImGuiCol_Separator);
    window->DrawList->AddRectFilled(bb_render.Min, bb_render.Max, col, 0.0f);
 
    return held;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdClickOffset, ImDrawList::AddRectFilled(), ButtonBehavior(), col(), ImGuiContext::CurrentItemFlags, ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImRect::Expand(), GetColorU32(), GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdPreviousFrame, ImGuiContext::HoveredIdTimer, IM_ASSERT, ImGuiAxis_X, ImGuiAxis_Y, ImGuiButtonFlags_AllowItemOverlap, ImGuiButtonFlags_FlattenChildren, ImGuiCol_Separator, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiItemFlags_NoNav, ImGuiItemFlags_NoNavDefaultFocus, ImGuiMouseCursor_ResizeEW, ImGuiMouseCursor_ResizeNS, ImMax(), ImGuiContext::IO, ItemAdd(), MarkItemEdited(), ImRect::Min, ImGuiIO::MousePos, SetItemAllowOverlap(), SetMouseCursor(), ImVec2::x, and ImVec2::y.

Here is the call graph for this function:

◆ StartMouseMovingWindow()

void ImGui::StartMouseMovingWindow ( ImGuiWindow * window )

{
    // Set ActiveId even if the _NoMove flag is set. Without it, dragging away from a window with _NoMove would activate hover on other windows.
    // We _also_ call this when clicking in a window empty space when io.ConfigWindowsMoveFromTitleBarOnly is set, but clear g.MovingWindow afterward.
    // This is because we want ActiveId to be set even when the window is not permitted to move.
    ImGuiContext& g = *GImGui;
    FocusWindow(window);
    SetActiveID(window->MoveId, window);
    g.NavDisableHighlight = true;
    g.ActiveIdNoClearOnFocusLoss = true;
    g.ActiveIdClickOffset = g.IO.MousePos - window->RootWindow->Pos;
 
    bool can_move_window = true;
    if ((window->Flags & ImGuiWindowFlags_NoMove) || (window->RootWindow->Flags & ImGuiWindowFlags_NoMove))
        can_move_window = false;
    if (can_move_window)
        g.MovingWindow = window;
}

References ImGuiContext::ActiveIdClickOffset, ImGuiContext::ActiveIdNoClearOnFocusLoss, ImGuiWindow::Flags, FocusWindow(), GImGui, ImGuiWindowFlags_NoMove, ImGuiContext::IO, ImGuiIO::MousePos, ImGuiWindow::MoveId, ImGuiContext::MovingWindow, ImGuiContext::NavDisableHighlight, ImGuiWindow::Pos, ImGuiWindow::RootWindow, and SetActiveID().

Referenced by CollapseButton(), and UpdateMouseMovingWindowEndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StyleColorsClassic()

void ImGui::StyleColorsClassic ( ImGuiStyle * dst = NULL )

{
    ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
    ImVec4* colors = style->Colors;
 
    colors[ImGuiCol_Text]                   = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
    colors[ImGuiCol_TextDisabled]           = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
    colors[ImGuiCol_WindowBg]               = ImVec4(0.00f, 0.00f, 0.00f, 0.85f);
    colors[ImGuiCol_ChildBg]                = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_PopupBg]                = ImVec4(0.11f, 0.11f, 0.14f, 0.92f);
    colors[ImGuiCol_Border]                 = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
    colors[ImGuiCol_BorderShadow]           = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_FrameBg]                = ImVec4(0.43f, 0.43f, 0.43f, 0.39f);
    colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.47f, 0.47f, 0.69f, 0.40f);
    colors[ImGuiCol_FrameBgActive]          = ImVec4(0.42f, 0.41f, 0.64f, 0.69f);
    colors[ImGuiCol_TitleBg]                = ImVec4(0.27f, 0.27f, 0.54f, 0.83f);
    colors[ImGuiCol_TitleBgActive]          = ImVec4(0.32f, 0.32f, 0.63f, 0.87f);
    colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(0.40f, 0.40f, 0.80f, 0.20f);
    colors[ImGuiCol_MenuBarBg]              = ImVec4(0.40f, 0.40f, 0.55f, 0.80f);
    colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.20f, 0.25f, 0.30f, 0.60f);
    colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.40f, 0.40f, 0.80f, 0.30f);
    colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.40f, 0.40f, 0.80f, 0.40f);
    colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);
    colors[ImGuiCol_CheckMark]              = ImVec4(0.90f, 0.90f, 0.90f, 0.50f);
    colors[ImGuiCol_SliderGrab]             = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);
    colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);
    colors[ImGuiCol_Button]                 = ImVec4(0.35f, 0.40f, 0.61f, 0.62f);
    colors[ImGuiCol_ButtonHovered]          = ImVec4(0.40f, 0.48f, 0.71f, 0.79f);
    colors[ImGuiCol_ButtonActive]           = ImVec4(0.46f, 0.54f, 0.80f, 1.00f);
    colors[ImGuiCol_Header]                 = ImVec4(0.40f, 0.40f, 0.90f, 0.45f);
    colors[ImGuiCol_HeaderHovered]          = ImVec4(0.45f, 0.45f, 0.90f, 0.80f);
    colors[ImGuiCol_HeaderActive]           = ImVec4(0.53f, 0.53f, 0.87f, 0.80f);
    colors[ImGuiCol_Separator]              = ImVec4(0.50f, 0.50f, 0.50f, 0.60f);
    colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.60f, 0.60f, 0.70f, 1.00f);
    colors[ImGuiCol_SeparatorActive]        = ImVec4(0.70f, 0.70f, 0.90f, 1.00f);
    colors[ImGuiCol_ResizeGrip]             = ImVec4(1.00f, 1.00f, 1.00f, 0.10f);
    colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.78f, 0.82f, 1.00f, 0.60f);
    colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.78f, 0.82f, 1.00f, 0.90f);
    colors[ImGuiCol_Tab]                    = ImLerp(colors[ImGuiCol_Header],       colors[ImGuiCol_TitleBgActive], 0.80f);
    colors[ImGuiCol_TabHovered]             = colors[ImGuiCol_HeaderHovered];
    colors[ImGuiCol_TabActive]              = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
    colors[ImGuiCol_TabUnfocused]           = ImLerp(colors[ImGuiCol_Tab],          colors[ImGuiCol_TitleBg], 0.80f);
    colors[ImGuiCol_TabUnfocusedActive]     = ImLerp(colors[ImGuiCol_TabActive],    colors[ImGuiCol_TitleBg], 0.40f);
    colors[ImGuiCol_PlotLines]              = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImGuiCol_PlotLinesHovered]       = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
    colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
    colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
    colors[ImGuiCol_TableHeaderBg]          = ImVec4(0.27f, 0.27f, 0.38f, 1.00f);
    colors[ImGuiCol_TableBorderStrong]      = ImVec4(0.31f, 0.31f, 0.45f, 1.00f);   // Prefer using Alpha=1.0 here
    colors[ImGuiCol_TableBorderLight]       = ImVec4(0.26f, 0.26f, 0.28f, 1.00f);   // Prefer using Alpha=1.0 here
    colors[ImGuiCol_TableRowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_TableRowBgAlt]          = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);
    colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.00f, 0.00f, 1.00f, 0.35f);
    colors[ImGuiCol_DragDropTarget]         = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
    colors[ImGuiCol_NavHighlight]           = colors[ImGuiCol_HeaderHovered];
    colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
    colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
    colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
}

References GetStyle(), ImGuiCol_Border, ImGuiCol_BorderShadow, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_CheckMark, ImGuiCol_ChildBg, ImGuiCol_DragDropTarget, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiCol_Header, ImGuiCol_HeaderActive, ImGuiCol_HeaderHovered, ImGuiCol_MenuBarBg, ImGuiCol_ModalWindowDimBg, ImGuiCol_NavHighlight, ImGuiCol_NavWindowingDimBg, ImGuiCol_NavWindowingHighlight, ImGuiCol_PlotHistogram, ImGuiCol_PlotHistogramHovered, ImGuiCol_PlotLines, ImGuiCol_PlotLinesHovered, ImGuiCol_PopupBg, ImGuiCol_ResizeGrip, ImGuiCol_ResizeGripActive, ImGuiCol_ResizeGripHovered, ImGuiCol_ScrollbarBg, ImGuiCol_ScrollbarGrab, ImGuiCol_ScrollbarGrabActive, ImGuiCol_ScrollbarGrabHovered, ImGuiCol_Separator, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiCol_SliderGrab, ImGuiCol_SliderGrabActive, ImGuiCol_Tab, ImGuiCol_TabActive, ImGuiCol_TabHovered, ImGuiCol_TableBorderLight, ImGuiCol_TableBorderStrong, ImGuiCol_TableHeaderBg, ImGuiCol_TableRowBg, ImGuiCol_TableRowBgAlt, ImGuiCol_TabUnfocused, ImGuiCol_TabUnfocusedActive, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiCol_TextSelectedBg, ImGuiCol_TitleBg, ImGuiCol_TitleBgActive, ImGuiCol_TitleBgCollapsed, ImGuiCol_WindowBg, ImLerp(), and style.

Referenced by ShowStyleSelector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StyleColorsDark()

void ImGui::StyleColorsDark ( ImGuiStyle * dst = NULL )

{
    ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
    ImVec4* colors = style->Colors;
 
    colors[ImGuiCol_Text]                   = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImGuiCol_TextDisabled]           = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
    colors[ImGuiCol_WindowBg]               = ImVec4(0.06f, 0.06f, 0.06f, 0.94f);
    colors[ImGuiCol_ChildBg]                = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_PopupBg]                = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
    colors[ImGuiCol_Border]                 = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
    colors[ImGuiCol_BorderShadow]           = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_FrameBg]                = ImVec4(0.16f, 0.29f, 0.48f, 0.54f);
    colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
    colors[ImGuiCol_FrameBgActive]          = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
    colors[ImGuiCol_TitleBg]                = ImVec4(0.04f, 0.04f, 0.04f, 1.00f);
    colors[ImGuiCol_TitleBgActive]          = ImVec4(0.16f, 0.29f, 0.48f, 1.00f);
    colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(0.00f, 0.00f, 0.00f, 0.51f);
    colors[ImGuiCol_MenuBarBg]              = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
    colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);
    colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
    colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
    colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
    colors[ImGuiCol_CheckMark]              = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_SliderGrab]             = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);
    colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_Button]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
    colors[ImGuiCol_ButtonHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_ButtonActive]           = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
    colors[ImGuiCol_Header]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
    colors[ImGuiCol_HeaderHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
    colors[ImGuiCol_HeaderActive]           = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_Separator]              = colors[ImGuiCol_Border];
    colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);
    colors[ImGuiCol_SeparatorActive]        = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);
    colors[ImGuiCol_ResizeGrip]             = ImVec4(0.26f, 0.59f, 0.98f, 0.20f);
    colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
    colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
    colors[ImGuiCol_Tab]                    = ImLerp(colors[ImGuiCol_Header],       colors[ImGuiCol_TitleBgActive], 0.80f);
    colors[ImGuiCol_TabHovered]             = colors[ImGuiCol_HeaderHovered];
    colors[ImGuiCol_TabActive]              = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
    colors[ImGuiCol_TabUnfocused]           = ImLerp(colors[ImGuiCol_Tab],          colors[ImGuiCol_TitleBg], 0.80f);
    colors[ImGuiCol_TabUnfocusedActive]     = ImLerp(colors[ImGuiCol_TabActive],    colors[ImGuiCol_TitleBg], 0.40f);
    colors[ImGuiCol_PlotLines]              = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
    colors[ImGuiCol_PlotLinesHovered]       = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
    colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
    colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
    colors[ImGuiCol_TableHeaderBg]          = ImVec4(0.19f, 0.19f, 0.20f, 1.00f);
    colors[ImGuiCol_TableBorderStrong]      = ImVec4(0.31f, 0.31f, 0.35f, 1.00f);   // Prefer using Alpha=1.0 here
    colors[ImGuiCol_TableBorderLight]       = ImVec4(0.23f, 0.23f, 0.25f, 1.00f);   // Prefer using Alpha=1.0 here
    colors[ImGuiCol_TableRowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_TableRowBgAlt]          = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
    colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
    colors[ImGuiCol_DragDropTarget]         = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
    colors[ImGuiCol_NavHighlight]           = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
    colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
    colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
}

References GetStyle(), ImGuiCol_Border, ImGuiCol_BorderShadow, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_CheckMark, ImGuiCol_ChildBg, ImGuiCol_DragDropTarget, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiCol_Header, ImGuiCol_HeaderActive, ImGuiCol_HeaderHovered, ImGuiCol_MenuBarBg, ImGuiCol_ModalWindowDimBg, ImGuiCol_NavHighlight, ImGuiCol_NavWindowingDimBg, ImGuiCol_NavWindowingHighlight, ImGuiCol_PlotHistogram, ImGuiCol_PlotHistogramHovered, ImGuiCol_PlotLines, ImGuiCol_PlotLinesHovered, ImGuiCol_PopupBg, ImGuiCol_ResizeGrip, ImGuiCol_ResizeGripActive, ImGuiCol_ResizeGripHovered, ImGuiCol_ScrollbarBg, ImGuiCol_ScrollbarGrab, ImGuiCol_ScrollbarGrabActive, ImGuiCol_ScrollbarGrabHovered, ImGuiCol_Separator, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiCol_SliderGrab, ImGuiCol_SliderGrabActive, ImGuiCol_Tab, ImGuiCol_TabActive, ImGuiCol_TabHovered, ImGuiCol_TableBorderLight, ImGuiCol_TableBorderStrong, ImGuiCol_TableHeaderBg, ImGuiCol_TableRowBg, ImGuiCol_TableRowBgAlt, ImGuiCol_TabUnfocused, ImGuiCol_TabUnfocusedActive, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiCol_TextSelectedBg, ImGuiCol_TitleBg, ImGuiCol_TitleBgActive, ImGuiCol_TitleBgCollapsed, ImGuiCol_WindowBg, ImLerp(), and style.

Referenced by ImGuiStyle::ImGuiStyle(), igl::opengl::glfw::imgui::ImGuiMenu::init(), and ShowStyleSelector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StyleColorsLight()

void ImGui::StyleColorsLight ( ImGuiStyle * dst = NULL )

{
    ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
    ImVec4* colors = style->Colors;
 
    colors[ImGuiCol_Text]                   = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImGuiCol_TextDisabled]           = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
    colors[ImGuiCol_WindowBg]               = ImVec4(0.94f, 0.94f, 0.94f, 1.00f);
    colors[ImGuiCol_ChildBg]                = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_PopupBg]                = ImVec4(1.00f, 1.00f, 1.00f, 0.98f);
    colors[ImGuiCol_Border]                 = ImVec4(0.00f, 0.00f, 0.00f, 0.30f);
    colors[ImGuiCol_BorderShadow]           = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_FrameBg]                = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
    colors[ImGuiCol_FrameBgActive]          = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
    colors[ImGuiCol_TitleBg]                = ImVec4(0.96f, 0.96f, 0.96f, 1.00f);
    colors[ImGuiCol_TitleBgActive]          = ImVec4(0.82f, 0.82f, 0.82f, 1.00f);
    colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(1.00f, 1.00f, 1.00f, 0.51f);
    colors[ImGuiCol_MenuBarBg]              = ImVec4(0.86f, 0.86f, 0.86f, 1.00f);
    colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.98f, 0.98f, 0.98f, 0.53f);
    colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.69f, 0.69f, 0.69f, 0.80f);
    colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.49f, 0.49f, 0.49f, 0.80f);
    colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.49f, 0.49f, 0.49f, 1.00f);
    colors[ImGuiCol_CheckMark]              = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_SliderGrab]             = ImVec4(0.26f, 0.59f, 0.98f, 0.78f);
    colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.46f, 0.54f, 0.80f, 0.60f);
    colors[ImGuiCol_Button]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
    colors[ImGuiCol_ButtonHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_ButtonActive]           = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
    colors[ImGuiCol_Header]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
    colors[ImGuiCol_HeaderHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
    colors[ImGuiCol_HeaderActive]           = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
    colors[ImGuiCol_Separator]              = ImVec4(0.39f, 0.39f, 0.39f, 0.62f);
    colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.14f, 0.44f, 0.80f, 0.78f);
    colors[ImGuiCol_SeparatorActive]        = ImVec4(0.14f, 0.44f, 0.80f, 1.00f);
    colors[ImGuiCol_ResizeGrip]             = ImVec4(0.35f, 0.35f, 0.35f, 0.17f);
    colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
    colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
    colors[ImGuiCol_Tab]                    = ImLerp(colors[ImGuiCol_Header],       colors[ImGuiCol_TitleBgActive], 0.90f);
    colors[ImGuiCol_TabHovered]             = colors[ImGuiCol_HeaderHovered];
    colors[ImGuiCol_TabActive]              = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
    colors[ImGuiCol_TabUnfocused]           = ImLerp(colors[ImGuiCol_Tab],          colors[ImGuiCol_TitleBg], 0.80f);
    colors[ImGuiCol_TabUnfocusedActive]     = ImLerp(colors[ImGuiCol_TabActive],    colors[ImGuiCol_TitleBg], 0.40f);
    colors[ImGuiCol_PlotLines]              = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);
    colors[ImGuiCol_PlotLinesHovered]       = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
    colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
    colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.45f, 0.00f, 1.00f);
    colors[ImGuiCol_TableHeaderBg]          = ImVec4(0.78f, 0.87f, 0.98f, 1.00f);
    colors[ImGuiCol_TableBorderStrong]      = ImVec4(0.57f, 0.57f, 0.64f, 1.00f);   // Prefer using Alpha=1.0 here
    colors[ImGuiCol_TableBorderLight]       = ImVec4(0.68f, 0.68f, 0.74f, 1.00f);   // Prefer using Alpha=1.0 here
    colors[ImGuiCol_TableRowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImGuiCol_TableRowBgAlt]          = ImVec4(0.30f, 0.30f, 0.30f, 0.09f);
    colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
    colors[ImGuiCol_DragDropTarget]         = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
    colors[ImGuiCol_NavHighlight]           = colors[ImGuiCol_HeaderHovered];
    colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(0.70f, 0.70f, 0.70f, 0.70f);
    colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.20f, 0.20f, 0.20f, 0.20f);
    colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
}

References GetStyle(), ImGuiCol_Border, ImGuiCol_BorderShadow, ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImGuiCol_CheckMark, ImGuiCol_ChildBg, ImGuiCol_DragDropTarget, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiCol_Header, ImGuiCol_HeaderActive, ImGuiCol_HeaderHovered, ImGuiCol_MenuBarBg, ImGuiCol_ModalWindowDimBg, ImGuiCol_NavHighlight, ImGuiCol_NavWindowingDimBg, ImGuiCol_NavWindowingHighlight, ImGuiCol_PlotHistogram, ImGuiCol_PlotHistogramHovered, ImGuiCol_PlotLines, ImGuiCol_PlotLinesHovered, ImGuiCol_PopupBg, ImGuiCol_ResizeGrip, ImGuiCol_ResizeGripActive, ImGuiCol_ResizeGripHovered, ImGuiCol_ScrollbarBg, ImGuiCol_ScrollbarGrab, ImGuiCol_ScrollbarGrabActive, ImGuiCol_ScrollbarGrabHovered, ImGuiCol_Separator, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiCol_SliderGrab, ImGuiCol_SliderGrabActive, ImGuiCol_Tab, ImGuiCol_TabActive, ImGuiCol_TabHovered, ImGuiCol_TableBorderLight, ImGuiCol_TableBorderStrong, ImGuiCol_TableHeaderBg, ImGuiCol_TableRowBg, ImGuiCol_TableRowBgAlt, ImGuiCol_TabUnfocused, ImGuiCol_TabUnfocusedActive, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiCol_TextSelectedBg, ImGuiCol_TitleBg, ImGuiCol_TitleBgActive, ImGuiCol_TitleBgCollapsed, ImGuiCol_WindowBg, ImLerp(), and style.

Referenced by ShowStyleSelector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarCalcMaxTabWidth()

static float ImGui::TabBarCalcMaxTabWidth ( )

static

{
    ImGuiContext& g = *GImGui;
    return g.FontSize * 20.0f;
}

References ImGuiContext::FontSize, and GImGui.

Referenced by TabItemCalcSize().

Here is the caller graph for this function:

◆ TabBarCalcTabID()

static ImU32 ImGui::TabBarCalcTabID	(	ImGuiTabBar *	tab_bar,
		const char *	label
	)

static

{
    if (tab_bar->Flags & ImGuiTabBarFlags_DockNode)
    {
        ImGuiID id = ImHashStr(label);
        KeepAliveID(id);
        return id;
    }
    else
    {
        ImGuiWindow* window = GImGui->CurrentWindow;
        return window->GetID(label);
    }
}

References ImGuiContext::CurrentWindow, ImGuiTabBar::Flags, ImGuiWindow::GetID(), GImGui, ImGuiTabBarFlags_DockNode, ImHashStr(), and KeepAliveID().

Referenced by SetTabItemClosed(), and TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarCloseTab()

void ImGui::TabBarCloseTab	(	ImGuiTabBar *	tab_bar,
		ImGuiTabItem *	tab
	)

{
    IM_ASSERT(!(tab->Flags & ImGuiTabItemFlags_Button));
    if (!(tab->Flags & ImGuiTabItemFlags_UnsavedDocument))
    {
        // This will remove a frame of lag for selecting another tab on closure.
        // However we don't run it in the case where the 'Unsaved' flag is set, so user gets a chance to fully undo the closure
        tab->WantClose = true;
        if (tab_bar->VisibleTabId == tab->ID)
        {
            tab->LastFrameVisible = -1;
            tab_bar->SelectedTabId = tab_bar->NextSelectedTabId = 0;
        }
    }
    else
    {
        // Actually select before expecting closure attempt (on an UnsavedDocument tab user is expect to e.g. show a popup)
        if (tab_bar->VisibleTabId != tab->ID)
            tab_bar->NextSelectedTabId = tab->ID;
    }
}

References ImGuiTabItem::Flags, ImGuiTabItem::ID, IM_ASSERT, ImGuiTabItemFlags_Button, ImGuiTabItemFlags_UnsavedDocument, ImGuiTabItem::LastFrameVisible, ImGuiTabBar::NextSelectedTabId, ImGuiTabBar::SelectedTabId, ImGuiTabBar::VisibleTabId, and ImGuiTabItem::WantClose.

Referenced by TabItemEx().

Here is the caller graph for this function:

◆ TabBarFindTabByID()

ImGuiTabItem * ImGui::TabBarFindTabByID	(	ImGuiTabBar *	tab_bar,
		ImGuiID	tab_id
	)

{
    if (tab_id != 0)
        for (int n = 0; n < tab_bar->Tabs.Size; n++)
            if (tab_bar->Tabs[n].ID == tab_id)
                return &tab_bar->Tabs[n];
    return NULL;
}

References ImVector< T >::Size, and ImGuiTabBar::Tabs.

Referenced by SetTabItemClosed(), TabBarProcessReorder(), TabBarRemoveTab(), TabBarScrollingButtons(), TabBarScrollToTab(), and TabItemEx().

Here is the caller graph for this function:

◆ TabBarLayout()

static void ImGui::TabBarLayout ( ImGuiTabBar * tab_bar )

static

{
    ImGuiContext& g = *GImGui;
    tab_bar->WantLayout = false;
 
    // Garbage collect by compacting list
    // Detect if we need to sort out tab list (e.g. in rare case where a tab changed section)
    int tab_dst_n = 0;
    bool need_sort_by_section = false;
    ImGuiTabBarSection sections[3]; // Layout sections: Leading, Central, Trailing
    for (int tab_src_n = 0; tab_src_n < tab_bar->Tabs.Size; tab_src_n++)
    {
        ImGuiTabItem* tab = &tab_bar->Tabs[tab_src_n];
        if (tab->LastFrameVisible < tab_bar->PrevFrameVisible || tab->WantClose)
        {
            // Remove tab
            if (tab_bar->VisibleTabId == tab->ID) { tab_bar->VisibleTabId = 0; }
            if (tab_bar->SelectedTabId == tab->ID) { tab_bar->SelectedTabId = 0; }
            if (tab_bar->NextSelectedTabId == tab->ID) { tab_bar->NextSelectedTabId = 0; }
            continue;
        }
        if (tab_dst_n != tab_src_n)
            tab_bar->Tabs[tab_dst_n] = tab_bar->Tabs[tab_src_n];
 
        tab = &tab_bar->Tabs[tab_dst_n];
        tab->IndexDuringLayout = (ImS16)tab_dst_n;
 
        // We will need sorting if tabs have changed section (e.g. moved from one of Leading/Central/Trailing to another)
        int curr_tab_section_n = TabItemGetSectionIdx(tab);
        if (tab_dst_n > 0)
        {
            ImGuiTabItem* prev_tab = &tab_bar->Tabs[tab_dst_n - 1];
            int prev_tab_section_n = TabItemGetSectionIdx(prev_tab);
            if (curr_tab_section_n == 0 && prev_tab_section_n != 0)
                need_sort_by_section = true;
            if (prev_tab_section_n == 2 && curr_tab_section_n != 2)
                need_sort_by_section = true;
        }
 
        sections[curr_tab_section_n].TabCount++;
        tab_dst_n++;
    }
    if (tab_bar->Tabs.Size != tab_dst_n)
        tab_bar->Tabs.resize(tab_dst_n);
 
    if (need_sort_by_section)
        ImQsort(tab_bar->Tabs.Data, tab_bar->Tabs.Size, sizeof(ImGuiTabItem), TabItemComparerBySection);
 
    // Calculate spacing between sections
    sections[0].Spacing = sections[0].TabCount > 0 && (sections[1].TabCount + sections[2].TabCount) > 0 ? g.Style.ItemInnerSpacing.x : 0.0f;
    sections[1].Spacing = sections[1].TabCount > 0 && sections[2].TabCount > 0 ? g.Style.ItemInnerSpacing.x : 0.0f;
 
    // Setup next selected tab
    ImGuiID scroll_to_tab_id = 0;
    if (tab_bar->NextSelectedTabId)
    {
        tab_bar->SelectedTabId = tab_bar->NextSelectedTabId;
        tab_bar->NextSelectedTabId = 0;
        scroll_to_tab_id = tab_bar->SelectedTabId;
    }
 
    // Process order change request (we could probably process it when requested but it's just saner to do it in a single spot).
    if (tab_bar->ReorderRequestTabId != 0)
    {
        if (TabBarProcessReorder(tab_bar))
            if (tab_bar->ReorderRequestTabId == tab_bar->SelectedTabId)
                scroll_to_tab_id = tab_bar->ReorderRequestTabId;
        tab_bar->ReorderRequestTabId = 0;
    }
 
    // Tab List Popup (will alter tab_bar->BarRect and therefore the available width!)
    const bool tab_list_popup_button = (tab_bar->Flags & ImGuiTabBarFlags_TabListPopupButton) != 0;
    if (tab_list_popup_button)
        if (ImGuiTabItem* tab_to_select = TabBarTabListPopupButton(tab_bar)) // NB: Will alter BarRect.Min.x!
            scroll_to_tab_id = tab_bar->SelectedTabId = tab_to_select->ID;
 
    // Leading/Trailing tabs will be shrink only if central one aren't visible anymore, so layout the shrink data as: leading, trailing, central
    // (whereas our tabs are stored as: leading, central, trailing)
    int shrink_buffer_indexes[3] = { 0, sections[0].TabCount + sections[2].TabCount, sections[0].TabCount };
    g.ShrinkWidthBuffer.resize(tab_bar->Tabs.Size);
 
    // Compute ideal tabs widths + store them into shrink buffer
    ImGuiTabItem* most_recently_selected_tab = NULL;
    int curr_section_n = -1;
    bool found_selected_tab_id = false;
    for (int tab_n = 0; tab_n < tab_bar->Tabs.Size; tab_n++)
    {
        ImGuiTabItem* tab = &tab_bar->Tabs[tab_n];
        IM_ASSERT(tab->LastFrameVisible >= tab_bar->PrevFrameVisible);
 
        if ((most_recently_selected_tab == NULL || most_recently_selected_tab->LastFrameSelected < tab->LastFrameSelected) && !(tab->Flags & ImGuiTabItemFlags_Button))
            most_recently_selected_tab = tab;
        if (tab->ID == tab_bar->SelectedTabId)
            found_selected_tab_id = true;
        if (scroll_to_tab_id == 0 && g.NavJustMovedToId == tab->ID)
            scroll_to_tab_id = tab->ID;
 
        // Refresh tab width immediately, otherwise changes of style e.g. style.FramePadding.x would noticeably lag in the tab bar.
        // Additionally, when using TabBarAddTab() to manipulate tab bar order we occasionally insert new tabs that don't have a width yet,
        // and we cannot wait for the next BeginTabItem() call. We cannot compute this width within TabBarAddTab() because font size depends on the active window.
        const char* tab_name = tab_bar->GetTabName(tab);
        const bool has_close_button = (tab->Flags & ImGuiTabItemFlags_NoCloseButton) ? false : true;
        tab->ContentWidth = TabItemCalcSize(tab_name, has_close_button).x;
 
        int section_n = TabItemGetSectionIdx(tab);
        ImGuiTabBarSection* section = &sections[section_n];
        section->Width += tab->ContentWidth + (section_n == curr_section_n ? g.Style.ItemInnerSpacing.x : 0.0f);
        curr_section_n = section_n;
 
        // Store data so we can build an array sorted by width if we need to shrink tabs down
        IM_MSVC_WARNING_SUPPRESS(6385);
        int shrink_buffer_index = shrink_buffer_indexes[section_n]++;
        g.ShrinkWidthBuffer[shrink_buffer_index].Index = tab_n;
        g.ShrinkWidthBuffer[shrink_buffer_index].Width = tab->ContentWidth;
 
        IM_ASSERT(tab->ContentWidth > 0.0f);
        tab->Width = tab->ContentWidth;
    }
 
    // Compute total ideal width (used for e.g. auto-resizing a window)
    tab_bar->WidthAllTabsIdeal = 0.0f;
    for (int section_n = 0; section_n < 3; section_n++)
        tab_bar->WidthAllTabsIdeal += sections[section_n].Width + sections[section_n].Spacing;
 
    // Horizontal scrolling buttons
    // (note that TabBarScrollButtons() will alter BarRect.Max.x)
    if ((tab_bar->WidthAllTabsIdeal > tab_bar->BarRect.GetWidth() && tab_bar->Tabs.Size > 1) && !(tab_bar->Flags & ImGuiTabBarFlags_NoTabListScrollingButtons) && (tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyScroll))
        if (ImGuiTabItem* scroll_and_select_tab = TabBarScrollingButtons(tab_bar))
        {
            scroll_to_tab_id = scroll_and_select_tab->ID;
            if ((scroll_and_select_tab->Flags & ImGuiTabItemFlags_Button) == 0)
                tab_bar->SelectedTabId = scroll_to_tab_id;
        }
 
    // Shrink widths if full tabs don't fit in their allocated space
    float section_0_w = sections[0].Width + sections[0].Spacing;
    float section_1_w = sections[1].Width + sections[1].Spacing;
    float section_2_w = sections[2].Width + sections[2].Spacing;
    bool central_section_is_visible = (section_0_w + section_2_w) < tab_bar->BarRect.GetWidth();
    float width_excess;
    if (central_section_is_visible)
        width_excess = ImMax(section_1_w - (tab_bar->BarRect.GetWidth() - section_0_w - section_2_w), 0.0f); // Excess used to shrink central section
    else
        width_excess = (section_0_w + section_2_w) - tab_bar->BarRect.GetWidth(); // Excess used to shrink leading/trailing section
 
    // With ImGuiTabBarFlags_FittingPolicyScroll policy, we will only shrink leading/trailing if the central section is not visible anymore
    if (width_excess > 0.0f && ((tab_bar->Flags & ImGuiTabBarFlags_FittingPolicyResizeDown) || !central_section_is_visible))
    {
        int shrink_data_count = (central_section_is_visible ? sections[1].TabCount : sections[0].TabCount + sections[2].TabCount);
        int shrink_data_offset = (central_section_is_visible ? sections[0].TabCount + sections[2].TabCount : 0);
        ShrinkWidths(g.ShrinkWidthBuffer.Data + shrink_data_offset, shrink_data_count, width_excess);
 
        // Apply shrunk values into tabs and sections
        for (int tab_n = shrink_data_offset; tab_n < shrink_data_offset + shrink_data_count; tab_n++)
        {
            ImGuiTabItem* tab = &tab_bar->Tabs[g.ShrinkWidthBuffer[tab_n].Index];
            float shrinked_width = IM_FLOOR(g.ShrinkWidthBuffer[tab_n].Width);
            if (shrinked_width < 0.0f)
                continue;
 
            int section_n = TabItemGetSectionIdx(tab);
            sections[section_n].Width -= (tab->Width - shrinked_width);
            tab->Width = shrinked_width;
        }
    }
 
    // Layout all active tabs
    int section_tab_index = 0;
    float tab_offset = 0.0f;
    tab_bar->WidthAllTabs = 0.0f;
    for (int section_n = 0; section_n < 3; section_n++)
    {
        ImGuiTabBarSection* section = &sections[section_n];
        if (section_n == 2)
            tab_offset = ImMin(ImMax(0.0f, tab_bar->BarRect.GetWidth() - section->Width), tab_offset);
 
        for (int tab_n = 0; tab_n < section->TabCount; tab_n++)
        {
            ImGuiTabItem* tab = &tab_bar->Tabs[section_tab_index + tab_n];
            tab->Offset = tab_offset;
            tab_offset += tab->Width + (tab_n < section->TabCount - 1 ? g.Style.ItemInnerSpacing.x : 0.0f);
        }
        tab_bar->WidthAllTabs += ImMax(section->Width + section->Spacing, 0.0f);
        tab_offset += section->Spacing;
        section_tab_index += section->TabCount;
    }
 
    // If we have lost the selected tab, select the next most recently active one
    if (found_selected_tab_id == false)
        tab_bar->SelectedTabId = 0;
    if (tab_bar->SelectedTabId == 0 && tab_bar->NextSelectedTabId == 0 && most_recently_selected_tab != NULL)
        scroll_to_tab_id = tab_bar->SelectedTabId = most_recently_selected_tab->ID;
 
    // Lock in visible tab
    tab_bar->VisibleTabId = tab_bar->SelectedTabId;
    tab_bar->VisibleTabWasSubmitted = false;
 
    // Update scrolling
    if (scroll_to_tab_id != 0)
        TabBarScrollToTab(tab_bar, scroll_to_tab_id, sections);
    tab_bar->ScrollingAnim = TabBarScrollClamp(tab_bar, tab_bar->ScrollingAnim);
    tab_bar->ScrollingTarget = TabBarScrollClamp(tab_bar, tab_bar->ScrollingTarget);
    if (tab_bar->ScrollingAnim != tab_bar->ScrollingTarget)
    {
        // Scrolling speed adjust itself so we can always reach our target in 1/3 seconds.
        // Teleport if we are aiming far off the visible line
        tab_bar->ScrollingSpeed = ImMax(tab_bar->ScrollingSpeed, 70.0f * g.FontSize);
        tab_bar->ScrollingSpeed = ImMax(tab_bar->ScrollingSpeed, ImFabs(tab_bar->ScrollingTarget - tab_bar->ScrollingAnim) / 0.3f);
        const bool teleport = (tab_bar->PrevFrameVisible + 1 < g.FrameCount) || (tab_bar->ScrollingTargetDistToVisibility > 10.0f * g.FontSize);
        tab_bar->ScrollingAnim = teleport ? tab_bar->ScrollingTarget : ImLinearSweep(tab_bar->ScrollingAnim, tab_bar->ScrollingTarget, g.IO.DeltaTime * tab_bar->ScrollingSpeed);
    }
    else
    {
        tab_bar->ScrollingSpeed = 0.0f;
    }
    tab_bar->ScrollingRectMinX = tab_bar->BarRect.Min.x + sections[0].Width + sections[0].Spacing;
    tab_bar->ScrollingRectMaxX = tab_bar->BarRect.Max.x - sections[2].Width - sections[1].Spacing;
 
    // Clear name buffers
    if ((tab_bar->Flags & ImGuiTabBarFlags_DockNode) == 0)
        tab_bar->TabsNames.Buf.resize(0);
 
    // Actual layout in host window (we don't do it in BeginTabBar() so as not to waste an extra frame)
    ImGuiWindow* window = g.CurrentWindow;
    window->DC.CursorPos = tab_bar->BarRect.Min;
    ItemSize(ImVec2(tab_bar->WidthAllTabs, tab_bar->BarRect.GetHeight()), tab_bar->FramePadding.y);
    window->DC.IdealMaxPos.x = ImMax(window->DC.IdealMaxPos.x, tab_bar->BarRect.Min.x + tab_bar->WidthAllTabsIdeal);
}

References ImGuiTabBar::BarRect, ImGuiTextBuffer::Buf, ImGuiTabItem::ContentWidth, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImVector< T >::Data, ImGuiWindow::DC, ImGuiIO::DeltaTime, ImGuiTabItem::Flags, ImGuiTabBar::Flags, ImGuiContext::FontSize, ImGuiContext::FrameCount, ImGuiTabBar::FramePadding, ImRect::GetHeight(), ImGuiTabBar::GetTabName(), ImRect::GetWidth(), GImGui, ImGuiTabItem::ID, ImGuiWindowTempData::IdealMaxPos, IM_ASSERT, IM_FLOOR, IM_MSVC_WARNING_SUPPRESS, ImFabs, ImGuiTabBarFlags_DockNode, ImGuiTabBarFlags_FittingPolicyResizeDown, ImGuiTabBarFlags_FittingPolicyScroll, ImGuiTabBarFlags_NoTabListScrollingButtons, ImGuiTabBarFlags_TabListPopupButton, ImGuiTabItemFlags_Button, ImGuiTabItemFlags_NoCloseButton, ImLinearSweep(), ImMax(), ImMin(), ImQsort, ImGuiTabItem::IndexDuringLayout, ImGuiContext::IO, ImGuiStyle::ItemInnerSpacing, ItemSize(), ImGuiTabItem::LastFrameSelected, ImGuiTabItem::LastFrameVisible, ImRect::Max, ImRect::Min, ImGuiContext::NavJustMovedToId, ImGuiTabBar::NextSelectedTabId, ImGuiTabItem::Offset, ImGuiTabBar::PrevFrameVisible, ImGuiTabBar::ReorderRequestTabId, ImVector< T >::resize(), ImGuiTabBar::ScrollingAnim, ImGuiTabBar::ScrollingRectMaxX, ImGuiTabBar::ScrollingRectMinX, ImGuiTabBar::ScrollingSpeed, ImGuiTabBar::ScrollingTarget, ImGuiTabBar::ScrollingTargetDistToVisibility, ImGuiTabBar::SelectedTabId, ImGuiContext::ShrinkWidthBuffer, ShrinkWidths(), ImVector< T >::Size, ImGuiTabBarSection::Spacing, ImGuiContext::Style, TabBarProcessReorder(), TabBarScrollClamp(), TabBarScrollingButtons(), TabBarScrollToTab(), TabBarTabListPopupButton(), ImGuiTabBarSection::TabCount, TabItemCalcSize(), TabItemComparerBySection(), TabItemGetSectionIdx(), ImGuiTabBar::Tabs, ImGuiTabBar::TabsNames, ImGuiTabBar::VisibleTabId, ImGuiTabBar::VisibleTabWasSubmitted, ImGuiTabItem::WantClose, ImGuiTabBar::WantLayout, ImGuiTabItem::Width, ImGuiTabBarSection::Width, ImGuiTabBar::WidthAllTabs, ImGuiTabBar::WidthAllTabsIdeal, ImVec2::x, and ImVec2::y.

Referenced by EndTabBar(), and TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarProcessReorder()

bool ImGui::TabBarProcessReorder ( ImGuiTabBar * tab_bar )

{
    ImGuiTabItem* tab1 = TabBarFindTabByID(tab_bar, tab_bar->ReorderRequestTabId);
    if (tab1 == NULL || (tab1->Flags & ImGuiTabItemFlags_NoReorder))
        return false;
 
    //IM_ASSERT(tab_bar->Flags & ImGuiTabBarFlags_Reorderable); // <- this may happen when using debug tools
    int tab2_order = tab_bar->GetTabOrder(tab1) + tab_bar->ReorderRequestOffset;
    if (tab2_order < 0 || tab2_order >= tab_bar->Tabs.Size)
        return false;
 
    // Reordered tabs must share the same section
    // (Note: TabBarQueueReorderFromMousePos() also has a similar test but since we allow direct calls to TabBarQueueReorder() we do it here too)
    ImGuiTabItem* tab2 = &tab_bar->Tabs[tab2_order];
    if (tab2->Flags & ImGuiTabItemFlags_NoReorder)
        return false;
    if ((tab1->Flags & ImGuiTabItemFlags_SectionMask_) != (tab2->Flags & ImGuiTabItemFlags_SectionMask_))
        return false;
 
    ImGuiTabItem item_tmp = *tab1;
    ImGuiTabItem* src_tab = (tab_bar->ReorderRequestOffset > 0) ? tab1 + 1 : tab2;
    ImGuiTabItem* dst_tab = (tab_bar->ReorderRequestOffset > 0) ? tab1 : tab2 + 1;
    const int move_count = (tab_bar->ReorderRequestOffset > 0) ? tab_bar->ReorderRequestOffset : -tab_bar->ReorderRequestOffset;
    memmove(dst_tab, src_tab, move_count * sizeof(ImGuiTabItem));
    *tab2 = item_tmp;
 
    if (tab_bar->Flags & ImGuiTabBarFlags_SaveSettings)
        MarkIniSettingsDirty();
    return true;
}

References ImGuiTabItem::Flags, ImGuiTabBar::Flags, ImGuiTabBar::GetTabOrder(), ImGuiTabBarFlags_SaveSettings, ImGuiTabItemFlags_NoReorder, ImGuiTabItemFlags_SectionMask_, MarkIniSettingsDirty(), ImGuiTabBar::ReorderRequestOffset, ImGuiTabBar::ReorderRequestTabId, ImVector< T >::Size, TabBarFindTabByID(), and ImGuiTabBar::Tabs.

Referenced by TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarQueueReorder()

void ImGui::TabBarQueueReorder	(	ImGuiTabBar *	tab_bar,
		const ImGuiTabItem *	tab,
		int	offset
	)

{
    IM_ASSERT(offset != 0);
    IM_ASSERT(tab_bar->ReorderRequestTabId == 0);
    tab_bar->ReorderRequestTabId = tab->ID;
    tab_bar->ReorderRequestOffset = (ImS16)offset;
}

References ImGuiTabItem::ID, IM_ASSERT, ImGuiTabBar::ReorderRequestOffset, and ImGuiTabBar::ReorderRequestTabId.

Referenced by DebugNodeTabBar(), and TabBarQueueReorderFromMousePos().

Here is the caller graph for this function:

◆ TabBarQueueReorderFromMousePos()

void ImGui::TabBarQueueReorderFromMousePos	(	ImGuiTabBar *	tab_bar,
		const ImGuiTabItem *	tab,
		ImVec2	mouse_pos
	)

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(tab_bar->ReorderRequestTabId == 0);
    if ((tab_bar->Flags & ImGuiTabBarFlags_Reorderable) == 0)
        return;
 
    const bool is_central_section = (src_tab->Flags & ImGuiTabItemFlags_SectionMask_) == 0;
    const float bar_offset = tab_bar->BarRect.Min.x - (is_central_section ? tab_bar->ScrollingTarget : 0);
 
    // Count number of contiguous tabs we are crossing over
    const int dir = (bar_offset + src_tab->Offset) > mouse_pos.x ? -1 : +1;
    const int src_idx = tab_bar->Tabs.index_from_ptr(src_tab);
    int dst_idx = src_idx;
    for (int i = src_idx; i >= 0 && i < tab_bar->Tabs.Size; i += dir)
    {
        // Reordered tabs must share the same section
        const ImGuiTabItem* dst_tab = &tab_bar->Tabs[i];
        if (dst_tab->Flags & ImGuiTabItemFlags_NoReorder)
            break;
        if ((dst_tab->Flags & ImGuiTabItemFlags_SectionMask_) != (src_tab->Flags & ImGuiTabItemFlags_SectionMask_))
            break;
        dst_idx = i;
 
        // Include spacing after tab, so when mouse cursor is between tabs we would not continue checking further tabs that are not hovered.
        const float x1 = bar_offset + dst_tab->Offset - g.Style.ItemInnerSpacing.x;
        const float x2 = bar_offset + dst_tab->Offset + dst_tab->Width + g.Style.ItemInnerSpacing.x;
        //GetForegroundDrawList()->AddRect(ImVec2(x1, tab_bar->BarRect.Min.y), ImVec2(x2, tab_bar->BarRect.Max.y), IM_COL32(255, 0, 0, 255));
        if ((dir < 0 && mouse_pos.x > x1) || (dir > 0 && mouse_pos.x < x2))
            break;
    }
 
    if (dst_idx != src_idx)
        TabBarQueueReorder(tab_bar, src_tab, dst_idx - src_idx);
}

References ImGuiTabBar::BarRect, ImGuiTabItem::Flags, ImGuiTabBar::Flags, GImGui, IM_ASSERT, ImGuiTabBarFlags_Reorderable, ImGuiTabItemFlags_NoReorder, ImGuiTabItemFlags_SectionMask_, ImVector< T >::index_from_ptr(), ImGuiStyle::ItemInnerSpacing, ImRect::Min, ImGuiTabItem::Offset, ImGuiTabBar::ReorderRequestTabId, ImGuiTabBar::ScrollingTarget, ImVector< T >::Size, ImGuiContext::Style, TabBarQueueReorder(), ImGuiTabBar::Tabs, ImGuiTabItem::Width, and ImVec2::x.

Referenced by TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarRemoveTab()

void ImGui::TabBarRemoveTab	(	ImGuiTabBar *	tab_bar,
		ImGuiID	tab_id
	)

{
    if (ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id))
        tab_bar->Tabs.erase(tab);
    if (tab_bar->VisibleTabId == tab_id)      { tab_bar->VisibleTabId = 0; }
    if (tab_bar->SelectedTabId == tab_id)     { tab_bar->SelectedTabId = 0; }
    if (tab_bar->NextSelectedTabId == tab_id) { tab_bar->NextSelectedTabId = 0; }
}

References ImVector< T >::erase(), ImGuiTabBar::NextSelectedTabId, ImGuiTabBar::SelectedTabId, TabBarFindTabByID(), ImGuiTabBar::Tabs, and ImGuiTabBar::VisibleTabId.

Here is the call graph for this function:

◆ TabBarScrollClamp()

static float ImGui::TabBarScrollClamp	(	ImGuiTabBar *	tab_bar,
		float	scrolling
	)

static

{
    scrolling = ImMin(scrolling, tab_bar->WidthAllTabs - tab_bar->BarRect.GetWidth());
    return ImMax(scrolling, 0.0f);
}

References ImGuiTabBar::BarRect, ImRect::GetWidth(), ImMax(), ImMin(), and ImGuiTabBar::WidthAllTabs.

Referenced by TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarScrollingButtons()

static ImGuiTabItem * ImGui::TabBarScrollingButtons ( ImGuiTabBar * tab_bar )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    const ImVec2 arrow_button_size(g.FontSize - 2.0f, g.FontSize + g.Style.FramePadding.y * 2.0f);
    const float scrolling_buttons_width = arrow_button_size.x * 2.0f;
 
    const ImVec2 backup_cursor_pos = window->DC.CursorPos;
    //window->DrawList->AddRect(ImVec2(tab_bar->BarRect.Max.x - scrolling_buttons_width, tab_bar->BarRect.Min.y), ImVec2(tab_bar->BarRect.Max.x, tab_bar->BarRect.Max.y), IM_COL32(255,0,0,255));
 
    int select_dir = 0;
    ImVec4 arrow_col = g.Style.Colors[ImGuiCol_Text];
    arrow_col.w *= 0.5f;
 
    PushStyleColor(ImGuiCol_Text, arrow_col);
    PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
    const float backup_repeat_delay = g.IO.KeyRepeatDelay;
    const float backup_repeat_rate = g.IO.KeyRepeatRate;
    g.IO.KeyRepeatDelay = 0.250f;
    g.IO.KeyRepeatRate = 0.200f;
    float x = ImMax(tab_bar->BarRect.Min.x, tab_bar->BarRect.Max.x - scrolling_buttons_width);
    window->DC.CursorPos = ImVec2(x, tab_bar->BarRect.Min.y);
    if (ArrowButtonEx("##<", ImGuiDir_Left, arrow_button_size, ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_Repeat))
        select_dir = -1;
    window->DC.CursorPos = ImVec2(x + arrow_button_size.x, tab_bar->BarRect.Min.y);
    if (ArrowButtonEx("##>", ImGuiDir_Right, arrow_button_size, ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_Repeat))
        select_dir = +1;
    PopStyleColor(2);
    g.IO.KeyRepeatRate = backup_repeat_rate;
    g.IO.KeyRepeatDelay = backup_repeat_delay;
 
    ImGuiTabItem* tab_to_scroll_to = NULL;
    if (select_dir != 0)
        if (ImGuiTabItem* tab_item = TabBarFindTabByID(tab_bar, tab_bar->SelectedTabId))
        {
            int selected_order = tab_bar->GetTabOrder(tab_item);
            int target_order = selected_order + select_dir;
 
            // Skip tab item buttons until another tab item is found or end is reached
            while (tab_to_scroll_to == NULL)
            {
                // If we are at the end of the list, still scroll to make our tab visible
                tab_to_scroll_to = &tab_bar->Tabs[(target_order >= 0 && target_order < tab_bar->Tabs.Size) ? target_order : selected_order];
 
                // Cross through buttons
                // (even if first/last item is a button, return it so we can update the scroll)
                if (tab_to_scroll_to->Flags & ImGuiTabItemFlags_Button)
                {
                    target_order += select_dir;
                    selected_order += select_dir;
                    tab_to_scroll_to = (target_order < 0 || target_order >= tab_bar->Tabs.Size) ? tab_to_scroll_to : NULL;
                }
            }
        }
    window->DC.CursorPos = backup_cursor_pos;
    tab_bar->BarRect.Max.x -= scrolling_buttons_width + 1.0f;
 
    return tab_to_scroll_to;
}

References ArrowButtonEx(), ImGuiTabBar::BarRect, ImGuiStyle::Colors, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiTabItem::Flags, ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImGuiTabBar::GetTabOrder(), GImGui, ImGuiButtonFlags_PressedOnClick, ImGuiButtonFlags_Repeat, ImGuiCol_Button, ImGuiCol_Text, ImGuiDir_Left, ImGuiDir_Right, ImGuiTabItemFlags_Button, ImMax(), ImGuiContext::IO, ImGuiIO::KeyRepeatDelay, ImGuiIO::KeyRepeatRate, ImRect::Max, ImRect::Min, PopStyleColor(), PushStyleColor(), ImGuiTabBar::SelectedTabId, ImVector< T >::Size, ImGuiContext::Style, TabBarFindTabByID(), ImGuiTabBar::Tabs, ImVec4::w, ImVec2::x, and ImVec2::y.

Referenced by TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarScrollToTab()

static void ImGui::TabBarScrollToTab	(	ImGuiTabBar *	tab_bar,
		ImGuiID	tab_id,
		ImGuiTabBarSection *	sections
	)

static

{
    ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id);
    if (tab == NULL)
        return;
    if (tab->Flags & ImGuiTabItemFlags_SectionMask_)
        return;
 
    ImGuiContext& g = *GImGui;
    float margin = g.FontSize * 1.0f; // When to scroll to make Tab N+1 visible always make a bit of N visible to suggest more scrolling area (since we don't have a scrollbar)
    int order = tab_bar->GetTabOrder(tab);
 
    // Scrolling happens only in the central section (leading/trailing sections are not scrolling)
    // FIXME: This is all confusing.
    float scrollable_width = tab_bar->BarRect.GetWidth() - sections[0].Width - sections[2].Width - sections[1].Spacing;
 
    // We make all tabs positions all relative Sections[0].Width to make code simpler
    float tab_x1 = tab->Offset - sections[0].Width + (order > sections[0].TabCount - 1 ? -margin : 0.0f);
    float tab_x2 = tab->Offset - sections[0].Width + tab->Width + (order + 1 < tab_bar->Tabs.Size - sections[2].TabCount ? margin : 1.0f);
    tab_bar->ScrollingTargetDistToVisibility = 0.0f;
    if (tab_bar->ScrollingTarget > tab_x1 || (tab_x2 - tab_x1 >= scrollable_width))
    {
        // Scroll to the left
        tab_bar->ScrollingTargetDistToVisibility = ImMax(tab_bar->ScrollingAnim - tab_x2, 0.0f);
        tab_bar->ScrollingTarget = tab_x1;
    }
    else if (tab_bar->ScrollingTarget < tab_x2 - scrollable_width)
    {
        // Scroll to the right
        tab_bar->ScrollingTargetDistToVisibility = ImMax((tab_x1 - scrollable_width) - tab_bar->ScrollingAnim, 0.0f);
        tab_bar->ScrollingTarget = tab_x2 - scrollable_width;
    }
}

References ImGuiTabBar::BarRect, ImGuiTabItem::Flags, ImGuiContext::FontSize, ImGuiTabBar::GetTabOrder(), ImRect::GetWidth(), GImGui, ImGuiTabItemFlags_SectionMask_, ImMax(), ImGuiTabItem::Offset, ImGuiTabBar::ScrollingAnim, ImGuiTabBar::ScrollingTarget, ImGuiTabBar::ScrollingTargetDistToVisibility, ImVector< T >::Size, ImGuiTabBarSection::Spacing, TabBarFindTabByID(), ImGuiTabBarSection::TabCount, ImGuiTabBar::Tabs, ImGuiTabItem::Width, and ImGuiTabBarSection::Width.

Referenced by TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabBarTabListPopupButton()

static ImGuiTabItem * ImGui::TabBarTabListPopupButton ( ImGuiTabBar * tab_bar )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    // We use g.Style.FramePadding.y to match the square ArrowButton size
    const float tab_list_popup_button_width = g.FontSize + g.Style.FramePadding.y;
    const ImVec2 backup_cursor_pos = window->DC.CursorPos;
    window->DC.CursorPos = ImVec2(tab_bar->BarRect.Min.x - g.Style.FramePadding.y, tab_bar->BarRect.Min.y);
    tab_bar->BarRect.Min.x += tab_list_popup_button_width;
 
    ImVec4 arrow_col = g.Style.Colors[ImGuiCol_Text];
    arrow_col.w *= 0.5f;
    PushStyleColor(ImGuiCol_Text, arrow_col);
    PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
    bool open = BeginCombo("##v", NULL, ImGuiComboFlags_NoPreview | ImGuiComboFlags_HeightLargest);
    PopStyleColor(2);
 
    ImGuiTabItem* tab_to_select = NULL;
    if (open)
    {
        for (int tab_n = 0; tab_n < tab_bar->Tabs.Size; tab_n++)
        {
            ImGuiTabItem* tab = &tab_bar->Tabs[tab_n];
            if (tab->Flags & ImGuiTabItemFlags_Button)
                continue;
 
            const char* tab_name = tab_bar->GetTabName(tab);
            if (Selectable(tab_name, tab_bar->SelectedTabId == tab->ID))
                tab_to_select = tab;
        }
        EndCombo();
    }
 
    window->DC.CursorPos = backup_cursor_pos;
    return tab_to_select;
}

References ImGuiTabBar::BarRect, BeginCombo(), ImGuiStyle::Colors, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, EndCombo(), ImGuiTabItem::Flags, ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImGuiTabBar::GetTabName(), GImGui, ImGuiTabItem::ID, ImGuiCol_Button, ImGuiCol_Text, ImGuiComboFlags_HeightLargest, ImGuiComboFlags_NoPreview, ImGuiTabItemFlags_Button, ImRect::Min, PopStyleColor(), PushStyleColor(), Selectable(), ImGuiTabBar::SelectedTabId, ImVector< T >::Size, ImGuiContext::Style, ImGuiTabBar::Tabs, ImVec4::w, ImVec2::x, and ImVec2::y.

Referenced by TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabItemBackground()

void ImGui::TabItemBackground	(	ImDrawList *	draw_list,
		const ImRect &	bb,
		ImGuiTabItemFlags	flags,
		ImU32	col
	)

{
    // While rendering tabs, we trim 1 pixel off the top of our bounding box so they can fit within a regular frame height while looking "detached" from it.
    ImGuiContext& g = *GImGui;
    const float width = bb.GetWidth();
    IM_UNUSED(flags);
    IM_ASSERT(width > 0.0f);
    const float rounding = ImMax(0.0f, ImMin((flags & ImGuiTabItemFlags_Button) ? g.Style.FrameRounding : g.Style.TabRounding, width * 0.5f - 1.0f));
    const float y1 = bb.Min.y + 1.0f;
    const float y2 = bb.Max.y - 1.0f;
    draw_list->PathLineTo(ImVec2(bb.Min.x, y2));
    draw_list->PathArcToFast(ImVec2(bb.Min.x + rounding, y1 + rounding), rounding, 6, 9);
    draw_list->PathArcToFast(ImVec2(bb.Max.x - rounding, y1 + rounding), rounding, 9, 12);
    draw_list->PathLineTo(ImVec2(bb.Max.x, y2));
    draw_list->PathFillConvex(col);
    if (g.Style.TabBorderSize > 0.0f)
    {
        draw_list->PathLineTo(ImVec2(bb.Min.x + 0.5f, y2));
        draw_list->PathArcToFast(ImVec2(bb.Min.x + rounding + 0.5f, y1 + rounding + 0.5f), rounding, 6, 9);
        draw_list->PathArcToFast(ImVec2(bb.Max.x - rounding - 0.5f, y1 + rounding + 0.5f), rounding, 9, 12);
        draw_list->PathLineTo(ImVec2(bb.Max.x - 0.5f, y2));
        draw_list->PathStroke(GetColorU32(ImGuiCol_Border), 0, g.Style.TabBorderSize);
    }
}

References col(), ImGuiStyle::FrameRounding, GetColorU32(), ImRect::GetWidth(), GImGui, IM_ASSERT, IM_UNUSED, ImGuiCol_Border, ImGuiTabItemFlags_Button, ImMax(), ImMin(), ImRect::Max, ImRect::Min, ImDrawList::PathArcToFast(), ImDrawList::PathFillConvex(), ImDrawList::PathLineTo(), ImDrawList::PathStroke(), ImGuiContext::Style, ImGuiStyle::TabBorderSize, ImGuiStyle::TabRounding, ImVec2::x, and ImVec2::y.

Referenced by TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabItemButton()

bool ImGui::TabItemButton	(	const char *	label,
		ImGuiTabItemFlags	flags = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    ImGuiTabBar* tab_bar = g.CurrentTabBar;
    if (tab_bar == NULL)
    {
        IM_ASSERT_USER_ERROR(tab_bar != NULL, "Needs to be called between BeginTabBar() and EndTabBar()!");
        return false;
    }
    return TabItemEx(tab_bar, label, NULL, flags | ImGuiTabItemFlags_Button | ImGuiTabItemFlags_NoReorder);
}

References ImGuiContext::CurrentTabBar, ImGuiContext::CurrentWindow, GImGui, IM_ASSERT_USER_ERROR, ImGuiTabItemFlags_Button, ImGuiTabItemFlags_NoReorder, ImGuiWindow::SkipItems, and TabItemEx().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabItemCalcSize()

ImVec2 ImGui::TabItemCalcSize	(	const char *	label,
		bool	has_close_button
	)

{
    ImGuiContext& g = *GImGui;
    ImVec2 label_size = CalcTextSize(label, NULL, true);
    ImVec2 size = ImVec2(label_size.x + g.Style.FramePadding.x, label_size.y + g.Style.FramePadding.y * 2.0f);
    if (has_close_button)
        size.x += g.Style.FramePadding.x + (g.Style.ItemInnerSpacing.x + g.FontSize); // We use Y intentionally to fit the close button circle.
    else
        size.x += g.Style.FramePadding.x + 1.0f;
    return ImVec2(ImMin(size.x, TabBarCalcMaxTabWidth()), size.y);
}

References CalcTextSize(), ImGuiContext::FontSize, ImGuiStyle::FramePadding, GImGui, ImMin(), ImGuiStyle::ItemInnerSpacing, ImGuiContext::Style, TabBarCalcMaxTabWidth(), ImVec2::x, and ImVec2::y.

Referenced by TabBarLayout(), and TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabItemEx()

bool ImGui::TabItemEx	(	ImGuiTabBar *	tab_bar,
		const char *	label,
		bool *	p_open,
		ImGuiTabItemFlags	flags
	)

{
    // Layout whole tab bar if not already done
    if (tab_bar->WantLayout)
        TabBarLayout(tab_bar);
 
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = TabBarCalcTabID(tab_bar, label);
 
    // If the user called us with *p_open == false, we early out and don't render.
    // We make a call to ItemAdd() so that attempts to use a contextual popup menu with an implicit ID won't use an older ID.
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    if (p_open && !*p_open)
    {
        PushItemFlag(ImGuiItemFlags_NoNav | ImGuiItemFlags_NoNavDefaultFocus, true);
        ItemAdd(ImRect(), id);
        PopItemFlag();
        return false;
    }
 
    IM_ASSERT(!p_open || !(flags & ImGuiTabItemFlags_Button));
    IM_ASSERT((flags & (ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing)) != (ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing)); // Can't use both Leading and Trailing
 
    // Store into ImGuiTabItemFlags_NoCloseButton, also honor ImGuiTabItemFlags_NoCloseButton passed by user (although not documented)
    if (flags & ImGuiTabItemFlags_NoCloseButton)
        p_open = NULL;
    else if (p_open == NULL)
        flags |= ImGuiTabItemFlags_NoCloseButton;
 
    // Calculate tab contents size
    ImVec2 size = TabItemCalcSize(label, p_open != NULL);
 
    // Acquire tab data
    ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, id);
    bool tab_is_new = false;
    if (tab == NULL)
    {
        tab_bar->Tabs.push_back(ImGuiTabItem());
        tab = &tab_bar->Tabs.back();
        tab->ID = id;
        tab->Width = size.x;
        tab_bar->TabsAddedNew = true;
        tab_is_new = true;
    }
    tab_bar->LastTabItemIdx = (ImS16)tab_bar->Tabs.index_from_ptr(tab);
    tab->ContentWidth = size.x;
    tab->BeginOrder = tab_bar->TabsActiveCount++;
 
    const bool tab_bar_appearing = (tab_bar->PrevFrameVisible + 1 < g.FrameCount);
    const bool tab_bar_focused = (tab_bar->Flags & ImGuiTabBarFlags_IsFocused) != 0;
    const bool tab_appearing = (tab->LastFrameVisible + 1 < g.FrameCount);
    const bool is_tab_button = (flags & ImGuiTabItemFlags_Button) != 0;
    tab->LastFrameVisible = g.FrameCount;
    tab->Flags = flags;
 
    // Append name with zero-terminator
    tab->NameOffset = (ImS16)tab_bar->TabsNames.size();
    tab_bar->TabsNames.append(label, label + strlen(label) + 1);
 
    // Update selected tab
    if (tab_appearing && (tab_bar->Flags & ImGuiTabBarFlags_AutoSelectNewTabs) && tab_bar->NextSelectedTabId == 0)
        if (!tab_bar_appearing || tab_bar->SelectedTabId == 0)
            if (!is_tab_button)
                tab_bar->NextSelectedTabId = id;  // New tabs gets activated
    if ((flags & ImGuiTabItemFlags_SetSelected) && (tab_bar->SelectedTabId != id)) // SetSelected can only be passed on explicit tab bar
        if (!is_tab_button)
            tab_bar->NextSelectedTabId = id;
 
    // Lock visibility
    // (Note: tab_contents_visible != tab_selected... because CTRL+TAB operations may preview some tabs without selecting them!)
    bool tab_contents_visible = (tab_bar->VisibleTabId == id);
    if (tab_contents_visible)
        tab_bar->VisibleTabWasSubmitted = true;
 
    // On the very first frame of a tab bar we let first tab contents be visible to minimize appearing glitches
    if (!tab_contents_visible && tab_bar->SelectedTabId == 0 && tab_bar_appearing)
        if (tab_bar->Tabs.Size == 1 && !(tab_bar->Flags & ImGuiTabBarFlags_AutoSelectNewTabs))
            tab_contents_visible = true;
 
    // Note that tab_is_new is not necessarily the same as tab_appearing! When a tab bar stops being submitted
    // and then gets submitted again, the tabs will have 'tab_appearing=true' but 'tab_is_new=false'.
    if (tab_appearing && (!tab_bar_appearing || tab_is_new))
    {
        PushItemFlag(ImGuiItemFlags_NoNav | ImGuiItemFlags_NoNavDefaultFocus, true);
        ItemAdd(ImRect(), id);
        PopItemFlag();
        if (is_tab_button)
            return false;
        return tab_contents_visible;
    }
 
    if (tab_bar->SelectedTabId == id)
        tab->LastFrameSelected = g.FrameCount;
 
    // Backup current layout position
    const ImVec2 backup_main_cursor_pos = window->DC.CursorPos;
 
    // Layout
    const bool is_central_section = (tab->Flags & ImGuiTabItemFlags_SectionMask_) == 0;
    size.x = tab->Width;
    if (is_central_section)
        window->DC.CursorPos = tab_bar->BarRect.Min + ImVec2(IM_FLOOR(tab->Offset - tab_bar->ScrollingAnim), 0.0f);
    else
        window->DC.CursorPos = tab_bar->BarRect.Min + ImVec2(tab->Offset, 0.0f);
    ImVec2 pos = window->DC.CursorPos;
    ImRect bb(pos, pos + size);
 
    // We don't have CPU clipping primitives to clip the CloseButton (until it becomes a texture), so need to add an extra draw call (temporary in the case of vertical animation)
    const bool want_clip_rect = is_central_section && (bb.Min.x < tab_bar->ScrollingRectMinX || bb.Max.x > tab_bar->ScrollingRectMaxX);
    if (want_clip_rect)
        PushClipRect(ImVec2(ImMax(bb.Min.x, tab_bar->ScrollingRectMinX), bb.Min.y - 1), ImVec2(tab_bar->ScrollingRectMaxX, bb.Max.y), true);
 
    ImVec2 backup_cursor_max_pos = window->DC.CursorMaxPos;
    ItemSize(bb.GetSize(), style.FramePadding.y);
    window->DC.CursorMaxPos = backup_cursor_max_pos;
 
    if (!ItemAdd(bb, id))
    {
        if (want_clip_rect)
            PopClipRect();
        window->DC.CursorPos = backup_main_cursor_pos;
        return tab_contents_visible;
    }
 
    // Click to Select a tab
    ImGuiButtonFlags button_flags = ((is_tab_button ? ImGuiButtonFlags_PressedOnClickRelease : ImGuiButtonFlags_PressedOnClick) | ImGuiButtonFlags_AllowItemOverlap);
    if (g.DragDropActive)
        button_flags |= ImGuiButtonFlags_PressedOnDragDropHold;
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, button_flags);
    if (pressed && !is_tab_button)
        tab_bar->NextSelectedTabId = id;
    hovered |= (g.HoveredId == id);
 
    // Allow the close button to overlap unless we are dragging (in which case we don't want any overlapping tabs to be hovered)
    if (g.ActiveId != id)
        SetItemAllowOverlap();
 
    // Drag and drop: re-order tabs
    if (held && !tab_appearing && IsMouseDragging(0))
    {
        if (!g.DragDropActive && (tab_bar->Flags & ImGuiTabBarFlags_Reorderable))
        {
            // While moving a tab it will jump on the other side of the mouse, so we also test for MouseDelta.x
            if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < bb.Min.x)
            {
                TabBarQueueReorderFromMousePos(tab_bar, tab, g.IO.MousePos);
            }
            else if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > bb.Max.x)
            {
                TabBarQueueReorderFromMousePos(tab_bar, tab, g.IO.MousePos);
            }
        }
    }
 
#if 0
    if (hovered && g.HoveredIdNotActiveTimer > TOOLTIP_DELAY && bb.GetWidth() < tab->ContentWidth)
    {
        // Enlarge tab display when hovering
        bb.Max.x = bb.Min.x + IM_FLOOR(ImLerp(bb.GetWidth(), tab->ContentWidth, ImSaturate((g.HoveredIdNotActiveTimer - 0.40f) * 6.0f)));
        display_draw_list = GetForegroundDrawList(window);
        TabItemBackground(display_draw_list, bb, flags, GetColorU32(ImGuiCol_TitleBgActive));
    }
#endif
 
    // Render tab shape
    ImDrawList* display_draw_list = window->DrawList;
    const ImU32 tab_col = GetColorU32((held || hovered) ? ImGuiCol_TabHovered : tab_contents_visible ? (tab_bar_focused ? ImGuiCol_TabActive : ImGuiCol_TabUnfocusedActive) : (tab_bar_focused ? ImGuiCol_Tab : ImGuiCol_TabUnfocused));
    TabItemBackground(display_draw_list, bb, flags, tab_col);
    RenderNavHighlight(bb, id);
 
    // Select with right mouse button. This is so the common idiom for context menu automatically highlight the current widget.
    const bool hovered_unblocked = IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup);
    if (hovered_unblocked && (IsMouseClicked(1) || IsMouseReleased(1)))
        if (!is_tab_button)
            tab_bar->NextSelectedTabId = id;
 
    if (tab_bar->Flags & ImGuiTabBarFlags_NoCloseWithMiddleMouseButton)
        flags |= ImGuiTabItemFlags_NoCloseWithMiddleMouseButton;
 
    // Render tab label, process close button
    const ImGuiID close_button_id = p_open ? GetIDWithSeed("#CLOSE", NULL, id) : 0;
    bool just_closed;
    bool text_clipped;
    TabItemLabelAndCloseButton(display_draw_list, bb, flags, tab_bar->FramePadding, label, id, close_button_id, tab_contents_visible, &just_closed, &text_clipped);
    if (just_closed && p_open != NULL)
    {
        *p_open = false;
        TabBarCloseTab(tab_bar, tab);
    }
 
    // Restore main window position so user can draw there
    if (want_clip_rect)
        PopClipRect();
    window->DC.CursorPos = backup_main_cursor_pos;
 
    // Tooltip (FIXME: Won't work over the close button because ItemOverlap systems messes up with HoveredIdTimer)
    // We test IsItemHovered() to discard e.g. when another item is active or drag and drop over the tab bar (which g.HoveredId ignores)
    if (text_clipped && g.HoveredId == id && !held && g.HoveredIdNotActiveTimer > g.TooltipSlowDelay && IsItemHovered())
        if (!(tab_bar->Flags & ImGuiTabBarFlags_NoTooltip) && !(tab->Flags & ImGuiTabItemFlags_NoTooltip))
            SetTooltip("%.*s", (int)(FindRenderedTextEnd(label) - label), label);
 
    IM_ASSERT(!is_tab_button || !(tab_bar->SelectedTabId == tab->ID && is_tab_button)); // TabItemButton should not be selected
    if (is_tab_button)
        return pressed;
    return tab_contents_visible;
}

References ImGuiContext::ActiveId, ImGuiTextBuffer::append(), ImVector< T >::back(), ImGuiTabBar::BarRect, ImGuiTabItem::BeginOrder, ButtonBehavior(), ImGuiTabItem::ContentWidth, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiContext::DragDropActive, ImGuiWindow::DrawList, FindRenderedTextEnd(), ImGuiTabItem::Flags, ImGuiTabBar::Flags, ImGuiContext::FrameCount, ImGuiTabBar::FramePadding, GetColorU32(), GetForegroundDrawList(), GetIDWithSeed(), ImRect::GetSize(), ImRect::GetWidth(), GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdNotActiveTimer, ImGuiTabItem::ID, IM_ASSERT, IM_FLOOR, IMGUI_TEST_ENGINE_ITEM_INFO, ImGuiButtonFlags_AllowItemOverlap, ImGuiButtonFlags_PressedOnClick, ImGuiButtonFlags_PressedOnClickRelease, ImGuiButtonFlags_PressedOnDragDropHold, ImGuiCol_Tab, ImGuiCol_TabActive, ImGuiCol_TabHovered, ImGuiCol_TabUnfocused, ImGuiCol_TabUnfocusedActive, ImGuiCol_TitleBgActive, ImGuiHoveredFlags_AllowWhenBlockedByPopup, ImGuiItemFlags_NoNav, ImGuiItemFlags_NoNavDefaultFocus, ImGuiTabBarFlags_AutoSelectNewTabs, ImGuiTabBarFlags_IsFocused, ImGuiTabBarFlags_NoCloseWithMiddleMouseButton, ImGuiTabBarFlags_NoTooltip, ImGuiTabBarFlags_Reorderable, ImGuiTabItemFlags_Button, ImGuiTabItemFlags_Leading, ImGuiTabItemFlags_NoCloseButton, ImGuiTabItemFlags_NoCloseWithMiddleMouseButton, ImGuiTabItemFlags_NoTooltip, ImGuiTabItemFlags_SectionMask_, ImGuiTabItemFlags_SetSelected, ImGuiTabItemFlags_Trailing, ImLerp(), ImMax(), ImSaturate(), ImVector< T >::index_from_ptr(), ImGuiContext::IO, IsItemHovered(), IsMouseClicked(), IsMouseDragging(), IsMouseReleased(), ItemAdd(), ItemSize(), ImGuiTabItem::LastFrameSelected, ImGuiTabItem::LastFrameVisible, ImGuiWindowTempData::LastItemStatusFlags, ImGuiTabBar::LastTabItemIdx, ImRect::Max, ImRect::Min, ImGuiIO::MouseDelta, ImGuiIO::MousePos, ImGuiTabItem::NameOffset, ImGuiTabBar::NextSelectedTabId, ImGuiTabItem::Offset, PopClipRect(), PopItemFlag(), ImGuiTabBar::PrevFrameVisible, ImVector< T >::push_back(), PushClipRect(), PushItemFlag(), RenderNavHighlight(), ImGuiTabBar::ScrollingAnim, ImGuiTabBar::ScrollingRectMaxX, ImGuiTabBar::ScrollingRectMinX, ImGuiTabBar::SelectedTabId, SetItemAllowOverlap(), SetTooltip(), ImVector< T >::Size, ImGuiTextBuffer::size(), ImGuiWindow::SkipItems, ImGuiContext::Style, style, TabBarCalcTabID(), TabBarCloseTab(), TabBarFindTabByID(), TabBarLayout(), TabBarQueueReorderFromMousePos(), TabItemBackground(), TabItemCalcSize(), TabItemLabelAndCloseButton(), ImGuiTabBar::Tabs, ImGuiTabBar::TabsActiveCount, ImGuiTabBar::TabsAddedNew, ImGuiTabBar::TabsNames, ImGuiContext::TooltipSlowDelay, ImGuiTabBar::VisibleTabId, ImGuiTabBar::VisibleTabWasSubmitted, ImGuiTabBar::WantLayout, ImGuiTabItem::Width, ImVec2::x, and ImVec2::y.

Referenced by BeginTabItem(), and TabItemButton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TabItemLabelAndCloseButton()

void ImGui::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
	)

{
    ImGuiContext& g = *GImGui;
    ImVec2 label_size = CalcTextSize(label, NULL, true);
 
    if (out_just_closed)
        *out_just_closed = false;
    if (out_text_clipped)
        *out_text_clipped = false;
 
    if (bb.GetWidth() <= 1.0f)
        return;
 
    // In Style V2 we'll have full override of all colors per state (e.g. focused, selected)
    // But right now if you want to alter text color of tabs this is what you need to do.
#if 0
    const float backup_alpha = g.Style.Alpha;
    if (!is_contents_visible)
        g.Style.Alpha *= 0.7f;
#endif
 
    // Render text label (with clipping + alpha gradient) + unsaved marker
    const char* TAB_UNSAVED_MARKER = "*";
    ImRect text_pixel_clip_bb(bb.Min.x + frame_padding.x, bb.Min.y + frame_padding.y, bb.Max.x - frame_padding.x, bb.Max.y);
    if (flags & ImGuiTabItemFlags_UnsavedDocument)
    {
        text_pixel_clip_bb.Max.x -= CalcTextSize(TAB_UNSAVED_MARKER, NULL, false).x;
        ImVec2 unsaved_marker_pos(ImMin(bb.Min.x + frame_padding.x + label_size.x + 2, text_pixel_clip_bb.Max.x), bb.Min.y + frame_padding.y + IM_FLOOR(-g.FontSize * 0.25f));
        RenderTextClippedEx(draw_list, unsaved_marker_pos, bb.Max - frame_padding, TAB_UNSAVED_MARKER, NULL, NULL);
    }
    ImRect text_ellipsis_clip_bb = text_pixel_clip_bb;
 
    // Return clipped state ignoring the close button
    if (out_text_clipped)
    {
        *out_text_clipped = (text_ellipsis_clip_bb.Min.x + label_size.x) > text_pixel_clip_bb.Max.x;
        //draw_list->AddCircle(text_ellipsis_clip_bb.Min, 3.0f, *out_text_clipped ? IM_COL32(255, 0, 0, 255) : IM_COL32(0, 255, 0, 255));
    }
 
    // Close Button
    // We are relying on a subtle and confusing distinction between 'hovered' and 'g.HoveredId' which happens because we are using ImGuiButtonFlags_AllowOverlapMode + SetItemAllowOverlap()
    //  'hovered' will be true when hovering the Tab but NOT when hovering the close button
    //  'g.HoveredId==id' will be true when hovering the Tab including when hovering the close button
    //  'g.ActiveId==close_button_id' will be true when we are holding on the close button, in which case both hovered booleans are false
    bool close_button_pressed = false;
    bool close_button_visible = false;
    if (close_button_id != 0)
        if (is_contents_visible || bb.GetWidth() >= g.Style.TabMinWidthForCloseButton)
            if (g.HoveredId == tab_id || g.HoveredId == close_button_id || g.ActiveId == tab_id || g.ActiveId == close_button_id)
                close_button_visible = true;
    if (close_button_visible)
    {
        ImGuiLastItemDataBackup last_item_backup;
        const float close_button_sz = g.FontSize;
        PushStyleVar(ImGuiStyleVar_FramePadding, frame_padding);
        if (CloseButton(close_button_id, ImVec2(bb.Max.x - frame_padding.x * 2.0f - close_button_sz, bb.Min.y)))
            close_button_pressed = true;
        PopStyleVar();
        last_item_backup.Restore();
 
        // Close with middle mouse button
        if (!(flags & ImGuiTabItemFlags_NoCloseWithMiddleMouseButton) && IsMouseClicked(2))
            close_button_pressed = true;
 
        text_pixel_clip_bb.Max.x -= close_button_sz;
    }
 
    // FIXME: if FramePadding is noticeably large, ellipsis_max_x will be wrong here (e.g. #3497), maybe for consistency that parameter of RenderTextEllipsis() shouldn't exist..
    float ellipsis_max_x = close_button_visible ? text_pixel_clip_bb.Max.x : bb.Max.x - 1.0f;
    RenderTextEllipsis(draw_list, text_ellipsis_clip_bb.Min, text_ellipsis_clip_bb.Max, text_pixel_clip_bb.Max.x, ellipsis_max_x, label, NULL, &label_size);
 
#if 0
    if (!is_contents_visible)
        g.Style.Alpha = backup_alpha;
#endif
 
    if (out_just_closed)
        *out_just_closed = close_button_pressed;
}

References ImGuiContext::ActiveId, ImGuiStyle::Alpha, CalcTextSize(), CloseButton(), ImGuiContext::FontSize, ImRect::GetWidth(), GImGui, ImGuiContext::HoveredId, IM_FLOOR, ImGuiStyleVar_FramePadding, ImGuiTabItemFlags_NoCloseWithMiddleMouseButton, ImGuiTabItemFlags_UnsavedDocument, ImMin(), IsMouseClicked(), ImRect::Max, ImRect::Min, PopStyleVar(), PushStyleVar(), RenderTextClippedEx(), RenderTextEllipsis(), ImGuiLastItemDataBackup::Restore(), ImGuiContext::Style, ImGuiStyle::TabMinWidthForCloseButton, ImVec2::x, and ImVec2::y.

Referenced by TabItemEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableBeginApplyRequests()

void ImGui::TableBeginApplyRequests ( ImGuiTable * table )

{
    // Handle resizing request
    // (We process this at the first TableBegin of the frame)
    // FIXME-TABLE: Contains columns if our work area doesn't allow for scrolling?
    if (table->InstanceCurrent == 0)
    {
        if (table->ResizedColumn != -1 && table->ResizedColumnNextWidth != FLT_MAX)
            TableSetColumnWidth(table->ResizedColumn, table->ResizedColumnNextWidth);
        table->LastResizedColumn = table->ResizedColumn;
        table->ResizedColumnNextWidth = FLT_MAX;
        table->ResizedColumn = -1;
 
        // Process auto-fit for single column, which is a special case for stretch columns and fixed columns with FixedSame policy.
        // FIXME-TABLE: Would be nice to redistribute available stretch space accordingly to other weights, instead of giving it all to siblings.
        if (table->AutoFitSingleColumn != -1)
        {
            TableSetColumnWidth(table->AutoFitSingleColumn, table->Columns[table->AutoFitSingleColumn].WidthAuto);
            table->AutoFitSingleColumn = -1;
        }
    }
 
    // Handle reordering request
    // Note: we don't clear ReorderColumn after handling the request.
    if (table->InstanceCurrent == 0)
    {
        if (table->HeldHeaderColumn == -1 && table->ReorderColumn != -1)
            table->ReorderColumn = -1;
        table->HeldHeaderColumn = -1;
        if (table->ReorderColumn != -1 && table->ReorderColumnDir != 0)
        {
            // We need to handle reordering across hidden columns.
            // In the configuration below, moving C to the right of E will lead to:
            //    ... C [D] E  --->  ... [D] E  C   (Column name/index)
            //    ... 2  3  4        ...  2  3  4   (Display order)
            const int reorder_dir = table->ReorderColumnDir;
            IM_ASSERT(reorder_dir == -1 || reorder_dir == +1);
            IM_ASSERT(table->Flags & ImGuiTableFlags_Reorderable);
            ImGuiTableColumn* src_column = &table->Columns[table->ReorderColumn];
            ImGuiTableColumn* dst_column = &table->Columns[(reorder_dir == -1) ? src_column->PrevEnabledColumn : src_column->NextEnabledColumn];
            IM_UNUSED(dst_column);
            const int src_order = src_column->DisplayOrder;
            const int dst_order = dst_column->DisplayOrder;
            src_column->DisplayOrder = (ImGuiTableColumnIdx)dst_order;
            for (int order_n = src_order + reorder_dir; order_n != dst_order + reorder_dir; order_n += reorder_dir)
                table->Columns[table->DisplayOrderToIndex[order_n]].DisplayOrder -= (ImGuiTableColumnIdx)reorder_dir;
            IM_ASSERT(dst_column->DisplayOrder == dst_order - reorder_dir);
 
            // Display order is stored in both columns->IndexDisplayOrder and table->DisplayOrder[],
            // rebuild the later from the former.
            for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                table->DisplayOrderToIndex[table->Columns[column_n].DisplayOrder] = (ImGuiTableColumnIdx)column_n;
            table->ReorderColumnDir = 0;
            table->IsSettingsDirty = true;
        }
    }
 
    // Handle display order reset request
    if (table->IsResetDisplayOrderRequest)
    {
        for (int n = 0; n < table->ColumnsCount; n++)
            table->DisplayOrderToIndex[n] = table->Columns[n].DisplayOrder = (ImGuiTableColumnIdx)n;
        table->IsResetDisplayOrderRequest = false;
        table->IsSettingsDirty = true;
    }
}

References ImGuiTable::AutoFitSingleColumn, ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableColumn::DisplayOrder, ImGuiTable::DisplayOrderToIndex, ImGuiTable::Flags, ImGuiTable::HeldHeaderColumn, IM_ASSERT, IM_UNUSED, ImGuiTableFlags_Reorderable, ImGuiTable::InstanceCurrent, ImGuiTable::IsResetDisplayOrderRequest, ImGuiTable::IsSettingsDirty, ImGuiTable::LastResizedColumn, ImGuiTableColumn::NextEnabledColumn, ImGuiTableColumn::PrevEnabledColumn, ImGuiTable::ReorderColumn, ImGuiTable::ReorderColumnDir, ImGuiTable::ResizedColumn, ImGuiTable::ResizedColumnNextWidth, and TableSetColumnWidth().

Referenced by BeginTableEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableBeginCell()

void ImGui::TableBeginCell	(	ImGuiTable *	table,
		int	column_n
	)

{
    ImGuiTableColumn* column = &table->Columns[column_n];
    ImGuiWindow* window = table->InnerWindow;
    table->CurrentColumn = column_n;
 
    // Start position is roughly ~~ CellRect.Min + CellPadding + Indent
    float start_x = column->WorkMinX;
    if (column->Flags & ImGuiTableColumnFlags_IndentEnable)
        start_x += table->RowIndentOffsetX; // ~~ += window.DC.Indent.x - table->HostIndentX, except we locked it for the row.
 
    window->DC.CursorPos.x = start_x;
    window->DC.CursorPos.y = table->RowPosY1 + table->CellPaddingY;
    window->DC.CursorMaxPos.x = window->DC.CursorPos.x;
    window->DC.ColumnsOffset.x = start_x - window->Pos.x - window->DC.Indent.x; // FIXME-WORKRECT
    window->DC.CurrLineTextBaseOffset = table->RowTextBaseline;
    window->DC.NavLayerCurrent = (ImGuiNavLayer)column->NavLayerCurrent;
 
    window->WorkRect.Min.y = window->DC.CursorPos.y;
    window->WorkRect.Min.x = column->WorkMinX;
    window->WorkRect.Max.x = column->WorkMaxX;
    window->DC.ItemWidth = column->ItemWidth;
 
    // To allow ImGuiListClipper to function we propagate our row height
    if (!column->IsEnabled)
        window->DC.CursorPos.y = ImMax(window->DC.CursorPos.y, table->RowPosY2);
 
    window->SkipItems = column->IsSkipItems;
    if (column->IsSkipItems)
    {
        window->DC.LastItemId = 0;
        window->DC.LastItemStatusFlags = 0;
    }
 
    if (table->Flags & ImGuiTableFlags_NoClip)
    {
        // FIXME: if we end up drawing all borders/bg in EndTable, could remove this and just assert that channel hasn't changed.
        table->DrawSplitter->SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_NOCLIP);
        //IM_ASSERT(table->DrawSplitter._Current == TABLE_DRAW_CHANNEL_NOCLIP);
    }
    else
    {
        // FIXME-TABLE: Could avoid this if draw channel is dummy channel?
        SetWindowClipRectBeforeSetChannel(window, column->ClipRect);
        table->DrawSplitter->SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
    }
 
    // Logging
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled && !column->IsSkipItems)
    {
        LogRenderedText(&window->DC.CursorPos, "|");
        g.LogLinePosY = FLT_MAX;
    }
}

Referenced by TableNextColumn(), and TableSetColumnIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableBeginInitMemory()

void ImGui::TableBeginInitMemory	(	ImGuiTable *	table,
		int	columns_count
	)

{
    // Allocate single buffer for our arrays
    ImSpanAllocator<3> span_allocator;
    span_allocator.Reserve(0, columns_count * sizeof(ImGuiTableColumn));
    span_allocator.Reserve(1, columns_count * sizeof(ImGuiTableColumnIdx));
    span_allocator.Reserve(2, columns_count * sizeof(ImGuiTableCellData), 4);
    table->RawData = IM_ALLOC(span_allocator.GetArenaSizeInBytes());
    memset(table->RawData, 0, span_allocator.GetArenaSizeInBytes());
    span_allocator.SetArenaBasePtr(table->RawData);
    span_allocator.GetSpan(0, &table->Columns);
    span_allocator.GetSpan(1, &table->DisplayOrderToIndex);
    span_allocator.GetSpan(2, &table->RowCellData);
}

References ImGuiTable::Columns, ImGuiTable::DisplayOrderToIndex, ImSpanAllocator< CHUNKS >::GetArenaSizeInBytes(), ImSpanAllocator< CHUNKS >::GetSpan(), IM_ALLOC, ImGuiTable::RawData, ImSpanAllocator< CHUNKS >::Reserve(), ImGuiTable::RowCellData, and ImSpanAllocator< CHUNKS >::SetArenaBasePtr().

Referenced by BeginTableEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableBeginRow()

void ImGui::TableBeginRow ( ImGuiTable * table )

{
    ImGuiWindow* window = table->InnerWindow;
    IM_ASSERT(!table->IsInsideRow);
 
    // New row
    table->CurrentRow++;
    table->CurrentColumn = -1;
    table->RowBgColor[0] = table->RowBgColor[1] = IM_COL32_DISABLE;
    table->RowCellDataCurrent = -1;
    table->IsInsideRow = true;
 
    // Begin frozen rows
    float next_y1 = table->RowPosY2;
    if (table->CurrentRow == 0 && table->FreezeRowsCount > 0)
        next_y1 = window->DC.CursorPos.y = table->OuterRect.Min.y;
 
    table->RowPosY1 = table->RowPosY2 = next_y1;
    table->RowTextBaseline = 0.0f;
    table->RowIndentOffsetX = window->DC.Indent.x - table->HostIndentX; // Lock indent
    window->DC.PrevLineTextBaseOffset = 0.0f;
    window->DC.CursorMaxPos.y = next_y1;
 
    // Making the header BG color non-transparent will allow us to overlay it multiple times when handling smooth dragging.
    if (table->RowFlags & ImGuiTableRowFlags_Headers)
    {
        TableSetBgColor(ImGuiTableBgTarget_RowBg0, GetColorU32(ImGuiCol_TableHeaderBg));
        if (table->CurrentRow == 0)
            table->IsUsingHeaders = true;
    }
}

References ImGuiTable::CurrentColumn, ImGuiTable::CurrentRow, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiTable::FreezeRowsCount, GetColorU32(), ImGuiTable::HostIndentX, IM_ASSERT, IM_COL32_DISABLE, ImGuiCol_TableHeaderBg, ImGuiTableBgTarget_RowBg0, ImGuiTableRowFlags_Headers, ImGuiWindowTempData::Indent, ImGuiTable::InnerWindow, ImGuiTable::IsInsideRow, ImGuiTable::IsUsingHeaders, ImRect::Min, ImGuiTable::OuterRect, ImGuiWindowTempData::PrevLineTextBaseOffset, ImGuiTable::RowBgColor, ImGuiTable::RowCellDataCurrent, ImGuiTable::RowFlags, ImGuiTable::RowIndentOffsetX, ImGuiTable::RowPosY1, ImGuiTable::RowPosY2, ImGuiTable::RowTextBaseline, TableSetBgColor(), ImVec1::x, and ImVec2::y.

Referenced by TableNextRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableDrawBorders()

void ImGui::TableDrawBorders ( ImGuiTable * table )

{
    ImGuiWindow* inner_window = table->InnerWindow;
    if (!table->OuterWindow->ClipRect.Overlaps(table->OuterRect))
        return;
 
    ImDrawList* inner_drawlist = inner_window->DrawList;
    table->DrawSplitter->SetCurrentChannel(inner_drawlist, TABLE_DRAW_CHANNEL_BG0);
    inner_drawlist->PushClipRect(table->Bg0ClipRectForDrawCmd.Min, table->Bg0ClipRectForDrawCmd.Max, false);
 
    // Draw inner border and resizing feedback
    const float border_size = TABLE_BORDER_SIZE;
    const float draw_y1 = table->InnerRect.Min.y;
    const float draw_y2_body = table->InnerRect.Max.y;
    const float draw_y2_head = table->IsUsingHeaders ? ImMin(table->InnerRect.Max.y, (table->FreezeRowsCount >= 1 ? table->InnerRect.Min.y : table->WorkRect.Min.y) + table->LastFirstRowHeight) : draw_y1;
    if (table->Flags & ImGuiTableFlags_BordersInnerV)
    {
        for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
        {
            if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n)))
                continue;
 
            const int column_n = table->DisplayOrderToIndex[order_n];
            ImGuiTableColumn* column = &table->Columns[column_n];
            const bool is_hovered = (table->HoveredColumnBorder == column_n);
            const bool is_resized = (table->ResizedColumn == column_n) && (table->InstanceInteracted == table->InstanceCurrent);
            const bool is_resizable = (column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_NoDirectResize_)) == 0;
            const bool is_frozen_separator = (table->FreezeColumnsCount != -1 && table->FreezeColumnsCount == order_n + 1);
            if (column->MaxX > table->InnerClipRect.Max.x && !is_resized)
                continue;
 
            // Decide whether right-most column is visible
            if (column->NextEnabledColumn == -1 && !is_resizable)
                if ((table->Flags & ImGuiTableFlags_SizingMask_) != ImGuiTableFlags_SizingFixedSame || (table->Flags & ImGuiTableFlags_NoHostExtendX))
                    continue;
            if (column->MaxX <= column->ClipRect.Min.x) // FIXME-TABLE FIXME-STYLE: Assume BorderSize==1, this is problematic if we want to increase the border size..
                continue;
 
            // Draw in outer window so right-most column won't be clipped
            // Always draw full height border when being resized/hovered, or on the delimitation of frozen column scrolling.
            ImU32 col;
            float draw_y2;
            if (is_hovered || is_resized || is_frozen_separator)
            {
                draw_y2 = draw_y2_body;
                col = is_resized ? GetColorU32(ImGuiCol_SeparatorActive) : is_hovered ? GetColorU32(ImGuiCol_SeparatorHovered) : table->BorderColorStrong;
            }
            else
            {
                draw_y2 = (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)) ? draw_y2_head : draw_y2_body;
                col = (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)) ? table->BorderColorStrong : table->BorderColorLight;
            }
 
            if (draw_y2 > draw_y1)
                inner_drawlist->AddLine(ImVec2(column->MaxX, draw_y1), ImVec2(column->MaxX, draw_y2), col, border_size);
        }
    }
 
    // Draw outer border
    // FIXME: could use AddRect or explicit VLine/HLine helper?
    if (table->Flags & ImGuiTableFlags_BordersOuter)
    {
        // Display outer border offset by 1 which is a simple way to display it without adding an extra draw call
        // (Without the offset, in outer_window it would be rendered behind cells, because child windows are above their
        // parent. In inner_window, it won't reach out over scrollbars. Another weird solution would be to display part
        // of it in inner window, and the part that's over scrollbars in the outer window..)
        // Either solution currently won't allow us to use a larger border size: the border would clipped.
        const ImRect outer_border = table->OuterRect;
        const ImU32 outer_col = table->BorderColorStrong;
        if ((table->Flags & ImGuiTableFlags_BordersOuter) == ImGuiTableFlags_BordersOuter)
        {
            inner_drawlist->AddRect(outer_border.Min, outer_border.Max, outer_col, 0.0f, 0, border_size);
        }
        else if (table->Flags & ImGuiTableFlags_BordersOuterV)
        {
            inner_drawlist->AddLine(outer_border.Min, ImVec2(outer_border.Min.x, outer_border.Max.y), outer_col, border_size);
            inner_drawlist->AddLine(ImVec2(outer_border.Max.x, outer_border.Min.y), outer_border.Max, outer_col, border_size);
        }
        else if (table->Flags & ImGuiTableFlags_BordersOuterH)
        {
            inner_drawlist->AddLine(outer_border.Min, ImVec2(outer_border.Max.x, outer_border.Min.y), outer_col, border_size);
            inner_drawlist->AddLine(ImVec2(outer_border.Min.x, outer_border.Max.y), outer_border.Max, outer_col, border_size);
        }
    }
    if ((table->Flags & ImGuiTableFlags_BordersInnerH) && table->RowPosY2 < table->OuterRect.Max.y)
    {
        // Draw bottom-most row border
        const float border_y = table->RowPosY2;
        if (border_y >= table->BgClipRect.Min.y && border_y < table->BgClipRect.Max.y)
            inner_drawlist->AddLine(ImVec2(table->BorderX1, border_y), ImVec2(table->BorderX2, border_y), table->BorderColorLight, border_size);
    }
 
    inner_drawlist->PopClipRect();
}

References ImDrawList::AddLine(), ImDrawList::AddRect(), ImGuiTable::Bg0ClipRectForDrawCmd, ImGuiTable::BgClipRect, ImGuiTable::BorderColorLight, ImGuiTable::BorderColorStrong, ImGuiTable::BorderX1, ImGuiTable::BorderX2, ImGuiWindow::ClipRect, ImGuiTableColumn::ClipRect, col(), ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::DisplayOrderToIndex, ImGuiWindow::DrawList, ImGuiTable::DrawSplitter, ImGuiTable::EnabledMaskByDisplayOrder, ImGuiTableColumn::Flags, ImGuiTable::Flags, ImGuiTable::FreezeColumnsCount, ImGuiTable::FreezeRowsCount, GetColorU32(), ImGuiTable::HoveredColumnBorder, ImGuiCol_SeparatorActive, ImGuiCol_SeparatorHovered, ImGuiTableColumnFlags_NoDirectResize_, ImGuiTableColumnFlags_NoResize, ImGuiTableFlags_BordersInnerH, ImGuiTableFlags_BordersInnerV, ImGuiTableFlags_BordersOuter, ImGuiTableFlags_BordersOuterH, ImGuiTableFlags_BordersOuterV, ImGuiTableFlags_NoBordersInBody, ImGuiTableFlags_NoBordersInBodyUntilResize, ImGuiTableFlags_NoHostExtendX, ImGuiTableFlags_SizingFixedSame, ImGuiTableFlags_SizingMask_, ImMin(), ImGuiTable::InnerClipRect, ImGuiTable::InnerRect, ImGuiTable::InnerWindow, ImGuiTable::InstanceCurrent, ImGuiTable::InstanceInteracted, ImGuiTable::IsUsingHeaders, ImGuiTable::LastFirstRowHeight, ImRect::Max, ImGuiTableColumn::MaxX, ImRect::Min, ImGuiTableColumn::NextEnabledColumn, ImGuiTable::OuterRect, ImGuiTable::OuterWindow, ImRect::Overlaps(), ImDrawList::PopClipRect(), ImDrawList::PushClipRect(), ImGuiTable::ResizedColumn, ImGuiTable::RowPosY2, ImDrawListSplitter::SetCurrentChannel(), TABLE_BORDER_SIZE, TABLE_DRAW_CHANNEL_BG0, ImGuiTable::WorkRect, ImVec2::x, and ImVec2::y.

Referenced by EndTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableDrawContextMenu()

void ImGui::TableDrawContextMenu ( ImGuiTable * table )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;
 
    bool want_separator = false;
    const int column_n = (table->ContextPopupColumn >= 0 && table->ContextPopupColumn < table->ColumnsCount) ? table->ContextPopupColumn : -1;
    ImGuiTableColumn* column = (column_n != -1) ? &table->Columns[column_n] : NULL;
 
    // Sizing
    if (table->Flags & ImGuiTableFlags_Resizable)
    {
        if (column != NULL)
        {
            const bool can_resize = !(column->Flags & ImGuiTableColumnFlags_NoResize) && column->IsEnabled;
            if (MenuItem("Size column to fit###SizeOne", NULL, false, can_resize))
                TableSetColumnWidthAutoSingle(table, column_n);
        }
 
        const char* size_all_desc;
        if (table->ColumnsEnabledFixedCount == table->ColumnsEnabledCount && (table->Flags & ImGuiTableFlags_SizingMask_) != ImGuiTableFlags_SizingFixedSame)
            size_all_desc = "Size all columns to fit###SizeAll";        // All fixed
        else
            size_all_desc = "Size all columns to default###SizeAll";    // All stretch or mixed
        if (MenuItem(size_all_desc, NULL))
            TableSetColumnWidthAutoAll(table);
        want_separator = true;
    }
 
    // Ordering
    if (table->Flags & ImGuiTableFlags_Reorderable)
    {
        if (MenuItem("Reset order", NULL, false, !table->IsDefaultDisplayOrder))
            table->IsResetDisplayOrderRequest = true;
        want_separator = true;
    }
 
    // Reset all (should work but seems unnecessary/noisy to expose?)
    //if (MenuItem("Reset all"))
    //    table->IsResetAllRequest = true;
 
    // Sorting
    // (modify TableOpenContextMenu() to add _Sortable flag if enabling this)
#if 0
    if ((table->Flags & ImGuiTableFlags_Sortable) && column != NULL && (column->Flags & ImGuiTableColumnFlags_NoSort) == 0)
    {
        if (want_separator)
            Separator();
        want_separator = true;
 
        bool append_to_sort_specs = g.IO.KeyShift;
        if (MenuItem("Sort in Ascending Order", NULL, column->SortOrder != -1 && column->SortDirection == ImGuiSortDirection_Ascending, (column->Flags & ImGuiTableColumnFlags_NoSortAscending) == 0))
            TableSetColumnSortDirection(table, column_n, ImGuiSortDirection_Ascending, append_to_sort_specs);
        if (MenuItem("Sort in Descending Order", NULL, column->SortOrder != -1 && column->SortDirection == ImGuiSortDirection_Descending, (column->Flags & ImGuiTableColumnFlags_NoSortDescending) == 0))
            TableSetColumnSortDirection(table, column_n, ImGuiSortDirection_Descending, append_to_sort_specs);
    }
#endif
 
    // Hiding / Visibility
    if (table->Flags & ImGuiTableFlags_Hideable)
    {
        if (want_separator)
            Separator();
        want_separator = true;
 
        PushItemFlag(ImGuiItemFlags_SelectableDontClosePopup, true);
        for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
        {
            ImGuiTableColumn* other_column = &table->Columns[other_column_n];
            const char* name = TableGetColumnName(table, other_column_n);
            if (name == NULL || name[0] == 0)
                name = "<Unknown>";
 
            // Make sure we can't hide the last active column
            bool menu_item_active = (other_column->Flags & ImGuiTableColumnFlags_NoHide) ? false : true;
            if (other_column->IsEnabled && table->ColumnsEnabledCount <= 1)
                menu_item_active = false;
            if (MenuItem(name, NULL, other_column->IsEnabled, menu_item_active))
                other_column->IsEnabledNextFrame = !other_column->IsEnabled;
        }
        PopItemFlag();
    }
}

References ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::ColumnsEnabledCount, ImGuiTable::ColumnsEnabledFixedCount, ImGuiTable::ContextPopupColumn, ImGuiContext::CurrentWindow, ImGuiTableColumn::Flags, ImGuiTable::Flags, GImGui, ImGuiItemFlags_SelectableDontClosePopup, ImGuiSortDirection_Ascending, ImGuiSortDirection_Descending, ImGuiTableColumnFlags_NoHide, ImGuiTableColumnFlags_NoResize, ImGuiTableColumnFlags_NoSort, ImGuiTableColumnFlags_NoSortAscending, ImGuiTableColumnFlags_NoSortDescending, ImGuiTableFlags_Hideable, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImGuiTableFlags_SizingFixedSame, ImGuiTableFlags_SizingMask_, ImGuiTableFlags_Sortable, ImGuiContext::IO, ImGuiTable::IsDefaultDisplayOrder, ImGuiTableColumn::IsEnabled, ImGuiTableColumn::IsEnabledNextFrame, ImGuiTable::IsResetDisplayOrderRequest, ImGuiIO::KeyShift, MenuItem(), PopItemFlag(), PushItemFlag(), Separator(), ImGuiWindow::SkipItems, ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortOrder, TableGetColumnName(), TableSetColumnSortDirection(), TableSetColumnWidthAutoAll(), and TableSetColumnWidthAutoSingle().

Referenced by TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableEndCell()

void ImGui::TableEndCell ( ImGuiTable * table )

{
    ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
    ImGuiWindow* window = table->InnerWindow;
 
    // Report maximum position so we can infer content size per column.
    float* p_max_pos_x;
    if (table->RowFlags & ImGuiTableRowFlags_Headers)
        p_max_pos_x = &column->ContentMaxXHeadersUsed;  // Useful in case user submit contents in header row that is not a TableHeader() call
    else
        p_max_pos_x = table->IsUnfrozenRows ? &column->ContentMaxXUnfrozen : &column->ContentMaxXFrozen;
    *p_max_pos_x = ImMax(*p_max_pos_x, window->DC.CursorMaxPos.x);
    table->RowPosY2 = ImMax(table->RowPosY2, window->DC.CursorMaxPos.y + table->CellPaddingY);
    column->ItemWidth = window->DC.ItemWidth;
 
    // Propagate text baseline for the entire row
    // FIXME-TABLE: Here we propagate text baseline from the last line of the cell.. instead of the first one.
    table->RowTextBaseline = ImMax(table->RowTextBaseline, window->DC.PrevLineTextBaseOffset);
}

References ImGuiTable::CellPaddingY, ImGuiTable::Columns, ImGuiTableColumn::ContentMaxXFrozen, ImGuiTableColumn::ContentMaxXHeadersUsed, ImGuiTableColumn::ContentMaxXUnfrozen, ImGuiTable::CurrentColumn, ImGuiWindowTempData::CursorMaxPos, ImGuiWindow::DC, ImGuiTableRowFlags_Headers, ImMax(), ImGuiTable::InnerWindow, ImGuiTable::IsUnfrozenRows, ImGuiWindowTempData::ItemWidth, ImGuiTableColumn::ItemWidth, ImGuiWindowTempData::PrevLineTextBaseOffset, ImGuiTable::RowFlags, ImGuiTable::RowPosY2, ImGuiTable::RowTextBaseline, ImVec2::x, and ImVec2::y.

Referenced by TableEndRow(), TableNextColumn(), and TableSetColumnIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableEndRow()

void ImGui::TableEndRow ( ImGuiTable * table )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(window == table->InnerWindow);
    IM_ASSERT(table->IsInsideRow);
 
    if (table->CurrentColumn != -1)
        TableEndCell(table);
 
    // Logging
    if (g.LogEnabled)
        LogRenderedText(NULL, "|");
 
    // Position cursor at the bottom of our row so it can be used for e.g. clipping calculation. However it is
    // likely that the next call to TableBeginCell() will reposition the cursor to take account of vertical padding.
    window->DC.CursorPos.y = table->RowPosY2;
 
    // Row background fill
    const float bg_y1 = table->RowPosY1;
    const float bg_y2 = table->RowPosY2;
    const bool unfreeze_rows_actual = (table->CurrentRow + 1 == table->FreezeRowsCount);
    const bool unfreeze_rows_request = (table->CurrentRow + 1 == table->FreezeRowsRequest);
    if (table->CurrentRow == 0)
        table->LastFirstRowHeight = bg_y2 - bg_y1;
 
    const bool is_visible = (bg_y2 >= table->InnerClipRect.Min.y && bg_y1 <= table->InnerClipRect.Max.y);
    if (is_visible)
    {
        // Decide of background color for the row
        ImU32 bg_col0 = 0;
        ImU32 bg_col1 = 0;
        if (table->RowBgColor[0] != IM_COL32_DISABLE)
            bg_col0 = table->RowBgColor[0];
        else if (table->Flags & ImGuiTableFlags_RowBg)
            bg_col0 = GetColorU32((table->RowBgColorCounter & 1) ? ImGuiCol_TableRowBgAlt : ImGuiCol_TableRowBg);
        if (table->RowBgColor[1] != IM_COL32_DISABLE)
            bg_col1 = table->RowBgColor[1];
 
        // Decide of top border color
        ImU32 border_col = 0;
        const float border_size = TABLE_BORDER_SIZE;
        if (table->CurrentRow > 0 || table->InnerWindow == table->OuterWindow)
            if (table->Flags & ImGuiTableFlags_BordersInnerH)
                border_col = (table->LastRowFlags & ImGuiTableRowFlags_Headers) ? table->BorderColorStrong : table->BorderColorLight;
 
        const bool draw_cell_bg_color = table->RowCellDataCurrent >= 0;
        const bool draw_strong_bottom_border = unfreeze_rows_actual;
        if ((bg_col0 | bg_col1 | border_col) != 0 || draw_strong_bottom_border || draw_cell_bg_color)
        {
            // In theory we could call SetWindowClipRectBeforeSetChannel() but since we know TableEndRow() is
            // always followed by a change of clipping rectangle we perform the smallest overwrite possible here.
            if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
                window->DrawList->_CmdHeader.ClipRect = table->Bg0ClipRectForDrawCmd.ToVec4();
            table->DrawSplitter->SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_BG0);
        }
 
        // Draw row background
        // We soft/cpu clip this so all backgrounds and borders can share the same clipping rectangle
        if (bg_col0 || bg_col1)
        {
            ImRect row_rect(table->WorkRect.Min.x, bg_y1, table->WorkRect.Max.x, bg_y2);
            row_rect.ClipWith(table->BgClipRect);
            if (bg_col0 != 0 && row_rect.Min.y < row_rect.Max.y)
                window->DrawList->AddRectFilled(row_rect.Min, row_rect.Max, bg_col0);
            if (bg_col1 != 0 && row_rect.Min.y < row_rect.Max.y)
                window->DrawList->AddRectFilled(row_rect.Min, row_rect.Max, bg_col1);
        }
 
        // Draw cell background color
        if (draw_cell_bg_color)
        {
            ImGuiTableCellData* cell_data_end = &table->RowCellData[table->RowCellDataCurrent];
            for (ImGuiTableCellData* cell_data = &table->RowCellData[0]; cell_data <= cell_data_end; cell_data++)
            {
                const ImGuiTableColumn* column = &table->Columns[cell_data->Column];
                ImRect cell_bg_rect = TableGetCellBgRect(table, cell_data->Column);
                cell_bg_rect.ClipWith(table->BgClipRect);
                cell_bg_rect.Min.x = ImMax(cell_bg_rect.Min.x, column->ClipRect.Min.x);     // So that first column after frozen one gets clipped
                cell_bg_rect.Max.x = ImMin(cell_bg_rect.Max.x, column->MaxX);
                window->DrawList->AddRectFilled(cell_bg_rect.Min, cell_bg_rect.Max, cell_data->BgColor);
            }
        }
 
        // Draw top border
        if (border_col && bg_y1 >= table->BgClipRect.Min.y && bg_y1 < table->BgClipRect.Max.y)
            window->DrawList->AddLine(ImVec2(table->BorderX1, bg_y1), ImVec2(table->BorderX2, bg_y1), border_col, border_size);
 
        // Draw bottom border at the row unfreezing mark (always strong)
        if (draw_strong_bottom_border && bg_y2 >= table->BgClipRect.Min.y && bg_y2 < table->BgClipRect.Max.y)
            window->DrawList->AddLine(ImVec2(table->BorderX1, bg_y2), ImVec2(table->BorderX2, bg_y2), table->BorderColorStrong, border_size);
    }
 
    // End frozen rows (when we are past the last frozen row line, teleport cursor and alter clipping rectangle)
    // We need to do that in TableEndRow() instead of TableBeginRow() so the list clipper can mark end of row and
    // get the new cursor position.
    if (unfreeze_rows_request)
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            column->NavLayerCurrent = (ImS8)((column_n < table->FreezeColumnsCount) ? ImGuiNavLayer_Menu : ImGuiNavLayer_Main);
        }
    if (unfreeze_rows_actual)
    {
        IM_ASSERT(table->IsUnfrozenRows == false);
        table->IsUnfrozenRows = true;
 
        // BgClipRect starts as table->InnerClipRect, reduce it now and make BgClipRectForDrawCmd == BgClipRect
        float y0 = ImMax(table->RowPosY2 + 1, window->InnerClipRect.Min.y);
        table->BgClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y = ImMin(y0, window->InnerClipRect.Max.y);
        table->BgClipRect.Max.y = table->Bg2ClipRectForDrawCmd.Max.y = window->InnerClipRect.Max.y;
        table->Bg2DrawChannelCurrent = table->Bg2DrawChannelUnfrozen;
        IM_ASSERT(table->Bg2ClipRectForDrawCmd.Min.y <= table->Bg2ClipRectForDrawCmd.Max.y);
 
        float row_height = table->RowPosY2 - table->RowPosY1;
        table->RowPosY2 = window->DC.CursorPos.y = table->WorkRect.Min.y + table->RowPosY2 - table->OuterRect.Min.y;
        table->RowPosY1 = table->RowPosY2 - row_height;
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            column->DrawChannelCurrent = column->DrawChannelUnfrozen;
            column->ClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y;
        }
 
        // Update cliprect ahead of TableBeginCell() so clipper can access to new ClipRect->Min.y
        SetWindowClipRectBeforeSetChannel(window, table->Columns[0].ClipRect);
        table->DrawSplitter->SetCurrentChannel(window->DrawList, table->Columns[0].DrawChannelCurrent);
    }
 
    if (!(table->RowFlags & ImGuiTableRowFlags_Headers))
        table->RowBgColorCounter++;
    table->IsInsideRow = false;
}

References ImDrawList::_CmdHeader, ImDrawList::AddLine(), ImDrawList::AddRectFilled(), ImGuiTable::Bg0ClipRectForDrawCmd, ImGuiTable::Bg2ClipRectForDrawCmd, ImGuiTable::Bg2DrawChannelCurrent, ImGuiTable::Bg2DrawChannelUnfrozen, ImGuiTable::BgClipRect, ImGuiTable::BorderColorLight, ImGuiTable::BorderColorStrong, ImGuiTable::BorderX1, ImGuiTable::BorderX2, ImDrawCmdHeader::ClipRect, ImGuiTableColumn::ClipRect, ImRect::ClipWith(), ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::CurrentColumn, ImGuiTable::CurrentRow, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiTableColumn::DrawChannelCurrent, ImGuiTableColumn::DrawChannelUnfrozen, ImGuiWindow::DrawList, ImGuiTable::DrawSplitter, ImGuiTable::Flags, ImGuiTable::FreezeRowsCount, ImGuiTable::FreezeRowsRequest, GetColorU32(), GImGui, IM_ASSERT, IM_COL32_DISABLE, ImGuiCol_TableRowBg, ImGuiCol_TableRowBgAlt, ImGuiNavLayer_Main, ImGuiNavLayer_Menu, ImGuiTableFlags_BordersInnerH, ImGuiTableFlags_NoClip, ImGuiTableFlags_RowBg, ImGuiTableRowFlags_Headers, ImMax(), ImMin(), ImGuiWindow::InnerClipRect, ImGuiTable::InnerClipRect, ImGuiTable::InnerWindow, ImGuiTable::IsInsideRow, ImGuiTable::IsUnfrozenRows, ImGuiTable::LastFirstRowHeight, ImGuiTable::LastRowFlags, ImGuiContext::LogEnabled, LogRenderedText(), ImRect::Max, ImGuiTableColumn::MaxX, ImRect::Min, ImGuiTableColumn::NavLayerCurrent, ImGuiTable::OuterRect, ImGuiTable::OuterWindow, ImGuiTable::RowBgColor, ImGuiTable::RowBgColorCounter, ImGuiTable::RowCellData, ImGuiTable::RowCellDataCurrent, ImGuiTable::RowFlags, ImGuiTable::RowPosY1, ImGuiTable::RowPosY2, ImDrawListSplitter::SetCurrentChannel(), SetWindowClipRectBeforeSetChannel(), TABLE_BORDER_SIZE, TABLE_DRAW_CHANNEL_BG0, TableEndCell(), TableGetCellBgRect(), ImRect::ToVec4(), ImGuiTable::WorkRect, ImVec2::x, and ImVec2::y.

Referenced by ImGuiListClipper::Begin(), EndTable(), SetCursorPosYAndSetupForPrevLine(), ImGuiListClipper::Step(), and TableNextRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableFindByID()

ImGuiTable * ImGui::TableFindByID ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    return g.Tables.GetByKey(id);
}

References ImPool< T >::GetByKey(), GImGui, and ImGuiContext::Tables.

Here is the call graph for this function:

◆ TableFixColumnSortDirection()

void ImGui::TableFixColumnSortDirection	(	ImGuiTable *	table,
		ImGuiTableColumn *	column
	)

{
    if (column->SortOrder == -1 || (column->SortDirectionsAvailMask & (1 << column->SortDirection)) != 0)
        return;
    column->SortDirection = (ImU8)TableGetColumnAvailSortDirection(column, 0);
    table->IsSortSpecsDirty = true;
}

References ImGuiTable::IsSortSpecsDirty, ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortDirectionsAvailMask, ImGuiTableColumn::SortOrder, and TableGetColumnAvailSortDirection().

Referenced by TableSetColumnSortDirection(), and TableSetupColumnFlags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGcCompactSettings()

void ImGui::TableGcCompactSettings ( )

{
    ImGuiContext& g = *GImGui;
    int required_memory = 0;
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
        if (settings->ID != 0)
            required_memory += (int)TableSettingsCalcChunkSize(settings->ColumnsCount);
    if (required_memory == g.SettingsTables.Buf.Size)
        return;
    ImChunkStream<ImGuiTableSettings> new_chunk_stream;
    new_chunk_stream.Buf.reserve(required_memory);
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
        if (settings->ID != 0)
            memcpy(new_chunk_stream.alloc_chunk(TableSettingsCalcChunkSize(settings->ColumnsCount)), settings, TableSettingsCalcChunkSize(settings->ColumnsCount));
    g.SettingsTables.swap(new_chunk_stream);
}

References ImChunkStream< T >::alloc_chunk(), ImChunkStream< T >::begin(), ImChunkStream< T >::Buf, GImGui, ImChunkStream< T >::next_chunk(), ImVector< T >::reserve(), ImGuiContext::SettingsTables, ImVector< T >::Size, ImChunkStream< T >::swap(), and TableSettingsCalcChunkSize().

Referenced by GcCompactTransientMiscBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGcCompactTransientBuffers() [1/2]

void ImGui::TableGcCompactTransientBuffers ( ImGuiTable * table )

{
    //IMGUI_DEBUG_LOG("TableGcCompactTransientBuffers() id=0x%08X\n", table->ID);
    ImGuiContext& g = *GImGui;
    IM_ASSERT(table->MemoryCompacted == false);
    table->SortSpecs.Specs = NULL;
    table->IsSortSpecsDirty = true;
    table->ColumnsNames.clear();
    table->MemoryCompacted = true;
    for (int n = 0; n < table->ColumnsCount; n++)
        table->Columns[n].NameOffset = -1;
    g.TablesLastTimeActive[g.Tables.GetIndex(table)] = -1.0f;
}

References ImGuiTextBuffer::clear(), ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::ColumnsNames, ImPool< T >::GetIndex(), GImGui, IM_ASSERT, ImGuiTable::IsSortSpecsDirty, ImGuiTable::MemoryCompacted, ImGuiTable::SortSpecs, ImGuiTableSortSpecs::Specs, ImGuiContext::Tables, and ImGuiContext::TablesLastTimeActive.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGcCompactTransientBuffers() [2/2]

void ImGui::TableGcCompactTransientBuffers ( ImGuiTableTempData * table )

{
    temp_data->DrawSplitter.ClearFreeMemory();
    temp_data->SortSpecsMulti.clear();
    temp_data->LastTimeActive = -1.0f;
}

References ImVector< T >::clear(), ImDrawListSplitter::ClearFreeMemory(), ImGuiTableTempData::DrawSplitter, ImGuiTableTempData::LastTimeActive, and ImGuiTableTempData::SortSpecsMulti.

Here is the call graph for this function:

◆ TableGetBoundSettings()

ImGuiTableSettings * ImGui::TableGetBoundSettings ( ImGuiTable * table )

{
    if (table->SettingsOffset != -1)
    {
        ImGuiContext& g = *GImGui;
        ImGuiTableSettings* settings = g.SettingsTables.ptr_from_offset(table->SettingsOffset);
        IM_ASSERT(settings->ID == table->ID);
        if (settings->ColumnsCountMax >= table->ColumnsCount)
            return settings; // OK
        settings->ID = 0; // Invalidate storage, we won't fit because of a count change
    }
    return NULL;
}

References ImGuiTable::ColumnsCount, ImGuiTableSettings::ColumnsCountMax, GImGui, ImGuiTable::ID, ImGuiTableSettings::ID, IM_ASSERT, ImChunkStream< T >::ptr_from_offset(), ImGuiTable::SettingsOffset, and ImGuiContext::SettingsTables.

Referenced by DebugNodeTable(), TableLoadSettings(), and TableSaveSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGetCellBgRect()

ImRect ImGui::TableGetCellBgRect	(	const ImGuiTable *	table,
		int	column_n
	)

{
    const ImGuiTableColumn* column = &table->Columns[column_n];
    float x1 = column->MinX;
    float x2 = column->MaxX;
    if (column->PrevEnabledColumn == -1)
        x1 -= table->CellSpacingX1;
    if (column->NextEnabledColumn == -1)
        x2 += table->CellSpacingX2;
    return ImRect(x1, table->RowPosY1, x2, table->RowPosY2);
}

References ImGuiTable::CellSpacingX1, ImGuiTable::CellSpacingX2, ImGuiTable::Columns, ImGuiTableColumn::MaxX, ImGuiTableColumn::MinX, ImGuiTableColumn::NextEnabledColumn, ImGuiTableColumn::PrevEnabledColumn, ImGuiTable::RowPosY1, and ImGuiTable::RowPosY2.

Referenced by TableEndRow(), and TableHeader().

Here is the caller graph for this function:

◆ TableGetColumnCount()

int ImGui::TableGetColumnCount ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    return table ? table->ColumnsCount : 0;
}

References ImGuiTable::ColumnsCount, ImGuiContext::CurrentTable, and GImGui.

Referenced by TableGetHeaderRowHeight(), and TableHeadersRow().

Here is the caller graph for this function:

◆ TableGetColumnFlags()

ImGuiTableColumnFlags ImGui::TableGetColumnFlags ( int column_n = -1 )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return ImGuiTableColumnFlags_None;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    if (column_n == table->ColumnsCount)
        return (table->HoveredColumnBody == column_n) ? ImGuiTableColumnFlags_IsHovered : ImGuiTableColumnFlags_None;
    return table->Columns[column_n].Flags;
}

References ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, GImGui, ImGuiTable::HoveredColumnBody, ImGuiTableColumnFlags_IsHovered, and ImGuiTableColumnFlags_None.

Referenced by ShowDemoWindowTables(), and TableGetHeaderRowHeight().

Here is the caller graph for this function:

◆ TableGetColumnIndex()

int ImGui::TableGetColumnIndex ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return 0;
    return table->CurrentColumn;
}

References ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, and GImGui.

Referenced by ShowDemoWindowTables().

Here is the caller graph for this function:

◆ TableGetColumnName() [1/2]

const char * ImGui::TableGetColumnName	(	const ImGuiTable *	table,
		int	column_n
	)

{
    if (table->IsLayoutLocked == false && column_n >= table->DeclColumnsCount)
        return ""; // NameOffset is invalid at this point
    const ImGuiTableColumn* column = &table->Columns[column_n];
    if (column->NameOffset == -1)
        return "";
    return &table->ColumnsNames.Buf[column->NameOffset];
}

References ImGuiTextBuffer::Buf, ImGuiTable::Columns, ImGuiTable::ColumnsNames, ImGuiTable::DeclColumnsCount, ImGuiTable::IsLayoutLocked, and ImGuiTableColumn::NameOffset.

◆ TableGetColumnName() [2/2]

const char * ImGui::TableGetColumnName ( int column_n = -1 )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return NULL;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    return TableGetColumnName(table, column_n);
}

References ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, GImGui, and TableGetColumnName().

Referenced by DebugNodeTable(), ShowDemoWindowTables(), TableDrawContextMenu(), TableGetColumnName(), TableGetHeaderRowHeight(), and TableHeadersRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGetColumnNextSortDirection()

ImGuiSortDirection ImGui::TableGetColumnNextSortDirection ( ImGuiTableColumn * column )

{
    IM_ASSERT(column->SortDirectionsAvailCount > 0);
    if (column->SortOrder == -1)
        return TableGetColumnAvailSortDirection(column, 0);
    for (int n = 0; n < 3; n++)
        if (column->SortDirection == TableGetColumnAvailSortDirection(column, n))
            return TableGetColumnAvailSortDirection(column, (n + 1) % column->SortDirectionsAvailCount);
    IM_ASSERT(0);
    return ImGuiSortDirection_None;
}

References IM_ASSERT, ImGuiSortDirection_None, ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortDirectionsAvailCount, ImGuiTableColumn::SortOrder, and TableGetColumnAvailSortDirection().

Referenced by TableHeader().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGetColumnResizeID()

ImGuiID ImGui::TableGetColumnResizeID	(	const ImGuiTable *	table,
		int	column_n,
		int	instance_no = `0`
	)

{
    IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
    ImGuiID id = table->ID + 1 + (instance_no * table->ColumnsCount) + column_n;
    return id;
}

References ImGuiTable::ColumnsCount, ImGuiTable::ID, and IM_ASSERT.

Referenced by TableUpdateBorders().

Here is the caller graph for this function:

◆ TableGetColumnWidthAuto()

float ImGui::TableGetColumnWidthAuto	(	ImGuiTable *	table,
		ImGuiTableColumn *	column
	)

{
    const float content_width_body = ImMax(column->ContentMaxXFrozen, column->ContentMaxXUnfrozen) - column->WorkMinX;
    const float content_width_headers = column->ContentMaxXHeadersIdeal - column->WorkMinX;
    float width_auto = content_width_body;
    if (!(column->Flags & ImGuiTableColumnFlags_NoHeaderWidth))
        width_auto = ImMax(width_auto, content_width_headers);
 
    // Non-resizable fixed columns preserve their requested width
    if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && column->InitStretchWeightOrWidth > 0.0f)
        if (!(table->Flags & ImGuiTableFlags_Resizable) || (column->Flags & ImGuiTableColumnFlags_NoResize))
            width_auto = column->InitStretchWeightOrWidth;
 
    return ImMax(width_auto, table->MinColumnWidth);
}

References ImGuiTableColumn::ContentMaxXFrozen, ImGuiTableColumn::ContentMaxXHeadersIdeal, ImGuiTableColumn::ContentMaxXUnfrozen, ImGuiTableColumn::Flags, ImGuiTable::Flags, ImGuiTableColumnFlags_NoHeaderWidth, ImGuiTableColumnFlags_NoResize, ImGuiTableColumnFlags_WidthFixed, ImGuiTableFlags_Resizable, ImMax(), ImGuiTableColumn::InitStretchWeightOrWidth, ImGuiTable::MinColumnWidth, and ImGuiTableColumn::WorkMinX.

Referenced by EndTable(), and TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGetHeaderRowHeight()

float ImGui::TableGetHeaderRowHeight ( )

{
    // Caring for a minor edge case:
    // Calculate row height, for the unlikely case that some labels may be taller than others.
    // If we didn't do that, uneven header height would highlight but smaller one before the tallest wouldn't catch input for all height.
    // In your custom header row you may omit this all together and just call TableNextRow() without a height...
    float row_height = GetTextLineHeight();
    int columns_count = TableGetColumnCount();
    for (int column_n = 0; column_n < columns_count; column_n++)
        if (TableGetColumnFlags(column_n) & ImGuiTableColumnFlags_IsEnabled)
            row_height = ImMax(row_height, CalcTextSize(TableGetColumnName(column_n)).y);
    row_height += GetStyle().CellPadding.y * 2.0f;
    return row_height;
}

References CalcTextSize(), ImGuiStyle::CellPadding, GetStyle(), GetTextLineHeight(), ImGuiTableColumnFlags_IsEnabled, ImMax(), TableGetColumnCount(), TableGetColumnFlags(), TableGetColumnName(), and ImVec2::y.

Referenced by TableHeadersRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableGetHoveredColumn()

int ImGui::TableGetHoveredColumn ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return -1;
    return (int)table->HoveredColumnBody;
}

References ImGuiContext::CurrentTable, GImGui, and ImGuiTable::HoveredColumnBody.

Referenced by TableHeadersRow().

Here is the caller graph for this function:

◆ TableGetMaxColumnWidth()

float ImGui::TableGetMaxColumnWidth	(	const ImGuiTable *	table,
		int	column_n
	)

{
    const ImGuiTableColumn* column = &table->Columns[column_n];
    float max_width = FLT_MAX;
    const float min_column_distance = table->MinColumnWidth + table->CellPaddingX * 2.0f + table->CellSpacingX1 + table->CellSpacingX2;
    if (table->Flags & ImGuiTableFlags_ScrollX)
    {
        // Frozen columns can't reach beyond visible width else scrolling will naturally break.
        if (column->DisplayOrder < table->FreezeColumnsRequest)
        {
            max_width = (table->InnerClipRect.Max.x - (table->FreezeColumnsRequest - column->DisplayOrder) * min_column_distance) - column->MinX;
            max_width = max_width - table->OuterPaddingX - table->CellPaddingX - table->CellSpacingX2;
        }
    }
    else if ((table->Flags & ImGuiTableFlags_NoKeepColumnsVisible) == 0)
    {
        // If horizontal scrolling if disabled, we apply a final lossless shrinking of columns in order to make
        // sure they are all visible. Because of this we also know that all of the columns will always fit in
        // table->WorkRect and therefore in table->InnerRect (because ScrollX is off)
        // FIXME-TABLE: This is solved incorrectly but also quite a difficult problem to fix as we also want ClipRect width to match.
        // See "table_width_distrib" and "table_width_keep_visible" tests
        max_width = table->WorkRect.Max.x - (table->ColumnsEnabledCount - column->IndexWithinEnabledSet - 1) * min_column_distance - column->MinX;
        //max_width -= table->CellSpacingX1;
        max_width -= table->CellSpacingX2;
        max_width -= table->CellPaddingX * 2.0f;
        max_width -= table->OuterPaddingX;
    }
    return max_width;
}

References ImGuiTable::CellPaddingX, ImGuiTable::CellSpacingX1, ImGuiTable::CellSpacingX2, ImGuiTable::Columns, ImGuiTable::ColumnsEnabledCount, ImGuiTableColumn::DisplayOrder, ImGuiTable::Flags, ImGuiTable::FreezeColumnsRequest, ImGuiTableFlags_NoKeepColumnsVisible, ImGuiTableFlags_ScrollX, ImGuiTableColumn::IndexWithinEnabledSet, ImGuiTable::InnerClipRect, ImRect::Max, ImGuiTable::MinColumnWidth, ImGuiTableColumn::MinX, ImGuiTable::OuterPaddingX, ImGuiTable::WorkRect, and ImVec2::x.

Referenced by TableSetColumnWidth(), and TableUpdateLayout().

Here is the caller graph for this function:

◆ TableGetRowIndex()

int ImGui::TableGetRowIndex ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return 0;
    return table->CurrentRow;
}

References ImGuiTable::CurrentRow, ImGuiContext::CurrentTable, and GImGui.

Referenced by ShowDemoWindowTables().

Here is the caller graph for this function:

◆ TableGetSortSpecs()

ImGuiTableSortSpecs * ImGui::TableGetSortSpecs ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL);
 
    if (!(table->Flags & ImGuiTableFlags_Sortable))
        return NULL;
 
    // Require layout (in case TableHeadersRow() hasn't been called) as it may alter IsSortSpecsDirty in some paths.
    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);
 
    if (table->IsSortSpecsDirty)
        TableSortSpecsBuild(table);
 
    return &table->SortSpecs;
}

References ImGuiContext::CurrentTable, ImGuiTable::Flags, GImGui, IM_ASSERT, ImGuiTableFlags_Sortable, ImGuiTable::IsLayoutLocked, ImGuiTable::IsSortSpecsDirty, ImGuiTable::SortSpecs, TableSortSpecsBuild(), and TableUpdateLayout().

Referenced by ShowDemoWindowTables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableHeader()

void ImGui::TableHeader ( const char * label )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;
 
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Need to call TableHeader() after BeginTable()!");
    IM_ASSERT(table->CurrentColumn != -1);
    const int column_n = table->CurrentColumn;
    ImGuiTableColumn* column = &table->Columns[column_n];
 
    // Label
    if (label == NULL)
        label = "";
    const char* label_end = FindRenderedTextEnd(label);
    ImVec2 label_size = CalcTextSize(label, label_end, true);
    ImVec2 label_pos = window->DC.CursorPos;
 
    // If we already got a row height, there's use that.
    // FIXME-TABLE: Padding problem if the correct outer-padding CellBgRect strays off our ClipRect?
    ImRect cell_r = TableGetCellBgRect(table, column_n);
    float label_height = ImMax(label_size.y, table->RowMinHeight - table->CellPaddingY * 2.0f);
 
    // Calculate ideal size for sort order arrow
    float w_arrow = 0.0f;
    float w_sort_text = 0.0f;
    char sort_order_suf[4] = "";
    const float ARROW_SCALE = 0.65f;
    if ((table->Flags & ImGuiTableFlags_Sortable) && !(column->Flags & ImGuiTableColumnFlags_NoSort))
    {
        w_arrow = ImFloor(g.FontSize * ARROW_SCALE + g.Style.FramePadding.x);
        if (column->SortOrder > 0)
        {
            ImFormatString(sort_order_suf, IM_ARRAYSIZE(sort_order_suf), "%d", column->SortOrder + 1);
            w_sort_text = g.Style.ItemInnerSpacing.x + CalcTextSize(sort_order_suf).x;
        }
    }
 
    // We feed our unclipped width to the column without writing on CursorMaxPos, so that column is still considering for merging.
    float max_pos_x = label_pos.x + label_size.x + w_sort_text + w_arrow;
    column->ContentMaxXHeadersUsed = ImMax(column->ContentMaxXHeadersUsed, column->WorkMaxX);
    column->ContentMaxXHeadersIdeal = ImMax(column->ContentMaxXHeadersIdeal, max_pos_x);
 
    // Keep header highlighted when context menu is open.
    const bool selected = (table->IsContextPopupOpen && table->ContextPopupColumn == column_n && table->InstanceInteracted == table->InstanceCurrent);
    ImGuiID id = window->GetID(label);
    ImRect bb(cell_r.Min.x, cell_r.Min.y, cell_r.Max.x, ImMax(cell_r.Max.y, cell_r.Min.y + label_height + g.Style.CellPadding.y * 2.0f));
    ItemSize(ImVec2(0.0f, label_height)); // Don't declare unclipped width, it'll be fed ContentMaxPosHeadersIdeal
    if (!ItemAdd(bb, id))
        return;
 
    //GetForegroundDrawList()->AddRect(cell_r.Min, cell_r.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]
    //GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]
 
    // Using AllowItemOverlap mode because we cover the whole cell, and we want user to be able to submit subsequent items.
    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_AllowItemOverlap);
    if (g.ActiveId != id)
        SetItemAllowOverlap();
    if (held || hovered || selected)
    {
        const ImU32 col = GetColorU32(held ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
        //RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
        TableSetBgColor(ImGuiTableBgTarget_CellBg, col, table->CurrentColumn);
        RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
    }
    else
    {
        // Submit single cell bg color in the case we didn't submit a full header row
        if ((table->RowFlags & ImGuiTableRowFlags_Headers) == 0)
            TableSetBgColor(ImGuiTableBgTarget_CellBg, GetColorU32(ImGuiCol_TableHeaderBg), table->CurrentColumn);
    }
    if (held)
        table->HeldHeaderColumn = (ImGuiTableColumnIdx)column_n;
    window->DC.CursorPos.y -= g.Style.ItemSpacing.y * 0.5f;
 
    // Drag and drop to re-order columns.
    // FIXME-TABLE: Scroll request while reordering a column and it lands out of the scrolling zone.
    if (held && (table->Flags & ImGuiTableFlags_Reorderable) && IsMouseDragging(0) && !g.DragDropActive)
    {
        // While moving a column it will jump on the other side of the mouse, so we also test for MouseDelta.x
        table->ReorderColumn = (ImGuiTableColumnIdx)column_n;
        table->InstanceInteracted = table->InstanceCurrent;
 
        // We don't reorder: through the frozen<>unfrozen line, or through a column that is marked with ImGuiTableColumnFlags_NoReorder.
        if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < cell_r.Min.x)
            if (ImGuiTableColumn* prev_column = (column->PrevEnabledColumn != -1) ? &table->Columns[column->PrevEnabledColumn] : NULL)
                if (!((column->Flags | prev_column->Flags) & ImGuiTableColumnFlags_NoReorder))
                    if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinEnabledSet < table->FreezeColumnsRequest))
                        table->ReorderColumnDir = -1;
        if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > cell_r.Max.x)
            if (ImGuiTableColumn* next_column = (column->NextEnabledColumn != -1) ? &table->Columns[column->NextEnabledColumn] : NULL)
                if (!((column->Flags | next_column->Flags) & ImGuiTableColumnFlags_NoReorder))
                    if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (next_column->IndexWithinEnabledSet < table->FreezeColumnsRequest))
                        table->ReorderColumnDir = +1;
    }
 
    // Sort order arrow
    const float ellipsis_max = cell_r.Max.x - w_arrow - w_sort_text;
    if ((table->Flags & ImGuiTableFlags_Sortable) && !(column->Flags & ImGuiTableColumnFlags_NoSort))
    {
        if (column->SortOrder != -1)
        {
            float x = ImMax(cell_r.Min.x, cell_r.Max.x - w_arrow - w_sort_text);
            float y = label_pos.y;
            if (column->SortOrder > 0)
            {
                PushStyleColor(ImGuiCol_Text, GetColorU32(ImGuiCol_Text, 0.70f));
                RenderText(ImVec2(x + g.Style.ItemInnerSpacing.x, y), sort_order_suf);
                PopStyleColor();
                x += w_sort_text;
            }
            RenderArrow(window->DrawList, ImVec2(x, y), GetColorU32(ImGuiCol_Text), column->SortDirection == ImGuiSortDirection_Ascending ? ImGuiDir_Up : ImGuiDir_Down, ARROW_SCALE);
        }
 
        // Handle clicking on column header to adjust Sort Order
        if (pressed && table->ReorderColumn != column_n)
        {
            ImGuiSortDirection sort_direction = TableGetColumnNextSortDirection(column);
            TableSetColumnSortDirection(column_n, sort_direction, g.IO.KeyShift);
        }
    }
 
    // Render clipped label. Clipping here ensure that in the majority of situations, all our header cells will
    // be merged into a single draw call.
    //window->DrawList->AddCircleFilled(ImVec2(ellipsis_max, label_pos.y), 40, IM_COL32_WHITE);
    RenderTextEllipsis(window->DrawList, label_pos, ImVec2(ellipsis_max, label_pos.y + label_height + g.Style.FramePadding.y), ellipsis_max, ellipsis_max, label, label_end, &label_size);
 
    const bool text_clipped = label_size.x > (ellipsis_max - label_pos.x);
    if (text_clipped && hovered && g.HoveredIdNotActiveTimer > g.TooltipSlowDelay)
        SetTooltip("%.*s", (int)(label_end - label), label);
 
    // We don't use BeginPopupContextItem() because we want the popup to stay up even after the column is hidden
    if (IsMouseReleased(1) && IsItemHovered())
        TableOpenContextMenu(column_n);
}

References ImGuiContext::ActiveId, ButtonBehavior(), CalcTextSize(), ImGuiStyle::CellPadding, ImGuiTable::CellPaddingY, col(), ImGuiTable::Columns, ImGuiTableColumn::ContentMaxXHeadersIdeal, ImGuiTableColumn::ContentMaxXHeadersUsed, ImGuiTable::ContextPopupColumn, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiContext::DragDropActive, ImGuiWindow::DrawList, FindRenderedTextEnd(), ImGuiTableColumn::Flags, ImGuiTable::Flags, ImGuiContext::FontSize, ImGuiStyle::FramePadding, ImGuiTable::FreezeColumnsRequest, GetColorU32(), ImGuiWindow::GetID(), GImGui, ImGuiTable::HeldHeaderColumn, ImGuiContext::HoveredIdNotActiveTimer, IM_ARRAYSIZE, IM_ASSERT, ImFloor(), ImFormatString(), ImGuiButtonFlags_AllowItemOverlap, ImGuiCol_Header, ImGuiCol_HeaderActive, ImGuiCol_HeaderHovered, ImGuiCol_TableHeaderBg, ImGuiCol_Text, ImGuiDir_Down, ImGuiDir_Up, ImGuiNavHighlightFlags_NoRounding, ImGuiNavHighlightFlags_TypeThin, ImGuiSortDirection_Ascending, ImGuiTableBgTarget_CellBg, ImGuiTableColumnFlags_NoReorder, ImGuiTableColumnFlags_NoSort, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Sortable, ImGuiTableRowFlags_Headers, ImMax(), ImGuiTableColumn::IndexWithinEnabledSet, ImGuiTable::InstanceCurrent, ImGuiTable::InstanceInteracted, ImGuiContext::IO, ImGuiTable::IsContextPopupOpen, IsItemHovered(), IsMouseDragging(), IsMouseReleased(), ItemAdd(), ImGuiStyle::ItemInnerSpacing, ItemSize(), ImGuiStyle::ItemSpacing, ImGuiIO::KeyShift, ImRect::Max, ImRect::Min, ImGuiIO::MouseDelta, ImGuiIO::MousePos, ImGuiTableColumn::NextEnabledColumn, PopStyleColor(), ImGuiTableColumn::PrevEnabledColumn, PushStyleColor(), RenderArrow(), RenderNavHighlight(), RenderText(), RenderTextEllipsis(), ImGuiTable::ReorderColumn, ImGuiTable::ReorderColumnDir, ImGuiTable::RowFlags, ImGuiTable::RowMinHeight, SetItemAllowOverlap(), SetTooltip(), ImGuiWindow::SkipItems, ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortOrder, ImGuiContext::Style, TableGetCellBgRect(), TableGetColumnNextSortDirection(), TableOpenContextMenu(), TableSetBgColor(), TableSetColumnSortDirection(), ImGuiContext::TooltipSlowDelay, ImGuiTableColumn::WorkMaxX, ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindowTables(), and TableHeadersRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableHeadersRow()

void ImGui::TableHeadersRow ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Need to call TableHeadersRow() after BeginTable()!");
 
    // Layout if not already done (this is automatically done by TableNextRow, we do it here solely to facilitate stepping in debugger as it is frequent to step in TableUpdateLayout)
    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);
 
    // Open row
    const float row_y1 = GetCursorScreenPos().y;
    const float row_height = TableGetHeaderRowHeight();
    TableNextRow(ImGuiTableRowFlags_Headers, row_height);
    if (table->HostSkipItems) // Merely an optimization, you may skip in your own code.
        return;
 
    const int columns_count = TableGetColumnCount();
    for (int column_n = 0; column_n < columns_count; column_n++)
    {
        if (!TableSetColumnIndex(column_n))
            continue;
 
        // Push an id to allow unnamed labels (generally accidental, but let's behave nicely with them)
        // - in your own code you may omit the PushID/PopID all-together, provided you know they won't collide
        // - table->InstanceCurrent is only >0 when we use multiple BeginTable/EndTable calls with same identifier.
        const char* name = TableGetColumnName(column_n);
        PushID(table->InstanceCurrent * table->ColumnsCount + column_n);
        TableHeader(name);
        PopID();
    }
 
    // Allow opening popup from the right-most section after the last column.
    ImVec2 mouse_pos = ImGui::GetMousePos();
    if (IsMouseReleased(1) && TableGetHoveredColumn() == columns_count)
        if (mouse_pos.y >= row_y1 && mouse_pos.y < row_y1 + row_height)
            TableOpenContextMenu(-1); // Will open a non-column-specific popup.
}

References ImGuiTable::ColumnsCount, ImGuiContext::CurrentTable, GetCursorScreenPos(), GetMousePos(), GImGui, ImGuiTable::HostSkipItems, IM_ASSERT, ImGuiTableRowFlags_Headers, ImGuiTable::InstanceCurrent, ImGuiTable::IsLayoutLocked, IsMouseReleased(), PopID(), PushID(), TableGetColumnCount(), TableGetColumnName(), TableGetHeaderRowHeight(), TableGetHoveredColumn(), TableHeader(), TableNextRow(), TableOpenContextMenu(), TableSetColumnIndex(), TableUpdateLayout(), and ImVec2::y.

Referenced by ShowDemoWindowTables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableLoadSettings()

void ImGui::TableLoadSettings ( ImGuiTable * table )

{
    ImGuiContext& g = *GImGui;
    table->IsSettingsRequestLoad = false;
    if (table->Flags & ImGuiTableFlags_NoSavedSettings)
        return;
 
    // Bind settings
    ImGuiTableSettings* settings;
    if (table->SettingsOffset == -1)
    {
        settings = TableSettingsFindByID(table->ID);
        if (settings == NULL)
            return;
        if (settings->ColumnsCount != table->ColumnsCount) // Allow settings if columns count changed. We could otherwise decide to return...
            table->IsSettingsDirty = true;
        table->SettingsOffset = g.SettingsTables.offset_from_ptr(settings);
    }
    else
    {
        settings = TableGetBoundSettings(table);
    }
 
    table->SettingsLoadedFlags = settings->SaveFlags;
    table->RefScale = settings->RefScale;
 
    // Serialize ImGuiTableSettings/ImGuiTableColumnSettings into ImGuiTable/ImGuiTableColumn
    ImGuiTableColumnSettings* column_settings = settings->GetColumnSettings();
    ImU64 display_order_mask = 0;
    for (int data_n = 0; data_n < settings->ColumnsCount; data_n++, column_settings++)
    {
        int column_n = column_settings->Index;
        if (column_n < 0 || column_n >= table->ColumnsCount)
            continue;
 
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (settings->SaveFlags & ImGuiTableFlags_Resizable)
        {
            if (column_settings->IsStretch)
                column->StretchWeight = column_settings->WidthOrWeight;
            else
                column->WidthRequest = column_settings->WidthOrWeight;
            column->AutoFitQueue = 0x00;
        }
        if (settings->SaveFlags & ImGuiTableFlags_Reorderable)
            column->DisplayOrder = column_settings->DisplayOrder;
        else
            column->DisplayOrder = (ImGuiTableColumnIdx)column_n;
        display_order_mask |= (ImU64)1 << column->DisplayOrder;
        column->IsEnabled = column->IsEnabledNextFrame = column_settings->IsEnabled;
        column->SortOrder = column_settings->SortOrder;
        column->SortDirection = column_settings->SortDirection;
    }
 
    // Validate and fix invalid display order data
    const ImU64 expected_display_order_mask = (settings->ColumnsCount == 64) ? ~0 : ((ImU64)1 << settings->ColumnsCount) - 1;
    if (display_order_mask != expected_display_order_mask)
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
            table->Columns[column_n].DisplayOrder = (ImGuiTableColumnIdx)column_n;
 
    // Rebuild index
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        table->DisplayOrderToIndex[table->Columns[column_n].DisplayOrder] = (ImGuiTableColumnIdx)column_n;
}

References ImGuiTableColumn::AutoFitQueue, ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableSettings::ColumnsCount, ImGuiTableColumn::DisplayOrder, ImGuiTableColumnSettings::DisplayOrder, ImGuiTable::DisplayOrderToIndex, ImGuiTable::Flags, ImGuiTableSettings::GetColumnSettings(), GImGui, ImGuiTable::ID, ImGuiTableFlags_NoSavedSettings, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImGuiTableColumnSettings::Index, ImGuiTableColumn::IsEnabled, ImGuiTableColumnSettings::IsEnabled, ImGuiTableColumn::IsEnabledNextFrame, ImGuiTable::IsSettingsDirty, ImGuiTable::IsSettingsRequestLoad, ImGuiTableColumnSettings::IsStretch, ImChunkStream< T >::offset_from_ptr(), ImGuiTable::RefScale, ImGuiTableSettings::RefScale, ImGuiTableSettings::SaveFlags, ImGuiTable::SettingsLoadedFlags, ImGuiTable::SettingsOffset, ImGuiContext::SettingsTables, ImGuiTableColumn::SortDirection, ImGuiTableColumnSettings::SortDirection, ImGuiTableColumn::SortOrder, ImGuiTableColumnSettings::SortOrder, ImGuiTableColumn::StretchWeight, TableGetBoundSettings(), TableSettingsFindByID(), ImGuiTableColumnSettings::WidthOrWeight, and ImGuiTableColumn::WidthRequest.

Referenced by BeginTableEx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableMergeDrawChannels()

void ImGui::TableMergeDrawChannels ( ImGuiTable * table )

{
    ImGuiContext& g = *GImGui;
    ImDrawListSplitter* splitter = table->DrawSplitter;
    const bool has_freeze_v = (table->FreezeRowsCount > 0);
    const bool has_freeze_h = (table->FreezeColumnsCount > 0);
    IM_ASSERT(splitter->_Current == 0);
 
    // Track which groups we are going to attempt to merge, and which channels goes into each group.
    struct MergeGroup
    {
        ImRect  ClipRect;
        int     ChannelsCount;
        ImBitArray<IMGUI_TABLE_MAX_DRAW_CHANNELS> ChannelsMask;
 
        MergeGroup() { ChannelsCount = 0; }
    };
    int merge_group_mask = 0x00;
    MergeGroup merge_groups[4];
 
    // 1. Scan channels and take note of those which can be merged
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        if ((table->VisibleMaskByIndex & ((ImU64)1 << column_n)) == 0)
            continue;
        ImGuiTableColumn* column = &table->Columns[column_n];
 
        const int merge_group_sub_count = has_freeze_v ? 2 : 1;
        for (int merge_group_sub_n = 0; merge_group_sub_n < merge_group_sub_count; merge_group_sub_n++)
        {
            const int channel_no = (merge_group_sub_n == 0) ? column->DrawChannelFrozen : column->DrawChannelUnfrozen;
 
            // Don't attempt to merge if there are multiple draw calls within the column
            ImDrawChannel* src_channel = &splitter->_Channels[channel_no];
            if (src_channel->_CmdBuffer.Size > 0 && src_channel->_CmdBuffer.back().ElemCount == 0)
                src_channel->_CmdBuffer.pop_back();
            if (src_channel->_CmdBuffer.Size != 1)
                continue;
 
            // Find out the width of this merge group and check if it will fit in our column
            // (note that we assume that rendering didn't stray on the left direction. we should need a CursorMinPos to detect it)
            if (!(column->Flags & ImGuiTableColumnFlags_NoClip))
            {
                float content_max_x;
                if (!has_freeze_v)
                    content_max_x = ImMax(column->ContentMaxXUnfrozen, column->ContentMaxXHeadersUsed); // No row freeze
                else if (merge_group_sub_n == 0)
                    content_max_x = ImMax(column->ContentMaxXFrozen, column->ContentMaxXHeadersUsed);   // Row freeze: use width before freeze
                else
                    content_max_x = column->ContentMaxXUnfrozen;                                        // Row freeze: use width after freeze
                if (content_max_x > column->ClipRect.Max.x)
                    continue;
            }
 
            const int merge_group_n = (has_freeze_h && column_n < table->FreezeColumnsCount ? 0 : 1) + (has_freeze_v && merge_group_sub_n == 0 ? 0 : 2);
            IM_ASSERT(channel_no < IMGUI_TABLE_MAX_DRAW_CHANNELS);
            MergeGroup* merge_group = &merge_groups[merge_group_n];
            if (merge_group->ChannelsCount == 0)
                merge_group->ClipRect = ImRect(+FLT_MAX, +FLT_MAX, -FLT_MAX, -FLT_MAX);
            merge_group->ChannelsMask.SetBit(channel_no);
            merge_group->ChannelsCount++;
            merge_group->ClipRect.Add(src_channel->_CmdBuffer[0].ClipRect);
            merge_group_mask |= (1 << merge_group_n);
        }
 
        // Invalidate current draw channel
        // (we don't clear DrawChannelFrozen/DrawChannelUnfrozen solely to facilitate debugging/later inspection of data)
        column->DrawChannelCurrent = (ImGuiTableDrawChannelIdx)-1;
    }
 
    // [DEBUG] Display merge groups
#if 0
    if (g.IO.KeyShift)
        for (int merge_group_n = 0; merge_group_n < IM_ARRAYSIZE(merge_groups); merge_group_n++)
        {
            MergeGroup* merge_group = &merge_groups[merge_group_n];
            if (merge_group->ChannelsCount == 0)
                continue;
            char buf[32];
            ImFormatString(buf, 32, "MG%d:%d", merge_group_n, merge_group->ChannelsCount);
            ImVec2 text_pos = merge_group->ClipRect.Min + ImVec2(4, 4);
            ImVec2 text_size = CalcTextSize(buf, NULL);
            GetForegroundDrawList()->AddRectFilled(text_pos, text_pos + text_size, IM_COL32(0, 0, 0, 255));
            GetForegroundDrawList()->AddText(text_pos, IM_COL32(255, 255, 0, 255), buf, NULL);
            GetForegroundDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 255, 0, 255));
        }
#endif
 
    // 2. Rewrite channel list in our preferred order
    if (merge_group_mask != 0)
    {
        // We skip channel 0 (Bg0/Bg1) and 1 (Bg2 frozen) from the shuffling since they won't move - see channels allocation in TableSetupDrawChannels().
        const int LEADING_DRAW_CHANNELS = 2;
        g.DrawChannelsTempMergeBuffer.resize(splitter->_Count - LEADING_DRAW_CHANNELS); // Use shared temporary storage so the allocation gets amortized
        ImDrawChannel* dst_tmp = g.DrawChannelsTempMergeBuffer.Data;
        ImBitArray<IMGUI_TABLE_MAX_DRAW_CHANNELS> remaining_mask;                       // We need 132-bit of storage
        remaining_mask.SetBitRange(LEADING_DRAW_CHANNELS, splitter->_Count);
        remaining_mask.ClearBit(table->Bg2DrawChannelUnfrozen);
        IM_ASSERT(has_freeze_v == false || table->Bg2DrawChannelUnfrozen != TABLE_DRAW_CHANNEL_BG2_FROZEN);
        int remaining_count = splitter->_Count - (has_freeze_v ? LEADING_DRAW_CHANNELS + 1 : LEADING_DRAW_CHANNELS);
        //ImRect host_rect = (table->InnerWindow == table->OuterWindow) ? table->InnerClipRect : table->HostClipRect;
        ImRect host_rect = table->HostClipRect;
        for (int merge_group_n = 0; merge_group_n < IM_ARRAYSIZE(merge_groups); merge_group_n++)
        {
            if (int merge_channels_count = merge_groups[merge_group_n].ChannelsCount)
            {
                MergeGroup* merge_group = &merge_groups[merge_group_n];
                ImRect merge_clip_rect = merge_group->ClipRect;
 
                // Extend outer-most clip limits to match those of host, so draw calls can be merged even if
                // outer-most columns have some outer padding offsetting them from their parent ClipRect.
                // The principal cases this is dealing with are:
                // - On a same-window table (not scrolling = single group), all fitting columns ClipRect -> will extend and match host ClipRect -> will merge
                // - Columns can use padding and have left-most ClipRect.Min.x and right-most ClipRect.Max.x != from host ClipRect -> will extend and match host ClipRect -> will merge
                // FIXME-TABLE FIXME-WORKRECT: We are wasting a merge opportunity on tables without scrolling if column doesn't fit
                // within host clip rect, solely because of the half-padding difference between window->WorkRect and window->InnerClipRect.
                if ((merge_group_n & 1) == 0 || !has_freeze_h)
                    merge_clip_rect.Min.x = ImMin(merge_clip_rect.Min.x, host_rect.Min.x);
                if ((merge_group_n & 2) == 0 || !has_freeze_v)
                    merge_clip_rect.Min.y = ImMin(merge_clip_rect.Min.y, host_rect.Min.y);
                if ((merge_group_n & 1) != 0)
                    merge_clip_rect.Max.x = ImMax(merge_clip_rect.Max.x, host_rect.Max.x);
                if ((merge_group_n & 2) != 0 && (table->Flags & ImGuiTableFlags_NoHostExtendY) == 0)
                    merge_clip_rect.Max.y = ImMax(merge_clip_rect.Max.y, host_rect.Max.y);
#if 0
                GetOverlayDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 0, 0, 200), 0.0f, 0, 1.0f);
                GetOverlayDrawList()->AddLine(merge_group->ClipRect.Min, merge_clip_rect.Min, IM_COL32(255, 100, 0, 200));
                GetOverlayDrawList()->AddLine(merge_group->ClipRect.Max, merge_clip_rect.Max, IM_COL32(255, 100, 0, 200));
#endif
                remaining_count -= merge_group->ChannelsCount;
                for (int n = 0; n < IM_ARRAYSIZE(remaining_mask.Storage); n++)
                    remaining_mask.Storage[n] &= ~merge_group->ChannelsMask.Storage[n];
                for (int n = 0; n < splitter->_Count && merge_channels_count != 0; n++)
                {
                    // Copy + overwrite new clip rect
                    if (!merge_group->ChannelsMask.TestBit(n))
                        continue;
                    merge_group->ChannelsMask.ClearBit(n);
                    merge_channels_count--;
 
                    ImDrawChannel* channel = &splitter->_Channels[n];
                    IM_ASSERT(channel->_CmdBuffer.Size == 1 && merge_clip_rect.Contains(ImRect(channel->_CmdBuffer[0].ClipRect)));
                    channel->_CmdBuffer[0].ClipRect = merge_clip_rect.ToVec4();
                    memcpy(dst_tmp++, channel, sizeof(ImDrawChannel));
                }
            }
 
            // Make sure Bg2DrawChannelUnfrozen appears in the middle of our groups (whereas Bg0/Bg1 and Bg2 frozen are fixed to 0 and 1)
            if (merge_group_n == 1 && has_freeze_v)
                memcpy(dst_tmp++, &splitter->_Channels[table->Bg2DrawChannelUnfrozen], sizeof(ImDrawChannel));
        }
 
        // Append unmergeable channels that we didn't reorder at the end of the list
        for (int n = 0; n < splitter->_Count && remaining_count != 0; n++)
        {
            if (!remaining_mask.TestBit(n))
                continue;
            ImDrawChannel* channel = &splitter->_Channels[n];
            memcpy(dst_tmp++, channel, sizeof(ImDrawChannel));
            remaining_count--;
        }
        IM_ASSERT(dst_tmp == g.DrawChannelsTempMergeBuffer.Data + g.DrawChannelsTempMergeBuffer.Size);
        memcpy(splitter->_Channels.Data + LEADING_DRAW_CHANNELS, g.DrawChannelsTempMergeBuffer.Data, (splitter->_Count - LEADING_DRAW_CHANNELS) * sizeof(ImDrawChannel));
    }
}

Referenced by EndTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableNextColumn()

bool ImGui::TableNextColumn ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return false;
 
    if (table->IsInsideRow && table->CurrentColumn + 1 < table->ColumnsCount)
    {
        if (table->CurrentColumn != -1)
            TableEndCell(table);
        TableBeginCell(table, table->CurrentColumn + 1);
    }
    else
    {
        TableNextRow();
        TableBeginCell(table, 0);
    }
 
    // Return whether the column is visible. User may choose to skip submitting items based on this return value,
    // however they shouldn't skip submitting for columns that may have the tallest contribution to row height.
    int column_n = table->CurrentColumn;
    return (table->RequestOutputMaskByIndex & ((ImU64)1 << column_n)) != 0;
}

References ImGuiTable::ColumnsCount, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, GImGui, ImGuiTable::IsInsideRow, ImGuiTable::RequestOutputMaskByIndex, TableBeginCell(), TableEndCell(), and TableNextRow().

Referenced by ShowDemoWindow(), ShowDemoWindowLayout(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableNextRow()

void ImGui::TableNextRow	(	ImGuiTableRowFlags	row_flags = `0`,
		float	min_row_height = `0.0f`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
 
    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);
    if (table->IsInsideRow)
        TableEndRow(table);
 
    table->LastRowFlags = table->RowFlags;
    table->RowFlags = row_flags;
    table->RowMinHeight = row_min_height;
    TableBeginRow(table);
 
    // We honor min_row_height requested by user, but cannot guarantee per-row maximum height,
    // because that would essentially require a unique clipping rectangle per-cell.
    table->RowPosY2 += table->CellPaddingY * 2.0f;
    table->RowPosY2 = ImMax(table->RowPosY2, table->RowPosY1 + row_min_height);
 
    // Disable output until user calls TableNextColumn()
    table->InnerWindow->SkipItems = true;
}

References ImGuiTable::CellPaddingY, ImGuiContext::CurrentTable, GImGui, ImMax(), ImGuiTable::InnerWindow, ImGuiTable::IsInsideRow, ImGuiTable::IsLayoutLocked, ImGuiTable::LastRowFlags, ImGuiTable::RowFlags, ImGuiTable::RowMinHeight, ImGuiTable::RowPosY1, ImGuiTable::RowPosY2, ImGuiWindow::SkipItems, TableBeginRow(), TableEndRow(), and TableUpdateLayout().

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::add_row_to_table(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowPlaceholderObject(), TableHeadersRow(), and TableNextColumn().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableOpenContextMenu()

void ImGui::TableOpenContextMenu ( int column_n = -1 )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (column_n == -1 && table->CurrentColumn != -1)   // When called within a column automatically use this one (for consistency)
        column_n = table->CurrentColumn;
    if (column_n == table->ColumnsCount)                // To facilitate using with TableGetHoveredColumn()
        column_n = -1;
    IM_ASSERT(column_n >= -1 && column_n < table->ColumnsCount);
    if (table->Flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable))
    {
        table->IsContextPopupOpen = true;
        table->ContextPopupColumn = (ImGuiTableColumnIdx)column_n;
        table->InstanceInteracted = table->InstanceCurrent;
        const ImGuiID context_menu_id = ImHashStr("##ContextMenu", 0, table->ID);
        OpenPopupEx(context_menu_id, ImGuiPopupFlags_None);
    }
}

References ImGuiTable::ColumnsCount, ImGuiTable::ContextPopupColumn, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, ImGuiTable::Flags, GImGui, ImGuiTable::ID, IM_ASSERT, ImGuiPopupFlags_None, ImGuiTableFlags_Hideable, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImHashStr(), ImGuiTable::InstanceCurrent, ImGuiTable::InstanceInteracted, ImGuiTable::IsContextPopupOpen, and OpenPopupEx().

Referenced by EndTable(), TableHeader(), and TableHeadersRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TablePopBackgroundChannel()

void ImGui::TablePopBackgroundChannel ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiTable* table = g.CurrentTable;
    ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
 
    // Optimization: avoid PopClipRect() + SetCurrentChannel()
    SetWindowClipRectBeforeSetChannel(window, table->HostBackupInnerClipRect);
    table->DrawSplitter->SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
}

References ImGuiTable::Columns, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiTableColumn::DrawChannelCurrent, ImGuiWindow::DrawList, ImGuiTable::DrawSplitter, GImGui, ImGuiTable::HostBackupInnerClipRect, ImDrawListSplitter::SetCurrentChannel(), and SetWindowClipRectBeforeSetChannel().

Referenced by Slic3r::GUI::selectable(), and Selectable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TablePushBackgroundChannel()

void ImGui::TablePushBackgroundChannel ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiTable* table = g.CurrentTable;
 
    // Optimization: avoid SetCurrentChannel() + PushClipRect()
    table->HostBackupInnerClipRect = window->ClipRect;
    SetWindowClipRectBeforeSetChannel(window, table->Bg2ClipRectForDrawCmd);
    table->DrawSplitter->SetCurrentChannel(window->DrawList, table->Bg2DrawChannelCurrent);
}

References ImGuiTable::Bg2ClipRectForDrawCmd, ImGuiTable::Bg2DrawChannelCurrent, ImGuiWindow::ClipRect, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiWindow::DrawList, ImGuiTable::DrawSplitter, GImGui, ImGuiTable::HostBackupInnerClipRect, ImDrawListSplitter::SetCurrentChannel(), and SetWindowClipRectBeforeSetChannel().

Referenced by Slic3r::GUI::selectable(), and Selectable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableRemove()

void ImGui::TableRemove ( ImGuiTable * table )

{
    //IMGUI_DEBUG_LOG("TableRemove() id=0x%08X\n", table->ID);
    ImGuiContext& g = *GImGui;
    int table_idx = g.Tables.GetIndex(table);
    //memset(table->RawData.Data, 0, table->RawData.size_in_bytes());
    //memset(table, 0, sizeof(ImGuiTable));
    g.Tables.Remove(table->ID, table);
    g.TablesLastTimeActive[table_idx] = -1.0f;
}

References ImPool< T >::GetIndex(), GImGui, ImGuiTable::ID, ImPool< T >::Remove(), ImGuiContext::Tables, and ImGuiContext::TablesLastTimeActive.

Here is the call graph for this function:

◆ TableResetSettings()

void ImGui::TableResetSettings ( ImGuiTable * table )

{
    table->IsInitializing = table->IsSettingsDirty = true;
    table->IsResetAllRequest = false;
    table->IsSettingsRequestLoad = false;                   // Don't reload from ini
    table->SettingsLoadedFlags = ImGuiTableFlags_None;      // Mark as nothing loaded so our initialized data becomes authoritative
}

References ImGuiTableFlags_None, ImGuiTable::IsInitializing, ImGuiTable::IsResetAllRequest, ImGuiTable::IsSettingsDirty, ImGuiTable::IsSettingsRequestLoad, and ImGuiTable::SettingsLoadedFlags.

Referenced by BeginTableEx().

Here is the caller graph for this function:

◆ TableSaveSettings()

void ImGui::TableSaveSettings ( ImGuiTable * table )

{
    table->IsSettingsDirty = false;
    if (table->Flags & ImGuiTableFlags_NoSavedSettings)
        return;
 
    // Bind or create settings data
    ImGuiContext& g = *GImGui;
    ImGuiTableSettings* settings = TableGetBoundSettings(table);
    if (settings == NULL)
    {
        settings = TableSettingsCreate(table->ID, table->ColumnsCount);
        table->SettingsOffset = g.SettingsTables.offset_from_ptr(settings);
    }
    settings->ColumnsCount = (ImGuiTableColumnIdx)table->ColumnsCount;
 
    // Serialize ImGuiTable/ImGuiTableColumn into ImGuiTableSettings/ImGuiTableColumnSettings
    IM_ASSERT(settings->ID == table->ID);
    IM_ASSERT(settings->ColumnsCount == table->ColumnsCount && settings->ColumnsCountMax >= settings->ColumnsCount);
    ImGuiTableColumn* column = table->Columns.Data;
    ImGuiTableColumnSettings* column_settings = settings->GetColumnSettings();
 
    bool save_ref_scale = false;
    settings->SaveFlags = ImGuiTableFlags_None;
    for (int n = 0; n < table->ColumnsCount; n++, column++, column_settings++)
    {
        const float width_or_weight = (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? column->StretchWeight : column->WidthRequest;
        column_settings->WidthOrWeight = width_or_weight;
        column_settings->Index = (ImGuiTableColumnIdx)n;
        column_settings->DisplayOrder = column->DisplayOrder;
        column_settings->SortOrder = column->SortOrder;
        column_settings->SortDirection = column->SortDirection;
        column_settings->IsEnabled = column->IsEnabled;
        column_settings->IsStretch = (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? 1 : 0;
        if ((column->Flags & ImGuiTableColumnFlags_WidthStretch) == 0)
            save_ref_scale = true;
 
        // We skip saving some data in the .ini file when they are unnecessary to restore our state.
        // Note that fixed width where initial width was derived from auto-fit will always be saved as InitStretchWeightOrWidth will be 0.0f.
        // FIXME-TABLE: We don't have logic to easily compare SortOrder to DefaultSortOrder yet so it's always saved when present.
        if (width_or_weight != column->InitStretchWeightOrWidth)
            settings->SaveFlags |= ImGuiTableFlags_Resizable;
        if (column->DisplayOrder != n)
            settings->SaveFlags |= ImGuiTableFlags_Reorderable;
        if (column->SortOrder != -1)
            settings->SaveFlags |= ImGuiTableFlags_Sortable;
        if (column->IsEnabled != ((column->Flags & ImGuiTableColumnFlags_DefaultHide) == 0))
            settings->SaveFlags |= ImGuiTableFlags_Hideable;
    }
    settings->SaveFlags &= table->Flags;
    settings->RefScale = save_ref_scale ? table->RefScale : 0.0f;
 
    MarkIniSettingsDirty();
}

References ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableSettings::ColumnsCount, ImGuiTableSettings::ColumnsCountMax, ImSpan< T >::Data, ImGuiTableColumn::DisplayOrder, ImGuiTableColumnSettings::DisplayOrder, ImGuiTableColumn::Flags, ImGuiTable::Flags, ImGuiTableSettings::GetColumnSettings(), GImGui, ImGuiTable::ID, ImGuiTableSettings::ID, IM_ASSERT, ImGuiTableColumnFlags_DefaultHide, ImGuiTableColumnFlags_WidthStretch, ImGuiTableFlags_Hideable, ImGuiTableFlags_None, ImGuiTableFlags_NoSavedSettings, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImGuiTableFlags_Sortable, ImGuiTableColumnSettings::Index, ImGuiTableColumn::InitStretchWeightOrWidth, ImGuiTableColumn::IsEnabled, ImGuiTableColumnSettings::IsEnabled, ImGuiTable::IsSettingsDirty, ImGuiTableColumnSettings::IsStretch, MarkIniSettingsDirty(), ImChunkStream< T >::offset_from_ptr(), ImGuiTable::RefScale, ImGuiTableSettings::RefScale, ImGuiTableSettings::SaveFlags, ImGuiTable::SettingsOffset, ImGuiContext::SettingsTables, ImGuiTableColumn::SortDirection, ImGuiTableColumnSettings::SortDirection, ImGuiTableColumn::SortOrder, ImGuiTableColumnSettings::SortOrder, ImGuiTableColumn::StretchWeight, TableGetBoundSettings(), TableSettingsCreate(), ImGuiTableColumnSettings::WidthOrWeight, and ImGuiTableColumn::WidthRequest.

Referenced by EndTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetBgColor()

void ImGui::TableSetBgColor	(	ImGuiTableBgTarget	target,
		ImU32	color,
		int	column_n = `-1`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(target != ImGuiTableBgTarget_None);
 
    if (color == IM_COL32_DISABLE)
        color = 0;
 
    // We cannot draw neither the cell or row background immediately as we don't know the row height at this point in time.
    switch (target)
    {
    case ImGuiTableBgTarget_CellBg:
    {
        if (table->RowPosY1 > table->InnerClipRect.Max.y) // Discard
            return;
        if (column_n == -1)
            column_n = table->CurrentColumn;
        if ((table->VisibleMaskByIndex & ((ImU64)1 << column_n)) == 0)
            return;
        if (table->RowCellDataCurrent < 0 || table->RowCellData[table->RowCellDataCurrent].Column != column_n)
            table->RowCellDataCurrent++;
        ImGuiTableCellData* cell_data = &table->RowCellData[table->RowCellDataCurrent];
        cell_data->BgColor = color;
        cell_data->Column = (ImGuiTableColumnIdx)column_n;
        break;
    }
    case ImGuiTableBgTarget_RowBg0:
    case ImGuiTableBgTarget_RowBg1:
    {
        if (table->RowPosY1 > table->InnerClipRect.Max.y) // Discard
            return;
        IM_ASSERT(column_n == -1);
        int bg_idx = (target == ImGuiTableBgTarget_RowBg1) ? 1 : 0;
        table->RowBgColor[bg_idx] = color;
        break;
    }
    default:
        IM_ASSERT(0);
    }
}

References ImGuiTableCellData::BgColor, ImGuiTableCellData::Column, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, GImGui, IM_ASSERT, IM_COL32_DISABLE, ImGuiTableBgTarget_CellBg, ImGuiTableBgTarget_None, ImGuiTableBgTarget_RowBg0, ImGuiTableBgTarget_RowBg1, ImGuiTable::InnerClipRect, ImRect::Max, ImGuiTable::RowBgColor, ImGuiTable::RowCellData, ImGuiTable::RowCellDataCurrent, ImGuiTable::RowPosY1, ImGuiTable::VisibleMaskByIndex, and ImVec2::y.

Referenced by ShowDemoWindowTables(), TableBeginRow(), and TableHeader().

Here is the caller graph for this function:

◆ TableSetColumnEnabled()

void ImGui::TableSetColumnEnabled	(	int	column_n,
		bool	v
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL);
    if (!table)
        return;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
    ImGuiTableColumn* column = &table->Columns[column_n];
    column->IsEnabledNextFrame = enabled;
}

References ImGuiTable::Columns, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, GImGui, IM_ASSERT, and ImGuiTableColumn::IsEnabledNextFrame.

◆ TableSetColumnIndex()

bool ImGui::TableSetColumnIndex ( int column_n )

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return false;
 
    if (table->CurrentColumn != column_n)
    {
        if (table->CurrentColumn != -1)
            TableEndCell(table);
        IM_ASSERT(column_n >= 0 && table->ColumnsCount);
        TableBeginCell(table, column_n);
    }
 
    // Return whether the column is visible. User may choose to skip submitting items based on this return value,
    // however they shouldn't skip submitting for columns that may have the tallest contribution to row height.
    return (table->RequestOutputMaskByIndex & ((ImU64)1 << column_n)) != 0;
}

References ImGuiTable::ColumnsCount, ImGuiTable::CurrentColumn, ImGuiContext::CurrentTable, GImGui, IM_ASSERT, ImGuiTable::RequestOutputMaskByIndex, TableBeginCell(), and TableEndCell().

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::add_row_to_table(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GCodeViewer::render_legend(), ShowDemoWindowTables(), ShowPlaceholderObject(), and TableHeadersRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetColumnSortDirection()

void ImGui::TableSetColumnSortDirection	(	int	column_n,
		ImGuiSortDirection	sort_direction,
		bool	append_to_sort_specs
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
 
    if (!(table->Flags & ImGuiTableFlags_SortMulti))
        append_to_sort_specs = false;
    if (!(table->Flags & ImGuiTableFlags_SortTristate))
        IM_ASSERT(sort_direction != ImGuiSortDirection_None);
 
    ImGuiTableColumnIdx sort_order_max = 0;
    if (append_to_sort_specs)
        for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
            sort_order_max = ImMax(sort_order_max, table->Columns[other_column_n].SortOrder);
 
    ImGuiTableColumn* column = &table->Columns[column_n];
    column->SortDirection = (ImU8)sort_direction;
    if (column->SortDirection == ImGuiSortDirection_None)
        column->SortOrder = -1;
    else if (column->SortOrder == -1 || !append_to_sort_specs)
        column->SortOrder = append_to_sort_specs ? sort_order_max + 1 : 0;
 
    for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
    {
        ImGuiTableColumn* other_column = &table->Columns[other_column_n];
        if (other_column != column && !append_to_sort_specs)
            other_column->SortOrder = -1;
        TableFixColumnSortDirection(table, other_column);
    }
    table->IsSettingsDirty = true;
    table->IsSortSpecsDirty = true;
}

References ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiContext::CurrentTable, ImGuiTable::Flags, GImGui, IM_ASSERT, ImGuiSortDirection_None, ImGuiTableFlags_SortMulti, ImGuiTableFlags_SortTristate, ImMax(), ImGuiTable::IsSettingsDirty, ImGuiTable::IsSortSpecsDirty, ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortOrder, and TableFixColumnSortDirection().

Referenced by TableDrawContextMenu(), and TableHeader().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetColumnWidth()

void ImGui::TableSetColumnWidth	(	int	column_n,
		float	width
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && table->IsLayoutLocked == false);
    IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
    ImGuiTableColumn* column_0 = &table->Columns[column_n];
    float column_0_width = width;
 
    // Apply constraints early
    // Compare both requested and actual given width to avoid overwriting requested width when column is stuck (minimum size, bounded)
    IM_ASSERT(table->MinColumnWidth > 0.0f);
    const float min_width = table->MinColumnWidth;
    const float max_width = ImMax(min_width, TableGetMaxColumnWidth(table, column_n));
    column_0_width = ImClamp(column_0_width, min_width, max_width);
    if (column_0->WidthGiven == column_0_width || column_0->WidthRequest == column_0_width)
        return;
 
    //IMGUI_DEBUG_LOG("TableSetColumnWidth(%d, %.1f->%.1f)\n", column_0_idx, column_0->WidthGiven, column_0_width);
    ImGuiTableColumn* column_1 = (column_0->NextEnabledColumn != -1) ? &table->Columns[column_0->NextEnabledColumn] : NULL;
 
    // In this surprisingly not simple because of how we support mixing Fixed and multiple Stretch columns.
    // - All fixed: easy.
    // - All stretch: easy.
    // - One or more fixed + one stretch: easy.
    // - One or more fixed + more than one stretch: tricky.
    // Qt when manual resize is enabled only support a single _trailing_ stretch column.
 
    // When forwarding resize from Wn| to Fn+1| we need to be considerate of the _NoResize flag on Fn+1.
    // FIXME-TABLE: Find a way to rewrite all of this so interactions feel more consistent for the user.
    // Scenarios:
    // - F1 F2 F3  resize from F1| or F2|   --> ok: alter ->WidthRequested of Fixed column. Subsequent columns will be offset.
    // - F1 F2 F3  resize from F3|          --> ok: alter ->WidthRequested of Fixed column. If active, ScrollX extent can be altered.
    // - F1 F2 W3  resize from F1| or F2|   --> ok: alter ->WidthRequested of Fixed column. If active, ScrollX extent can be altered, but it doesn't make much sense as the Stretch column will always be minimal size.
    // - F1 F2 W3  resize from W3|          --> ok: no-op (disabled by Resize Rule 1)
    // - W1 W2 W3  resize from W1| or W2|   --> ok
    // - W1 W2 W3  resize from W3|          --> ok: no-op (disabled by Resize Rule 1)
    // - W1 F2 F3  resize from F3|          --> ok: no-op (disabled by Resize Rule 1)
    // - W1 F2     resize from F2|          --> ok: no-op (disabled by Resize Rule 1)
    // - W1 W2 F3  resize from W1| or W2|   --> ok
    // - W1 F2 W3  resize from W1| or F2|   --> ok
    // - F1 W2 F3  resize from W2|          --> ok
    // - F1 W3 F2  resize from W3|          --> ok
    // - W1 F2 F3  resize from W1|          --> ok: equivalent to resizing |F2. F3 will not move.
    // - W1 F2 F3  resize from F2|          --> ok
    // All resizes from a Wx columns are locking other columns.
 
    // Possible improvements:
    // - W1 W2 W3  resize W1|               --> to not be stuck, both W2 and W3 would stretch down. Seems possible to fix. Would be most beneficial to simplify resize of all-weighted columns.
    // - W3 F1 F2  resize W3|               --> to not be stuck past F1|, both F1 and F2 would need to stretch down, which would be lossy or ambiguous. Seems hard to fix.
 
    // [Resize Rule 1] Can't resize from right of right-most visible column if there is any Stretch column. Implemented in TableUpdateLayout().
 
    // If we have all Fixed columns OR resizing a Fixed column that doesn't come after a Stretch one, we can do an offsetting resize.
    // This is the preferred resize path
    if (column_0->Flags & ImGuiTableColumnFlags_WidthFixed)
        if (!column_1 || table->LeftMostStretchedColumn == -1 || table->Columns[table->LeftMostStretchedColumn].DisplayOrder >= column_0->DisplayOrder)
        {
            column_0->WidthRequest = column_0_width;
            table->IsSettingsDirty = true;
            return;
        }
 
    // We can also use previous column if there's no next one (this is used when doing an auto-fit on the right-most stretch column)
    if (column_1 == NULL)
        column_1 = (column_0->PrevEnabledColumn != -1) ? &table->Columns[column_0->PrevEnabledColumn] : NULL;
    if (column_1 == NULL)
        return;
 
    // Resizing from right-side of a Stretch column before a Fixed column forward sizing to left-side of fixed column.
    // (old_a + old_b == new_a + new_b) --> (new_a == old_a + old_b - new_b)
    float column_1_width = ImMax(column_1->WidthRequest - (column_0_width - column_0->WidthRequest), min_width);
    column_0_width = column_0->WidthRequest + column_1->WidthRequest - column_1_width;
    IM_ASSERT(column_0_width > 0.0f && column_1_width > 0.0f);
    column_0->WidthRequest = column_0_width;
    column_1->WidthRequest = column_1_width;
    if ((column_0->Flags | column_1->Flags) & ImGuiTableColumnFlags_WidthStretch)
        TableUpdateColumnsWeightFromWidth(table);
    table->IsSettingsDirty = true;
}

References ImGuiTable::Columns, ImGuiContext::CurrentTable, ImGuiTableColumn::DisplayOrder, ImGuiTableColumn::Flags, GImGui, IM_ASSERT, ImClamp(), ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_WidthStretch, ImMax(), ImGuiTable::IsLayoutLocked, ImGuiTable::IsSettingsDirty, ImGuiTable::LeftMostStretchedColumn, ImGuiTable::MinColumnWidth, ImGuiTableColumn::NextEnabledColumn, ImGuiTableColumn::PrevEnabledColumn, TableGetMaxColumnWidth(), TableUpdateColumnsWeightFromWidth(), ImGuiTableColumn::WidthGiven, and ImGuiTableColumn::WidthRequest.

Referenced by TableBeginApplyRequests().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetColumnWidthAutoAll()

void ImGui::TableSetColumnWidthAutoAll ( ImGuiTable * table )

{
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (!column->IsEnabled && !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) // Cannot reset weight of hidden stretch column
            continue;
        column->CannotSkipItemsQueue = (1 << 0);
        column->AutoFitQueue = (1 << 1);
    }
}

References ImGuiTableColumn::AutoFitQueue, ImGuiTableColumn::CannotSkipItemsQueue, ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableColumn::Flags, ImGuiTableColumnFlags_WidthStretch, and ImGuiTableColumn::IsEnabled.

Referenced by TableDrawContextMenu().

Here is the caller graph for this function:

◆ TableSetColumnWidthAutoSingle()

void ImGui::TableSetColumnWidthAutoSingle	(	ImGuiTable *	table,
		int	column_n
	)

{
    // Single auto width uses auto-fit
    ImGuiTableColumn* column = &table->Columns[column_n];
    if (!column->IsEnabled)
        return;
    column->CannotSkipItemsQueue = (1 << 0);
    table->AutoFitSingleColumn = (ImGuiTableColumnIdx)column_n;
}

References ImGuiTable::AutoFitSingleColumn, ImGuiTableColumn::CannotSkipItemsQueue, ImGuiTable::Columns, and ImGuiTableColumn::IsEnabled.

Referenced by TableDrawContextMenu(), and TableUpdateBorders().

Here is the caller graph for this function:

◆ TableSettingsCreate()

ImGuiTableSettings * ImGui::TableSettingsCreate	(	ImGuiID	id,
		int	columns_count
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTableSettings* settings = g.SettingsTables.alloc_chunk(TableSettingsCalcChunkSize(columns_count));
    TableSettingsInit(settings, id, columns_count, columns_count);
    return settings;
}

References ImChunkStream< T >::alloc_chunk(), GImGui, ImGuiContext::SettingsTables, TableSettingsCalcChunkSize(), and TableSettingsInit().

Referenced by TableSaveSettings(), and TableSettingsHandler_ReadOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSettingsFindByID()

ImGuiTableSettings * ImGui::TableSettingsFindByID ( ImGuiID id )

{
    // FIXME-OPT: Might want to store a lookup map for this?
    ImGuiContext& g = *GImGui;
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
        if (settings->ID == id)
            return settings;
    return NULL;
}

References ImChunkStream< T >::begin(), GImGui, ImChunkStream< T >::next_chunk(), and ImGuiContext::SettingsTables.

Referenced by TableLoadSettings(), and TableSettingsHandler_ReadOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSettingsInstallHandler()

void ImGui::TableSettingsInstallHandler ( ImGuiContext * context )

{
    ImGuiContext& g = *context;
    ImGuiSettingsHandler ini_handler;
    ini_handler.TypeName = "Table";
    ini_handler.TypeHash = ImHashStr("Table");
    ini_handler.ClearAllFn = TableSettingsHandler_ClearAll;
    ini_handler.ReadOpenFn = TableSettingsHandler_ReadOpen;
    ini_handler.ReadLineFn = TableSettingsHandler_ReadLine;
    ini_handler.ApplyAllFn = TableSettingsHandler_ApplyAll;
    ini_handler.WriteAllFn = TableSettingsHandler_WriteAll;
    g.SettingsHandlers.push_back(ini_handler);
}

References ImGuiSettingsHandler::ApplyAllFn, ImGuiSettingsHandler::ClearAllFn, ImHashStr(), ImVector< T >::push_back(), ImGuiSettingsHandler::ReadLineFn, ImGuiSettingsHandler::ReadOpenFn, ImGuiContext::SettingsHandlers, TableSettingsHandler_ApplyAll(), TableSettingsHandler_ClearAll(), TableSettingsHandler_ReadLine(), TableSettingsHandler_ReadOpen(), TableSettingsHandler_WriteAll(), ImGuiSettingsHandler::TypeHash, ImGuiSettingsHandler::TypeName, and ImGuiSettingsHandler::WriteAllFn.

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetupColumn()

void ImGui::TableSetupColumn	(	const char *	label,
		ImGuiTableColumnFlags	flags = `0`,
		float	init_width_or_weight = `0.0f`,
		ImGuiID	user_id = `0`
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Need to call TableSetupColumn() after BeginTable()!");
    IM_ASSERT(table->IsLayoutLocked == false && "Need to call call TableSetupColumn() before first row!");
    IM_ASSERT((flags & ImGuiTableColumnFlags_StatusMask_) == 0 && "Illegal to pass StatusMask values to TableSetupColumn()");
    if (table->DeclColumnsCount >= table->ColumnsCount)
    {
        IM_ASSERT_USER_ERROR(table->DeclColumnsCount < table->ColumnsCount, "Called TableSetupColumn() too many times!");
        return;
    }
 
    ImGuiTableColumn* column = &table->Columns[table->DeclColumnsCount];
    table->DeclColumnsCount++;
 
    // Assert when passing a width or weight if policy is entirely left to default, to avoid storing width into weight and vice-versa.
    // Give a grace to users of ImGuiTableFlags_ScrollX.
    if (table->IsDefaultSizingPolicy && (flags & ImGuiTableColumnFlags_WidthMask_) == 0 && (flags & ImGuiTableFlags_ScrollX) == 0)
        IM_ASSERT(init_width_or_weight <= 0.0f && "Can only specify width/weight if sizing policy is set explicitly in either Table or Column.");
 
    // When passing a width automatically enforce WidthFixed policy
    // (whereas TableSetupColumnFlags would default to WidthAuto if table is not Resizable)
    if ((flags & ImGuiTableColumnFlags_WidthMask_) == 0 && init_width_or_weight > 0.0f)
        if ((table->Flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedFit || (table->Flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedSame)
            flags |= ImGuiTableColumnFlags_WidthFixed;
 
    TableSetupColumnFlags(table, column, flags);
    column->UserID = user_id;
    flags = column->Flags;
 
    // Initialize defaults
    column->InitStretchWeightOrWidth = init_width_or_weight;
    if (table->IsInitializing)
    {
        // Init width or weight
        if (column->WidthRequest < 0.0f && column->StretchWeight < 0.0f)
        {
            if ((flags & ImGuiTableColumnFlags_WidthFixed) && init_width_or_weight > 0.0f)
                column->WidthRequest = init_width_or_weight;
            if (flags & ImGuiTableColumnFlags_WidthStretch)
                column->StretchWeight = (init_width_or_weight > 0.0f) ? init_width_or_weight : -1.0f;
 
            // Disable auto-fit if an explicit width/weight has been specified
            if (init_width_or_weight > 0.0f)
                column->AutoFitQueue = 0x00;
        }
 
        // Init default visibility/sort state
        if ((flags & ImGuiTableColumnFlags_DefaultHide) && (table->SettingsLoadedFlags & ImGuiTableFlags_Hideable) == 0)
            column->IsEnabled = column->IsEnabledNextFrame = false;
        if (flags & ImGuiTableColumnFlags_DefaultSort && (table->SettingsLoadedFlags & ImGuiTableFlags_Sortable) == 0)
        {
            column->SortOrder = 0; // Multiple columns using _DefaultSort will be reassigned unique SortOrder values when building the sort specs.
            column->SortDirection = (column->Flags & ImGuiTableColumnFlags_PreferSortDescending) ? (ImS8)ImGuiSortDirection_Descending : (ImU8)(ImGuiSortDirection_Ascending);
        }
    }
 
    // Store name (append with zero-terminator in contiguous buffer)
    column->NameOffset = -1;
    if (label != NULL && label[0] != 0)
    {
        column->NameOffset = (ImS16)table->ColumnsNames.size();
        table->ColumnsNames.append(label, label + strlen(label) + 1);
    }
}

References ImGuiTextBuffer::append(), ImGuiTableColumn::AutoFitQueue, ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::ColumnsNames, ImGuiContext::CurrentTable, ImGuiTable::DeclColumnsCount, ImGuiTableColumn::Flags, ImGuiTable::Flags, GImGui, IM_ASSERT, IM_ASSERT_USER_ERROR, ImGuiSortDirection_Ascending, ImGuiSortDirection_Descending, ImGuiTableColumnFlags_DefaultHide, ImGuiTableColumnFlags_DefaultSort, ImGuiTableColumnFlags_PreferSortDescending, ImGuiTableColumnFlags_StatusMask_, ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_WidthMask_, ImGuiTableColumnFlags_WidthStretch, ImGuiTableFlags_Hideable, ImGuiTableFlags_ScrollX, ImGuiTableFlags_SizingFixedFit, ImGuiTableFlags_SizingFixedSame, ImGuiTableFlags_SizingMask_, ImGuiTableFlags_Sortable, ImGuiTableColumn::InitStretchWeightOrWidth, ImGuiTable::IsDefaultSizingPolicy, ImGuiTableColumn::IsEnabled, ImGuiTableColumn::IsEnabledNextFrame, ImGuiTable::IsInitializing, ImGuiTable::IsLayoutLocked, ImGuiTableColumn::NameOffset, ImGuiTable::SettingsLoadedFlags, ImGuiTextBuffer::size(), ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortOrder, ImGuiTableColumn::StretchWeight, TableSetupColumnFlags(), ImGuiTableColumn::UserID, and ImGuiTableColumn::WidthRequest.

Referenced by ShowDemoWindowTables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetupDrawChannels()

void ImGui::TableSetupDrawChannels ( ImGuiTable * table )

{
    const int freeze_row_multiplier = (table->FreezeRowsCount > 0) ? 2 : 1;
    const int channels_for_row = (table->Flags & ImGuiTableFlags_NoClip) ? 1 : table->ColumnsEnabledCount;
    const int channels_for_bg = 1 + 1 * freeze_row_multiplier;
    const int channels_for_dummy = (table->ColumnsEnabledCount < table->ColumnsCount || table->VisibleMaskByIndex != table->EnabledMaskByIndex) ? +1 : 0;
    const int channels_total = channels_for_bg + (channels_for_row * freeze_row_multiplier) + channels_for_dummy;
    table->DrawSplitter->Split(table->InnerWindow->DrawList, channels_total);
    table->DummyDrawChannel = (ImGuiTableDrawChannelIdx)((channels_for_dummy > 0) ? channels_total - 1 : -1);
    table->Bg2DrawChannelCurrent = TABLE_DRAW_CHANNEL_BG2_FROZEN;
    table->Bg2DrawChannelUnfrozen = (ImGuiTableDrawChannelIdx)((table->FreezeRowsCount > 0) ? 2 + channels_for_row : TABLE_DRAW_CHANNEL_BG2_FROZEN);
 
    int draw_channel_current = 2;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (column->IsVisibleX && column->IsVisibleY)
        {
            column->DrawChannelFrozen = (ImGuiTableDrawChannelIdx)(draw_channel_current);
            column->DrawChannelUnfrozen = (ImGuiTableDrawChannelIdx)(draw_channel_current + (table->FreezeRowsCount > 0 ? channels_for_row + 1 : 0));
            if (!(table->Flags & ImGuiTableFlags_NoClip))
                draw_channel_current++;
        }
        else
        {
            column->DrawChannelFrozen = column->DrawChannelUnfrozen = table->DummyDrawChannel;
        }
        column->DrawChannelCurrent = column->DrawChannelFrozen;
    }
 
    // Initial draw cmd starts with a BgClipRect that matches the one of its host, to facilitate merge draw commands by default.
    // All our cell highlight are manually clipped with BgClipRect. When unfreezing it will be made smaller to fit scrolling rect.
    // (This technically isn't part of setting up draw channels, but is reasonably related to be done here)
    table->BgClipRect = table->InnerClipRect;
    table->Bg0ClipRectForDrawCmd = table->OuterWindow->ClipRect;
    table->Bg2ClipRectForDrawCmd = table->HostClipRect;
    IM_ASSERT(table->BgClipRect.Min.y <= table->BgClipRect.Max.y);
}

References ImGuiTable::Bg0ClipRectForDrawCmd, ImGuiTable::Bg2ClipRectForDrawCmd, ImGuiTable::Bg2DrawChannelCurrent, ImGuiTable::Bg2DrawChannelUnfrozen, ImGuiTable::BgClipRect, ImGuiWindow::ClipRect, ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::ColumnsEnabledCount, ImGuiTableColumn::DrawChannelCurrent, ImGuiTableColumn::DrawChannelFrozen, ImGuiTableColumn::DrawChannelUnfrozen, ImGuiWindow::DrawList, ImGuiTable::DrawSplitter, ImGuiTable::DummyDrawChannel, ImGuiTable::EnabledMaskByIndex, ImGuiTable::Flags, ImGuiTable::FreezeRowsCount, ImGuiTable::HostClipRect, IM_ASSERT, ImGuiTableFlags_NoClip, ImGuiTable::InnerClipRect, ImGuiTable::InnerWindow, ImGuiTableColumn::IsVisibleX, ImGuiTableColumn::IsVisibleY, ImRect::Max, ImRect::Min, ImGuiTable::OuterWindow, ImDrawListSplitter::Split(), TABLE_DRAW_CHANNEL_BG2_FROZEN, ImGuiTable::VisibleMaskByIndex, and ImVec2::y.

Referenced by TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSetupScrollFreeze()

void ImGui::TableSetupScrollFreeze	(	int	cols,
		int	rows
	)

{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Need to call TableSetupColumn() after BeginTable()!");
    IM_ASSERT(table->IsLayoutLocked == false && "Need to call TableSetupColumn() before first row!");
    IM_ASSERT(columns >= 0 && columns < IMGUI_TABLE_MAX_COLUMNS);
    IM_ASSERT(rows >= 0 && rows < 128); // Arbitrary limit
 
    table->FreezeColumnsRequest = (table->Flags & ImGuiTableFlags_ScrollX) ? (ImGuiTableColumnIdx)columns : 0;
    table->FreezeColumnsCount = (table->InnerWindow->Scroll.x != 0.0f) ? table->FreezeColumnsRequest : 0;
    table->FreezeRowsRequest = (table->Flags & ImGuiTableFlags_ScrollY) ? (ImGuiTableColumnIdx)rows : 0;
    table->FreezeRowsCount = (table->InnerWindow->Scroll.y != 0.0f) ? table->FreezeRowsRequest : 0;
    table->IsUnfrozenRows = (table->FreezeRowsCount == 0); // Make sure this is set before TableUpdateLayout() so ImGuiListClipper can benefit from it.b
}

References ImGuiContext::CurrentTable, ImGuiTable::Flags, ImGuiTable::FreezeColumnsCount, ImGuiTable::FreezeColumnsRequest, ImGuiTable::FreezeRowsCount, ImGuiTable::FreezeRowsRequest, GImGui, IM_ASSERT, IMGUI_TABLE_MAX_COLUMNS, ImGuiTableFlags_ScrollX, ImGuiTableFlags_ScrollY, ImGuiTable::InnerWindow, ImGuiTable::IsLayoutLocked, ImGuiTable::IsUnfrozenRows, ImGuiWindow::Scroll, ImVec2::x, and ImVec2::y.

Referenced by ShowDemoWindowTables().

Here is the caller graph for this function:

◆ TableSortSpecsBuild()

void ImGui::TableSortSpecsBuild ( ImGuiTable * table )

{
    IM_ASSERT(table->IsSortSpecsDirty);
    TableSortSpecsSanitize(table);
 
    // Write output
    ImGuiTableTempData* temp_data = table->TempData;
    temp_data->SortSpecsMulti.resize(table->SortSpecsCount <= 1 ? 0 : table->SortSpecsCount);
    ImGuiTableColumnSortSpecs* sort_specs = (table->SortSpecsCount == 0) ? NULL : (table->SortSpecsCount == 1) ? &temp_data->SortSpecsSingle : temp_data->SortSpecsMulti.Data;
    if (sort_specs != NULL)
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            if (column->SortOrder == -1)
                continue;
            IM_ASSERT(column->SortOrder < table->SortSpecsCount);
            ImGuiTableColumnSortSpecs* sort_spec = &sort_specs[column->SortOrder];
            sort_spec->ColumnUserID = column->UserID;
            sort_spec->ColumnIndex = (ImGuiTableColumnIdx)column_n;
            sort_spec->SortOrder = (ImGuiTableColumnIdx)column->SortOrder;
            sort_spec->SortDirection = column->SortDirection;
        }
    table->SortSpecs.Specs = sort_specs;
    table->SortSpecs.SpecsCount = table->SortSpecsCount;
    table->SortSpecs.SpecsDirty = true; // Mark as dirty for user
    table->IsSortSpecsDirty = false; // Mark as not dirty for us
}

References ImGuiTableColumnSortSpecs::ColumnIndex, ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableColumnSortSpecs::ColumnUserID, ImVector< T >::Data, IM_ASSERT, ImGuiTable::IsSortSpecsDirty, ImVector< T >::resize(), ImGuiTableColumnSortSpecs::SortDirection, ImGuiTableColumn::SortDirection, ImGuiTableColumnSortSpecs::SortOrder, ImGuiTableColumn::SortOrder, ImGuiTable::SortSpecs, ImGuiTable::SortSpecsCount, ImGuiTableTempData::SortSpecsMulti, ImGuiTableTempData::SortSpecsSingle, ImGuiTableSortSpecs::Specs, ImGuiTableSortSpecs::SpecsCount, ImGuiTableSortSpecs::SpecsDirty, TableSortSpecsSanitize(), ImGuiTable::TempData, and ImGuiTableColumn::UserID.

Referenced by TableGetSortSpecs(), and TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableSortSpecsSanitize()

void ImGui::TableSortSpecsSanitize ( ImGuiTable * table )

{
    IM_ASSERT(table->Flags & ImGuiTableFlags_Sortable);
 
    // Clear SortOrder from hidden column and verify that there's no gap or duplicate.
    int sort_order_count = 0;
    ImU64 sort_order_mask = 0x00;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (column->SortOrder != -1 && !column->IsEnabled)
            column->SortOrder = -1;
        if (column->SortOrder == -1)
            continue;
        sort_order_count++;
        sort_order_mask |= ((ImU64)1 << column->SortOrder);
        IM_ASSERT(sort_order_count < (int)sizeof(sort_order_mask) * 8);
    }
 
    const bool need_fix_linearize = ((ImU64)1 << sort_order_count) != (sort_order_mask + 1);
    const bool need_fix_single_sort_order = (sort_order_count > 1) && !(table->Flags & ImGuiTableFlags_SortMulti);
    if (need_fix_linearize || need_fix_single_sort_order)
    {
        ImU64 fixed_mask = 0x00;
        for (int sort_n = 0; sort_n < sort_order_count; sort_n++)
        {
            // Fix: Rewrite sort order fields if needed so they have no gap or duplicate.
            // (e.g. SortOrder 0 disappeared, SortOrder 1..2 exists --> rewrite then as SortOrder 0..1)
            int column_with_smallest_sort_order = -1;
            for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                if ((fixed_mask & ((ImU64)1 << (ImU64)column_n)) == 0 && table->Columns[column_n].SortOrder != -1)
                    if (column_with_smallest_sort_order == -1 || table->Columns[column_n].SortOrder < table->Columns[column_with_smallest_sort_order].SortOrder)
                        column_with_smallest_sort_order = column_n;
            IM_ASSERT(column_with_smallest_sort_order != -1);
            fixed_mask |= ((ImU64)1 << column_with_smallest_sort_order);
            table->Columns[column_with_smallest_sort_order].SortOrder = (ImGuiTableColumnIdx)sort_n;
 
            // Fix: Make sure only one column has a SortOrder if ImGuiTableFlags_MultiSortable is not set.
            if (need_fix_single_sort_order)
            {
                sort_order_count = 1;
                for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                    if (column_n != column_with_smallest_sort_order)
                        table->Columns[column_n].SortOrder = -1;
                break;
            }
        }
    }
 
    // Fallback default sort order (if no column had the ImGuiTableColumnFlags_DefaultSort flag)
    if (sort_order_count == 0 && !(table->Flags & ImGuiTableFlags_SortTristate))
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            if (column->IsEnabled && !(column->Flags & ImGuiTableColumnFlags_NoSort))
            {
                sort_order_count = 1;
                column->SortOrder = 0;
                column->SortDirection = (ImU8)TableGetColumnAvailSortDirection(column, 0);
                break;
            }
        }
 
    table->SortSpecsCount = (ImGuiTableColumnIdx)sort_order_count;
}

References ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableColumn::Flags, ImGuiTable::Flags, IM_ASSERT, ImGuiTableColumnFlags_NoSort, ImGuiTableFlags_Sortable, ImGuiTableFlags_SortMulti, ImGuiTableFlags_SortTristate, ImGuiTableColumn::IsEnabled, ImGuiTableColumn::SortDirection, ImGuiTableColumn::SortOrder, ImGuiTable::SortSpecsCount, and TableGetColumnAvailSortDirection().

Referenced by TableSortSpecsBuild().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableUpdateBorders()

void ImGui::TableUpdateBorders ( ImGuiTable * table )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(table->Flags & ImGuiTableFlags_Resizable);
 
    // At this point OuterRect height may be zero or under actual final height, so we rely on temporal coherency and
    // use the final height from last frame. Because this is only affecting _interaction_ with columns, it is not
    // really problematic (whereas the actual visual will be displayed in EndTable() and using the current frame height).
    // Actual columns highlight/render will be performed in EndTable() and not be affected.
    const float hit_half_width = TABLE_RESIZE_SEPARATOR_HALF_THICKNESS;
    const float hit_y1 = table->OuterRect.Min.y;
    const float hit_y2_body = ImMax(table->OuterRect.Max.y, hit_y1 + table->LastOuterHeight);
    const float hit_y2_head = hit_y1 + table->LastFirstRowHeight;
 
    for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
    {
        if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n)))
            continue;
 
        const int column_n = table->DisplayOrderToIndex[order_n];
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_NoDirectResize_))
            continue;
 
        // ImGuiTableFlags_NoBordersInBodyUntilResize will be honored in TableDrawBorders()
        const float border_y2_hit = (table->Flags & ImGuiTableFlags_NoBordersInBody) ? hit_y2_head : hit_y2_body;
        if ((table->Flags & ImGuiTableFlags_NoBordersInBody) && table->IsUsingHeaders == false)
            continue;
 
        if (table->FreezeColumnsCount > 0)
            if (column->MaxX < table->Columns[table->DisplayOrderToIndex[table->FreezeColumnsCount - 1]].MaxX)
                continue;
 
        ImGuiID column_id = TableGetColumnResizeID(table, column_n, table->InstanceCurrent);
        ImRect hit_rect(column->MaxX - hit_half_width, hit_y1, column->MaxX + hit_half_width, border_y2_hit);
        //GetForegroundDrawList()->AddRect(hit_rect.Min, hit_rect.Max, IM_COL32(255, 0, 0, 100));
        KeepAliveID(column_id);
 
        bool hovered = false, held = false;
        bool pressed = ButtonBehavior(hit_rect, column_id, &hovered, &held, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_AllowItemOverlap | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnDoubleClick);
        if (pressed && IsMouseDoubleClicked(0))
        {
            TableSetColumnWidthAutoSingle(table, column_n);
            ClearActiveID();
            held = hovered = false;
        }
        if (held)
        {
            if (table->LastResizedColumn == -1)
                table->ResizeLockMinContentsX2 = table->RightMostEnabledColumn != -1 ? table->Columns[table->RightMostEnabledColumn].MaxX : -FLT_MAX;
            table->ResizedColumn = (ImGuiTableColumnIdx)column_n;
            table->InstanceInteracted = table->InstanceCurrent;
        }
        if ((hovered && g.HoveredIdTimer > TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER) || held)
        {
            table->HoveredColumnBorder = (ImGuiTableColumnIdx)column_n;
            SetMouseCursor(ImGuiMouseCursor_ResizeEW);
        }
    }
}

References ButtonBehavior(), ClearActiveID(), ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTable::DisplayOrderToIndex, ImGuiTable::EnabledMaskByDisplayOrder, ImGuiTableColumn::Flags, ImGuiTable::Flags, ImGuiTable::FreezeColumnsCount, GImGui, ImGuiTable::HoveredColumnBorder, ImGuiContext::HoveredIdTimer, IM_ASSERT, ImGuiButtonFlags_AllowItemOverlap, ImGuiButtonFlags_FlattenChildren, ImGuiButtonFlags_PressedOnClick, ImGuiButtonFlags_PressedOnDoubleClick, ImGuiMouseCursor_ResizeEW, ImGuiTableColumnFlags_NoDirectResize_, ImGuiTableColumnFlags_NoResize, ImGuiTableFlags_NoBordersInBody, ImGuiTableFlags_Resizable, ImMax(), ImGuiTable::InstanceCurrent, ImGuiTable::InstanceInteracted, IsMouseDoubleClicked(), ImGuiTable::IsUsingHeaders, KeepAliveID(), ImGuiTable::LastFirstRowHeight, ImGuiTable::LastOuterHeight, ImGuiTable::LastResizedColumn, ImRect::Max, ImGuiTableColumn::MaxX, ImRect::Min, ImGuiTable::OuterRect, ImGuiTable::ResizedColumn, ImGuiTable::ResizeLockMinContentsX2, ImGuiTable::RightMostEnabledColumn, SetMouseCursor(), TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER, TABLE_RESIZE_SEPARATOR_HALF_THICKNESS, TableGetColumnResizeID(), TableSetColumnWidthAutoSingle(), and ImVec2::y.

Referenced by TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TableUpdateColumnsWeightFromWidth()

void ImGui::TableUpdateColumnsWeightFromWidth ( ImGuiTable * table )

{
    IM_ASSERT(table->LeftMostStretchedColumn != -1 && table->RightMostStretchedColumn != -1);
 
    // Measure existing quantity
    float visible_weight = 0.0f;
    float visible_width = 0.0f;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch))
            continue;
        IM_ASSERT(column->StretchWeight > 0.0f);
        visible_weight += column->StretchWeight;
        visible_width += column->WidthRequest;
    }
    IM_ASSERT(visible_weight > 0.0f && visible_width > 0.0f);
 
    // Apply new weights
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch))
            continue;
        column->StretchWeight = (column->WidthRequest / visible_width) * visible_weight;
        IM_ASSERT(column->StretchWeight > 0.0f);
    }
}

References ImGuiTable::Columns, ImGuiTable::ColumnsCount, ImGuiTableColumn::Flags, IM_ASSERT, ImGuiTableColumnFlags_WidthStretch, ImGuiTableColumn::IsEnabled, ImGuiTable::LeftMostStretchedColumn, ImGuiTable::RightMostStretchedColumn, ImGuiTableColumn::StretchWeight, and ImGuiTableColumn::WidthRequest.

Referenced by TableSetColumnWidth().

Here is the caller graph for this function:

◆ TableUpdateLayout()

void ImGui::TableUpdateLayout ( ImGuiTable * table )

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(table->IsLayoutLocked == false);
 
    const ImGuiTableFlags table_sizing_policy = (table->Flags & ImGuiTableFlags_SizingMask_);
    table->IsDefaultDisplayOrder = true;
    table->ColumnsEnabledCount = 0;
    table->EnabledMaskByIndex = 0x00;
    table->EnabledMaskByDisplayOrder = 0x00;
    table->LeftMostEnabledColumn = -1;
    table->MinColumnWidth = ImMax(1.0f, g.Style.FramePadding.x * 1.0f); // g.Style.ColumnsMinSpacing; // FIXME-TABLE
 
    // [Part 1] Apply/lock Enabled and Order states. Calculate auto/ideal width for columns. Count fixed/stretch columns.
    // Process columns in their visible orders as we are building the Prev/Next indices.
    int count_fixed = 0;                // Number of columns that have fixed sizing policies
    int count_stretch = 0;              // Number of columns that have stretch sizing policies
    int prev_visible_column_idx = -1;
    bool has_auto_fit_request = false;
    bool has_resizable = false;
    float stretch_sum_width_auto = 0.0f;
    float fixed_max_width_auto = 0.0f;
    for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
    {
        const int column_n = table->DisplayOrderToIndex[order_n];
        if (column_n != order_n)
            table->IsDefaultDisplayOrder = false;
        ImGuiTableColumn* column = &table->Columns[column_n];
 
        // Clear column setup if not submitted by user. Currently we make it mandatory to call TableSetupColumn() every frame.
        // It would easily work without but we're not ready to guarantee it since e.g. names need resubmission anyway.
        // We take a slight shortcut but in theory we could be calling TableSetupColumn() here with dummy values, it should yield the same effect.
        if (table->DeclColumnsCount <= column_n)
        {
            TableSetupColumnFlags(table, column, ImGuiTableColumnFlags_None);
            column->NameOffset = -1;
            column->UserID = 0;
            column->InitStretchWeightOrWidth = -1.0f;
        }
 
        // Update Enabled state, mark settings/sortspecs dirty
        if (!(table->Flags & ImGuiTableFlags_Hideable) || (column->Flags & ImGuiTableColumnFlags_NoHide))
            column->IsEnabledNextFrame = true;
        if (column->IsEnabled != column->IsEnabledNextFrame)
        {
            column->IsEnabled = column->IsEnabledNextFrame;
            table->IsSettingsDirty = true;
            if (!column->IsEnabled && column->SortOrder != -1)
                table->IsSortSpecsDirty = true;
        }
        if (column->SortOrder > 0 && !(table->Flags & ImGuiTableFlags_SortMulti))
            table->IsSortSpecsDirty = true;
 
        // Auto-fit unsized columns
        const bool start_auto_fit = (column->Flags & ImGuiTableColumnFlags_WidthFixed) ? (column->WidthRequest < 0.0f) : (column->StretchWeight < 0.0f);
        if (start_auto_fit)
            column->AutoFitQueue = column->CannotSkipItemsQueue = (1 << 3) - 1; // Fit for three frames
 
        if (!column->IsEnabled)
        {
            column->IndexWithinEnabledSet = -1;
            continue;
        }
 
        // Mark as enabled and link to previous/next enabled column
        column->PrevEnabledColumn = (ImGuiTableColumnIdx)prev_visible_column_idx;
        column->NextEnabledColumn = -1;
        if (prev_visible_column_idx != -1)
            table->Columns[prev_visible_column_idx].NextEnabledColumn = (ImGuiTableColumnIdx)column_n;
        else
            table->LeftMostEnabledColumn = (ImGuiTableColumnIdx)column_n;
        column->IndexWithinEnabledSet = table->ColumnsEnabledCount++;
        table->EnabledMaskByIndex |= (ImU64)1 << column_n;
        table->EnabledMaskByDisplayOrder |= (ImU64)1 << column->DisplayOrder;
        prev_visible_column_idx = column_n;
        IM_ASSERT(column->IndexWithinEnabledSet <= column->DisplayOrder);
 
        // Calculate ideal/auto column width (that's the width required for all contents to be visible without clipping)
        // Combine width from regular rows + width from headers unless requested not to.
        if (!column->IsPreserveWidthAuto)
            column->WidthAuto = TableGetColumnWidthAuto(table, column);
 
        // Non-resizable columns keep their requested width (apply user value regardless of IsPreserveWidthAuto)
        const bool column_is_resizable = (column->Flags & ImGuiTableColumnFlags_NoResize) == 0;
        if (column_is_resizable)
            has_resizable = true;
        if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && column->InitStretchWeightOrWidth > 0.0f && !column_is_resizable)
            column->WidthAuto = column->InitStretchWeightOrWidth;
 
        if (column->AutoFitQueue != 0x00)
            has_auto_fit_request = true;
        if (column->Flags & ImGuiTableColumnFlags_WidthStretch)
        {
            stretch_sum_width_auto += column->WidthAuto;
            count_stretch++;
        }
        else
        {
            fixed_max_width_auto = ImMax(fixed_max_width_auto, column->WidthAuto);
            count_fixed++;
        }
    }
    if ((table->Flags & ImGuiTableFlags_Sortable) && table->SortSpecsCount == 0 && !(table->Flags & ImGuiTableFlags_SortTristate))
        table->IsSortSpecsDirty = true;
    table->RightMostEnabledColumn = (ImGuiTableColumnIdx)prev_visible_column_idx;
    IM_ASSERT(table->LeftMostEnabledColumn >= 0 && table->RightMostEnabledColumn >= 0);
 
    // [Part 2] Disable child window clipping while fitting columns. This is not strictly necessary but makes it possible
    // to avoid the column fitting having to wait until the first visible frame of the child container (may or not be a good thing).
    // FIXME-TABLE: for always auto-resizing columns may not want to do that all the time.
    if (has_auto_fit_request && table->OuterWindow != table->InnerWindow)
        table->InnerWindow->SkipItems = false;
    if (has_auto_fit_request)
        table->IsSettingsDirty = true;
 
    // [Part 3] Fix column flags and record a few extra information.
    float sum_width_requests = 0.0f;        // Sum of all width for fixed and auto-resize columns, excluding width contributed by Stretch columns but including spacing/padding.
    float stretch_sum_weights = 0.0f;       // Sum of all weights for stretch columns.
    table->LeftMostStretchedColumn = table->RightMostStretchedColumn = -1;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        if (!(table->EnabledMaskByIndex & ((ImU64)1 << column_n)))
            continue;
        ImGuiTableColumn* column = &table->Columns[column_n];
 
        const bool column_is_resizable = (column->Flags & ImGuiTableColumnFlags_NoResize) == 0;
        if (column->Flags & ImGuiTableColumnFlags_WidthFixed)
        {
            // Apply same widths policy
            float width_auto = column->WidthAuto;
            if (table_sizing_policy == ImGuiTableFlags_SizingFixedSame && (column->AutoFitQueue != 0x00 || !column_is_resizable))
                width_auto = fixed_max_width_auto;
 
            // Apply automatic width
            // Latch initial size for fixed columns and update it constantly for auto-resizing column (unless clipped!)
            if (column->AutoFitQueue != 0x00)
                column->WidthRequest = width_auto;
            else if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && !column_is_resizable && (table->RequestOutputMaskByIndex & ((ImU64)1 << column_n)))
                column->WidthRequest = width_auto;
 
            // FIXME-TABLE: Increase minimum size during init frame to avoid biasing auto-fitting widgets
            // (e.g. TextWrapped) too much. Otherwise what tends to happen is that TextWrapped would output a very
            // large height (= first frame scrollbar display very off + clipper would skip lots of items).
            // This is merely making the side-effect less extreme, but doesn't properly fixes it.
            // FIXME: Move this to ->WidthGiven to avoid temporary lossyless?
            // FIXME: This break IsPreserveWidthAuto from not flickering if the stored WidthAuto was smaller.
            if (column->AutoFitQueue > 0x01 && table->IsInitializing && !column->IsPreserveWidthAuto)
                column->WidthRequest = ImMax(column->WidthRequest, table->MinColumnWidth * 4.0f); // FIXME-TABLE: Another constant/scale?
            sum_width_requests += column->WidthRequest;
        }
        else
        {
            // Initialize stretch weight
            if (column->AutoFitQueue != 0x00 || column->StretchWeight < 0.0f || !column_is_resizable)
            {
                if (column->InitStretchWeightOrWidth > 0.0f)
                    column->StretchWeight = column->InitStretchWeightOrWidth;
                else if (table_sizing_policy == ImGuiTableFlags_SizingStretchProp)
                    column->StretchWeight = (column->WidthAuto / stretch_sum_width_auto) * count_stretch;
                else
                    column->StretchWeight = 1.0f;
            }
 
            stretch_sum_weights += column->StretchWeight;
            if (table->LeftMostStretchedColumn == -1 || table->Columns[table->LeftMostStretchedColumn].DisplayOrder > column->DisplayOrder)
                table->LeftMostStretchedColumn = (ImGuiTableColumnIdx)column_n;
            if (table->RightMostStretchedColumn == -1 || table->Columns[table->RightMostStretchedColumn].DisplayOrder < column->DisplayOrder)
                table->RightMostStretchedColumn = (ImGuiTableColumnIdx)column_n;
        }
        column->IsPreserveWidthAuto = false;
        sum_width_requests += table->CellPaddingX * 2.0f;
    }
    table->ColumnsEnabledFixedCount = (ImGuiTableColumnIdx)count_fixed;
 
    // [Part 4] Apply final widths based on requested widths
    const ImRect work_rect = table->WorkRect;
    const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1);
    const float width_avail = ((table->Flags & ImGuiTableFlags_ScrollX) && table->InnerWidth == 0.0f) ? table->InnerClipRect.GetWidth() : work_rect.GetWidth();
    const float width_avail_for_stretched_columns = width_avail - width_spacings - sum_width_requests;
    float width_remaining_for_stretched_columns = width_avail_for_stretched_columns;
    table->ColumnsGivenWidth = width_spacings + (table->CellPaddingX * 2.0f) * table->ColumnsEnabledCount;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        if (!(table->EnabledMaskByIndex & ((ImU64)1 << column_n)))
            continue;
        ImGuiTableColumn* column = &table->Columns[column_n];
 
        // Allocate width for stretched/weighted columns (StretchWeight gets converted into WidthRequest)
        if (column->Flags & ImGuiTableColumnFlags_WidthStretch)
        {
            float weight_ratio = column->StretchWeight / stretch_sum_weights;
            column->WidthRequest = IM_FLOOR(ImMax(width_avail_for_stretched_columns * weight_ratio, table->MinColumnWidth) + 0.01f);
            width_remaining_for_stretched_columns -= column->WidthRequest;
        }
 
        // [Resize Rule 1] The right-most Visible column is not resizable if there is at least one Stretch column
        // See additional comments in TableSetColumnWidth().
        if (column->NextEnabledColumn == -1 && table->LeftMostStretchedColumn != -1)
            column->Flags |= ImGuiTableColumnFlags_NoDirectResize_;
 
        // Assign final width, record width in case we will need to shrink
        column->WidthGiven = ImFloor(ImMax(column->WidthRequest, table->MinColumnWidth));
        table->ColumnsGivenWidth += column->WidthGiven;
    }
 
    // [Part 5] Redistribute stretch remainder width due to rounding (remainder width is < 1.0f * number of Stretch column).
    // Using right-to-left distribution (more likely to match resizing cursor).
    if (width_remaining_for_stretched_columns >= 1.0f && !(table->Flags & ImGuiTableFlags_PreciseWidths))
        for (int order_n = table->ColumnsCount - 1; stretch_sum_weights > 0.0f && width_remaining_for_stretched_columns >= 1.0f && order_n >= 0; order_n--)
        {
            if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n)))
                continue;
            ImGuiTableColumn* column = &table->Columns[table->DisplayOrderToIndex[order_n]];
            if (!(column->Flags & ImGuiTableColumnFlags_WidthStretch))
                continue;
            column->WidthRequest += 1.0f;
            column->WidthGiven += 1.0f;
            width_remaining_for_stretched_columns -= 1.0f;
        }
 
    table->HoveredColumnBody = -1;
    table->HoveredColumnBorder = -1;
    const ImRect mouse_hit_rect(table->OuterRect.Min.x, table->OuterRect.Min.y, table->OuterRect.Max.x, ImMax(table->OuterRect.Max.y, table->OuterRect.Min.y + table->LastOuterHeight));
    const bool is_hovering_table = ItemHoverable(mouse_hit_rect, 0);
 
    // [Part 6] Setup final position, offset, skip/clip states and clipping rectangles, detect hovered column
    // Process columns in their visible orders as we are comparing the visible order and adjusting host_clip_rect while looping.
    int visible_n = 0;
    bool offset_x_frozen = (table->FreezeColumnsCount > 0);
    float offset_x = ((table->FreezeColumnsCount > 0) ? table->OuterRect.Min.x : work_rect.Min.x) + table->OuterPaddingX - table->CellSpacingX1;
    ImRect host_clip_rect = table->InnerClipRect;
    //host_clip_rect.Max.x += table->CellPaddingX + table->CellSpacingX2;
    table->VisibleMaskByIndex = 0x00;
    table->RequestOutputMaskByIndex = 0x00;
    for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
    {
        const int column_n = table->DisplayOrderToIndex[order_n];
        ImGuiTableColumn* column = &table->Columns[column_n];
 
        column->NavLayerCurrent = (ImS8)((table->FreezeRowsCount > 0 || column_n < table->FreezeColumnsCount) ? ImGuiNavLayer_Menu : ImGuiNavLayer_Main);
 
        if (offset_x_frozen && table->FreezeColumnsCount == visible_n)
        {
            offset_x += work_rect.Min.x - table->OuterRect.Min.x;
            offset_x_frozen = false;
        }
 
        // Clear status flags
        column->Flags &= ~ImGuiTableColumnFlags_StatusMask_;
 
        if ((table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n)) == 0)
        {
            // Hidden column: clear a few fields and we are done with it for the remainder of the function.
            // We set a zero-width clip rect but set Min.y/Max.y properly to not interfere with the clipper.
            column->MinX = column->MaxX = column->WorkMinX = column->ClipRect.Min.x = column->ClipRect.Max.x = offset_x;
            column->WidthGiven = 0.0f;
            column->ClipRect.Min.y = work_rect.Min.y;
            column->ClipRect.Max.y = FLT_MAX;
            column->ClipRect.ClipWithFull(host_clip_rect);
            column->IsVisibleX = column->IsVisibleY = column->IsRequestOutput = false;
            column->IsSkipItems = true;
            column->ItemWidth = 1.0f;
            continue;
        }
 
        // Detect hovered column
        if (is_hovering_table && g.IO.MousePos.x >= column->ClipRect.Min.x && g.IO.MousePos.x < column->ClipRect.Max.x)
            table->HoveredColumnBody = (ImGuiTableColumnIdx)column_n;
 
        // Lock start position
        column->MinX = offset_x;
 
        // Lock width based on start position and minimum/maximum width for this position
        float max_width = TableGetMaxColumnWidth(table, column_n);
        column->WidthGiven = ImMin(column->WidthGiven, max_width);
        column->WidthGiven = ImMax(column->WidthGiven, ImMin(column->WidthRequest, table->MinColumnWidth));
        column->MaxX = offset_x + column->WidthGiven + table->CellSpacingX1 + table->CellSpacingX2 + table->CellPaddingX * 2.0f;
 
        // Lock other positions
        // - ClipRect.Min.x: Because merging draw commands doesn't compare min boundaries, we make ClipRect.Min.x match left bounds to be consistent regardless of merging.
        // - ClipRect.Max.x: using WorkMaxX instead of MaxX (aka including padding) makes things more consistent when resizing down, tho slightly detrimental to visibility in very-small column.
        // - ClipRect.Max.x: using MaxX makes it easier for header to receive hover highlight with no discontinuity and display sorting arrow.
        // - FIXME-TABLE: We want equal width columns to have equal (ClipRect.Max.x - WorkMinX) width, which means ClipRect.max.x cannot stray off host_clip_rect.Max.x else right-most column may appear shorter.
        column->WorkMinX = column->MinX + table->CellPaddingX + table->CellSpacingX1;
        column->WorkMaxX = column->MaxX - table->CellPaddingX - table->CellSpacingX2; // Expected max
        column->ItemWidth = ImFloor(column->WidthGiven * 0.65f);
        column->ClipRect.Min.x = column->MinX;
        column->ClipRect.Min.y = work_rect.Min.y;
        column->ClipRect.Max.x = column->MaxX; //column->WorkMaxX;
        column->ClipRect.Max.y = FLT_MAX;
        column->ClipRect.ClipWithFull(host_clip_rect);
 
        // Mark column as Clipped (not in sight)
        // Note that scrolling tables (where inner_window != outer_window) handle Y clipped earlier in BeginTable() so IsVisibleY really only applies to non-scrolling tables.
        // FIXME-TABLE: Because InnerClipRect.Max.y is conservatively ==outer_window->ClipRect.Max.y, we never can mark columns _Above_ the scroll line as not IsVisibleY.
        // Taking advantage of LastOuterHeight would yield good results there...
        // FIXME-TABLE: Y clipping is disabled because it effectively means not submitting will reduce contents width which is fed to outer_window->DC.CursorMaxPos.x,
        // and this may be used (e.g. typically by outer_window using AlwaysAutoResize or outer_window's horizontal scrollbar, but could be something else).
        // Possible solution to preserve last known content width for clipped column. Test 'table_reported_size' fails when enabling Y clipping and window is resized small.
        column->IsVisibleX = (column->ClipRect.Max.x > column->ClipRect.Min.x);
        column->IsVisibleY = true; // (column->ClipRect.Max.y > column->ClipRect.Min.y);
        const bool is_visible = column->IsVisibleX; //&& column->IsVisibleY;
        if (is_visible)
            table->VisibleMaskByIndex |= ((ImU64)1 << column_n);
 
        // Mark column as requesting output from user. Note that fixed + non-resizable sets are auto-fitting at all times and therefore always request output.
        column->IsRequestOutput = is_visible || column->AutoFitQueue != 0 || column->CannotSkipItemsQueue != 0;
        if (column->IsRequestOutput)
            table->RequestOutputMaskByIndex |= ((ImU64)1 << column_n);
 
        // Mark column as SkipItems (ignoring all items/layout)
        column->IsSkipItems = !column->IsEnabled || table->HostSkipItems;
        if (column->IsSkipItems)
            IM_ASSERT(!is_visible);
 
        // Update status flags
        column->Flags |= ImGuiTableColumnFlags_IsEnabled;
        if (is_visible)
            column->Flags |= ImGuiTableColumnFlags_IsVisible;
        if (column->SortOrder != -1)
            column->Flags |= ImGuiTableColumnFlags_IsSorted;
        if (table->HoveredColumnBody == column_n)
            column->Flags |= ImGuiTableColumnFlags_IsHovered;
 
        // Alignment
        // FIXME-TABLE: This align based on the whole column width, not per-cell, and therefore isn't useful in
        // many cases (to be able to honor this we might be able to store a log of cells width, per row, for
        // visible rows, but nav/programmatic scroll would have visible artifacts.)
        //if (column->Flags & ImGuiTableColumnFlags_AlignRight)
        //    column->WorkMinX = ImMax(column->WorkMinX, column->MaxX - column->ContentWidthRowsUnfrozen);
        //else if (column->Flags & ImGuiTableColumnFlags_AlignCenter)
        //    column->WorkMinX = ImLerp(column->WorkMinX, ImMax(column->StartX, column->MaxX - column->ContentWidthRowsUnfrozen), 0.5f);
 
        // Reset content width variables
        column->ContentMaxXFrozen = column->ContentMaxXUnfrozen = column->WorkMinX;
        column->ContentMaxXHeadersUsed = column->ContentMaxXHeadersIdeal = column->WorkMinX;
 
        // Don't decrement auto-fit counters until container window got a chance to submit its items
        if (table->HostSkipItems == false)
        {
            column->AutoFitQueue >>= 1;
            column->CannotSkipItemsQueue >>= 1;
        }
 
        if (visible_n < table->FreezeColumnsCount)
            host_clip_rect.Min.x = ImClamp(column->MaxX + TABLE_BORDER_SIZE, host_clip_rect.Min.x, host_clip_rect.Max.x);
 
        offset_x += column->WidthGiven + table->CellSpacingX1 + table->CellSpacingX2 + table->CellPaddingX * 2.0f;
        visible_n++;
    }
 
    // [Part 7] Detect/store when we are hovering the unused space after the right-most column (so e.g. context menus can react on it)
    // Clear Resizable flag if none of our column are actually resizable (either via an explicit _NoResize flag, either
    // because of using _WidthAuto/_WidthStretch). This will hide the resizing option from the context menu.
    const float unused_x1 = ImMax(table->WorkRect.Min.x, table->Columns[table->RightMostEnabledColumn].ClipRect.Max.x);
    if (is_hovering_table && table->HoveredColumnBody == -1)
    {
        if (g.IO.MousePos.x >= unused_x1)
            table->HoveredColumnBody = (ImGuiTableColumnIdx)table->ColumnsCount;
    }
    if (has_resizable == false && (table->Flags & ImGuiTableFlags_Resizable))
        table->Flags &= ~ImGuiTableFlags_Resizable;
 
    // [Part 8] Lock actual OuterRect/WorkRect right-most position.
    // This is done late to handle the case of fixed-columns tables not claiming more widths that they need.
    // Because of this we are careful with uses of WorkRect and InnerClipRect before this point.
    if (table->RightMostStretchedColumn != -1)
        table->Flags &= ~ImGuiTableFlags_NoHostExtendX;
    if (table->Flags & ImGuiTableFlags_NoHostExtendX)
    {
        table->OuterRect.Max.x = table->WorkRect.Max.x = unused_x1;
        table->InnerClipRect.Max.x = ImMin(table->InnerClipRect.Max.x, unused_x1);
    }
    table->InnerWindow->ParentWorkRect = table->WorkRect;
    table->BorderX1 = table->InnerClipRect.Min.x;// +((table->Flags & ImGuiTableFlags_BordersOuter) ? 0.0f : -1.0f);
    table->BorderX2 = table->InnerClipRect.Max.x;// +((table->Flags & ImGuiTableFlags_BordersOuter) ? 0.0f : +1.0f);
 
    // [Part 9] Allocate draw channels and setup background cliprect
    TableSetupDrawChannels(table);
 
    // [Part 10] Hit testing on borders
    if (table->Flags & ImGuiTableFlags_Resizable)
        TableUpdateBorders(table);
    table->LastFirstRowHeight = 0.0f;
    table->IsLayoutLocked = true;
    table->IsUsingHeaders = false;
 
    // [Part 11] Context menu
    if (table->IsContextPopupOpen && table->InstanceCurrent == table->InstanceInteracted)
    {
        const ImGuiID context_menu_id = ImHashStr("##ContextMenu", 0, table->ID);
        if (BeginPopupEx(context_menu_id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings))
        {
            TableDrawContextMenu(table);
            EndPopup();
        }
        else
        {
            table->IsContextPopupOpen = false;
        }
    }
 
    // [Part 13] Sanitize and build sort specs before we have a change to use them for display.
    // This path will only be exercised when sort specs are modified before header rows (e.g. init or visibility change)
    if (table->IsSortSpecsDirty && (table->Flags & ImGuiTableFlags_Sortable))
        TableSortSpecsBuild(table);
 
    // Initial state
    ImGuiWindow* inner_window = table->InnerWindow;
    if (table->Flags & ImGuiTableFlags_NoClip)
        table->DrawSplitter->SetCurrentChannel(inner_window->DrawList, TABLE_DRAW_CHANNEL_NOCLIP);
    else
        inner_window->DrawList->PushClipRect(inner_window->ClipRect.Min, inner_window->ClipRect.Max, false);
}

Referenced by EndTable(), TableGetSortSpecs(), TableHeadersRow(), and TableNextRow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TempInputIsActive()

bool ImGui::TempInputIsActive ( ImGuiID id )

inline

2591{ ImGuiContext& g = *GImGui; return (g.ActiveId == id && g.TempInputId == id); }

References ImGuiContext::ActiveId, GImGui, and ImGuiContext::TempInputId.

Referenced by DragScalar(), and SliderScalar().

Here is the caller graph for this function:

◆ TempInputScalar()

bool ImGui::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`
	)

{
    ImGuiContext& g = *GImGui;
 
    char fmt_buf[32];
    char data_buf[32];
    format = ImParseFormatTrimDecorations(format, fmt_buf, IM_ARRAYSIZE(fmt_buf));
    DataTypeFormatString(data_buf, IM_ARRAYSIZE(data_buf), data_type, p_data, format);
    ImStrTrimBlanks(data_buf);
 
    ImGuiInputTextFlags flags = ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoMarkEdited;
    flags |= ((data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double) ? ImGuiInputTextFlags_CharsScientific : ImGuiInputTextFlags_CharsDecimal);
    bool value_changed = false;
    if (TempInputText(bb, id, label, data_buf, IM_ARRAYSIZE(data_buf), flags))
    {
        // Backup old value
        size_t data_type_size = DataTypeGetInfo(data_type)->Size;
        ImGuiDataTypeTempStorage data_backup;
        memcpy(&data_backup, p_data, data_type_size);
 
        // Apply new value (or operations) then clamp
        DataTypeApplyOpFromText(data_buf, g.InputTextState.InitialTextA.Data, data_type, p_data, NULL);
        if (p_clamp_min || p_clamp_max)
        {
            if (p_clamp_min && p_clamp_max && DataTypeCompare(data_type, p_clamp_min, p_clamp_max) > 0)
                ImSwap(p_clamp_min, p_clamp_max);
            DataTypeClamp(data_type, p_data, p_clamp_min, p_clamp_max);
        }
 
        // Only mark as edited if new value is different
        value_changed = memcmp(&data_backup, p_data, data_type_size) != 0;
        if (value_changed)
            MarkItemEdited(id);
    }
    return value_changed;
}

References ImVector< T >::Data, DataTypeApplyOpFromText(), DataTypeClamp(), DataTypeCompare(), DataTypeFormatString(), DataTypeGetInfo(), GImGui, IM_ARRAYSIZE, ImGuiDataType_Double, ImGuiDataType_Float, ImGuiInputTextFlags_AutoSelectAll, ImGuiInputTextFlags_CharsDecimal, ImGuiInputTextFlags_CharsScientific, ImGuiInputTextFlags_NoMarkEdited, ImParseFormatTrimDecorations(), ImStrTrimBlanks(), ImSwap(), ImGuiInputTextState::InitialTextA, ImGuiContext::InputTextState, MarkItemEdited(), ImGuiDataTypeInfo::Size, and TempInputText().

Referenced by DragScalar(), and SliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TempInputText()

bool ImGui::TempInputText	(	const ImRect &	bb,
		ImGuiID	id,
		const char *	label,
		char *	buf,
		int	buf_size,
		ImGuiInputTextFlags	flags
	)

{
    // On the first frame, g.TempInputTextId == 0, then on subsequent frames it becomes == id.
    // We clear ActiveID on the first frame to allow the InputText() taking it back.
    ImGuiContext& g = *GImGui;
    const bool init = (g.TempInputId != id);
    if (init)
        ClearActiveID();
 
    g.CurrentWindow->DC.CursorPos = bb.Min;
    bool value_changed = InputTextEx(label, NULL, buf, buf_size, bb.GetSize(), flags | ImGuiInputTextFlags_MergedItem);
    if (init)
    {
        // First frame we started displaying the InputText widget, we expect it to take the active id.
        IM_ASSERT(g.ActiveId == id);
        g.TempInputId = g.ActiveId;
    }
    return value_changed;
}

References ImGuiContext::ActiveId, ClearActiveID(), ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImRect::GetSize(), GImGui, IM_ASSERT, ImGuiInputTextFlags_MergedItem, InputTextEx(), ImRect::Min, and ImGuiContext::TempInputId.

Referenced by TempInputScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Text()

void ImGui::Text	(	const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    TextV(fmt, args);
    va_end(args);
}

References TextV().

Referenced by ColorPicker4(), ColorTooltip(), DebugNodeTabBar(), DebugNodeWindowSettings(), DebugNodeWindowsList(), MyDocument::DisplayContents(), Slic3r::GUI::draw(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), priv::draw_transparent_icon(), EditTableSizingFlags(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::render_extruders_combo(), ShowAboutWindow(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppAutoResize(), ShowExampleAppConstrainedResize(), ShowExampleAppCustomRendering(), ShowExampleAppDocuments(), ShowExampleAppLayout(), ShowExampleAppLongText(), ShowExampleAppSimpleOverlay(), ShowExampleAppWindowTitles(), ShowExampleMenuFile(), ShowFont(), ShowMetricsWindow(), ShowPlaceholderObject(), ShowStyleEditor(), Slic3r::GUI::ImGuiWrapper::text(), UpdateDebugToolItemPicker(), Value(), Value(), Value(), and Value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextColored()

void ImGui::TextColored	(	const ImVec4 &	col,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    TextColoredV(col, fmt, args);
    va_end(args);
}

References col(), and TextColoredV().

Referenced by DebugNodeDrawList(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), Slic3r::GUI::ImGuiWrapper::text_colored(), and UpdateDebugToolItemPicker().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextColoredV()

void ImGui::TextColoredV	(	const ImVec4 &	col,
		const char *	fmt,
		va_list	args
	)

{
    PushStyleColor(ImGuiCol_Text, col);
    if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
        TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
    else
        TextV(fmt, args);
    PopStyleColor();
}

References col(), ImGuiCol_Text, ImGuiTextFlags_NoWidthForLargeClippedText, PopStyleColor(), PushStyleColor(), TextEx(), and TextV().

Referenced by TextColored().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextDisabled()

void ImGui::TextDisabled	(	const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    TextDisabledV(fmt, args);
    va_end(args);
}

References TextDisabledV().

Referenced by DebugNodeDrawList(), DebugNodeWindow(), EditTableSizingFlags(), HelpMarker(), MetricsHelpMarker(), ShowDemoWindowTables(), and ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextDisabledV()

void ImGui::TextDisabledV	(	const char *	fmt,
		va_list	args
	)

{
    ImGuiContext& g = *GImGui;
    PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
    if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
        TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
    else
        TextV(fmt, args);
    PopStyleColor();
}

References ImGuiStyle::Colors, GImGui, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiTextFlags_NoWidthForLargeClippedText, PopStyleColor(), PushStyleColor(), ImGuiContext::Style, TextEx(), and TextV().

Referenced by TextDisabled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextEx()

void ImGui::TextEx	(	const char *	text,
		const char *	text_end = `NULL`,
		ImGuiTextFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    IM_ASSERT(text != NULL);
    const char* text_begin = text;
    if (text_end == NULL)
        text_end = text + strlen(text); // FIXME-OPT
 
    const ImVec2 text_pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);
    const float wrap_pos_x = window->DC.TextWrapPos;
    const bool wrap_enabled = (wrap_pos_x >= 0.0f);
    if (text_end - text > 2000 && !wrap_enabled)
    {
        // Long text!
        // Perform manual coarse clipping to optimize for long multi-line text
        // - From this point we will only compute the width of lines that are visible. Optimization only available when word-wrapping is disabled.
        // - We also don't vertically center the text within the line full height, which is unlikely to matter because we are likely the biggest and only item on the line.
        // - We use memchr(), pay attention that well optimized versions of those str/mem functions are much faster than a casually written loop.
        const char* line = text;
        const float line_height = GetTextLineHeight();
        ImVec2 text_size(0, 0);
 
        // Lines to skip (can't skip when logging text)
        ImVec2 pos = text_pos;
        if (!g.LogEnabled)
        {
            int lines_skippable = (int)((window->ClipRect.Min.y - text_pos.y) / line_height);
            if (lines_skippable > 0)
            {
                int lines_skipped = 0;
                while (line < text_end && lines_skipped < lines_skippable)
                {
                    const char* line_end = (const char*)memchr(line, '\n', text_end - line);
                    if (!line_end)
                        line_end = text_end;
                    if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)
                        text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);
                    line = line_end + 1;
                    lines_skipped++;
                }
                pos.y += lines_skipped * line_height;
            }
        }
 
        // Lines to render
        if (line < text_end)
        {
            ImRect line_rect(pos, pos + ImVec2(FLT_MAX, line_height));
            while (line < text_end)
            {
                if (IsClippedEx(line_rect, 0, false))
                    break;
 
                const char* line_end = (const char*)memchr(line, '\n', text_end - line);
                if (!line_end)
                    line_end = text_end;
                text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);
                RenderText(pos, line, line_end, false);
                line = line_end + 1;
                line_rect.Min.y += line_height;
                line_rect.Max.y += line_height;
                pos.y += line_height;
            }
 
            // Count remaining lines
            int lines_skipped = 0;
            while (line < text_end)
            {
                const char* line_end = (const char*)memchr(line, '\n', text_end - line);
                if (!line_end)
                    line_end = text_end;
                if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)
                    text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);
                line = line_end + 1;
                lines_skipped++;
            }
            pos.y += lines_skipped * line_height;
        }
        text_size.y = (pos - text_pos).y;
 
        ImRect bb(text_pos, text_pos + text_size);
        ItemSize(text_size, 0.0f);
        ItemAdd(bb, 0);
    }
    else
    {
        const float wrap_width = wrap_enabled ? CalcWrapWidthForPos(window->DC.CursorPos, wrap_pos_x) : 0.0f;
        const ImVec2 text_size = CalcTextSize(text_begin, text_end, false, wrap_width);
 
        ImRect bb(text_pos, text_pos + text_size);
        ItemSize(text_size, 0.0f);
        if (!ItemAdd(bb, 0))
            return;
 
        // Render (we don't hide text after ## in this end-user function)
        RenderTextWrapped(bb.Min, text_begin, text_end, wrap_width);
    }
}

References CalcTextSize(), CalcWrapWidthForPos(), ImGuiWindow::ClipRect, ImGuiWindowTempData::CurrLineTextBaseOffset, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), GetTextLineHeight(), GImGui, IM_ASSERT, ImGuiTextFlags_NoWidthForLargeClippedText, ImMax(), IsClippedEx(), ItemAdd(), ItemSize(), ImGuiContext::LogEnabled, ImRect::Max, ImRect::Min, RenderText(), RenderTextWrapped(), ImGuiWindow::SkipItems, ImGuiWindowTempData::TextWrapPos, ImVec2::x, and ImVec2::y.

Referenced by ColorButton(), ColorEdit4(), ColorPicker4(), ColorTooltip(), DragFloatRange2(), DragIntRange2(), DragScalarN(), InputScalar(), InputScalarN(), SliderScalarN(), TextColoredV(), TextDisabledV(), TextUnformatted(), TextV(), and TextWrappedV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextUnformatted()

void ImGui::TextUnformatted	(	const char *	text,
		const char *	text_end = `NULL`
	)

{
    TextEx(text, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);
}

References ImGuiTextFlags_NoWidthForLargeClippedText, and TextEx().

Referenced by ExampleAppConsole::Draw(), ExampleAppLog::Draw(), EditTableSizingFlags(), HelpMarker(), MetricsHelpMarker(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay(), ShowDemoWindowLayout(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowExampleAppAutoResize(), ShowExampleAppLongText(), ShowMetricsWindow(), ShowStyleEditor(), and Slic3r::GUI::ImGuiWrapper::tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextV()

void ImGui::TextV	(	const char *	fmt,
		va_list	args
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
 
    ImGuiContext& g = *GImGui;
    const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    TextEx(g.TempBuffer, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);
}

References GetCurrentWindow(), GImGui, IM_ARRAYSIZE, ImFormatStringV(), ImGuiTextFlags_NoWidthForLargeClippedText, ImGuiWindow::SkipItems, ImGuiContext::TempBuffer, and TextEx().

Referenced by SetTooltipV(), Text(), TextColoredV(), TextDisabledV(), and TextWrappedV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextWrapped()

void ImGui::TextWrapped	(	const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    TextWrappedV(fmt, args);
    va_end(args);
}

References TextWrappedV().

Referenced by MyDocument::DisplayContents(), ExampleAppConsole::Draw(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowExampleAppLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextWrappedV()

void ImGui::TextWrappedV	(	const char *	fmt,
		va_list	args
	)

{
    ImGuiContext& g = *GImGui;
    bool need_backup = (g.CurrentWindow->DC.TextWrapPos < 0.0f);  // Keep existing wrap position if one is already set
    if (need_backup)
        PushTextWrapPos(0.0f);
    if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
        TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
    else
        TextV(fmt, args);
    if (need_backup)
        PopTextWrapPos();
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiTextFlags_NoWidthForLargeClippedText, PopTextWrapPos(), PushTextWrapPos(), TextEx(), TextV(), and ImGuiWindowTempData::TextWrapPos.

Referenced by TextWrapped().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeAdvanceToLabelPos()

static void ImGui::TreeAdvanceToLabelPos ( )

inlinestatic

2808{ SetCursorPosX(GetCursorPosX() + GetTreeNodeToLabelSpacing()); }

ImGui::GetCursorPosX

IMGUI_API float GetCursorPosX()

Definition imgui.cpp:7499

ImGui::SetCursorPosX

IMGUI_API void SetCursorPosX(float local_x)

Definition imgui.cpp:7518

References GetCursorPosX(), GetTreeNodeToLabelSpacing(), SetCursorPosX(), and TreeAdvanceToLabelPos().

Referenced by TreeAdvanceToLabelPos().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeNode() [1/3]

bool ImGui::TreeNode ( const char * label )

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
    return TreeNodeBehavior(window->GetID(label), 0, label, NULL);
}

References GetCurrentWindow(), ImGuiWindow::GetID(), ImGuiWindow::SkipItems, and TreeNodeBehavior().

Referenced by DebugNodeColumns(), DebugNodeDrawList(), DebugNodeStorage(), DebugNodeTabBar(), DebugNodeTable(), DebugNodeTableSettings(), DebugNodeViewport(), DebugNodeWindow(), DebugNodeWindowsList(), Slic3r::GUI::GLGizmoEmboss::draw_window(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowFont(), ShowFontAtlas(), ShowMetricsWindow(), and ShowPlaceholderObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeNode() [2/3]

bool ImGui::TreeNode	(	const char *	str_id,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    bool is_open = TreeNodeExV(str_id, 0, fmt, args);
    va_end(args);
    return is_open;
}

References TreeNodeExV().

Here is the call graph for this function:

◆ TreeNode() [3/3]

bool ImGui::TreeNode	(	const void *	ptr_id,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    bool is_open = TreeNodeExV(ptr_id, 0, fmt, args);
    va_end(args);
    return is_open;
}

References TreeNodeExV().

Here is the call graph for this function:

◆ TreeNodeBehavior()

bool ImGui::TreeNodeBehavior	(	ImGuiID	id,
		ImGuiTreeNodeFlags	flags,
		const char *	label,
		const char *	label_end = `NULL`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const bool display_frame = (flags & ImGuiTreeNodeFlags_Framed) != 0;
    const ImVec2 padding = (display_frame || (flags & ImGuiTreeNodeFlags_FramePadding)) ? style.FramePadding : ImVec2(style.FramePadding.x, ImMin(window->DC.CurrLineTextBaseOffset, style.FramePadding.y));
 
    if (!label_end)
        label_end = FindRenderedTextEnd(label);
    const ImVec2 label_size = CalcTextSize(label, label_end, false);
 
    // We vertically grow up to current line height up the typical widget height.
    const float frame_height = ImMax(ImMin(window->DC.CurrLineSize.y, g.FontSize + style.FramePadding.y * 2), label_size.y + padding.y * 2);
    ImRect frame_bb;
    frame_bb.Min.x = (flags & ImGuiTreeNodeFlags_SpanFullWidth) ? window->WorkRect.Min.x : window->DC.CursorPos.x;
    frame_bb.Min.y = window->DC.CursorPos.y;
    frame_bb.Max.x = window->WorkRect.Max.x;
    frame_bb.Max.y = window->DC.CursorPos.y + frame_height;
    if (display_frame)
    {
        // Framed header expand a little outside the default padding, to the edge of InnerClipRect
        // (FIXME: May remove this at some point and make InnerClipRect align with WindowPadding.x instead of WindowPadding.x*0.5f)
        frame_bb.Min.x -= IM_FLOOR(window->WindowPadding.x * 0.5f - 1.0f);
        frame_bb.Max.x += IM_FLOOR(window->WindowPadding.x * 0.5f);
    }
 
    const float text_offset_x = g.FontSize + (display_frame ? padding.x * 3 : padding.x * 2);           // Collapser arrow width + Spacing
    const float text_offset_y = ImMax(padding.y, window->DC.CurrLineTextBaseOffset);                    // Latch before ItemSize changes it
    const float text_width = g.FontSize + (label_size.x > 0.0f ? label_size.x + padding.x * 2 : 0.0f);  // Include collapser
    ImVec2 text_pos(window->DC.CursorPos.x + text_offset_x, window->DC.CursorPos.y + text_offset_y);
    ItemSize(ImVec2(text_width, frame_height), padding.y);
 
    // For regular tree nodes, we arbitrary allow to click past 2 worth of ItemSpacing
    ImRect interact_bb = frame_bb;
    if (!display_frame && (flags & (ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_SpanFullWidth)) == 0)
        interact_bb.Max.x = frame_bb.Min.x + text_width + style.ItemSpacing.x * 2.0f;
 
    // Store a flag for the current depth to tell if we will allow closing this node when navigating one of its child.
    // For this purpose we essentially compare if g.NavIdIsAlive went from 0 to 1 between TreeNode() and TreePop().
    // This is currently only support 32 level deep and we are fine with (1 << Depth) overflowing into a zero.
    const bool is_leaf = (flags & ImGuiTreeNodeFlags_Leaf) != 0;
    bool is_open = TreeNodeBehaviorIsOpen(id, flags);
    if (is_open && !g.NavIdIsAlive && (flags & ImGuiTreeNodeFlags_NavLeftJumpsBackHere) && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
        window->DC.TreeJumpToParentOnPopMask |= (1 << window->DC.TreeDepth);
 
    bool item_add = ItemAdd(interact_bb, id);
    window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_HasDisplayRect;
    window->DC.LastItemDisplayRect = frame_bb;
 
    if (!item_add)
    {
        if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
            TreePushOverrideID(id);
        IMGUI_TEST_ENGINE_ITEM_INFO(window->DC.LastItemId, label, window->DC.LastItemStatusFlags | (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) | (is_open ? ImGuiItemStatusFlags_Opened : 0));
        return is_open;
    }
 
    ImGuiButtonFlags button_flags = ImGuiTreeNodeFlags_None;
    if (flags & ImGuiTreeNodeFlags_AllowItemOverlap)
        button_flags |= ImGuiButtonFlags_AllowItemOverlap;
    if (!is_leaf)
        button_flags |= ImGuiButtonFlags_PressedOnDragDropHold;
 
    // We allow clicking on the arrow section with keyboard modifiers held, in order to easily
    // allow browsing a tree while preserving selection with code implementing multi-selection patterns.
    // When clicking on the rest of the tree node we always disallow keyboard modifiers.
    const float arrow_hit_x1 = (text_pos.x - text_offset_x) - style.TouchExtraPadding.x;
    const float arrow_hit_x2 = (text_pos.x - text_offset_x) + (g.FontSize + padding.x * 2.0f) + style.TouchExtraPadding.x;
    const bool is_mouse_x_over_arrow = (g.IO.MousePos.x >= arrow_hit_x1 && g.IO.MousePos.x < arrow_hit_x2);
    if (window != g.HoveredWindow || !is_mouse_x_over_arrow)
        button_flags |= ImGuiButtonFlags_NoKeyModifiers;
 
    // Open behaviors can be altered with the _OpenOnArrow and _OnOnDoubleClick flags.
    // Some alteration have subtle effects (e.g. toggle on MouseUp vs MouseDown events) due to requirements for multi-selection and drag and drop support.
    // - Single-click on label = Toggle on MouseUp (default, when _OpenOnArrow=0)
    // - Single-click on arrow = Toggle on MouseDown (when _OpenOnArrow=0)
    // - Single-click on arrow = Toggle on MouseDown (when _OpenOnArrow=1)
    // - Double-click on label = Toggle on MouseDoubleClick (when _OpenOnDoubleClick=1)
    // - Double-click on arrow = Toggle on MouseDoubleClick (when _OpenOnDoubleClick=1 and _OpenOnArrow=0)
    // It is rather standard that arrow click react on Down rather than Up.
    // We set ImGuiButtonFlags_PressedOnClickRelease on OpenOnDoubleClick because we want the item to be active on the initial MouseDown in order for drag and drop to work.
    if (is_mouse_x_over_arrow)
        button_flags |= ImGuiButtonFlags_PressedOnClick;
    else if (flags & ImGuiTreeNodeFlags_OpenOnDoubleClick)
        button_flags |= ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnDoubleClick;
    else
        button_flags |= ImGuiButtonFlags_PressedOnClickRelease;
 
    bool selected = (flags & ImGuiTreeNodeFlags_Selected) != 0;
    const bool was_selected = selected;
 
    bool hovered, held;
    bool pressed = ButtonBehavior(interact_bb, id, &hovered, &held, button_flags);
    bool toggled = false;
    if (!is_leaf)
    {
        if (pressed && g.DragDropHoldJustPressedId != id)
        {
            if ((flags & (ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick)) == 0 || (g.NavActivateId == id))
                toggled = true;
            if (flags & ImGuiTreeNodeFlags_OpenOnArrow)
                toggled |= is_mouse_x_over_arrow && !g.NavDisableMouseHover; // Lightweight equivalent of IsMouseHoveringRect() since ButtonBehavior() already did the job
            if ((flags & ImGuiTreeNodeFlags_OpenOnDoubleClick) && g.IO.MouseDoubleClicked[0])
                toggled = true;
        }
        else if (pressed && g.DragDropHoldJustPressedId == id)
        {
            IM_ASSERT(button_flags & ImGuiButtonFlags_PressedOnDragDropHold);
            if (!is_open) // When using Drag and Drop "hold to open" we keep the node highlighted after opening, but never close it again.
                toggled = true;
        }
 
        if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Left && is_open)
        {
            toggled = true;
            NavMoveRequestCancel();
        }
        if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Right && !is_open) // If there's something upcoming on the line we may want to give it the priority?
        {
            toggled = true;
            NavMoveRequestCancel();
        }
 
        if (toggled)
        {
            is_open = !is_open;
            window->DC.StateStorage->SetInt(id, is_open);
            window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_ToggledOpen;
        }
    }
    if (flags & ImGuiTreeNodeFlags_AllowItemOverlap)
        SetItemAllowOverlap();
 
    // In this branch, TreeNodeBehavior() cannot toggle the selection so this will never trigger.
    if (selected != was_selected) //-V547
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_ToggledSelection;
 
    // Render
    const ImU32 text_col = GetColorU32(ImGuiCol_Text);
    ImGuiNavHighlightFlags nav_highlight_flags = ImGuiNavHighlightFlags_TypeThin;
    if (display_frame)
    {
        // Framed type
        const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
        RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, true, style.FrameRounding);
        RenderNavHighlight(frame_bb, id, nav_highlight_flags);
        if (flags & ImGuiTreeNodeFlags_Bullet)
            RenderBullet(window->DrawList, ImVec2(text_pos.x - text_offset_x * 0.60f, text_pos.y + g.FontSize * 0.5f), text_col);
        else if (!is_leaf)
            RenderArrow(window->DrawList, ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y), text_col, is_open ? ImGuiDir_Down : ImGuiDir_Right, 1.0f);
        else // Leaf without bullet, left-adjusted text
            text_pos.x -= text_offset_x;
        if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)
            frame_bb.Max.x -= g.FontSize + style.FramePadding.x;
 
        if (g.LogEnabled)
            LogSetNextTextDecoration("###", "###");
        RenderTextClipped(text_pos, frame_bb.Max, label, label_end, &label_size);
    }
    else
    {
        // Unframed typed for tree nodes
        if (hovered || selected)
        {
            const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
            RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, false);
            RenderNavHighlight(frame_bb, id, nav_highlight_flags);
        }
        if (flags & ImGuiTreeNodeFlags_Bullet)
            RenderBullet(window->DrawList, ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f), text_col);
        else if (!is_leaf)
            RenderArrow(window->DrawList, ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.15f), text_col, is_open ? ImGuiDir_Down : ImGuiDir_Right, 0.70f);
        if (g.LogEnabled)
            LogSetNextTextDecoration(">", NULL);
        RenderText(text_pos, label, label_end, false);
    }
 
    if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
        TreePushOverrideID(id);
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags | (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) | (is_open ? ImGuiItemStatusFlags_Opened : 0));
    return is_open;
}

Referenced by CollapsingHeader(), CollapsingHeader(), TreeNode(), TreeNodeEx(), TreeNodeExV(), and TreeNodeExV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeNodeBehaviorIsOpen()

bool ImGui::TreeNodeBehaviorIsOpen	(	ImGuiID	id,
		ImGuiTreeNodeFlags	flags = `0`
	)

{
    if (flags & ImGuiTreeNodeFlags_Leaf)
        return true;
 
    // We only write to the tree storage if the user clicks (or explicitly use the SetNextItemOpen function)
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiStorage* storage = window->DC.StateStorage;
 
    bool is_open;
    if (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasOpen)
    {
        if (g.NextItemData.OpenCond & ImGuiCond_Always)
        {
            is_open = g.NextItemData.OpenVal;
            storage->SetInt(id, is_open);
        }
        else
        {
            // We treat ImGuiCond_Once and ImGuiCond_FirstUseEver the same because tree node state are not saved persistently.
            const int stored_value = storage->GetInt(id, -1);
            if (stored_value == -1)
            {
                is_open = g.NextItemData.OpenVal;
                storage->SetInt(id, is_open);
            }
            else
            {
                is_open = stored_value != 0;
            }
        }
    }
    else
    {
        is_open = storage->GetInt(id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;
    }
 
    // When logging is enabled, we automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behavior).
    // NB- If we are above max depth we still allow manually opened nodes to be logged.
    if (g.LogEnabled && !(flags & ImGuiTreeNodeFlags_NoAutoOpenOnLog) && (window->DC.TreeDepth - g.LogDepthRef) < g.LogDepthToExpand)
        is_open = true;
 
    return is_open;
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiNextItemData::Flags, ImGuiStorage::GetInt(), GImGui, ImGuiCond_Always, ImGuiNextItemDataFlags_HasOpen, ImGuiTreeNodeFlags_DefaultOpen, ImGuiTreeNodeFlags_Leaf, ImGuiTreeNodeFlags_NoAutoOpenOnLog, ImGuiContext::LogDepthRef, ImGuiContext::LogDepthToExpand, ImGuiContext::LogEnabled, ImGuiContext::NextItemData, ImGuiNextItemData::OpenCond, ImGuiNextItemData::OpenVal, ImGuiStorage::SetInt(), ImGuiWindowTempData::StateStorage, and ImGuiWindowTempData::TreeDepth.

Referenced by TreeNodeBehavior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeNodeEx() [1/3]

bool ImGui::TreeNodeEx	(	const char *	label,
		ImGuiTreeNodeFlags	flags = `0`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    return TreeNodeBehavior(window->GetID(label), flags, label, NULL);
}

References GetCurrentWindow(), ImGuiWindow::GetID(), ImGuiWindow::SkipItems, and TreeNodeBehavior().

Referenced by DebugNodeWindow(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), and ShowPlaceholderObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeNodeEx() [2/3]

bool ImGui::TreeNodeEx	(	const char *	str_id,
		ImGuiTreeNodeFlags	flags,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    bool is_open = TreeNodeExV(str_id, flags, fmt, args);
    va_end(args);
    return is_open;
}

References TreeNodeExV().

Here is the call graph for this function:

◆ TreeNodeEx() [3/3]

bool ImGui::TreeNodeEx	(	const void *	ptr_id,
		ImGuiTreeNodeFlags	flags,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
    bool is_open = TreeNodeExV(ptr_id, flags, fmt, args);
    va_end(args);
    return is_open;
}

References TreeNodeExV().

Here is the call graph for this function:

◆ TreeNodeExV() [1/2]

bool ImGui::TreeNodeExV	(	const char *	str_id,
		ImGuiTreeNodeFlags	flags,
		const char *	fmt,
		va_list	args
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const char* label_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    return TreeNodeBehavior(window->GetID(str_id), flags, g.TempBuffer, label_end);
}

References GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, IM_ARRAYSIZE, ImFormatStringV(), ImGuiWindow::SkipItems, ImGuiContext::TempBuffer, and TreeNodeBehavior().

Referenced by TreeNode(), TreeNode(), TreeNodeEx(), TreeNodeEx(), TreeNodeV(), and TreeNodeV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreeNodeExV() [2/2]

bool ImGui::TreeNodeExV	(	const void *	ptr_id,
		ImGuiTreeNodeFlags	flags,
		const char *	fmt,
		va_list	args
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const char* label_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    return TreeNodeBehavior(window->GetID(ptr_id), flags, g.TempBuffer, label_end);
}

References GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, IM_ARRAYSIZE, ImFormatStringV(), ImGuiWindow::SkipItems, ImGuiContext::TempBuffer, and TreeNodeBehavior().

Here is the call graph for this function:

◆ TreeNodeV() [1/2]

bool ImGui::TreeNodeV	(	const char *	str_id,
		const char *	fmt,
		va_list	args
	)

{
    return TreeNodeExV(str_id, 0, fmt, args);
}

References TreeNodeExV().

Here is the call graph for this function:

◆ TreeNodeV() [2/2]

bool ImGui::TreeNodeV	(	const void *	ptr_id,
		const char *	fmt,
		va_list	args
	)

{
    return TreeNodeExV(ptr_id, 0, fmt, args);
}

References TreeNodeExV().

Here is the call graph for this function:

◆ TreePop()

void ImGui::TreePop ( )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    Unindent();
 
    window->DC.TreeDepth--;
    ImU32 tree_depth_mask = (1 << window->DC.TreeDepth);
 
    // Handle Left arrow to move to parent tree node (when ImGuiTreeNodeFlags_NavLeftJumpsBackHere is enabled)
    if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window && NavMoveRequestButNoResultYet())
        if (g.NavIdIsAlive && (window->DC.TreeJumpToParentOnPopMask & tree_depth_mask))
        {
            SetNavID(window->IDStack.back(), g.NavLayer, 0, ImRect());
            NavMoveRequestCancel();
        }
    window->DC.TreeJumpToParentOnPopMask &= tree_depth_mask - 1;
 
    IM_ASSERT(window->IDStack.Size > 1); // There should always be 1 element in the IDStack (pushed during window creation). If this triggers you called TreePop/PopID too much.
    PopID();
}

References ImVector< T >::back(), ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiWindow::IDStack, IM_ASSERT, ImGuiDir_Left, ImGuiContext::NavIdIsAlive, ImGuiContext::NavLayer, ImGuiContext::NavMoveDir, NavMoveRequestButNoResultYet(), NavMoveRequestCancel(), ImGuiContext::NavWindow, PopID(), SetNavID(), ImVector< T >::Size, ImGuiWindowTempData::TreeDepth, ImGuiWindowTempData::TreeJumpToParentOnPopMask, and Unindent().

Referenced by DebugNodeColumns(), DebugNodeDrawList(), DebugNodeStorage(), DebugNodeTabBar(), DebugNodeTable(), DebugNodeTableSettings(), DebugNodeViewport(), DebugNodeWindow(), DebugNodeWindowsList(), Slic3r::GUI::GLGizmoEmboss::draw_window(), ErrorCheckEndFrameRecover(), ShowDemoWindow(), ShowDemoWindowColumns(), ShowDemoWindowLayout(), ShowDemoWindowMisc(), ShowDemoWindowPopups(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowFont(), ShowFontAtlas(), ShowMetricsWindow(), and ShowPlaceholderObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TreePush() [1/2]

void ImGui::TreePush ( const char * str_id )

{
    ImGuiWindow* window = GetCurrentWindow();
    Indent();
    window->DC.TreeDepth++;
    PushID(str_id ? str_id : "#TreePush");
}

References ImGuiWindow::DC, GetCurrentWindow(), Indent(), PushID(), and ImGuiWindowTempData::TreeDepth.

Here is the call graph for this function:

◆ TreePush() [2/2]

void ImGui::TreePush ( const void * ptr_id = NULL )

{
    ImGuiWindow* window = GetCurrentWindow();
    Indent();
    window->DC.TreeDepth++;
    PushID(ptr_id ? ptr_id : (const void*)"#TreePush");
}

References ImGuiWindow::DC, GetCurrentWindow(), Indent(), PushID(), and ImGuiWindowTempData::TreeDepth.

Here is the call graph for this function:

◆ TreePushOverrideID()

void ImGui::TreePushOverrideID ( ImGuiID id )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    Indent();
    window->DC.TreeDepth++;
    window->IDStack.push_back(id);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiWindow::IDStack, Indent(), ImVector< T >::push_back(), and ImGuiWindowTempData::TreeDepth.

Referenced by TreeNodeBehavior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Unindent()

void ImGui::Unindent ( float indent_w = 0.0f )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.Indent.x -= (indent_w != 0.0f) ? indent_w : g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x;
}

References ImGuiWindowTempData::ColumnsOffset, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, GetCurrentWindow(), GImGui, ImGuiWindowTempData::Indent, ImGuiStyle::IndentSpacing, ImGuiWindow::Pos, ImGuiContext::Style, ImVec2::x, and ImVec1::x.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_window(), ShowDemoWindowLayout(), ShowDemoWindowTables(), ShowDemoWindowWidgets(), ShowExampleAppFullscreen(), ShowMetricsWindow(), ShowUserGuide(), and TreePop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDebugToolItemPicker()

void ImGui::UpdateDebugToolItemPicker ( )

static

{
    ImGuiContext& g = *GImGui;
    g.DebugItemPickerBreakId = 0;
    if (g.DebugItemPickerActive)
    {
        const ImGuiID hovered_id = g.HoveredIdPreviousFrame;
        SetMouseCursor(ImGuiMouseCursor_Hand);
        if (IsKeyPressedMap(ImGuiKey_Escape))
            g.DebugItemPickerActive = false;
        if (IsMouseClicked(0) && hovered_id)
        {
            g.DebugItemPickerBreakId = hovered_id;
            g.DebugItemPickerActive = false;
        }
        SetNextWindowBgAlpha(0.60f);
        BeginTooltip();
        Text("HoveredId: 0x%08X", hovered_id);
        Text("Press ESC to abort picking.");
        TextColored(GetStyleColorVec4(hovered_id ? ImGuiCol_Text : ImGuiCol_TextDisabled), "Click to break in debugger!");
        EndTooltip();
    }
}

References BeginTooltip(), ImGuiContext::DebugItemPickerActive, ImGuiContext::DebugItemPickerBreakId, EndTooltip(), GetStyleColorVec4(), GImGui, ImGuiContext::HoveredIdPreviousFrame, ImGuiCol_Text, ImGuiCol_TextDisabled, ImGuiKey_Escape, ImGuiMouseCursor_Hand, IsKeyPressedMap(), IsMouseClicked(), SetMouseCursor(), SetNextWindowBgAlpha(), Text(), and TextColored().

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateHoveredWindowAndCaptureFlags()

void ImGui::UpdateHoveredWindowAndCaptureFlags ( )

{
    ImGuiContext& g = *GImGui;
    g.WindowsHoverPadding = ImMax(g.Style.TouchExtraPadding, ImVec2(WINDOWS_HOVER_PADDING, WINDOWS_HOVER_PADDING));
 
    // Find the window hovered by mouse:
    // - Child windows can extend beyond the limit of their parent so we need to derive HoveredRootWindow from HoveredWindow.
    // - When moving a window we can skip the search, which also conveniently bypasses the fact that window->WindowRectClipped is lagging as this point of the frame.
    // - We also support the moved window toggling the NoInputs flag after moving has started in order to be able to detect windows below it, which is useful for e.g. docking mechanisms.
    bool clear_hovered_windows = false;
    FindHoveredWindow();
 
    // Modal windows prevents mouse from hovering behind them.
    ImGuiWindow* modal_window = GetTopMostPopupModal();
    if (modal_window && g.HoveredWindow && !IsWindowChildOf(g.HoveredWindow->RootWindow, modal_window))
        clear_hovered_windows = true;
 
    // Disabled mouse?
    if (g.IO.ConfigFlags & ImGuiConfigFlags_NoMouse)
        clear_hovered_windows = true;
 
    // We track click ownership. When clicked outside of a window the click is owned by the application and won't report hovering nor request capture even while dragging over our windows afterward.
    int mouse_earliest_button_down = -1;
    bool mouse_any_down = false;
    for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++)
    {
        if (g.IO.MouseClicked[i])
            g.IO.MouseDownOwned[i] = (g.HoveredWindow != NULL) || (g.OpenPopupStack.Size > 0);
        mouse_any_down |= g.IO.MouseDown[i];
        if (g.IO.MouseDown[i])
            if (mouse_earliest_button_down == -1 || g.IO.MouseClickedTime[i] < g.IO.MouseClickedTime[mouse_earliest_button_down])
                mouse_earliest_button_down = i;
    }
    const bool mouse_avail_to_imgui = (mouse_earliest_button_down == -1) || g.IO.MouseDownOwned[mouse_earliest_button_down];
 
    // If mouse was first clicked outside of ImGui bounds we also cancel out hovering.
    // FIXME: For patterns of drag and drop across OS windows, we may need to rework/remove this test (first committed 311c0ca9 on 2015/02)
    const bool mouse_dragging_extern_payload = g.DragDropActive && (g.DragDropSourceFlags & ImGuiDragDropFlags_SourceExtern) != 0;
    if (!mouse_avail_to_imgui && !mouse_dragging_extern_payload)
        clear_hovered_windows = true;
 
    if (clear_hovered_windows)
        g.HoveredWindow = g.HoveredWindowUnderMovingWindow = NULL;
 
    // Update io.WantCaptureMouse for the user application (true = dispatch mouse info to imgui, false = dispatch mouse info to Dear ImGui + app)
    if (g.WantCaptureMouseNextFrame != -1)
        g.IO.WantCaptureMouse = (g.WantCaptureMouseNextFrame != 0);
    else
        g.IO.WantCaptureMouse = (mouse_avail_to_imgui && (g.HoveredWindow != NULL || mouse_any_down)) || (g.OpenPopupStack.Size > 0);
 
    // Update io.WantCaptureKeyboard for the user application (true = dispatch keyboard info to imgui, false = dispatch keyboard info to Dear ImGui + app)
    if (g.WantCaptureKeyboardNextFrame != -1)
        g.IO.WantCaptureKeyboard = (g.WantCaptureKeyboardNextFrame != 0);
    else
        g.IO.WantCaptureKeyboard = (g.ActiveId != 0) || (modal_window != NULL);
    if (g.IO.NavActive && (g.IO.ConfigFlags & ImGuiConfigFlags_NavEnableKeyboard) && !(g.IO.ConfigFlags & ImGuiConfigFlags_NavNoCaptureKeyboard))
        g.IO.WantCaptureKeyboard = true;
 
    // Update io.WantTextInput flag, this is to allow systems without a keyboard (e.g. mobile, hand-held) to show a software keyboard if possible
    g.IO.WantTextInput = (g.WantTextInputNextFrame != -1) ? (g.WantTextInputNextFrame != 0) : false;
}

References ImGuiContext::ActiveId, ImGuiIO::ConfigFlags, ImGuiContext::DragDropActive, ImGuiContext::DragDropSourceFlags, FindHoveredWindow(), GetTopMostPopupModal(), GImGui, ImGuiContext::HoveredWindow, ImGuiContext::HoveredWindowUnderMovingWindow, IM_ARRAYSIZE, ImGuiConfigFlags_NavEnableKeyboard, ImGuiConfigFlags_NavNoCaptureKeyboard, ImGuiConfigFlags_NoMouse, ImGuiDragDropFlags_SourceExtern, ImMax(), ImGuiContext::IO, IsWindowChildOf(), ImGuiIO::MouseClicked, ImGuiIO::MouseClickedTime, ImGuiIO::MouseDown, ImGuiIO::MouseDownOwned, ImGuiIO::NavActive, ImGuiContext::OpenPopupStack, ImGuiWindow::RootWindow, ImVector< T >::Size, ImGuiContext::Style, ImGuiStyle::TouchExtraPadding, ImGuiIO::WantCaptureKeyboard, ImGuiContext::WantCaptureKeyboardNextFrame, ImGuiIO::WantCaptureMouse, ImGuiContext::WantCaptureMouseNextFrame, ImGuiIO::WantTextInput, ImGuiContext::WantTextInputNextFrame, WINDOWS_HOVER_PADDING, and ImGuiContext::WindowsHoverPadding.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMouseInputs()

static void ImGui::UpdateMouseInputs ( )

static

{
    ImGuiContext& g = *GImGui;
 
    // Round mouse position to avoid spreading non-rounded position (e.g. UpdateManualResize doesn't support them well)
    if (IsMousePosValid(&g.IO.MousePos))
        g.IO.MousePos = g.LastValidMousePos = ImFloor(g.IO.MousePos);
 
    // If mouse just appeared or disappeared (usually denoted by -FLT_MAX components) we cancel out movement in MouseDelta
    if (IsMousePosValid(&g.IO.MousePos) && IsMousePosValid(&g.IO.MousePosPrev))
        g.IO.MouseDelta = g.IO.MousePos - g.IO.MousePosPrev;
    else
        g.IO.MouseDelta = ImVec2(0.0f, 0.0f);
    if (g.IO.MouseDelta.x != 0.0f || g.IO.MouseDelta.y != 0.0f)
        g.NavDisableMouseHover = false;
 
    g.IO.MousePosPrev = g.IO.MousePos;
    for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++)
    {
        g.IO.MouseClicked[i] = g.IO.MouseDown[i] && g.IO.MouseDownDuration[i] < 0.0f;
        g.IO.MouseReleased[i] = !g.IO.MouseDown[i] && g.IO.MouseDownDuration[i] >= 0.0f;
        g.IO.MouseDownDurationPrev[i] = g.IO.MouseDownDuration[i];
        g.IO.MouseDownDuration[i] = g.IO.MouseDown[i] ? (g.IO.MouseDownDuration[i] < 0.0f ? 0.0f : g.IO.MouseDownDuration[i] + g.IO.DeltaTime) : -1.0f;
        g.IO.MouseDoubleClicked[i] = false;
        if (g.IO.MouseClicked[i])
        {
            if ((float)(g.Time - g.IO.MouseClickedTime[i]) < g.IO.MouseDoubleClickTime)
            {
                ImVec2 delta_from_click_pos = IsMousePosValid(&g.IO.MousePos) ? (g.IO.MousePos - g.IO.MouseClickedPos[i]) : ImVec2(0.0f, 0.0f);
                if (ImLengthSqr(delta_from_click_pos) < g.IO.MouseDoubleClickMaxDist * g.IO.MouseDoubleClickMaxDist)
                    g.IO.MouseDoubleClicked[i] = true;
                g.IO.MouseClickedTime[i] = -g.IO.MouseDoubleClickTime * 2.0f; // Mark as "old enough" so the third click isn't turned into a double-click
            }
            else
            {
                g.IO.MouseClickedTime[i] = g.Time;
            }
            g.IO.MouseClickedPos[i] = g.IO.MousePos;
            g.IO.MouseDownWasDoubleClick[i] = g.IO.MouseDoubleClicked[i];
            g.IO.MouseDragMaxDistanceAbs[i] = ImVec2(0.0f, 0.0f);
            g.IO.MouseDragMaxDistanceSqr[i] = 0.0f;
        }
        else if (g.IO.MouseDown[i])
        {
            // Maintain the maximum distance we reaching from the initial click position, which is used with dragging threshold
            ImVec2 delta_from_click_pos = IsMousePosValid(&g.IO.MousePos) ? (g.IO.MousePos - g.IO.MouseClickedPos[i]) : ImVec2(0.0f, 0.0f);
            g.IO.MouseDragMaxDistanceSqr[i] = ImMax(g.IO.MouseDragMaxDistanceSqr[i], ImLengthSqr(delta_from_click_pos));
            g.IO.MouseDragMaxDistanceAbs[i].x = ImMax(g.IO.MouseDragMaxDistanceAbs[i].x, delta_from_click_pos.x < 0.0f ? -delta_from_click_pos.x : delta_from_click_pos.x);
            g.IO.MouseDragMaxDistanceAbs[i].y = ImMax(g.IO.MouseDragMaxDistanceAbs[i].y, delta_from_click_pos.y < 0.0f ? -delta_from_click_pos.y : delta_from_click_pos.y);
        }
        if (!g.IO.MouseDown[i] && !g.IO.MouseReleased[i])
            g.IO.MouseDownWasDoubleClick[i] = false;
        if (g.IO.MouseClicked[i]) // Clicking any mouse button reactivate mouse hovering which may have been deactivated by gamepad/keyboard navigation
            g.NavDisableMouseHover = false;
    }
}

References ImGuiIO::DeltaTime, GImGui, IM_ARRAYSIZE, ImFloor(), ImLengthSqr(), ImMax(), ImGuiContext::IO, IsMousePosValid(), ImGuiContext::LastValidMousePos, ImGuiIO::MouseClicked, ImGuiIO::MouseClickedPos, ImGuiIO::MouseClickedTime, ImGuiIO::MouseDelta, ImGuiIO::MouseDoubleClicked, ImGuiIO::MouseDoubleClickMaxDist, ImGuiIO::MouseDoubleClickTime, ImGuiIO::MouseDown, ImGuiIO::MouseDownDuration, ImGuiIO::MouseDownDurationPrev, ImGuiIO::MouseDownWasDoubleClick, ImGuiIO::MouseDragMaxDistanceAbs, ImGuiIO::MouseDragMaxDistanceSqr, ImGuiIO::MousePos, ImGuiIO::MousePosPrev, ImGuiIO::MouseReleased, ImGuiContext::NavDisableMouseHover, ImGuiContext::Time, ImVec2::x, and ImVec2::y.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMouseMovingWindowEndFrame()

void ImGui::UpdateMouseMovingWindowEndFrame ( )

{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId != 0 || g.HoveredId != 0)
        return;
 
    // Unless we just made a window/popup appear
    if (g.NavWindow && g.NavWindow->Appearing)
        return;
 
    // Click on empty space to focus window and start moving
    // (after we're done with all our widgets)
    if (g.IO.MouseClicked[0])
    {
        // Handle the edge case of a popup being closed while clicking in its empty space.
        // If we try to focus it, FocusWindow() > ClosePopupsOverWindow() will accidentally close any parent popups because they are not linked together any more.
        ImGuiWindow* root_window = g.HoveredWindow ? g.HoveredWindow->RootWindow : NULL;
        const bool is_closed_popup = root_window && (root_window->Flags & ImGuiWindowFlags_Popup) && !IsPopupOpen(root_window->PopupId, ImGuiPopupFlags_AnyPopupLevel);
 
        if (root_window != NULL && !is_closed_popup)
        {
            StartMouseMovingWindow(g.HoveredWindow); //-V595
 
            // Cancel moving if clicked outside of title bar
            if (g.IO.ConfigWindowsMoveFromTitleBarOnly && !(root_window->Flags & ImGuiWindowFlags_NoTitleBar))
                if (!root_window->TitleBarRect().Contains(g.IO.MouseClickedPos[0]))
                    g.MovingWindow = NULL;
 
            // Cancel moving if clicked over an item which was disabled or inhibited by popups (note that we know HoveredId == 0 already)
            if (g.HoveredIdDisabled)
                g.MovingWindow = NULL;
        }
        else if (root_window == NULL && g.NavWindow != NULL && GetTopMostPopupModal() == NULL)
        {
            // Clicking on void disable focus
            FocusWindow(NULL);
        }
    }
 
    // With right mouse button we close popups without changing focus based on where the mouse is aimed
    // Instead, focus will be restored to the window under the bottom-most closed popup.
    // (The left mouse button path calls FocusWindow on the hovered window, which will lead NewFrame->ClosePopupsOverWindow to trigger)
    if (g.IO.MouseClicked[1])
    {
        // Find the top-most window between HoveredWindow and the top-most Modal Window.
        // This is where we can trim the popup stack.
        ImGuiWindow* modal = GetTopMostPopupModal();
        bool hovered_window_above_modal = g.HoveredWindow && IsWindowAbove(g.HoveredWindow, modal);
        ClosePopupsOverWindow(hovered_window_above_modal ? g.HoveredWindow : modal, true);
    }
}

References ImGuiContext::ActiveId, ImGuiWindow::Appearing, ClosePopupsOverWindow(), ImGuiIO::ConfigWindowsMoveFromTitleBarOnly, ImRect::Contains(), ImGuiWindow::Flags, FocusWindow(), GetTopMostPopupModal(), GImGui, ImGuiContext::HoveredId, ImGuiContext::HoveredIdDisabled, ImGuiContext::HoveredWindow, ImGuiPopupFlags_AnyPopupLevel, ImGuiWindowFlags_NoTitleBar, ImGuiWindowFlags_Popup, ImGuiContext::IO, IsPopupOpen(), IsWindowAbove(), ImGuiIO::MouseClicked, ImGuiIO::MouseClickedPos, ImGuiContext::MovingWindow, ImGuiContext::NavWindow, ImGuiWindow::PopupId, ImGuiWindow::RootWindow, StartMouseMovingWindow(), and ImGuiWindow::TitleBarRect().

Referenced by EndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMouseMovingWindowNewFrame()

void ImGui::UpdateMouseMovingWindowNewFrame ( )

{
    ImGuiContext& g = *GImGui;
    if (g.MovingWindow != NULL)
    {
        // We actually want to move the root window. g.MovingWindow == window we clicked on (could be a child window).
        // We track it to preserve Focus and so that generally ActiveIdWindow == MovingWindow and ActiveId == MovingWindow->MoveId for consistency.
        KeepAliveID(g.ActiveId);
        IM_ASSERT(g.MovingWindow && g.MovingWindow->RootWindow);
        ImGuiWindow* moving_window = g.MovingWindow->RootWindow;
        if (g.IO.MouseDown[0] && IsMousePosValid(&g.IO.MousePos))
        {
            ImVec2 pos = g.IO.MousePos - g.ActiveIdClickOffset;
            if (moving_window->Pos.x != pos.x || moving_window->Pos.y != pos.y)
            {
                MarkIniSettingsDirty(moving_window);
                SetWindowPos(moving_window, pos, ImGuiCond_Always);
            }
            FocusWindow(g.MovingWindow);
        }
        else
        {
            ClearActiveID();
            g.MovingWindow = NULL;
        }
    }
    else
    {
        // When clicking/dragging from a window that has the _NoMove flag, we still set the ActiveId in order to prevent hovering others.
        if (g.ActiveIdWindow && g.ActiveIdWindow->MoveId == g.ActiveId)
        {
            KeepAliveID(g.ActiveId);
            if (!g.IO.MouseDown[0])
                ClearActiveID();
        }
    }
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdClickOffset, ImGuiContext::ActiveIdWindow, ClearActiveID(), FocusWindow(), GImGui, IM_ASSERT, ImGuiCond_Always, ImGuiContext::IO, IsMousePosValid(), KeepAliveID(), MarkIniSettingsDirty(), ImGuiIO::MouseDown, ImGuiIO::MousePos, ImGuiWindow::MoveId, ImGuiContext::MovingWindow, ImGuiWindow::Pos, ImGuiWindow::RootWindow, SetWindowPos(), ImVec2::x, and ImVec2::y.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMouseWheel()

void ImGui::UpdateMouseWheel ( )

static

{
    ImGuiContext& g = *GImGui;
 
    // Reset the locked window if we move the mouse or after the timer elapses
    if (g.WheelingWindow != NULL)
    {
        g.WheelingWindowTimer -= g.IO.DeltaTime;
        if (IsMousePosValid() && ImLengthSqr(g.IO.MousePos - g.WheelingWindowRefMousePos) > g.IO.MouseDragThreshold * g.IO.MouseDragThreshold)
            g.WheelingWindowTimer = 0.0f;
        if (g.WheelingWindowTimer <= 0.0f)
        {
            g.WheelingWindow = NULL;
            g.WheelingWindowTimer = 0.0f;
        }
    }
 
    if (g.IO.MouseWheel == 0.0f && g.IO.MouseWheelH == 0.0f)
        return;
 
    if ((g.ActiveId != 0 && g.ActiveIdUsingMouseWheel) || (g.HoveredIdPreviousFrame != 0 && g.HoveredIdPreviousFrameUsingMouseWheel))
        return;
 
    ImGuiWindow* window = g.WheelingWindow ? g.WheelingWindow : g.HoveredWindow;
    if (!window || window->Collapsed)
        return;
 
    // Zoom / Scale window
    // FIXME-OBSOLETE: This is an old feature, it still works but pretty much nobody is using it and may be best redesigned.
    if (g.IO.MouseWheel != 0.0f && g.IO.KeyCtrl && g.IO.FontAllowUserScaling)
    {
        StartLockWheelingWindow(window);
        const float new_font_scale = ImClamp(window->FontWindowScale + g.IO.MouseWheel * 0.10f, 0.50f, 2.50f);
        const float scale = new_font_scale / window->FontWindowScale;
        window->FontWindowScale = new_font_scale;
        if (window == window->RootWindow)
        {
            const ImVec2 offset = window->Size * (1.0f - scale) * (g.IO.MousePos - window->Pos) / window->Size;
            SetWindowPos(window, window->Pos + offset, 0);
            window->Size = ImFloor(window->Size * scale);
            window->SizeFull = ImFloor(window->SizeFull * scale);
        }
        return;
    }
 
    // Mouse wheel scrolling
    // If a child window has the ImGuiWindowFlags_NoScrollWithMouse flag, we give a chance to scroll its parent
    if (g.IO.KeyCtrl)
        return;
 
    // As a standard behavior holding SHIFT while using Vertical Mouse Wheel triggers Horizontal scroll instead
    // (we avoid doing it on OSX as it the OS input layer handles this already)
    const bool swap_axis = g.IO.KeyShift && !g.IO.ConfigMacOSXBehaviors;
    const float wheel_y = swap_axis ? 0.0f : g.IO.MouseWheel;
    const float wheel_x = swap_axis ? g.IO.MouseWheel : g.IO.MouseWheelH;
 
    // Vertical Mouse Wheel scrolling
    if (wheel_y != 0.0f)
    {
        StartLockWheelingWindow(window);
        while ((window->Flags & ImGuiWindowFlags_ChildWindow) && ((window->ScrollMax.y == 0.0f) || ((window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))))
            window = window->ParentWindow;
        if (!(window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))
        {
            float max_step = window->InnerRect.GetHeight() * 0.67f;
            float scroll_step = ImFloor(ImMin(5 * window->CalcFontSize(), max_step));
            SetScrollY(window, window->Scroll.y - wheel_y * scroll_step);
        }
    }
 
    // Horizontal Mouse Wheel scrolling, or Vertical Mouse Wheel w/ Shift held
    if (wheel_x != 0.0f)
    {
        StartLockWheelingWindow(window);
        while ((window->Flags & ImGuiWindowFlags_ChildWindow) && ((window->ScrollMax.x == 0.0f) || ((window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))))
            window = window->ParentWindow;
        if (!(window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))
        {
            float max_step = window->InnerRect.GetWidth() * 0.67f;
            float scroll_step = ImFloor(ImMin(2 * window->CalcFontSize(), max_step));
            SetScrollX(window, window->Scroll.x - wheel_x * scroll_step);
        }
    }
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdUsingMouseWheel, ImGuiWindow::CalcFontSize(), ImGuiWindow::Collapsed, ImGuiIO::ConfigMacOSXBehaviors, ImGuiIO::DeltaTime, ImGuiWindow::Flags, ImGuiIO::FontAllowUserScaling, ImGuiWindow::FontWindowScale, ImRect::GetHeight(), ImRect::GetWidth(), GImGui, ImGuiContext::HoveredIdPreviousFrame, ImGuiContext::HoveredIdPreviousFrameUsingMouseWheel, ImGuiContext::HoveredWindow, ImClamp(), ImFloor(), ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NoMouseInputs, ImGuiWindowFlags_NoScrollWithMouse, ImLengthSqr(), ImMin(), ImGuiWindow::InnerRect, ImGuiContext::IO, IsMousePosValid(), ImGuiIO::KeyCtrl, ImGuiIO::KeyShift, ImGuiIO::MouseDragThreshold, ImGuiIO::MousePos, ImGuiIO::MouseWheel, ImGuiIO::MouseWheelH, ImGuiWindow::ParentWindow, ImGuiWindow::Pos, ImGuiWindow::RootWindow, scale(), ImGuiWindow::Scroll, ImGuiWindow::ScrollMax, SetScrollX(), SetScrollY(), SetWindowPos(), ImGuiWindow::Size, ImGuiWindow::SizeFull, StartLockWheelingWindow(), ImGuiContext::WheelingWindow, ImGuiContext::WheelingWindowRefMousePos, ImGuiContext::WheelingWindowTimer, ImVec2::x, and ImVec2::y.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateSettings()

void ImGui::UpdateSettings ( )

static

{
    // Load settings on first frame (if not explicitly loaded manually before)
    ImGuiContext& g = *GImGui;
    if (!g.SettingsLoaded)
    {
        IM_ASSERT(g.SettingsWindows.empty());
        if (g.IO.IniFilename)
            LoadIniSettingsFromDisk(g.IO.IniFilename);
        g.SettingsLoaded = true;
    }
 
    // Save settings (with a delay after the last modification, so we don't spam disk too much)
    if (g.SettingsDirtyTimer > 0.0f)
    {
        g.SettingsDirtyTimer -= g.IO.DeltaTime;
        if (g.SettingsDirtyTimer <= 0.0f)
        {
            if (g.IO.IniFilename != NULL)
                SaveIniSettingsToDisk(g.IO.IniFilename);
            else
                g.IO.WantSaveIniSettings = true;  // Let user know they can call SaveIniSettingsToMemory(). user will need to clear io.WantSaveIniSettings themselves.
            g.SettingsDirtyTimer = 0.0f;
        }
    }
}

References ImGuiIO::DeltaTime, ImChunkStream< T >::empty(), GImGui, IM_ASSERT, ImGuiIO::IniFilename, ImGuiContext::IO, LoadIniSettingsFromDisk(), SaveIniSettingsToDisk(), ImGuiContext::SettingsDirtyTimer, ImGuiContext::SettingsLoaded, ImGuiContext::SettingsWindows, and ImGuiIO::WantSaveIniSettings.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTabFocus()

void ImGui::UpdateTabFocus ( )

static

{
    ImGuiContext& g = *GImGui;
 
    // Pressing TAB activate widget focus
    g.TabFocusPressed = (g.NavWindow && g.NavWindow->Active && !(g.NavWindow->Flags & ImGuiWindowFlags_NoNavInputs) && !g.IO.KeyCtrl && IsKeyPressedMap(ImGuiKey_Tab));
    if (g.ActiveId == 0 && g.TabFocusPressed)
    {
        // - This path is only taken when no widget are active/tabbed-into yet.
        //   Subsequent tabbing will be processed by FocusableItemRegister()
        // - Note that SetKeyboardFocusHere() sets the Next fields mid-frame. To be consistent we also
        //   manipulate the Next fields here even though they will be turned into Curr fields below.
        g.TabFocusRequestNextWindow = g.NavWindow;
        g.TabFocusRequestNextCounterRegular = INT_MAX;
        if (g.NavId != 0 && g.NavIdTabCounter != INT_MAX)
            g.TabFocusRequestNextCounterTabStop = g.NavIdTabCounter + (g.IO.KeyShift ? -1 : 0);
        else
            g.TabFocusRequestNextCounterTabStop = g.IO.KeyShift ? -1 : 0;
    }
 
    // Turn queued focus request into current one
    g.TabFocusRequestCurrWindow = NULL;
    g.TabFocusRequestCurrCounterRegular = g.TabFocusRequestCurrCounterTabStop = INT_MAX;
    if (g.TabFocusRequestNextWindow != NULL)
    {
        ImGuiWindow* window = g.TabFocusRequestNextWindow;
        g.TabFocusRequestCurrWindow = window;
        if (g.TabFocusRequestNextCounterRegular != INT_MAX && window->DC.FocusCounterRegular != -1)
            g.TabFocusRequestCurrCounterRegular = ImModPositive(g.TabFocusRequestNextCounterRegular, window->DC.FocusCounterRegular + 1);
        if (g.TabFocusRequestNextCounterTabStop != INT_MAX && window->DC.FocusCounterTabStop != -1)
            g.TabFocusRequestCurrCounterTabStop = ImModPositive(g.TabFocusRequestNextCounterTabStop, window->DC.FocusCounterTabStop + 1);
        g.TabFocusRequestNextWindow = NULL;
        g.TabFocusRequestNextCounterRegular = g.TabFocusRequestNextCounterTabStop = INT_MAX;
    }
 
    g.NavIdTabCounter = INT_MAX;
}

References ImGuiWindow::Active, ImGuiContext::ActiveId, ImGuiWindow::DC, ImGuiWindow::Flags, ImGuiWindowTempData::FocusCounterRegular, ImGuiWindowTempData::FocusCounterTabStop, GImGui, ImGuiKey_Tab, ImGuiWindowFlags_NoNavInputs, ImModPositive(), ImGuiContext::IO, IsKeyPressedMap(), ImGuiIO::KeyCtrl, ImGuiIO::KeyShift, ImGuiContext::NavId, ImGuiContext::NavIdTabCounter, ImGuiContext::NavWindow, ImGuiContext::TabFocusPressed, ImGuiContext::TabFocusRequestCurrCounterRegular, ImGuiContext::TabFocusRequestCurrCounterTabStop, ImGuiContext::TabFocusRequestCurrWindow, ImGuiContext::TabFocusRequestNextCounterRegular, ImGuiContext::TabFocusRequestNextCounterTabStop, and ImGuiContext::TabFocusRequestNextWindow.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateViewportsNewFrame()

static void ImGui::UpdateViewportsNewFrame ( )

static

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.Viewports.Size == 1);
 
    // Update main viewport with current platform position.
    // FIXME-VIEWPORT: Size is driven by backend/user code for backward-compatibility but we should aim to make this more consistent.
    ImGuiViewportP* main_viewport = g.Viewports[0];
    main_viewport->Flags = ImGuiViewportFlags_IsPlatformWindow | ImGuiViewportFlags_OwnedByApp;
    main_viewport->Pos = ImVec2(0.0f, 0.0f);
    main_viewport->Size = g.IO.DisplaySize;
 
    for (int n = 0; n < g.Viewports.Size; n++)
    {
        ImGuiViewportP* viewport = g.Viewports[n];
 
        // Lock down space taken by menu bars and status bars, reset the offset for fucntions like BeginMainMenuBar() to alter them again.
        viewport->WorkOffsetMin = viewport->BuildWorkOffsetMin;
        viewport->WorkOffsetMax = viewport->BuildWorkOffsetMax;
        viewport->BuildWorkOffsetMin = viewport->BuildWorkOffsetMax = ImVec2(0.0f, 0.0f);
        viewport->UpdateWorkRect();
    }
}

References ImGuiViewportP::BuildWorkOffsetMax, ImGuiViewportP::BuildWorkOffsetMin, ImGuiIO::DisplaySize, ImGuiViewport::Flags, GImGui, IM_ASSERT, ImGuiViewportFlags_IsPlatformWindow, ImGuiViewportFlags_OwnedByApp, ImGuiContext::IO, ImGuiViewport::Pos, ImVector< T >::Size, ImGuiViewport::Size, ImGuiViewportP::UpdateWorkRect(), ImGuiContext::Viewports, ImGuiViewportP::WorkOffsetMax, and ImGuiViewportP::WorkOffsetMin.

Referenced by NewFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateWindowManualResize()

static bool ImGui::UpdateWindowManualResize	(	ImGuiWindow *	window,
		const ImVec2 &	size_auto_fit,
		int *	border_held,
		int	resize_grip_count,
		ImU32	resize_grip_col[4],
		const ImRect &	visibility_rect
	)

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindowFlags flags = window->Flags;
 
    if ((flags & ImGuiWindowFlags_NoResize) || (flags & ImGuiWindowFlags_AlwaysAutoResize) || window->AutoFitFramesX > 0 || window->AutoFitFramesY > 0)
        return false;
    if (window->WasActive == false) // Early out to avoid running this code for e.g. an hidden implicit/fallback Debug window.
        return false;
 
    bool ret_auto_fit = false;
    const int resize_border_count = g.IO.ConfigWindowsResizeFromEdges ? 4 : 0;
    const float grip_draw_size = IM_FLOOR(ImMax(g.FontSize * 1.35f, window->WindowRounding + 1.0f + g.FontSize * 0.2f));
    const float grip_hover_inner_size = IM_FLOOR(grip_draw_size * 0.75f);
    const float grip_hover_outer_size = g.IO.ConfigWindowsResizeFromEdges ? WINDOWS_HOVER_PADDING : 0.0f;
 
    ImVec2 pos_target(FLT_MAX, FLT_MAX);
    ImVec2 size_target(FLT_MAX, FLT_MAX);
 
    // Resize grips and borders are on layer 1
    window->DC.NavLayerCurrent = ImGuiNavLayer_Menu;
 
    // Manual resize grips
    PushID("#RESIZE");
    for (int resize_grip_n = 0; resize_grip_n < resize_grip_count; resize_grip_n++)
    {
        const ImGuiResizeGripDef& def = resize_grip_def[resize_grip_n];
        const ImVec2 corner = ImLerp(window->Pos, window->Pos + window->Size, def.CornerPosN);
 
        // Using the FlattenChilds button flag we make the resize button accessible even if we are hovering over a child window
        bool hovered, held;
        ImRect resize_rect(corner - def.InnerDir * grip_hover_outer_size, corner + def.InnerDir * grip_hover_inner_size);
        if (resize_rect.Min.x > resize_rect.Max.x) ImSwap(resize_rect.Min.x, resize_rect.Max.x);
        if (resize_rect.Min.y > resize_rect.Max.y) ImSwap(resize_rect.Min.y, resize_rect.Max.y);
        ImGuiID resize_grip_id = window->GetID(resize_grip_n); // == GetWindowResizeCornerID()
        ButtonBehavior(resize_rect, resize_grip_id, &hovered, &held, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_NoNavFocus);
        //GetForegroundDrawList(window)->AddRect(resize_rect.Min, resize_rect.Max, IM_COL32(255, 255, 0, 255));
        if (hovered || held)
            g.MouseCursor = (resize_grip_n & 1) ? ImGuiMouseCursor_ResizeNESW : ImGuiMouseCursor_ResizeNWSE;
 
        if (held && g.IO.MouseDoubleClicked[0] && resize_grip_n == 0)
        {
            // Manual auto-fit when double-clicking
            size_target = CalcWindowSizeAfterConstraint(window, size_auto_fit);
            ret_auto_fit = true;
            ClearActiveID();
        }
        else if (held)
        {
            // Resize from any of the four corners
            // We don't use an incremental MouseDelta but rather compute an absolute target size based on mouse position
            ImVec2 clamp_min = ImVec2(def.CornerPosN.x == 1.0f ? visibility_rect.Min.x : -FLT_MAX, def.CornerPosN.y == 1.0f ? visibility_rect.Min.y : -FLT_MAX);
            ImVec2 clamp_max = ImVec2(def.CornerPosN.x == 0.0f ? visibility_rect.Max.x : +FLT_MAX, def.CornerPosN.y == 0.0f ? visibility_rect.Max.y : +FLT_MAX);
            ImVec2 corner_target = g.IO.MousePos - g.ActiveIdClickOffset + ImLerp(def.InnerDir * grip_hover_outer_size, def.InnerDir * -grip_hover_inner_size, def.CornerPosN); // Corner of the window corresponding to our corner grip
            corner_target = ImClamp(corner_target, clamp_min, clamp_max);
            CalcResizePosSizeFromAnyCorner(window, corner_target, def.CornerPosN, &pos_target, &size_target);
        }
 
        // Only lower-left grip is visible before hovering/activating
        if (resize_grip_n == 0 || held || hovered)
            resize_grip_col[resize_grip_n] = GetColorU32(held ? ImGuiCol_ResizeGripActive : hovered ? ImGuiCol_ResizeGripHovered : ImGuiCol_ResizeGrip);
    }
    for (int border_n = 0; border_n < resize_border_count; border_n++)
    {
        const ImGuiResizeBorderDef& def = resize_border_def[border_n];
        const ImGuiAxis axis = (border_n == ImGuiDir_Left || border_n == ImGuiDir_Right) ? ImGuiAxis_X : ImGuiAxis_Y;
 
        bool hovered, held;
        ImRect border_rect = GetResizeBorderRect(window, border_n, grip_hover_inner_size, WINDOWS_HOVER_PADDING);
        ImGuiID border_id = window->GetID(border_n + 4); // == GetWindowResizeBorderID()
        ButtonBehavior(border_rect, border_id, &hovered, &held, ImGuiButtonFlags_FlattenChildren);
        //GetForegroundDrawLists(window)->AddRect(border_rect.Min, border_rect.Max, IM_COL32(255, 255, 0, 255));
        if ((hovered && g.HoveredIdTimer > WINDOWS_RESIZE_FROM_EDGES_FEEDBACK_TIMER) || held)
        {
            g.MouseCursor = (axis == ImGuiAxis_X) ? ImGuiMouseCursor_ResizeEW : ImGuiMouseCursor_ResizeNS;
            if (held)
                *border_held = border_n;
        }
        if (held)
        {
            ImVec2 clamp_min(border_n == ImGuiDir_Right ? visibility_rect.Min.x : -FLT_MAX, border_n == ImGuiDir_Down ? visibility_rect.Min.y : -FLT_MAX);
            ImVec2 clamp_max(border_n == ImGuiDir_Left  ? visibility_rect.Max.x : +FLT_MAX, border_n == ImGuiDir_Up   ? visibility_rect.Max.y : +FLT_MAX);
            ImVec2 border_target = window->Pos;
            border_target[axis] = g.IO.MousePos[axis] - g.ActiveIdClickOffset[axis] + WINDOWS_HOVER_PADDING;
            border_target = ImClamp(border_target, clamp_min, clamp_max);
            CalcResizePosSizeFromAnyCorner(window, border_target, ImMin(def.SegmentN1, def.SegmentN2), &pos_target, &size_target);
        }
    }
    PopID();
 
    // Restore nav layer
    window->DC.NavLayerCurrent = ImGuiNavLayer_Main;
 
    // Navigation resize (keyboard/gamepad)
    if (g.NavWindowingTarget && g.NavWindowingTarget->RootWindow == window)
    {
        ImVec2 nav_resize_delta;
        if (g.NavInputSource == ImGuiInputSource_Keyboard && g.IO.KeyShift)
            nav_resize_delta = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard, ImGuiInputReadMode_Down);
        if (g.NavInputSource == ImGuiInputSource_Gamepad)
            nav_resize_delta = GetNavInputAmount2d(ImGuiNavDirSourceFlags_PadDPad, ImGuiInputReadMode_Down);
        if (nav_resize_delta.x != 0.0f || nav_resize_delta.y != 0.0f)
        {
            const float NAV_RESIZE_SPEED = 600.0f;
            nav_resize_delta *= ImFloor(NAV_RESIZE_SPEED * g.IO.DeltaTime * ImMin(g.IO.DisplayFramebufferScale.x, g.IO.DisplayFramebufferScale.y));
            nav_resize_delta = ImMax(nav_resize_delta, visibility_rect.Min - window->Pos - window->Size);
            g.NavWindowingToggleLayer = false;
            g.NavDisableMouseHover = true;
            resize_grip_col[0] = GetColorU32(ImGuiCol_ResizeGripActive);
            // FIXME-NAV: Should store and accumulate into a separate size buffer to handle sizing constraints properly, right now a constraint will make us stuck.
            size_target = CalcWindowSizeAfterConstraint(window, window->SizeFull + nav_resize_delta);
        }
    }
 
    // Apply back modified position/size to window
    if (size_target.x != FLT_MAX)
    {
        window->SizeFull = size_target;
        MarkIniSettingsDirty(window);
    }
    if (pos_target.x != FLT_MAX)
    {
        window->Pos = ImFloor(pos_target);
        MarkIniSettingsDirty(window);
    }
 
    window->Size = window->SizeFull;
    return ret_auto_fit;
}

References ImGuiContext::ActiveIdClickOffset, ImGuiWindow::AutoFitFramesX, ImGuiWindow::AutoFitFramesY, ButtonBehavior(), CalcResizePosSizeFromAnyCorner(), CalcWindowSizeAfterConstraint(), ClearActiveID(), ImGuiIO::ConfigWindowsResizeFromEdges, ImGuiResizeGripDef::CornerPosN, ImGuiWindow::DC, ImGuiIO::DeltaTime, ImGuiIO::DisplayFramebufferScale, ImGuiWindow::Flags, ImGuiContext::FontSize, GetColorU32(), ImGuiWindow::GetID(), GetNavInputAmount2d(), GetResizeBorderRect(), GImGui, ImGuiContext::HoveredIdTimer, IM_FLOOR, ImClamp(), ImFloor(), ImGuiAxis_X, ImGuiAxis_Y, ImGuiButtonFlags_FlattenChildren, ImGuiButtonFlags_NoNavFocus, ImGuiCol_ResizeGrip, ImGuiCol_ResizeGripActive, ImGuiCol_ResizeGripHovered, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_Right, ImGuiDir_Up, ImGuiInputReadMode_Down, ImGuiInputSource_Gamepad, ImGuiInputSource_Keyboard, ImGuiMouseCursor_ResizeEW, ImGuiMouseCursor_ResizeNESW, ImGuiMouseCursor_ResizeNS, ImGuiMouseCursor_ResizeNWSE, ImGuiNavDirSourceFlags_Keyboard, ImGuiNavDirSourceFlags_PadDPad, ImGuiNavLayer_Main, ImGuiNavLayer_Menu, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoResize, ImLerp(), ImMax(), ImMin(), ImSwap(), ImGuiResizeGripDef::InnerDir, ImGuiContext::IO, ImGuiIO::KeyShift, MarkIniSettingsDirty(), ImRect::Max, ImRect::Min, ImGuiContext::MouseCursor, ImGuiIO::MouseDoubleClicked, ImGuiIO::MousePos, ImGuiContext::NavDisableMouseHover, ImGuiContext::NavInputSource, ImGuiWindowTempData::NavLayerCurrent, ImGuiContext::NavWindowingTarget, ImGuiContext::NavWindowingToggleLayer, PopID(), ImGuiWindow::Pos, PushID(), resize_border_def, resize_grip_def, ImGuiWindow::RootWindow, ImGuiResizeBorderDef::SegmentN1, ImGuiResizeBorderDef::SegmentN2, ImGuiWindow::Size, ImGuiWindow::SizeFull, ImGuiWindow::WasActive, ImGuiWindow::WindowRounding, WINDOWS_HOVER_PADDING, WINDOWS_RESIZE_FROM_EDGES_FEEDBACK_TIMER, ImVec2::x, and ImVec2::y.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateWindowParentAndRootLinks()

void ImGui::UpdateWindowParentAndRootLinks	(	ImGuiWindow *	window,
		ImGuiWindowFlags	flags,
		ImGuiWindow *	parent_window
	)

{
    window->ParentWindow = parent_window;
    window->RootWindow = window->RootWindowForTitleBarHighlight = window->RootWindowForNav = window;
    if (parent_window && (flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Tooltip))
        window->RootWindow = parent_window->RootWindow;
    if (parent_window && !(flags & ImGuiWindowFlags_Modal) && (flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)))
        window->RootWindowForTitleBarHighlight = parent_window->RootWindowForTitleBarHighlight;
    while (window->RootWindowForNav->Flags & ImGuiWindowFlags_NavFlattened)
    {
        IM_ASSERT(window->RootWindowForNav->ParentWindow != NULL);
        window->RootWindowForNav = window->RootWindowForNav->ParentWindow;
    }
}

References ImGuiWindow::Flags, IM_ASSERT, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_Modal, ImGuiWindowFlags_NavFlattened, ImGuiWindowFlags_Popup, ImGuiWindowFlags_Tooltip, ImGuiWindow::ParentWindow, ImGuiWindow::RootWindow, ImGuiWindow::RootWindowForNav, and ImGuiWindow::RootWindowForTitleBarHighlight.

Referenced by Begin().

Here is the caller graph for this function:

◆ Value() [1/4]

void ImGui::Value	(	const char *	prefix,
		bool	b
	)

{
    Text("%s: %s", prefix, (b ? "true" : "false"));
}

References Text().

Here is the call graph for this function:

◆ Value() [2/4]

void ImGui::Value	(	const char *	prefix,
		float	v,
		const char *	float_format = `NULL`
	)

{
    if (float_format)
    {
        char fmt[64];
        ImFormatString(fmt, IM_ARRAYSIZE(fmt), "%%s: %s", float_format);
        Text(fmt, prefix, v);
    }
    else
    {
        Text("%s: %.3f", prefix, v);
    }
}

References IM_ARRAYSIZE, ImFormatString(), and Text().

Here is the call graph for this function:

◆ Value() [3/4]

void ImGui::Value	(	const char *	prefix,
		int	v
	)

{
    Text("%s: %d", prefix, v);
}

References Text().

Here is the call graph for this function:

◆ Value() [4/4]

void ImGui::Value	(	const char *	prefix,
		unsigned int	v
	)

{
    Text("%s: %d", prefix, v);
}

References Text().

Here is the call graph for this function:

◆ VSliderFloat()

bool ImGui::VSliderFloat	(	const char *	label,
		const ImVec2 &	size,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = `"%.3f"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return VSliderScalar(label, size, ImGuiDataType_Float, v, &v_min, &v_max, format, flags);
}

References ImGuiDataType_Float, and VSliderScalar().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VSliderInt()

bool ImGui::VSliderInt	(	const char *	label,
		const ImVec2 &	size,
		int *	v,
		int	v_min,
		int	v_max,
		const char *	format = `"%d"`,
		ImGuiSliderFlags	flags = `0`
	)

{
    return VSliderScalar(label, size, ImGuiDataType_S32, v, &v_min, &v_max, format, flags);
}

References ImGuiDataType_S32, and VSliderScalar().

Referenced by ShowDemoWindowWidgets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VSliderScalar()

bool ImGui::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`
	)

{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
 
    const ImVec2 label_size = CalcTextSize(label, NULL, true);
    const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + size);
    const ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
 
    ItemSize(bb, style.FramePadding.y);
    if (!ItemAdd(frame_bb, id))
        return false;
 
    // Default format string when passing NULL
    if (format == NULL)
        format = DataTypeGetInfo(data_type)->PrintFmt;
    else if (data_type == ImGuiDataType_S32 && strcmp(format, "%d") != 0) // (FIXME-LEGACY: Patch old "%.0f" format string to use "%d", read function more details.)
        format = PatchFormatStringFloatToInt(format);
 
    const bool hovered = ItemHoverable(frame_bb, id);
    if ((hovered && g.IO.MouseClicked[0]) || g.NavActivateId == id || g.NavInputId == id)
    {
        SetActiveID(id, window);
        SetFocusID(id, window);
        FocusWindow(window);
        g.ActiveIdUsingNavDirMask |= (1 << ImGuiDir_Up) | (1 << ImGuiDir_Down);
    }
 
    // Draw frame
    const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : g.HoveredId == id ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
    RenderNavHighlight(frame_bb, id);
    RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, true, g.Style.FrameRounding);
 
    // Slider behavior
    ImRect grab_bb;
    const bool value_changed = SliderBehavior(frame_bb, id, data_type, p_data, p_min, p_max, format, flags | ImGuiSliderFlags_Vertical, &grab_bb);
    if (value_changed)
        MarkItemEdited(id);
 
    // Render grab
    if (grab_bb.Max.y > grab_bb.Min.y)
        window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, GetColorU32(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), style.GrabRounding);
 
    // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
    // For the vertical slider we allow centered text to overlap the frame padding
    char value_buf[64];
    const char* value_buf_end = value_buf + DataTypeFormatString(value_buf, IM_ARRAYSIZE(value_buf), data_type, p_data, format);
    RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, value_buf, value_buf_end, NULL, ImVec2(0.5f, 0.0f));
    if (label_size.x > 0.0f)
        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
    return value_changed;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdUsingNavDirMask, ImDrawList::AddRectFilled(), CalcTextSize(), ImGuiWindowTempData::CursorPos, DataTypeFormatString(), DataTypeGetInfo(), ImGuiWindow::DC, ImGuiWindow::DrawList, FocusWindow(), ImGuiStyle::FrameRounding, GetColorU32(), GetCurrentWindow(), ImGuiWindow::GetID(), GImGui, ImGuiContext::HoveredId, IM_ARRAYSIZE, ImGuiCol_FrameBg, ImGuiCol_FrameBgActive, ImGuiCol_FrameBgHovered, ImGuiCol_SliderGrab, ImGuiCol_SliderGrabActive, ImGuiDataType_S32, ImGuiDir_Down, ImGuiDir_Up, ImGuiSliderFlags_Vertical, ImGuiContext::IO, ItemAdd(), ItemHoverable(), ItemSize(), MarkItemEdited(), ImRect::Max, ImRect::Min, ImGuiIO::MouseClicked, ImGuiContext::NavActivateId, ImGuiContext::NavInputId, PatchFormatStringFloatToInt(), ImGuiDataTypeInfo::PrintFmt, RenderFrame(), RenderNavHighlight(), RenderText(), RenderTextClipped(), SetActiveID(), SetFocusID(), ImGuiWindow::SkipItems, SliderBehavior(), ImGuiContext::Style, style, ImVec2::x, and ImVec2::y.

Referenced by VSliderFloat(), and VSliderInt().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ CancelButton

const wchar_t ImGui::CancelButton = 0x14

Referenced by Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::ProgressBarWithCancelNotification::render_cancel_button_inner(), and Slic3r::GUI::NotificationManager::URLDownloadNotification::render_cancel_button_inner().

◆ CancelHoverButton

const wchar_t ImGui::CancelHoverButton = 0x15

Referenced by Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::ProgressBarWithCancelNotification::render_cancel_button_inner(), and Slic3r::GUI::NotificationManager::URLDownloadNotification::render_cancel_button_inner().

◆ ClipboardBtnIcon

const wchar_t ImGui::ClipboardBtnIcon = 0x2606

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

◆ ClippyMarker

const wchar_t ImGui::ClippyMarker = 0x2602

Referenced by Slic3r::GUI::NotificationManager::HintNotification::render_logo().

◆ CloseNotifButton

const wchar_t ImGui::CloseNotifButton = 0xB

Referenced by Slic3r::GUI::NotificationManager::PopNotification::render_close_button(), Slic3r::GUI::NotificationManager::HintNotification::render_close_button(), Slic3r::GUI::NotificationManager::ProgressBarWithCancelNotification::render_close_button_inner(), and Slic3r::GUI::NotificationManager::URLDownloadNotification::render_close_button_inner().

◆ CloseNotifHoverButton

const wchar_t ImGui::CloseNotifHoverButton = 0xC

Referenced by Slic3r::GUI::NotificationManager::PopNotification::render_close_button(), Slic3r::GUI::NotificationManager::HintNotification::render_close_button(), Slic3r::GUI::NotificationManager::ProgressBarWithCancelNotification::render_close_button_inner(), and Slic3r::GUI::NotificationManager::URLDownloadNotification::render_close_button_inner().

◆ CollapseBtn

const wchar_t ImGui::CollapseBtn = 0x2715

Referenced by Slic3r::GUI::GLGizmoCut3D::render_shortcuts().

◆ ColorMarkerEnd

const char ImGui::ColorMarkerEnd = 0x3

Referenced by Slic3r::GUI::HintDatabase::load_hints_from_file(), Slic3r::Search::mark_string(), Slic3r::GUI::NotificationManager::HintNotification::render_text(), ImFont::RenderText(), and Slic3r::Search::OptionsSearcher::search().

◆ ColorMarkerHovered

const char ImGui::ColorMarkerHovered = 0x1

Referenced by ImFont::RenderText(), and Slic3r::GUI::selectable().

◆ ColorMarkerStart

const char ImGui::ColorMarkerStart = 0x2

Referenced by Slic3r::GUI::HintDatabase::load_hints_from_file(), Slic3r::Search::mark_string(), Slic3r::GUI::NotificationManager::HintNotification::render_text(), ImFont::RenderText(), and Slic3r::Search::OptionsSearcher::search().

◆ DocumentationButton

const wchar_t ImGui::DocumentationButton = 0x2600

Referenced by Slic3r::GUI::NotificationManager::HintNotification::render_documentation_button().

◆ DocumentationHoverButton

const wchar_t ImGui::DocumentationHoverButton = 0x2601

Referenced by Slic3r::GUI::NotificationManager::HintNotification::render_documentation_button().

◆ DowelMarker

const wchar_t ImGui::DowelMarker = 0x1D

Referenced by Slic3r::GUI::GLGizmoCut3D::GLGizmoCut3D().

◆ EjectButton

const wchar_t ImGui::EjectButton = 0x12

Referenced by Slic3r::GUI::NotificationManager::HintNotification::render_documentation_button(), Slic3r::GUI::NotificationManager::ExportFinishedNotification::render_eject_button(), and Slic3r::GUI::NotificationManager::HintNotification::render_logo().

◆ EjectHoverButton

const wchar_t ImGui::EjectHoverButton = 0x13

Referenced by Slic3r::GUI::NotificationManager::ExportFinishedNotification::render_eject_button().

◆ ErrorMarker

const wchar_t ImGui::ErrorMarker = 0x11

Referenced by Slic3r::GUI::NotificationManager::PopNotification::count_spaces(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::count_spaces(), Slic3r::GUI::NotificationManager::ExportFinishedNotification::count_spaces(), Slic3r::GUI::NotificationManager::PopNotification::render_left_sign(), and Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_left_sign().

◆ ExpandBtn

const wchar_t ImGui::ExpandBtn = 0x2714

Referenced by Slic3r::GUI::GLGizmoCut3D::render_shortcuts().

◆ FilamentIconMarker

const wchar_t ImGui::FilamentIconMarker = 0x7

Referenced by Slic3r::Search::marker_by_type().

◆ InfoMarker

const wchar_t ImGui::InfoMarker = 0x2603

Referenced by Slic3r::GUI::NotificationManager::PopNotification::render_left_sign().

◆ InfoMarkerSmall

const wchar_t ImGui::InfoMarkerSmall = 0x2716

Referenced by Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window().

◆ LegendCOG

const wchar_t ImGui::LegendCOG = 0x2710

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendColorChanges

const wchar_t ImGui::LegendColorChanges = 0x2707

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendCustomGCodes

const wchar_t ImGui::LegendCustomGCodes = 0x2709

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendDeretract

const wchar_t ImGui::LegendDeretract = 0x2704

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendPausePrints

const wchar_t ImGui::LegendPausePrints = 0x2708

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendRetract

const wchar_t ImGui::LegendRetract = 0x2703

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendSeams

const wchar_t ImGui::LegendSeams = 0x2705

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendShells

const wchar_t ImGui::LegendShells = 0x2711

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendToolChanges

const wchar_t ImGui::LegendToolChanges = 0x2706

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendToolMarker

const wchar_t ImGui::LegendToolMarker = 0x2712

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendTravel

const wchar_t ImGui::LegendTravel = 0x2701

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ LegendWipe

const wchar_t ImGui::LegendWipe = 0x2702

Referenced by Slic3r::GUI::GCodeViewer::render_legend().

◆ MaterialIconMarker

const wchar_t ImGui::MaterialIconMarker = 0x8

Referenced by Slic3r::Search::marker_by_type().

◆ MinimalizeButton

const wchar_t ImGui::MinimalizeButton = 0xE

Referenced by Slic3r::GUI::NotificationManager::PopNotification::render_minimize_button().

◆ MinimalizeHoverButton

const wchar_t ImGui::MinimalizeHoverButton = 0xF

Referenced by Slic3r::GUI::NotificationManager::PopNotification::render_minimize_button().

◆ OpenButton

const wchar_t ImGui::OpenButton = 0x261C

Referenced by Slic3r::GUI::NotificationManager::URLDownloadNotification::render_open_button_inner().

◆ OpenHoverButton

const wchar_t ImGui::OpenHoverButton = 0x261D

Referenced by Slic3r::GUI::NotificationManager::URLDownloadNotification::render_open_button_inner().

◆ PauseButton

const wchar_t ImGui::PauseButton = 0x261A

Referenced by Slic3r::GUI::NotificationManager::URLDownloadNotification::render_pause_button_inner().

◆ PauseHoverButton

const wchar_t ImGui::PauseHoverButton = 0x261B

Referenced by Slic3r::GUI::NotificationManager::URLDownloadNotification::render_pause_button_inner().

◆ PlayButton

const wchar_t ImGui::PlayButton = 0x2618

Referenced by Slic3r::GUI::NotificationManager::URLDownloadNotification::render_pause_button_inner().

◆ PlayHoverButton

const wchar_t ImGui::PlayHoverButton = 0x2619

Referenced by Slic3r::GUI::NotificationManager::URLDownloadNotification::render_pause_button_inner().

◆ PlugMarker

const wchar_t ImGui::PlugMarker = 0x1C

Referenced by Slic3r::GUI::GLGizmoCut3D::GLGizmoCut3D().

◆ PreferencesButton

const wchar_t ImGui::PreferencesButton = 0x1A

Referenced by Slic3r::Search::marker_by_type(), and Slic3r::GUI::NotificationManager::HintNotification::render_preferences_button().

◆ PreferencesHoverButton

const wchar_t ImGui::PreferencesHoverButton = 0x1B

Referenced by Slic3r::GUI::NotificationManager::HintNotification::render_preferences_button().

◆ PrinterIconMarker

const wchar_t ImGui::PrinterIconMarker = 0x5

Referenced by Slic3r::Search::marker_by_type().

◆ PrinterSlaIconMarker

const wchar_t ImGui::PrinterSlaIconMarker = 0x6

Referenced by Slic3r::Search::marker_by_type().

◆ PrintIconMarker

const wchar_t ImGui::PrintIconMarker = 0x4

Referenced by Slic3r::Search::marker_by_type().

◆ RevertButton

const wchar_t ImGui::RevertButton = 0x16

Referenced by Slic3r::GUI::GLGizmoCut3D::render_reset_button().

◆ RightArrowButton

const wchar_t ImGui::RightArrowButton = 0x18

Referenced by Slic3r::GUI::NotificationManager::HintNotification::render_right_arrow_button().

◆ RightArrowHoverButton

const wchar_t ImGui::RightArrowHoverButton = 0x19

◆ SlaViewOriginal

const wchar_t ImGui::SlaViewOriginal = 0x261E

Referenced by Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button().

◆ SlaViewProcessed

const wchar_t ImGui::SlaViewProcessed = 0x261F

Referenced by Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button().

◆ SliderFloatEditBtnIcon

const wchar_t ImGui::SliderFloatEditBtnIcon = 0x2604

Referenced by Slic3r::GUI::ImGuiWrapper::get_slider_icon_size(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), and Slic3r::GUI::ImGuiWrapper::slider_float().

◆ SliderFloatEditBtnPressedIcon

const wchar_t ImGui::SliderFloatEditBtnPressedIcon = 0x2605

Referenced by Slic3r::GUI::ImGuiWrapper::slider_float().

◆ vector_getter

auto ImGui::vector_getter

static

Initial value:

= [](void* vec, int idx, const char** out_text)
{
  auto& vector = *static_cast<std::vector<std::string>*>(vec);
  if (idx < 0 || idx >= static_cast<int>(vector.size())) { return false; }
  *out_text = vector.at(idx).c_str();
  return true;
}

Referenced by Combo(), and ListBox().

◆ WarningMarker

const wchar_t ImGui::WarningMarker = 0x10

Referenced by Slic3r::GUI::NotificationManager::PopNotification::count_spaces(), Slic3r::GUI::NotificationManager::HintNotification::count_spaces(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::count_spaces(), Slic3r::GUI::NotificationManager::ExportFinishedNotification::count_spaces(), Slic3r::GUI::NotificationManager::UpdatedItemsInfoNotification::count_spaces(), Slic3r::GUI::NotificationManager::PopNotification::render_left_sign(), and Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_left_sign().

◆ WarningMarkerSmall

const wchar_t ImGui::WarningMarkerSmall = 0x2713

Referenced by Slic3r::GUI::GLGizmoCut3D::render_input_window_warning().