imgui.cpp File Reference

#include "imgui.h"
#include "imgui_internal.h"
#include <ctype.h>
#include <stdio.h>
#include <stdint.h>

Include dependency graph for imgui.cpp:

Go to the source code of this file.

Classes
struct	ImGuiStyleVarInfo
struct	ImGuiResizeGripDef
struct	ImGuiResizeBorderDef

Namespaces
namespace	ImGui

Macros
#define	IMGUI_DEFINE_MATH_OPERATORS
#define	IMGUI_DEBUG_NAV_SCORING   0
#define	IMGUI_DEBUG_NAV_RECTS   0
#define	IMGUI_DEBUG_INI_SETTINGS   0
#define	va_copy(dest, src)   (dest = src)
#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)

Functions
static void	SetCurrentWindow (ImGuiWindow *window)
static void	FindHoveredWindow ()
static ImGuiWindow *	CreateNewWindow (const char *name, ImGuiWindowFlags flags)
static ImVec2	CalcNextScrollFromScrollTargetAndClamp (ImGuiWindow *window)
static void	AddDrawListToDrawData (ImVector< ImDrawList * > *out_list, ImDrawList *draw_list)
static void	AddWindowToSortBuffer (ImVector< ImGuiWindow * > *out_sorted_windows, ImGuiWindow *window)
static void	WindowSettingsHandler_ClearAll (ImGuiContext *, ImGuiSettingsHandler *)
static void *	WindowSettingsHandler_ReadOpen (ImGuiContext *, ImGuiSettingsHandler *, const char *name)
static void	WindowSettingsHandler_ReadLine (ImGuiContext *, ImGuiSettingsHandler *, void *entry, const char *line)
static void	WindowSettingsHandler_ApplyAll (ImGuiContext *, ImGuiSettingsHandler *)
static void	WindowSettingsHandler_WriteAll (ImGuiContext *, ImGuiSettingsHandler *, ImGuiTextBuffer *buf)
static const char *	GetClipboardTextFn_DefaultImpl (void *user_data)
static void	SetClipboardTextFn_DefaultImpl (void *user_data, const char *text)
static void	ImeSetInputScreenPosFn_DefaultImpl (int x, int y)
static void	ImGui::NavUpdate ()
static void	ImGui::NavUpdateWindowing ()
static void	ImGui::NavUpdateWindowingOverlay ()
static void	ImGui::NavUpdateMoveResult ()
static void	ImGui::NavUpdateInitResult ()
static float	ImGui::NavUpdatePageUpPageDown ()
static void	ImGui::NavUpdateAnyRequestFlag ()
static void	ImGui::NavEndFrame ()
static bool	ImGui::NavScoreItem (ImGuiNavItemData *result, ImRect cand)
static void	ImGui::NavApplyItemToResult (ImGuiNavItemData *result, ImGuiWindow *window, ImGuiID id, const ImRect &nav_bb_rel)
static void	ImGui::NavProcessItem (ImGuiWindow *window, const ImRect &nav_bb, ImGuiID id)
static ImVec2	ImGui::NavCalcPreferredRefPos ()
static void	ImGui::NavSaveLastChildNavWindowIntoParent (ImGuiWindow *nav_window)
static ImGuiWindow *	ImGui::NavRestoreLastChildNavWindow (ImGuiWindow *window)
static void	ImGui::NavRestoreLayer (ImGuiNavLayer layer)
static int	ImGui::FindWindowFocusIndex (ImGuiWindow *window)
static void	ImGui::ErrorCheckNewFrameSanityChecks ()
static void	ImGui::ErrorCheckEndFrameSanityChecks ()
static void	ImGui::UpdateSettings ()
static void	ImGui::UpdateMouseInputs ()
static void	ImGui::UpdateMouseWheel ()
static void	ImGui::UpdateTabFocus ()
static void	ImGui::UpdateDebugToolItemPicker ()
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 void	ImGui::RenderWindowOuterBorders (ImGuiWindow *window)
static 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 void	ImGui::RenderWindowTitleBarContents (ImGuiWindow *window, const ImRect &title_bar_rect, const char *name, bool *p_open)
static void	ImGui::UpdateViewportsNewFrame ()
static void *	MallocWrapper (size_t size, void *user_data)
static void	FreeWrapper (void *ptr, void *user_data)
ImVec2	ImBezierCubicClosestPoint (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, const ImVec2 &p, int num_segments)
static void	ImBezierCubicClosestPointCasteljauStep (const ImVec2 &p, ImVec2 &p_closest, ImVec2 &p_last, float &p_closest_dist2, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float tess_tol, int level)
ImVec2	ImBezierCubicClosestPointCasteljau (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, const ImVec2 &p, float tess_tol)
ImVec2	ImLineClosestPoint (const ImVec2 &a, const ImVec2 &b, const ImVec2 &p)
bool	ImTriangleContainsPoint (const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
void	ImTriangleBarycentricCoords (const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p, float &out_u, float &out_v, float &out_w)
ImVec2	ImTriangleClosestPoint (const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
int	ImStricmp (const char *str1, const char *str2)
int	ImStrnicmp (const char *str1, const char *str2, size_t count)
void	ImStrncpy (char *dst, const char *src, size_t count)
char *	ImStrdup (const char *str)
char *	ImStrdupcpy (char *dst, size_t *p_dst_size, const char *src)
const char *	ImStrchrRange (const char *str, const char *str_end, char c)
int	ImStrlenW (const ImWchar *str)
const char *	ImStreolRange (const char *str, const char *str_end)
const ImWchar *	ImStrbolW (const ImWchar *buf_mid_line, const ImWchar *buf_begin)
const char *	ImStristr (const char *haystack, const char *haystack_end, const char *needle, const char *needle_end)
void	ImStrTrimBlanks (char *buf)
const char *	ImStrSkipBlank (const char *str)
int	ImFormatString (char *buf, size_t buf_size, const char *fmt,...)
int	ImFormatStringV (char *buf, size_t buf_size, const char *fmt, va_list args)
ImGuiID	ImHashData (const void *data_p, size_t data_size, ImU32 seed)
ImGuiID	ImHashStr (const char *data_p, size_t data_size, ImU32 seed)
ImFileHandle	ImFileOpen (const char *filename, const char *mode)
bool	ImFileClose (ImFileHandle f)
ImU64	ImFileGetSize (ImFileHandle f)
ImU64	ImFileRead (void *data, ImU64 sz, ImU64 count, ImFileHandle f)
ImU64	ImFileWrite (const void *data, ImU64 sz, ImU64 count, ImFileHandle f)
void *	ImFileLoadToMemory (const char *filename, const char *mode, size_t *out_file_size, int padding_bytes)
int	ImTextCharFromUtf8 (unsigned int *out_char, const char *in_text, const char *in_text_end)
int	ImTextStrFromUtf8 (ImWchar *buf, int buf_size, const char *in_text, const char *in_text_end, const char **in_text_remaining)
int	ImTextCountCharsFromUtf8 (const char *in_text, const char *in_text_end)
static int	ImTextCharToUtf8 (char *buf, int buf_size, unsigned int c)
int	ImTextCountUtf8BytesFromChar (const char *in_text, const char *in_text_end)
static int	ImTextCountUtf8BytesFromChar (unsigned int c)
int	ImTextStrToUtf8 (char *buf, int buf_size, const ImWchar *in_text, const ImWchar *in_text_end)
int	ImTextCountUtf8BytesFromStr (const ImWchar *in_text, const ImWchar *in_text_end)
IMGUI_API ImU32	ImAlphaBlendColors (ImU32 col_a, ImU32 col_b)
static ImGuiStorage::ImGuiStoragePair *	LowerBound (ImVector< ImGuiStorage::ImGuiStoragePair > &data, ImGuiID key)
static bool	GetSkipItemForListClipping ()
static void	SetCursorPosYAndSetupForPrevLine (float pos_y, float line_height)
static const ImGuiStyleVarInfo *	GetStyleVarInfo (ImGuiStyleVar idx)
static bool	IsWindowContentHoverable (ImGuiWindow *window, ImGuiHoveredFlags flags)
static ImDrawList *	GetViewportDrawList (ImGuiViewportP *viewport, size_t drawlist_no, const char *drawlist_name)
static bool	IsWindowActiveAndVisible (ImGuiWindow *window)
static void	StartLockWheelingWindow (ImGuiWindow *window)
static int IMGUI_CDECL	ChildWindowComparer (const void *lhs, const void *rhs)
static void	AddWindowToDrawData (ImGuiWindow *window, int layer)
static void	AddRootWindowToDrawData (ImGuiWindow *window)
static void	SetupViewportDrawData (ImGuiViewportP *viewport, ImVector< ImDrawList * > *draw_lists)
static void	SetWindowConditionAllowFlags (ImGuiWindow *window, ImGuiCond flags, bool enabled)
static void	ApplyWindowSettings (ImGuiWindow *window, ImGuiWindowSettings *settings)
static ImVec2	CalcWindowSizeAfterConstraint (ImGuiWindow *window, const ImVec2 &size_desired)
static void	CalcWindowContentSizes (ImGuiWindow *window, ImVec2 *content_size_current, ImVec2 *content_size_ideal)
static ImVec2	CalcWindowAutoFitSize (ImGuiWindow *window, const ImVec2 &size_contents)
static ImGuiCol	GetWindowBgColorIdxFromFlags (ImGuiWindowFlags flags)
static void	CalcResizePosSizeFromAnyCorner (ImGuiWindow *window, const ImVec2 &corner_target, const ImVec2 &corner_norm, ImVec2 *out_pos, ImVec2 *out_size)
static ImRect	GetResizeBorderRect (ImGuiWindow *window, int border_n, float perp_padding, float thickness)
static void	ClampWindowRect (ImGuiWindow *window, const ImRect &visibility_rect)
static float	CalcScrollEdgeSnap (float target, float snap_min, float snap_max, float snap_threshold, float center_ratio)
ImGuiDir	ImGetDirQuadrantFromDelta (float dx, float dy)
static float	NavScoreItemDistInterval (float a0, float a1, float b0, float b1)
static void	NavClampRectToVisibleAreaForMoveDir (ImGuiDir move_dir, ImRect &r, const ImRect &clip_rect)
static ImGuiWindow *	FindWindowNavFocusable (int i_start, int i_stop, int dir)
static void	NavUpdateWindowingHighlightWindow (int focus_change_dir)
static const char *	GetFallbackWindowNameForWindowingList (ImGuiWindow *window)
static void	LogTextV (ImGuiContext &g, const char *fmt, va_list args)
static void	RenderViewportsThumbnails ()
static void	MetricsHelpMarker (const char *desc)
void	ImGui::ShowFontAtlas (ImFontAtlas *atlas)

Variables
static const float	NAV_WINDOWING_HIGHLIGHT_DELAY = 0.20f
static const float	NAV_WINDOWING_LIST_APPEAR_DELAY = 0.15f
static const float	WINDOWS_HOVER_PADDING = 4.0f
static const float	WINDOWS_RESIZE_FROM_EDGES_FEEDBACK_TIMER = 0.04f
static const float	WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER = 2.00f
ImGuiContext *	GImGui = NULL
static ImGuiMemAllocFunc	GImAllocatorAllocFunc = MallocWrapper
static ImGuiMemFreeFunc	GImAllocatorFreeFunc = FreeWrapper
static void *	GImAllocatorUserData = NULL
static const ImU32	GCrc32LookupTable [256]
static const ImGuiStyleVarInfo	GStyleVarInfo []
static const ImGuiResizeGripDef	resize_grip_def [4]
static const ImGuiResizeBorderDef	resize_border_def [4]

---

Class Documentation

ImGuiResizeGripDef

struct ImGuiResizeGripDef

Collaboration diagram for ImGuiResizeGripDef:

Class Members
int	AngleMax12
int	AngleMin12
ImVec2	CornerPosN
ImVec2	InnerDir

ImGuiResizeBorderDef

struct ImGuiResizeBorderDef

Collaboration diagram for ImGuiResizeBorderDef:

Class Members
ImVec2	InnerDir
float	OuterAngle
ImVec2	SegmentN1
ImVec2	SegmentN2

Macro Definition Documentation

IMGUI_DEBUG_INI_SETTINGS

#define IMGUI_DEBUG_INI_SETTINGS   0

IMGUI_DEBUG_NAV_RECTS

#define IMGUI_DEBUG_NAV_RECTS   0

IMGUI_DEBUG_NAV_SCORING

#define IMGUI_DEBUG_NAV_SCORING   0

IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

NAV_MAP_KEY

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

va_copy

#define va_copy	(		dest,
			src
	)		(dest = src)

Function Documentation

AddDrawListToDrawData()

static void AddDrawListToDrawData ( ImVector< ImDrawList * > *  out_list, ImDrawList *  draw_list  )

static

{
    // Remove trailing command if unused.
    // Technically we could return directly instead of popping, but this make things looks neat in Metrics/Debugger window as well.
    draw_list->_PopUnusedDrawCmd();
    if (draw_list->CmdBuffer.Size == 0)
        return;
 
    // Draw list sanity check. Detect mismatch between PrimReserve() calls and incrementing _VtxCurrentIdx, _VtxWritePtr etc.
    // May trigger for you if you are using PrimXXX functions incorrectly.
    IM_ASSERT(draw_list->VtxBuffer.Size == 0 || draw_list->_VtxWritePtr == draw_list->VtxBuffer.Data + draw_list->VtxBuffer.Size);
    IM_ASSERT(draw_list->IdxBuffer.Size == 0 || draw_list->_IdxWritePtr == draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size);
    if (!(draw_list->Flags & ImDrawListFlags_AllowVtxOffset))
        IM_ASSERT((int)draw_list->_VtxCurrentIdx == draw_list->VtxBuffer.Size);
 
    // Check that draw_list doesn't use more vertices than indexable (default ImDrawIdx = unsigned short = 2 bytes = 64K vertices per ImDrawList = per window)
    // If this assert triggers because you are drawing lots of stuff manually:
    // - First, make sure you are coarse clipping yourself and not trying to draw many things outside visible bounds.
    //   Be mindful that the ImDrawList API doesn't filter vertices. Use the Metrics/Debugger window to inspect draw list contents.
    // - If you want large meshes with more than 64K vertices, you can either:
    //   (A) Handle the ImDrawCmd::VtxOffset value in your renderer backend, and set 'io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset'.
    //       Most example backends already support this from 1.71. Pre-1.71 backends won't.
    //       Some graphics API such as GL ES 1/2 don't have a way to offset the starting vertex so it is not supported for them.
    //   (B) Or handle 32-bit indices in your renderer backend, and uncomment '#define ImDrawIdx unsigned int' line in imconfig.h.
    //       Most example backends already support this. For example, the OpenGL example code detect index size at compile-time:
    //         glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
    //       Your own engine or render API may use different parameters or function calls to specify index sizes.
    //       2 and 4 bytes indices are generally supported by most graphics API.
    // - If for some reason neither of those solutions works for you, a workaround is to call BeginChild()/EndChild() before reaching
    //   the 64K limit to split your draw commands in multiple draw lists.
    if (sizeof(ImDrawIdx) == 2)
        IM_ASSERT(draw_list->_VtxCurrentIdx < (1 << 16) && "Too many vertices in ImDrawList using 16-bit indices. Read comment above");
 
    out_list->push_back(draw_list);
}

References ImDrawList::_IdxWritePtr, ImDrawList::_PopUnusedDrawCmd(), ImDrawList::_VtxCurrentIdx, ImDrawList::_VtxWritePtr, ImDrawList::CmdBuffer, ImVector< T >::Data, ImDrawList::Flags, ImDrawList::IdxBuffer, IM_ASSERT, ImDrawListFlags_AllowVtxOffset, ImVector< T >::push_back(), ImVector< T >::Size, and ImDrawList::VtxBuffer.

Referenced by AddWindowToDrawData(), and ImGui::Render().

Here is the call graph for this function:

Here is the caller graph for this function:

AddRootWindowToDrawData()

static void AddRootWindowToDrawData ( ImGuiWindow *  window )

static

{
    int layer = (window->Flags & ImGuiWindowFlags_Tooltip) ? 1 : 0;
    AddWindowToDrawData(window, layer);
}

References AddWindowToDrawData(), ImGuiWindow::Flags, and ImGuiWindowFlags_Tooltip.

Referenced by ImGui::Render().

Here is the call graph for this function:

Here is the caller graph for this function:

AddWindowToDrawData()

static void AddWindowToDrawData ( ImGuiWindow *  window, int  layer  )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiViewportP* viewport = g.Viewports[0];
    g.IO.MetricsRenderWindows++;
    AddDrawListToDrawData(&viewport->DrawDataBuilder.Layers[layer], window->DrawList);
    for (int i = 0; i < window->DC.ChildWindows.Size; i++)
    {
        ImGuiWindow* child = window->DC.ChildWindows[i];
        if (IsWindowActiveAndVisible(child)) // Clipped children may have been marked not active
            AddWindowToDrawData(child, layer);
    }
}

References AddDrawListToDrawData(), AddWindowToDrawData(), ImGuiWindowTempData::ChildWindows, ImGuiWindow::DC, ImGuiViewportP::DrawDataBuilder, ImGuiWindow::DrawList, GImGui, ImGuiContext::IO, IsWindowActiveAndVisible(), ImDrawDataBuilder::Layers, ImGuiIO::MetricsRenderWindows, ImVector< T >::Size, and ImGuiContext::Viewports.

Referenced by AddRootWindowToDrawData(), and AddWindowToDrawData().

Here is the call graph for this function:

Here is the caller graph for this function:

AddWindowToSortBuffer()

static void AddWindowToSortBuffer ( ImVector< ImGuiWindow * > *  out_sorted_windows, ImGuiWindow *  window  )

static

{
    out_sorted_windows->push_back(window);
    if (window->Active)
    {
        int count = window->DC.ChildWindows.Size;
        if (count > 1)
            ImQsort(window->DC.ChildWindows.Data, (size_t)count, sizeof(ImGuiWindow*), ChildWindowComparer);
        for (int i = 0; i < count; i++)
        {
            ImGuiWindow* child = window->DC.ChildWindows[i];
            if (child->Active)
                AddWindowToSortBuffer(out_sorted_windows, child);
        }
    }
}

References ImGuiWindow::Active, AddWindowToSortBuffer(), ChildWindowComparer(), ImGuiWindowTempData::ChildWindows, ImVector< T >::Data, ImGuiWindow::DC, ImQsort, ImVector< T >::push_back(), and ImVector< T >::Size.

Referenced by AddWindowToSortBuffer(), and ImGui::EndFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyWindowSettings()

static void ApplyWindowSettings ( ImGuiWindow *  window, ImGuiWindowSettings *  settings  )

static

{
    window->Pos = ImFloor(ImVec2(settings->Pos.x, settings->Pos.y));
    if (settings->Size.x > 0 && settings->Size.y > 0)
        window->Size = window->SizeFull = ImFloor(ImVec2(settings->Size.x, settings->Size.y));
    window->Collapsed = settings->Collapsed;
}

References ImGuiWindowSettings::Collapsed, ImGuiWindow::Collapsed, ImFloor(), ImGuiWindowSettings::Pos, ImGuiWindow::Pos, ImGuiWindowSettings::Size, ImGuiWindow::Size, ImGuiWindow::SizeFull, ImVec2ih::x, and ImVec2ih::y.

Referenced by CreateNewWindow(), and WindowSettingsHandler_ApplyAll().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcNextScrollFromScrollTargetAndClamp()

static ImVec2 CalcNextScrollFromScrollTargetAndClamp ( ImGuiWindow *  window )

static

{
    ImVec2 scroll = window->Scroll;
    if (window->ScrollTarget.x < FLT_MAX)
    {
        float decoration_total_width = window->ScrollbarSizes.x;
        float center_x_ratio = window->ScrollTargetCenterRatio.x;
        float scroll_target_x = window->ScrollTarget.x;
        if (window->ScrollTargetEdgeSnapDist.x > 0.0f)
        {
            float snap_x_min = 0.0f;
            float snap_x_max = window->ScrollMax.x + window->SizeFull.x - decoration_total_width;
            scroll_target_x = CalcScrollEdgeSnap(scroll_target_x, snap_x_min, snap_x_max, window->ScrollTargetEdgeSnapDist.x, center_x_ratio);
        }
        scroll.x = scroll_target_x - center_x_ratio * (window->SizeFull.x - decoration_total_width);
    }
    if (window->ScrollTarget.y < FLT_MAX)
    {
        float decoration_total_height = window->TitleBarHeight() + window->MenuBarHeight() + window->ScrollbarSizes.y;
        float center_y_ratio = window->ScrollTargetCenterRatio.y;
        float scroll_target_y = window->ScrollTarget.y;
        if (window->ScrollTargetEdgeSnapDist.y > 0.0f)
        {
            float snap_y_min = 0.0f;
            float snap_y_max = window->ScrollMax.y + window->SizeFull.y - decoration_total_height;
            scroll_target_y = CalcScrollEdgeSnap(scroll_target_y, snap_y_min, snap_y_max, window->ScrollTargetEdgeSnapDist.y, center_y_ratio);
        }
        scroll.y = scroll_target_y - center_y_ratio * (window->SizeFull.y - decoration_total_height);
    }
    scroll.x = IM_FLOOR(ImMax(scroll.x, 0.0f));
    scroll.y = IM_FLOOR(ImMax(scroll.y, 0.0f));
    if (!window->Collapsed && !window->SkipItems)
    {
        scroll.x = ImMin(scroll.x, window->ScrollMax.x);
        scroll.y = ImMin(scroll.y, window->ScrollMax.y);
    }
    return scroll;
}

References CalcScrollEdgeSnap(), ImGuiWindow::Collapsed, IM_FLOOR, ImMax(), ImMin(), ImGuiWindow::MenuBarHeight(), ImGuiWindow::Scroll, ImGuiWindow::ScrollbarSizes, ImGuiWindow::ScrollMax, ImGuiWindow::ScrollTarget, ImGuiWindow::ScrollTargetCenterRatio, ImGuiWindow::ScrollTargetEdgeSnapDist, ImGuiWindow::SizeFull, ImGuiWindow::SkipItems, ImGuiWindow::TitleBarHeight(), ImVec2::x, and ImVec2::y.

Referenced by ImGui::Begin(), and ImGui::ScrollToBringRectIntoView().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcResizePosSizeFromAnyCorner()

static void CalcResizePosSizeFromAnyCorner ( ImGuiWindow *  window, const ImVec2 &  corner_target, const ImVec2 &  corner_norm, ImVec2 *  out_pos, ImVec2 *  out_size  )

static

{
    ImVec2 pos_min = ImLerp(corner_target, window->Pos, corner_norm);                // Expected window upper-left
    ImVec2 pos_max = ImLerp(window->Pos + window->Size, corner_target, corner_norm); // Expected window lower-right
    ImVec2 size_expected = pos_max - pos_min;
    ImVec2 size_constrained = CalcWindowSizeAfterConstraint(window, size_expected);
    *out_pos = pos_min;
    if (corner_norm.x == 0.0f)
        out_pos->x -= (size_constrained.x - size_expected.x);
    if (corner_norm.y == 0.0f)
        out_pos->y -= (size_constrained.y - size_expected.y);
    *out_size = size_constrained;
}

References CalcWindowSizeAfterConstraint(), ImLerp(), ImGuiWindow::Pos, ImGuiWindow::Size, ImVec2::x, and ImVec2::y.

Referenced by ImGui::UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcScrollEdgeSnap()

static float CalcScrollEdgeSnap ( float  target, float  snap_min, float  snap_max, float  snap_threshold, float  center_ratio  )

static

{
    if (target <= snap_min + snap_threshold)
        return ImLerp(snap_min, target, center_ratio);
    if (target >= snap_max - snap_threshold)
        return ImLerp(target, snap_max, center_ratio);
    return target;
}

References ImLerp().

Referenced by CalcNextScrollFromScrollTargetAndClamp().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcWindowAutoFitSize()

static ImVec2 CalcWindowAutoFitSize ( ImGuiWindow *  window, const ImVec2 &  size_contents  )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiStyle& style = g.Style;
    const float decoration_up_height = window->TitleBarHeight() + window->MenuBarHeight();
    ImVec2 size_pad = window->WindowPadding * 2.0f;
    ImVec2 size_desired = size_contents + size_pad + ImVec2(0.0f, decoration_up_height);
    if (window->Flags & ImGuiWindowFlags_Tooltip)
    {
        // Tooltip always resize
        return size_desired;
    }
    else
    {
        // Maximum window size is determined by the viewport size or monitor size
        const bool is_popup = (window->Flags & ImGuiWindowFlags_Popup) != 0;
        const bool is_menu = (window->Flags & ImGuiWindowFlags_ChildMenu) != 0;
        ImVec2 size_min = style.WindowMinSize;
        if (is_popup || is_menu) // Popups and menus bypass style.WindowMinSize by default, but we give then a non-zero minimum size to facilitate understanding problematic cases (e.g. empty popups)
            size_min = ImMin(size_min, ImVec2(4.0f, 4.0f));
 
        // FIXME-VIEWPORT-WORKAREA: May want to use GetWorkSize() instead of Size depending on the type of windows?
        ImVec2 avail_size = ImGui::GetMainViewport()->Size;
        ImVec2 size_auto_fit = ImClamp(size_desired, size_min, ImMax(size_min, avail_size - style.DisplaySafeAreaPadding * 2.0f));
 
        // When the window cannot fit all contents (either because of constraints, either because screen is too small),
        // we are growing the size on the other axis to compensate for expected scrollbar. FIXME: Might turn bigger than ViewportSize-WindowPadding.
        ImVec2 size_auto_fit_after_constraint = CalcWindowSizeAfterConstraint(window, size_auto_fit);
        bool will_have_scrollbar_x = (size_auto_fit_after_constraint.x - size_pad.x - 0.0f                 < size_contents.x && !(window->Flags & ImGuiWindowFlags_NoScrollbar) && (window->Flags & ImGuiWindowFlags_HorizontalScrollbar)) || (window->Flags & ImGuiWindowFlags_AlwaysHorizontalScrollbar);
        bool will_have_scrollbar_y = (size_auto_fit_after_constraint.y - size_pad.y - decoration_up_height < size_contents.y && !(window->Flags & ImGuiWindowFlags_NoScrollbar)) || (window->Flags & ImGuiWindowFlags_AlwaysVerticalScrollbar);
        if (will_have_scrollbar_x)
            size_auto_fit.y += style.ScrollbarSize;
        if (will_have_scrollbar_y)
            size_auto_fit.x += style.ScrollbarSize;
        return size_auto_fit;
    }
}

References CalcWindowSizeAfterConstraint(), ImGuiWindow::Flags, ImGui::GetMainViewport(), GImGui, ImClamp(), ImGuiWindowFlags_AlwaysHorizontalScrollbar, ImGuiWindowFlags_AlwaysVerticalScrollbar, ImGuiWindowFlags_ChildMenu, ImGuiWindowFlags_HorizontalScrollbar, ImGuiWindowFlags_NoScrollbar, ImGuiWindowFlags_Popup, ImGuiWindowFlags_Tooltip, ImMax(), ImMin(), ImGuiWindow::MenuBarHeight(), ImGuiViewport::Size, ImGuiContext::Style, style, ImGuiWindow::TitleBarHeight(), ImGuiWindow::WindowPadding, ImVec2::x, and ImVec2::y.

Referenced by ImGui::Begin(), and ImGui::CalcWindowNextAutoFitSize().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcWindowContentSizes()

static void CalcWindowContentSizes ( ImGuiWindow *  window, ImVec2 *  content_size_current, ImVec2 *  content_size_ideal  )

static

{
    bool preserve_old_content_sizes = false;
    if (window->Collapsed && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0)
        preserve_old_content_sizes = true;
    else if (window->Hidden && window->HiddenFramesCannotSkipItems == 0 && window->HiddenFramesCanSkipItems > 0)
        preserve_old_content_sizes = true;
    if (preserve_old_content_sizes)
    {
        *content_size_current = window->ContentSize;
        *content_size_ideal = window->ContentSizeIdeal;
        return;
    }
 
    content_size_current->x = (window->ContentSizeExplicit.x != 0.0f) ? window->ContentSizeExplicit.x : IM_FLOOR(window->DC.CursorMaxPos.x - window->DC.CursorStartPos.x);
    content_size_current->y = (window->ContentSizeExplicit.y != 0.0f) ? window->ContentSizeExplicit.y : IM_FLOOR(window->DC.CursorMaxPos.y - window->DC.CursorStartPos.y);
    content_size_ideal->x = (window->ContentSizeExplicit.x != 0.0f) ? window->ContentSizeExplicit.x : IM_FLOOR(ImMax(window->DC.CursorMaxPos.x, window->DC.IdealMaxPos.x) - window->DC.CursorStartPos.x);
    content_size_ideal->y = (window->ContentSizeExplicit.y != 0.0f) ? window->ContentSizeExplicit.y : IM_FLOOR(ImMax(window->DC.CursorMaxPos.y, window->DC.IdealMaxPos.y) - window->DC.CursorStartPos.y);
}

References ImGuiWindow::AutoFitFramesX, ImGuiWindow::AutoFitFramesY, ImGuiWindow::Collapsed, ImGuiWindow::ContentSize, ImGuiWindow::ContentSizeExplicit, ImGuiWindow::ContentSizeIdeal, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorStartPos, ImGuiWindow::DC, ImGuiWindow::Hidden, ImGuiWindow::HiddenFramesCannotSkipItems, ImGuiWindow::HiddenFramesCanSkipItems, ImGuiWindowTempData::IdealMaxPos, IM_FLOOR, ImMax(), ImVec2::x, and ImVec2::y.

Referenced by ImGui::Begin(), and ImGui::CalcWindowNextAutoFitSize().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcWindowSizeAfterConstraint()

static ImVec2 CalcWindowSizeAfterConstraint ( ImGuiWindow *  window, const ImVec2 &  size_desired  )

static

{
    ImGuiContext& g = *GImGui;
    ImVec2 new_size = size_desired;
    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint)
    {
        // Using -1,-1 on either X/Y axis to preserve the current size.
        ImRect cr = g.NextWindowData.SizeConstraintRect;
        new_size.x = (cr.Min.x >= 0 && cr.Max.x >= 0) ? ImClamp(new_size.x, cr.Min.x, cr.Max.x) : window->SizeFull.x;
        new_size.y = (cr.Min.y >= 0 && cr.Max.y >= 0) ? ImClamp(new_size.y, cr.Min.y, cr.Max.y) : window->SizeFull.y;
        if (g.NextWindowData.SizeCallback)
        {
            ImGuiSizeCallbackData data;
            data.UserData = g.NextWindowData.SizeCallbackUserData;
            data.Pos = window->Pos;
            data.CurrentSize = window->SizeFull;
            data.DesiredSize = new_size;
            g.NextWindowData.SizeCallback(&data);
            new_size = data.DesiredSize;
        }
        new_size.x = IM_FLOOR(new_size.x);
        new_size.y = IM_FLOOR(new_size.y);
    }
 
    // Minimum size
    if (!(window->Flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_AlwaysAutoResize)))
    {
        ImGuiWindow* window_for_height = window;
        const float decoration_up_height = window_for_height->TitleBarHeight() + window_for_height->MenuBarHeight();
        new_size = ImMax(new_size, g.Style.WindowMinSize);
        new_size.y = ImMax(new_size.y, decoration_up_height + ImMax(0.0f, g.Style.WindowRounding - 1.0f)); // Reduce artifacts with very small windows
    }
    return new_size;
}

References ImGuiNextWindowData::Flags, ImGuiWindow::Flags, GImGui, IM_FLOOR, ImClamp(), ImGuiNextWindowDataFlags_HasSizeConstraint, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_ChildWindow, ImMax(), ImRect::Max, ImGuiWindow::MenuBarHeight(), ImRect::Min, ImGuiContext::NextWindowData, ImGuiWindow::Pos, ImGuiNextWindowData::SizeCallback, ImGuiNextWindowData::SizeCallbackUserData, ImGuiNextWindowData::SizeConstraintRect, ImGuiWindow::SizeFull, ImGuiContext::Style, ImGuiWindow::TitleBarHeight(), ImGuiStyle::WindowMinSize, ImGuiStyle::WindowRounding, ImVec2::x, and ImVec2::y.

Referenced by ImGui::Begin(), CalcResizePosSizeFromAnyCorner(), CalcWindowAutoFitSize(), ImGui::CalcWindowNextAutoFitSize(), and ImGui::UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

ChildWindowComparer()

static int IMGUI_CDECL ChildWindowComparer ( const void *  lhs, const void *  rhs  )

static

{
    const ImGuiWindow* const a = *(const ImGuiWindow* const *)lhs;
    const ImGuiWindow* const b = *(const ImGuiWindow* const *)rhs;
    if (int d = (a->Flags & ImGuiWindowFlags_Popup) - (b->Flags & ImGuiWindowFlags_Popup))
        return d;
    if (int d = (a->Flags & ImGuiWindowFlags_Tooltip) - (b->Flags & ImGuiWindowFlags_Tooltip))
        return d;
    return (a->BeginOrderWithinParent - b->BeginOrderWithinParent);
}

References ImGuiWindowFlags_Popup, and ImGuiWindowFlags_Tooltip.

Referenced by AddWindowToSortBuffer().

Here is the caller graph for this function:

ClampWindowRect()

static void ClampWindowRect ( ImGuiWindow *  window, const ImRect &  visibility_rect  )

inlinestatic

{
    ImGuiContext& g = *GImGui;
    ImVec2 size_for_clamping = window->Size;
    if (g.IO.ConfigWindowsMoveFromTitleBarOnly && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
        size_for_clamping.y = window->TitleBarHeight();
    window->Pos = ImClamp(window->Pos, visibility_rect.Min - size_for_clamping, visibility_rect.Max);
}

References ImGuiIO::ConfigWindowsMoveFromTitleBarOnly, ImGuiWindow::Flags, GImGui, ImClamp(), ImGuiWindowFlags_NoTitleBar, ImGuiContext::IO, ImRect::Max, ImRect::Min, ImGuiWindow::Pos, ImGuiWindow::Size, ImGuiWindow::TitleBarHeight(), and ImVec2::y.

Referenced by ImGui::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateNewWindow()

static ImGuiWindow * CreateNewWindow ( const char *  name, ImGuiWindowFlags  flags  )

static

{
    ImGuiContext& g = *GImGui;
    //IMGUI_DEBUG_LOG("CreateNewWindow '%s', flags = 0x%08X\n", name, flags);
 
    // Create window the first time
    ImGuiWindow* window = IM_NEW(ImGuiWindow)(&g, name);
    window->Flags = flags;
    g.WindowsById.SetVoidPtr(window->ID, window);
 
    // Default/arbitrary window position. Use SetNextWindowPos() with the appropriate condition flag to change the initial position of a window.
    const ImGuiViewport* main_viewport = ImGui::GetMainViewport();
    window->Pos = main_viewport->Pos + ImVec2(60, 60);
 
    // User can disable loading and saving of settings. Tooltip and child windows also don't store settings.
    if (!(flags & ImGuiWindowFlags_NoSavedSettings))
        if (ImGuiWindowSettings* settings = ImGui::FindWindowSettings(window->ID))
        {
            // Retrieve settings from .ini file
            window->SettingsOffset = g.SettingsWindows.offset_from_ptr(settings);
            SetWindowConditionAllowFlags(window, ImGuiCond_FirstUseEver, false);
            ApplyWindowSettings(window, settings);
        }
    window->DC.CursorStartPos = window->DC.CursorMaxPos = window->Pos; // So first call to CalcContentSize() doesn't return crazy values
 
    if ((flags & ImGuiWindowFlags_AlwaysAutoResize) != 0)
    {
        window->AutoFitFramesX = window->AutoFitFramesY = 2;
        window->AutoFitOnlyGrows = false;
    }
    else
    {
        if (window->Size.x <= 0.0f)
            window->AutoFitFramesX = 2;
        if (window->Size.y <= 0.0f)
            window->AutoFitFramesY = 2;
        window->AutoFitOnlyGrows = (window->AutoFitFramesX > 0) || (window->AutoFitFramesY > 0);
    }
 
    if (!(flags & ImGuiWindowFlags_ChildWindow))
    {
        g.WindowsFocusOrder.push_back(window);
        window->FocusOrder = (short)(g.WindowsFocusOrder.Size - 1);
    }
 
    if (flags & ImGuiWindowFlags_NoBringToFrontOnFocus)
        g.Windows.push_front(window); // Quite slow but rare and only once
    else
        g.Windows.push_back(window);
    return window;
}

References ApplyWindowSettings(), ImGuiWindow::AutoFitFramesX, ImGuiWindow::AutoFitFramesY, ImGuiWindow::AutoFitOnlyGrows, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorStartPos, ImGuiWindow::DC, ImGui::FindWindowSettings(), ImGuiWindow::Flags, ImGuiWindow::FocusOrder, ImGui::GetMainViewport(), GImGui, ImGuiWindow::ID, IM_NEW, ImGuiCond_FirstUseEver, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NoBringToFrontOnFocus, ImGuiWindowFlags_NoSavedSettings, ImChunkStream< T >::offset_from_ptr(), ImGuiViewport::Pos, ImGuiWindow::Pos, ImVector< T >::push_back(), ImVector< T >::push_front(), ImGuiWindow::SettingsOffset, ImGuiContext::SettingsWindows, ImGuiStorage::SetVoidPtr(), SetWindowConditionAllowFlags(), ImVector< T >::Size, ImGuiWindow::Size, ImGuiContext::Windows, ImGuiContext::WindowsById, ImGuiContext::WindowsFocusOrder, ImVec2::x, and ImVec2::y.

Referenced by ImGui::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

FindHoveredWindow()

static void FindHoveredWindow ( )

static

{
    ImGuiContext& g = *GImGui;
 
    ImGuiWindow* hovered_window = NULL;
    ImGuiWindow* hovered_window_ignoring_moving_window = NULL;
    if (g.MovingWindow && !(g.MovingWindow->Flags & ImGuiWindowFlags_NoMouseInputs))
        hovered_window = g.MovingWindow;
 
    ImVec2 padding_regular = g.Style.TouchExtraPadding;
    ImVec2 padding_for_resize = g.IO.ConfigWindowsResizeFromEdges ? g.WindowsHoverPadding : padding_regular;
    for (int i = g.Windows.Size - 1; i >= 0; i--)
    {
        ImGuiWindow* window = g.Windows[i];
        IM_MSVC_WARNING_SUPPRESS(28182); // [Static Analyzer] Dereferencing NULL pointer.
        if (!window->Active || window->Hidden)
            continue;
        if (window->Flags & ImGuiWindowFlags_NoMouseInputs)
            continue;
 
        // Using the clipped AABB, a child window will typically be clipped by its parent (not always)
        ImRect bb(window->OuterRectClipped);
        if (window->Flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize))
            bb.Expand(padding_regular);
        else
            bb.Expand(padding_for_resize);
        if (!bb.Contains(g.IO.MousePos))
            continue;
 
        // Support for one rectangular hole in any given window
        // FIXME: Consider generalizing hit-testing override (with more generic data, callback, etc.) (#1512)
        if (window->HitTestHoleSize.x != 0)
        {
            ImVec2 hole_pos(window->Pos.x + (float)window->HitTestHoleOffset.x, window->Pos.y + (float)window->HitTestHoleOffset.y);
            ImVec2 hole_size((float)window->HitTestHoleSize.x, (float)window->HitTestHoleSize.y);
            if (ImRect(hole_pos, hole_pos + hole_size).Contains(g.IO.MousePos))
                continue;
        }
 
        if (hovered_window == NULL)
            hovered_window = window;
        IM_MSVC_WARNING_SUPPRESS(28182); // [Static Analyzer] Dereferencing NULL pointer.
        if (hovered_window_ignoring_moving_window == NULL && (!g.MovingWindow || window->RootWindow != g.MovingWindow->RootWindow))
            hovered_window_ignoring_moving_window = window;
        if (hovered_window && hovered_window_ignoring_moving_window)
            break;
    }
 
    g.HoveredWindow = hovered_window;
    g.HoveredWindowUnderMovingWindow = hovered_window_ignoring_moving_window;
}

References ImGuiWindow::Active, ImGuiIO::ConfigWindowsResizeFromEdges, ImRect::Contains(), ImRect::Expand(), ImGuiWindow::Flags, GImGui, ImGuiWindow::Hidden, ImGuiWindow::HitTestHoleOffset, ImGuiWindow::HitTestHoleSize, ImGuiContext::HoveredWindow, ImGuiContext::HoveredWindowUnderMovingWindow, IM_MSVC_WARNING_SUPPRESS, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_NoMouseInputs, ImGuiWindowFlags_NoResize, ImGuiContext::IO, ImGuiIO::MousePos, ImGuiContext::MovingWindow, ImGuiWindow::OuterRectClipped, ImGuiWindow::Pos, ImGuiWindow::RootWindow, ImVector< T >::Size, ImGuiContext::Style, ImGuiStyle::TouchExtraPadding, ImGuiContext::Windows, ImGuiContext::WindowsHoverPadding, ImVec2::x, ImVec2ih::x, ImVec2::y, and ImVec2ih::y.

Referenced by ImGui::UpdateHoveredWindowAndCaptureFlags().

Here is the call graph for this function:

Here is the caller graph for this function:

FindWindowNavFocusable()

static ImGuiWindow * FindWindowNavFocusable ( int  i_start, int  i_stop, int  dir  )

static

{
    ImGuiContext& g = *GImGui;
    for (int i = i_start; i >= 0 && i < g.WindowsFocusOrder.Size && i != i_stop; i += dir)
        if (ImGui::IsWindowNavFocusable(g.WindowsFocusOrder[i]))
            return g.WindowsFocusOrder[i];
    return NULL;
}

References GImGui, ImGui::IsWindowNavFocusable(), ImVector< T >::Size, and ImGuiContext::WindowsFocusOrder.

Referenced by ImGui::NavUpdateWindowing(), and NavUpdateWindowingHighlightWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeWrapper()

static void FreeWrapper ( void *  ptr, void *  user_data  )

static

{ IM_UNUSED(user_data); free(ptr); }

References free(), and IM_UNUSED.

Here is the call graph for this function:

GetClipboardTextFn_DefaultImpl()

static const char * GetClipboardTextFn_DefaultImpl ( void *  user_data )

static

{
    ImGuiContext& g = *GImGui;
    return g.ClipboardHandlerData.empty() ? NULL : g.ClipboardHandlerData.begin();
}

References ImVector< T >::begin(), ImGuiContext::ClipboardHandlerData, ImVector< T >::empty(), and GImGui.

Referenced by ImGuiIO::ImGuiIO().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFallbackWindowNameForWindowingList()

static const char * GetFallbackWindowNameForWindowingList ( ImGuiWindow *  window )

static

{
    if (window->Flags & ImGuiWindowFlags_Popup)
        return "(Popup)";
    if ((window->Flags & ImGuiWindowFlags_MenuBar) && strcmp(window->Name, "##MainMenuBar") == 0)
        return "(Main menu bar)";
    return "(Untitled)";
}

References ImGuiWindow::Flags, ImGuiWindowFlags_MenuBar, ImGuiWindowFlags_Popup, and ImGuiWindow::Name.

Referenced by ImGui::NavUpdateWindowingOverlay().

Here is the caller graph for this function:

GetResizeBorderRect()

static ImRect GetResizeBorderRect ( ImGuiWindow *  window, int  border_n, float  perp_padding, float  thickness  )

static

{
    ImRect rect = window->Rect();
    if (thickness == 0.0f)
        rect.Max -= ImVec2(1, 1);
    if (border_n == ImGuiDir_Left)  { return ImRect(rect.Min.x - thickness,    rect.Min.y + perp_padding, rect.Min.x + thickness,    rect.Max.y - perp_padding); }
    if (border_n == ImGuiDir_Right) { return ImRect(rect.Max.x - thickness,    rect.Min.y + perp_padding, rect.Max.x + thickness,    rect.Max.y - perp_padding); }
    if (border_n == ImGuiDir_Up)    { return ImRect(rect.Min.x + perp_padding, rect.Min.y - thickness,    rect.Max.x - perp_padding, rect.Min.y + thickness);    }
    if (border_n == ImGuiDir_Down)  { return ImRect(rect.Min.x + perp_padding, rect.Max.y - thickness,    rect.Max.x - perp_padding, rect.Max.y + thickness);    }
    IM_ASSERT(0);
    return ImRect();
}

References IM_ASSERT, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_Right, ImGuiDir_Up, ImRect::Max, ImRect::Min, ImGuiWindow::Rect(), ImVec2::x, and ImVec2::y.

Referenced by ImGui::RenderWindowOuterBorders(), and ImGui::UpdateWindowManualResize().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSkipItemForListClipping()

static bool GetSkipItemForListClipping ( )

static

{
    ImGuiContext& g = *GImGui;
    return (g.CurrentTable ? g.CurrentTable->HostSkipItems : g.CurrentWindow->SkipItems);
}

References ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, GImGui, ImGuiTable::HostSkipItems, and ImGuiWindow::SkipItems.

Referenced by ImGui::CalcListClipping(), and ImGuiListClipper::Step().

Here is the caller graph for this function:

GetStyleVarInfo()

static const ImGuiStyleVarInfo * GetStyleVarInfo ( ImGuiStyleVar  idx )

static

{
    IM_ASSERT(idx >= 0 && idx < ImGuiStyleVar_COUNT);
    IM_ASSERT(IM_ARRAYSIZE(GStyleVarInfo) == ImGuiStyleVar_COUNT);
    return &GStyleVarInfo[idx];
}

References GStyleVarInfo, IM_ARRAYSIZE, IM_ASSERT, and ImGuiStyleVar_COUNT.

Referenced by ImGui::PopStyleVar(), ImGui::PushStyleVar(), and ImGui::PushStyleVar().

Here is the caller graph for this function:

GetViewportDrawList()

static ImDrawList * GetViewportDrawList ( ImGuiViewportP *  viewport, size_t  drawlist_no, const char *  drawlist_name  )

static

{
    // Create the draw list on demand, because they are not frequently used for all viewports
    ImGuiContext& g = *GImGui;
    IM_ASSERT(drawlist_no < IM_ARRAYSIZE(viewport->DrawLists));
    ImDrawList* draw_list = viewport->DrawLists[drawlist_no];
    if (draw_list == NULL)
    {
        draw_list = IM_NEW(ImDrawList)(&g.DrawListSharedData);
        draw_list->_OwnerName = drawlist_name;
        viewport->DrawLists[drawlist_no] = draw_list;
    }
 
    // Our ImDrawList system requires that there is always a command
    if (viewport->DrawListsLastFrame[drawlist_no] != g.FrameCount)
    {
        draw_list->_ResetForNewFrame();
        draw_list->PushTextureID(g.IO.Fonts->TexID);
        draw_list->PushClipRect(viewport->Pos, viewport->Pos + viewport->Size, false);
        viewport->DrawListsLastFrame[drawlist_no] = g.FrameCount;
    }
    return draw_list;
}

References ImDrawList::_OwnerName, ImDrawList::_ResetForNewFrame(), ImGuiViewportP::DrawLists, ImGuiContext::DrawListSharedData, ImGuiViewportP::DrawListsLastFrame, ImGuiIO::Fonts, ImGuiContext::FrameCount, GImGui, IM_ARRAYSIZE, IM_ASSERT, IM_NEW, ImGuiContext::IO, ImGuiViewport::Pos, ImDrawList::PushClipRect(), ImDrawList::PushTextureID(), ImGuiViewport::Size, and ImFontAtlas::TexID.

Referenced by ImGui::GetBackgroundDrawList(), and ImGui::GetForegroundDrawList().

Here is the call graph for this function:

Here is the caller graph for this function:

GetWindowBgColorIdxFromFlags()

static ImGuiCol GetWindowBgColorIdxFromFlags ( ImGuiWindowFlags  flags )

static

{
    if (flags & (ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_Popup))
        return ImGuiCol_PopupBg;
    if (flags & ImGuiWindowFlags_ChildWindow)
        return ImGuiCol_ChildBg;
    return ImGuiCol_WindowBg;
}

References ImGuiCol_ChildBg, ImGuiCol_PopupBg, ImGuiCol_WindowBg, ImGuiWindowFlags_ChildWindow, ImGuiWindowFlags_Popup, and ImGuiWindowFlags_Tooltip.

Referenced by ImGui::RenderWindowDecorations().

Here is the caller graph for this function:

ImAlphaBlendColors()

IMGUI_API ImU32 ImAlphaBlendColors	(	ImU32	col_a,
		ImU32	col_b
	)

{
    float t = ((col_b >> IM_COL32_A_SHIFT) & 0xFF) / 255.f;
    int r = ImLerp((int)(col_a >> IM_COL32_R_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_R_SHIFT) & 0xFF, t);
    int g = ImLerp((int)(col_a >> IM_COL32_G_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_G_SHIFT) & 0xFF, t);
    int b = ImLerp((int)(col_a >> IM_COL32_B_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_B_SHIFT) & 0xFF, t);
    return IM_COL32(r, g, b, 0xFF);
}

References IM_COL32, IM_COL32_A_SHIFT, IM_COL32_B_SHIFT, IM_COL32_G_SHIFT, IM_COL32_R_SHIFT, and ImLerp().

Referenced by ImGui::RenderColorRectWithAlphaCheckerboard().

Here is the call graph for this function:

Here is the caller graph for this function:

ImBezierCubicClosestPoint()

ImVec2 ImBezierCubicClosestPoint	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		const ImVec2 &	p,
		int	num_segments
	)

{
    IM_ASSERT(num_segments > 0); // Use ImBezierCubicClosestPointCasteljau()
    ImVec2 p_last = p1;
    ImVec2 p_closest;
    float p_closest_dist2 = FLT_MAX;
    float t_step = 1.0f / (float)num_segments;
    for (int i_step = 1; i_step <= num_segments; i_step++)
    {
        ImVec2 p_current = ImBezierCubicCalc(p1, p2, p3, p4, t_step * i_step);
        ImVec2 p_line = ImLineClosestPoint(p_last, p_current, p);
        float dist2 = ImLengthSqr(p - p_line);
        if (dist2 < p_closest_dist2)
        {
            p_closest = p_line;
            p_closest_dist2 = dist2;
        }
        p_last = p_current;
    }
    return p_closest;
}

References IM_ASSERT, ImBezierCubicCalc(), ImLengthSqr(), and ImLineClosestPoint().

Here is the call graph for this function:

ImBezierCubicClosestPointCasteljau()

ImVec2 ImBezierCubicClosestPointCasteljau	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		const ImVec2 &	p,
		float	tess_tol
	)

{
    IM_ASSERT(tess_tol > 0.0f);
    ImVec2 p_last = p1;
    ImVec2 p_closest;
    float p_closest_dist2 = FLT_MAX;
    ImBezierCubicClosestPointCasteljauStep(p, p_closest, p_last, p_closest_dist2, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y, tess_tol, 0);
    return p_closest;
}

References IM_ASSERT, ImBezierCubicClosestPointCasteljauStep(), ImVec2::x, and ImVec2::y.

Here is the call graph for this function:

ImBezierCubicClosestPointCasteljauStep()

static void ImBezierCubicClosestPointCasteljauStep ( const ImVec2 &  p, ImVec2 &  p_closest, ImVec2 &  p_last, float &  p_closest_dist2, float  x1, float  y1, float  x2, float  y2, float  x3, float  y3, float  x4, float  y4, float  tess_tol, int  level  )

static

{
    float dx = x4 - x1;
    float dy = y4 - y1;
    float d2 = ((x2 - x4) * dy - (y2 - y4) * dx);
    float d3 = ((x3 - x4) * dy - (y3 - y4) * dx);
    d2 = (d2 >= 0) ? d2 : -d2;
    d3 = (d3 >= 0) ? d3 : -d3;
    if ((d2 + d3) * (d2 + d3) < tess_tol * (dx * dx + dy * dy))
    {
        ImVec2 p_current(x4, y4);
        ImVec2 p_line = ImLineClosestPoint(p_last, p_current, p);
        float dist2 = ImLengthSqr(p - p_line);
        if (dist2 < p_closest_dist2)
        {
            p_closest = p_line;
            p_closest_dist2 = dist2;
        }
        p_last = p_current;
    }
    else if (level < 10)
    {
        float x12 = (x1 + x2)*0.5f,       y12 = (y1 + y2)*0.5f;
        float x23 = (x2 + x3)*0.5f,       y23 = (y2 + y3)*0.5f;
        float x34 = (x3 + x4)*0.5f,       y34 = (y3 + y4)*0.5f;
        float x123 = (x12 + x23)*0.5f,    y123 = (y12 + y23)*0.5f;
        float x234 = (x23 + x34)*0.5f,    y234 = (y23 + y34)*0.5f;
        float x1234 = (x123 + x234)*0.5f, y1234 = (y123 + y234)*0.5f;
        ImBezierCubicClosestPointCasteljauStep(p, p_closest, p_last, p_closest_dist2, x1, y1, x12, y12, x123, y123, x1234, y1234, tess_tol, level + 1);
        ImBezierCubicClosestPointCasteljauStep(p, p_closest, p_last, p_closest_dist2, x1234, y1234, x234, y234, x34, y34, x4, y4, tess_tol, level + 1);
    }
}

References ImBezierCubicClosestPointCasteljauStep(), ImLengthSqr(), and ImLineClosestPoint().

Referenced by ImBezierCubicClosestPointCasteljau(), and ImBezierCubicClosestPointCasteljauStep().

Here is the call graph for this function:

Here is the caller graph for this function:

ImeSetInputScreenPosFn_DefaultImpl()

static void ImeSetInputScreenPosFn_DefaultImpl ( int  x, int  y  )

static

{}

Referenced by ImGuiIO::ImGuiIO().

Here is the caller graph for this function:

ImFileClose()

bool ImFileClose

(

ImFileHandle

f

)

{ return fclose(f) == 0; }

Referenced by ImFileLoadToMemory(), ImGui::LogFinish(), ImGui::SaveIniSettingsToDisk(), and ImGui::Shutdown().

Here is the caller graph for this function:

ImFileGetSize()

ImU64 ImFileGetSize

(

ImFileHandle

f

)

{ long off = 0, sz = 0; return ((off = ftell(f)) != -1 && !fseek(f, 0, SEEK_END) && (sz = ftell(f)) != -1 && !fseek(f, off, SEEK_SET)) ? (ImU64)sz : (ImU64)-1; }

References SEEK_SET.

Referenced by ImFileLoadToMemory().

Here is the caller graph for this function:

ImFileLoadToMemory()

void * ImFileLoadToMemory	(	const char *	filename,
		const char *	mode,
		size_t *	out_file_size,
		int	padding_bytes
	)

{
    IM_ASSERT(filename && mode);
    if (out_file_size)
        *out_file_size = 0;
 
    ImFileHandle f;
    if ((f = ImFileOpen(filename, mode)) == NULL)
        return NULL;
 
    size_t file_size = (size_t)ImFileGetSize(f);
    if (file_size == (size_t)-1)
    {
        ImFileClose(f);
        return NULL;
    }
 
    void* file_data = IM_ALLOC(file_size + padding_bytes);
    if (file_data == NULL)
    {
        ImFileClose(f);
        return NULL;
    }
    if (ImFileRead(file_data, 1, file_size, f) != file_size)
    {
        ImFileClose(f);
        IM_FREE(file_data);
        return NULL;
    }
    if (padding_bytes > 0)
        memset((void*)(((char*)file_data) + file_size), 0, (size_t)padding_bytes);
 
    ImFileClose(f);
    if (out_file_size)
        *out_file_size = file_size;
 
    return file_data;
}

References IM_ALLOC, IM_ASSERT, IM_FREE, ImFileClose(), ImFileGetSize(), ImFileOpen(), and ImFileRead().

Referenced by ImFontAtlas::AddFontFromFileTTF(), and ImGui::LoadIniSettingsFromDisk().

Here is the call graph for this function:

Here is the caller graph for this function:

ImFileOpen()

ImFileHandle ImFileOpen	(	const char *	filename,
		const char *	mode
	)

{
#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS) && !defined(__CYGWIN__) && !defined(__GNUC__)
    // We need a fopen() wrapper because MSVC/Windows fopen doesn't handle UTF-8 filenames.
    // Previously we used ImTextCountCharsFromUtf8/ImTextStrFromUtf8 here but we now need to support ImWchar16 and ImWchar32!
    const int filename_wsize = ::MultiByteToWideChar(CP_UTF8, 0, filename, -1, NULL, 0);
    const int mode_wsize = ::MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0);
    ImVector<ImWchar> buf;
    buf.resize(filename_wsize + mode_wsize);
    ::MultiByteToWideChar(CP_UTF8, 0, filename, -1, (wchar_t*)&buf[0], filename_wsize);
    ::MultiByteToWideChar(CP_UTF8, 0, mode, -1, (wchar_t*)&buf[filename_wsize], mode_wsize);
    return ::_wfopen((const wchar_t*)&buf[0], (const wchar_t*)&buf[filename_wsize]);
#else
    return fopen(filename, mode);
#endif
}

References ImVector< T >::resize().

Referenced by ImFileLoadToMemory(), ImGui::LogToFile(), and ImGui::SaveIniSettingsToDisk().

Here is the call graph for this function:

Here is the caller graph for this function:

ImFileRead()

ImU64 ImFileRead	(	void *	data,
		ImU64	sz,
		ImU64	count,
		ImFileHandle	f
	)

{ return fread(data, (size_t)sz, (size_t)count, f); }

Referenced by ImFileLoadToMemory().

Here is the caller graph for this function:

ImFileWrite()

ImU64 ImFileWrite	(	const void *	data,
		ImU64	sz,
		ImU64	count,
		ImFileHandle	f
	)

{ return fwrite(data, (size_t)sz, (size_t)count, f); }

Referenced by LogTextV(), and ImGui::SaveIniSettingsToDisk().

Here is the caller graph for this function:

ImFormatString()

int ImFormatString	(	char *	buf,
		size_t	buf_size,
		const char *	fmt,
			...
	)

{
    va_list args;
    va_start(args, fmt);
#ifdef IMGUI_USE_STB_SPRINTF
    int w = stbsp_vsnprintf(buf, (int)buf_size, fmt, args);
#else
    int w = vsnprintf(buf, buf_size, fmt, args);
#endif
    va_end(args);
    if (buf == NULL)
        return w;
    if (w == -1 || w >= (int)buf_size)
        w = (int)buf_size - 1;
    buf[w] = 0;
    return w;
}

Referenced by ImFontAtlas::AddFontDefault(), ImFontAtlas::AddFontFromFileTTF(), ImGui::BeginChildEx(), ImGui::BeginCombo(), ImGui::BeginPopupEx(), ImGui::BeginTooltipEx(), ImGui::ColorEdit4(), ImGui::ColorEditOptionsPopup(), ImGui::DataTypeFormatString(), ImGui::DebugNodeDrawList(), ImGui::DebugNodeTabBar(), ImGui::DebugNodeTable(), ImGui::NavScoreItem(), ImGui::NavUpdate(), PatchFormatStringFloatToInt(), ImGui::ProgressBar(), ImGui::ShowMetricsWindow(), ImGui::TableHeader(), ImGui::TableMergeDrawChannels(), and ImGui::Value().

Here is the caller graph for this function:

ImFormatStringV()

int ImFormatStringV	(	char *	buf,
		size_t	buf_size,
		const char *	fmt,
		va_list	args
	)

{
#ifdef IMGUI_USE_STB_SPRINTF
    int w = stbsp_vsnprintf(buf, (int)buf_size, fmt, args);
#else
    int w = vsnprintf(buf, buf_size, fmt, args);
#endif
    if (buf == NULL)
        return w;
    if (w == -1 || w >= (int)buf_size)
        w = (int)buf_size - 1;
    buf[w] = 0;
    return w;
}

Referenced by ImGuiTextBuffer::appendfv(), ImGui::BulletTextV(), ImGui::LabelTextV(), ImGui::TextV(), ImGui::TreeNodeExV(), and ImGui::TreeNodeExV().

Here is the caller graph for this function:

ImGetDirQuadrantFromDelta()

ImGuiDir ImGetDirQuadrantFromDelta	(	float	dx,
		float	dy
	)

{
    if (ImFabs(dx) > ImFabs(dy))
        return (dx > 0.0f) ? ImGuiDir_Right : ImGuiDir_Left;
    return (dy > 0.0f) ? ImGuiDir_Down : ImGuiDir_Up;
}

References ImFabs, ImGuiDir_Down, ImGuiDir_Left, ImGuiDir_Right, and ImGuiDir_Up.

Referenced by ImGui::NavScoreItem().

Here is the caller graph for this function:

ImHashData()

ImGuiID ImHashData	(	const void *	data_p,
		size_t	data_size,
		ImU32	seed
	)

{
    ImU32 crc = ~seed;
    const unsigned char* data = (const unsigned char*)data_p;
    const ImU32* crc32_lut = GCrc32LookupTable;
    while (data_size-- != 0)
        crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *data++];
    return ~crc;
}

References GCrc32LookupTable.

Referenced by ImGuiWindow::GetID(), ImGuiWindow::GetID(), ImGuiWindow::GetIDFromRectangle(), ImGuiWindow::GetIDNoKeepAlive(), ImGuiWindow::GetIDNoKeepAlive(), ImGui::GetWindowResizeBorderID(), ImGui::GetWindowResizeCornerID(), and ImHash().

Here is the caller graph for this function:

ImHashStr()

ImGuiID ImHashStr	(	const char *	data_p,
		size_t	data_size,
		ImU32	seed
	)

{
    seed = ~seed;
    ImU32 crc = seed;
    const unsigned char* data = (const unsigned char*)data_p;
    const ImU32* crc32_lut = GCrc32LookupTable;
    if (data_size != 0)
    {
        while (data_size-- != 0)
        {
            unsigned char c = *data++;
            if (c == '#' && data_size >= 2 && data[0] == '#' && data[1] == '#')
                crc = seed;
            crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c];
        }
    }
    else
    {
        while (unsigned char c = *data++)
        {
            if (c == '#' && data[0] == '#' && data[1] == '#')
                crc = seed;
            crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c];
        }
    }
    return ~crc;
}

References GCrc32LookupTable.

Referenced by ImGuiWindow::ImGuiWindow(), ImGui::BeginCombo(), ImGui::BeginDragDropSource(), ImGui::CreateNewWindowSettings(), ImGui::FindOrCreateWindowSettings(), ImGui::FindSettingsHandler(), ImGui::FindWindowByName(), ImGuiWindow::GetID(), ImGuiWindow::GetIDNoKeepAlive(), ImGui::GetIDWithSeed(), ImGui::GetWindowResizeBorderID(), ImGui::GetWindowResizeCornerID(), ImHash(), ImGui::Initialize(), ImGui::TabBarCalcTabID(), ImGui::TableOpenContextMenu(), ImGui::TableSettingsInstallHandler(), and ImGui::TableUpdateLayout().

Here is the caller graph for this function:

ImLineClosestPoint()

ImVec2 ImLineClosestPoint	(	const ImVec2 &	a,
		const ImVec2 &	b,
		const ImVec2 &	p
	)

{
    ImVec2 ap = p - a;
    ImVec2 ab_dir = b - a;
    float dot = ap.x * ab_dir.x + ap.y * ab_dir.y;
    if (dot < 0.0f)
        return a;
    float ab_len_sqr = ab_dir.x * ab_dir.x + ab_dir.y * ab_dir.y;
    if (dot > ab_len_sqr)
        return b;
    return a + ab_dir * dot / ab_len_sqr;
}

References ImVec2::x, and ImVec2::y.

Referenced by ImBezierCubicClosestPoint(), ImBezierCubicClosestPointCasteljauStep(), and ImTriangleClosestPoint().

Here is the caller graph for this function:

ImStrbolW()

const ImWchar * ImStrbolW	(	const ImWchar *	buf_mid_line,
		const ImWchar *	buf_begin
	)

{
    while (buf_mid_line > buf_begin && buf_mid_line[-1] != '\n')
        buf_mid_line--;
    return buf_mid_line;
}

Referenced by ImGui::InputTextEx().

Here is the caller graph for this function:

ImStrchrRange()

const char * ImStrchrRange	(	const char *	str,
		const char *	str_end,
		char	c
	)

{
    const char* p = (const char*)memchr(str, (int)c, str_end - str);
    return p;
}

Referenced by ImGui::LoadIniSettingsFromMemory().

Here is the caller graph for this function:

ImStrdup()

char * ImStrdup

(

const char *

str

)

{
    size_t len = strlen(str);
    void* buf = IM_ALLOC(len + 1);
    return (char*)memcpy(buf, (const void*)str, len + 1);
}

References IM_ALLOC.

Referenced by ImGuiWindow::ImGuiWindow().

Here is the caller graph for this function:

ImStrdupcpy()

char * ImStrdupcpy	(	char *	dst,
		size_t *	p_dst_size,
		const char *	src
	)

{
    size_t dst_buf_size = p_dst_size ? *p_dst_size : strlen(dst) + 1;
    size_t src_size = strlen(src) + 1;
    if (dst_buf_size < src_size)
    {
        IM_FREE(dst);
        dst = (char*)IM_ALLOC(src_size);
        if (p_dst_size)
            *p_dst_size = src_size;
    }
    return (char*)memcpy(dst, (const void*)src, src_size);
}

References IM_ALLOC, and IM_FREE.

Referenced by ImGui::Begin().

Here is the caller graph for this function:

ImStreolRange()

const char * ImStreolRange	(	const char *	str,
		const char *	str_end
	)

{
    const char* p = (const char*)memchr(str, '\n', str_end - str);
    return p ? p : str_end;
}

Referenced by ImGui::LogRenderedText().

Here is the caller graph for this function:

ImStricmp()

int ImStricmp	(	const char *	str1,
		const char *	str2
	)

{
    int d;
    while ((d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; }
    return d;
}

ImStristr()

const char * ImStristr	(	const char *	haystack,
		const char *	haystack_end,
		const char *	needle,
		const char *	needle_end
	)

{
    if (!needle_end)
        needle_end = needle + strlen(needle);
 
    const char un0 = (char)toupper(*needle);
    while ((!haystack_end && *haystack) || (haystack_end && haystack < haystack_end))
    {
        if (toupper(*haystack) == un0)
        {
            const char* b = needle + 1;
            for (const char* a = haystack + 1; b < needle_end; a++, b++)
                if (toupper(*a) != toupper(*b))
                    break;
            if (b == needle_end)
                return haystack;
        }
        haystack++;
    }
    return NULL;
}

Referenced by ImGuiTextFilter::PassFilter().

Here is the caller graph for this function:

ImStrlenW()

int ImStrlenW

(

const ImWchar *

str

)

{
    //return (int)wcslen((const wchar_t*)str);  // FIXME-OPT: Could use this when wchar_t are 16-bit
    int n = 0;
    while (*str++) n++;
    return n;
}

ImStrncpy()

void ImStrncpy	(	char *	dst,
		const char *	src,
		size_t	count
	)

{
    if (count < 1)
        return;
    if (count > 1)
        strncpy(dst, src, count - 1);
    dst[count - 1] = 0;
}

Referenced by ImGuiTextFilter::ImGuiTextFilter(), ImParseFormatTrimDecorations(), ImGui::InputTextEx(), and ImGui::SetDragDropPayload().

Here is the caller graph for this function:

ImStrnicmp()

int ImStrnicmp	(	const char *	str1,
		const char *	str2,
		size_t	count
	)

{
    int d = 0;
    while (count > 0 && (d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; count--; }
    return d;
}

ImStrSkipBlank()

const char * ImStrSkipBlank

(

const char *

str

)

{
    while (str[0] == ' ' || str[0] == '\t')
        str++;
    return str;
}

Referenced by TableSettingsHandler_ReadLine().

Here is the caller graph for this function:

ImStrTrimBlanks()

void ImStrTrimBlanks

(

char *

buf

)

{
    char* p = buf;
    while (p[0] == ' ' || p[0] == '\t')     // Leading blanks
        p++;
    char* p_start = p;
    while (*p != 0)                         // Find end of string
        p++;
    while (p > p_start && (p[-1] == ' ' || p[-1] == '\t'))  // Trailing blanks
        p--;
    if (p_start != buf)                     // Copy memory if we had leading blanks
        memmove(buf, p_start, p - p_start);
    buf[p - p_start] = 0;                   // Zero terminate
}

Referenced by ImGui::TempInputScalar().

Here is the caller graph for this function:

ImTextCharFromUtf8()

int ImTextCharFromUtf8	(	unsigned int *	out_char,
		const char *	in_text,
		const char *	in_text_end
	)

{
    static const char lengths[32] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 3, 3, 4, 0 };
    static const int masks[]  = { 0x00, 0x7f, 0x1f, 0x0f, 0x07 };
    static const uint32_t mins[] = { 0x400000, 0, 0x80, 0x800, 0x10000 };
    static const int shiftc[] = { 0, 18, 12, 6, 0 };
    static const int shifte[] = { 0, 6, 4, 2, 0 };
    int len = lengths[*(const unsigned char*)in_text >> 3];
    int wanted = len + !len;
 
    if (in_text_end == NULL)
        in_text_end = in_text + wanted; // Max length, nulls will be taken into account.
 
    // Copy at most 'len' bytes, stop copying at 0 or past in_text_end. Branch predictor does a good job here,
    // so it is fast even with excessive branching.
    unsigned char s[4];
    s[0] = in_text + 0 < in_text_end ? in_text[0] : 0;
    s[1] = in_text + 1 < in_text_end ? in_text[1] : 0;
    s[2] = in_text + 2 < in_text_end ? in_text[2] : 0;
    s[3] = in_text + 3 < in_text_end ? in_text[3] : 0;
 
    // Assume a four-byte character and load four bytes. Unused bits are shifted out.
    *out_char  = (uint32_t)(s[0] & masks[len]) << 18;
    *out_char |= (uint32_t)(s[1] & 0x3f) << 12;
    *out_char |= (uint32_t)(s[2] & 0x3f) <<  6;
    *out_char |= (uint32_t)(s[3] & 0x3f) <<  0;
    *out_char >>= shiftc[len];
 
    // Accumulate the various error conditions.
    int e = 0;
    e  = (*out_char < mins[len]) << 6; // non-canonical encoding
    e |= ((*out_char >> 11) == 0x1b) << 7;  // surrogate half?
    e |= (*out_char > IM_UNICODE_CODEPOINT_MAX) << 8;  // out of range?
    e |= (s[1] & 0xc0) >> 2;
    e |= (s[2] & 0xc0) >> 4;
    e |= (s[3]       ) >> 6;
    e ^= 0x2a; // top two bits of each tail byte correct?
    e >>= shifte[len];
 
    if (e)
    {
        // No bytes are consumed when *in_text == 0 || in_text == in_text_end.
        // One byte is consumed in case of invalid first byte of in_text.
        // All available bytes (at most `len` bytes) are consumed on incomplete/invalid second to last bytes.
        // Invalid or incomplete input may consume less bytes than wanted, therefore every byte has to be inspected in s.
        wanted = ImMin(wanted, !!s[0] + !!s[1] + !!s[2] + !!s[3]);
        *out_char = IM_UNICODE_CODEPOINT_INVALID;
    }
 
    return wanted;
}

References IM_UNICODE_CODEPOINT_INVALID, IM_UNICODE_CODEPOINT_MAX, and ImMin().

Referenced by ImGuiIO::AddInputCharactersUTF8(), ImFontGlyphRangesBuilder::AddText(), ImFont::CalcTextSizeA(), ImFont::CalcWordWrapPositionA(), ImTextCountCharsFromUtf8(), ImTextCountUtf8BytesFromChar(), ImTextStrFromUtf8(), ImGui::InputTextEx(), Slic3r::GUI::ImGuiWrapper::is_chars_in_ranges(), and ImFont::RenderText().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTextCharToUtf8()

static int ImTextCharToUtf8 ( char *  buf, int  buf_size, unsigned int  c  )

inlinestatic

{
    if (c < 0x80)
    {
        buf[0] = (char)c;
        return 1;
    }
    if (c < 0x800)
    {
        if (buf_size < 2) return 0;
        buf[0] = (char)(0xc0 + (c >> 6));
        buf[1] = (char)(0x80 + (c & 0x3f));
        return 2;
    }
    if (c < 0x10000)
    {
        if (buf_size < 3) return 0;
        buf[0] = (char)(0xe0 + (c >> 12));
        buf[1] = (char)(0x80 + ((c >> 6) & 0x3f));
        buf[2] = (char)(0x80 + ((c ) & 0x3f));
        return 3;
    }
    if (c <= 0x10FFFF)
    {
        if (buf_size < 4) return 0;
        buf[0] = (char)(0xf0 + (c >> 18));
        buf[1] = (char)(0x80 + ((c >> 12) & 0x3f));
        buf[2] = (char)(0x80 + ((c >> 6) & 0x3f));
        buf[3] = (char)(0x80 + ((c ) & 0x3f));
        return 4;
    }
    // Invalid code point, the max unicode is 0x10FFFF
    return 0;
}

Referenced by ImTextStrToUtf8().

Here is the caller graph for this function:

ImTextCountCharsFromUtf8()

int ImTextCountCharsFromUtf8	(	const char *	in_text,
		const char *	in_text_end
	)

{
    int char_count = 0;
    while ((!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c;
        in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
        if (c == 0)
            break;
        char_count++;
    }
    return char_count;
}

References ImTextCharFromUtf8().

Referenced by ImGui::InputTextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTextCountUtf8BytesFromChar() [1/2]

int ImTextCountUtf8BytesFromChar	(	const char *	in_text,
		const char *	in_text_end
	)

{
    unsigned int unused = 0;
    return ImTextCharFromUtf8(&unused, in_text, in_text_end);
}

References ImTextCharFromUtf8().

Referenced by ImTextCountUtf8BytesFromStr(), and ImGui::RenderTextEllipsis().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTextCountUtf8BytesFromChar() [2/2]

static int ImTextCountUtf8BytesFromChar ( unsigned int  c )

inlinestatic

{
    if (c < 0x80) return 1;
    if (c < 0x800) return 2;
    if (c < 0x10000) return 3;
    if (c <= 0x10FFFF) return 4;
    return 3;
}

ImTextCountUtf8BytesFromStr()

int ImTextCountUtf8BytesFromStr	(	const ImWchar *	in_text,
		const ImWchar *	in_text_end
	)

{
    int bytes_count = 0;
    while ((!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c = (unsigned int)(*in_text++);
        if (c < 0x80)
            bytes_count++;
        else
            bytes_count += ImTextCountUtf8BytesFromChar(c);
    }
    return bytes_count;
}

References ImTextCountUtf8BytesFromChar().

Referenced by ImGui::InputTextEx(), ImStb::STB_TEXTEDIT_DELETECHARS(), and ImStb::STB_TEXTEDIT_INSERTCHARS().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTextStrFromUtf8()

int ImTextStrFromUtf8	(	ImWchar *	buf,
		int	buf_size,
		const char *	in_text,
		const char *	in_text_end,
		const char **	in_text_remaining
	)

{
    ImWchar* buf_out = buf;
    ImWchar* buf_end = buf + buf_size;
    while (buf_out < buf_end - 1 && (!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c;
        in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
        if (c == 0)
            break;
        *buf_out++ = (ImWchar)c;
    }
    *buf_out = 0;
    if (in_text_remaining)
        *in_text_remaining = in_text;
    return (int)(buf_out - buf);
}

References ImTextCharFromUtf8().

Referenced by ImGui::InputTextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTextStrToUtf8()

int ImTextStrToUtf8	(	char *	buf,
		int	buf_size,
		const ImWchar *	in_text,
		const ImWchar *	in_text_end
	)

{
    char* buf_out = buf;
    const char* buf_end = buf + buf_size;
    while (buf_out < buf_end - 1 && (!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c = (unsigned int)(*in_text++);
        if (c < 0x80)
            *buf_out++ = (char)c;
        else
            buf_out += ImTextCharToUtf8(buf_out, (int)(buf_end - buf_out - 1), c);
    }
    *buf_out = 0;
    return (int)(buf_out - buf);
}

References ImTextCharToUtf8().

Referenced by ImGui::InputTextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTriangleBarycentricCoords()

void ImTriangleBarycentricCoords	(	const ImVec2 &	a,
		const ImVec2 &	b,
		const ImVec2 &	c,
		const ImVec2 &	p,
		float &	out_u,
		float &	out_v,
		float &	out_w
	)

{
    ImVec2 v0 = b - a;
    ImVec2 v1 = c - a;
    ImVec2 v2 = p - a;
    const float denom = v0.x * v1.y - v1.x * v0.y;
    out_v = (v2.x * v1.y - v1.x * v2.y) / denom;
    out_w = (v0.x * v2.y - v2.x * v0.y) / denom;
    out_u = 1.0f - out_v - out_w;
}

References ImVec2::x, and ImVec2::y.

Referenced by ImGui::ColorPicker4().

Here is the caller graph for this function:

ImTriangleClosestPoint()

ImVec2 ImTriangleClosestPoint	(	const ImVec2 &	a,
		const ImVec2 &	b,
		const ImVec2 &	c,
		const ImVec2 &	p
	)

{
    ImVec2 proj_ab = ImLineClosestPoint(a, b, p);
    ImVec2 proj_bc = ImLineClosestPoint(b, c, p);
    ImVec2 proj_ca = ImLineClosestPoint(c, a, p);
    float dist2_ab = ImLengthSqr(p - proj_ab);
    float dist2_bc = ImLengthSqr(p - proj_bc);
    float dist2_ca = ImLengthSqr(p - proj_ca);
    float m = ImMin(dist2_ab, ImMin(dist2_bc, dist2_ca));
    if (m == dist2_ab)
        return proj_ab;
    if (m == dist2_bc)
        return proj_bc;
    return proj_ca;
}

References ImLengthSqr(), ImLineClosestPoint(), and ImMin().

Referenced by ImGui::ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

ImTriangleContainsPoint()

bool ImTriangleContainsPoint	(	const ImVec2 &	a,
		const ImVec2 &	b,
		const ImVec2 &	c,
		const ImVec2 &	p
	)

{
    bool b1 = ((p.x - b.x) * (a.y - b.y) - (p.y - b.y) * (a.x - b.x)) < 0.0f;
    bool b2 = ((p.x - c.x) * (b.y - c.y) - (p.y - c.y) * (b.x - c.x)) < 0.0f;
    bool b3 = ((p.x - a.x) * (c.y - a.y) - (p.y - a.y) * (c.x - a.x)) < 0.0f;
    return ((b1 == b2) && (b2 == b3));
}

References ImVec2::x, and ImVec2::y.

Referenced by ImGui::BeginMenu(), and ImGui::ColorPicker4().

Here is the caller graph for this function:

IsWindowActiveAndVisible()

static bool IsWindowActiveAndVisible ( ImGuiWindow *  window )

static

{
    return (window->Active) && (!window->Hidden);
}

References ImGuiWindow::Active, and ImGuiWindow::Hidden.

Referenced by AddWindowToDrawData(), and ImGui::Render().

Here is the caller graph for this function:

IsWindowContentHoverable()

static bool IsWindowContentHoverable ( ImGuiWindow *  window, ImGuiHoveredFlags  flags  )

inlinestatic

{
    // An active popup disable hovering on other windows (apart from its own children)
    // FIXME-OPT: This could be cached/stored within the window.
    ImGuiContext& g = *GImGui;
    if (g.NavWindow)
        if (ImGuiWindow* focused_root_window = g.NavWindow->RootWindow)
            if (focused_root_window->WasActive && focused_root_window != window->RootWindow)
            {
                // For the purpose of those flags we differentiate "standard popup" from "modal popup"
                // NB: The order of those two tests is important because Modal windows are also Popups.
                if (focused_root_window->Flags & ImGuiWindowFlags_Modal)
                    return false;
                if ((focused_root_window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiHoveredFlags_AllowWhenBlockedByPopup))
                    return false;
            }
    return true;
}

References GImGui, ImGuiHoveredFlags_AllowWhenBlockedByPopup, ImGuiWindowFlags_Modal, ImGuiWindowFlags_Popup, ImGuiContext::NavWindow, and ImGuiWindow::RootWindow.

Referenced by ImGui::IsItemHovered(), ImGui::IsWindowHovered(), and ImGui::ItemHoverable().

Here is the caller graph for this function:

LogTextV()

static void LogTextV ( ImGuiContext &  g, const char *  fmt, va_list  args  )

inlinestatic

{
    if (g.LogFile)
    {
        g.LogBuffer.Buf.resize(0);
        g.LogBuffer.appendfv(fmt, args);
        ImFileWrite(g.LogBuffer.c_str(), sizeof(char), (ImU64)g.LogBuffer.size(), g.LogFile);
    }
    else
    {
        g.LogBuffer.appendfv(fmt, args);
    }
}

References ImGuiTextBuffer::appendfv(), ImGuiTextBuffer::Buf, ImGuiTextBuffer::c_str(), ImFileWrite(), ImGuiContext::LogBuffer, ImGuiContext::LogFile, ImVector< T >::resize(), and ImGuiTextBuffer::size().

Referenced by ImGui::LogText(), and ImGui::LogTextV().

Here is the call graph for this function:

Here is the caller graph for this function:

LowerBound()

static ImGuiStorage::ImGuiStoragePair * LowerBound ( ImVector< ImGuiStorage::ImGuiStoragePair > &  data, ImGuiID  key  )

static

{
    ImGuiStorage::ImGuiStoragePair* first = data.Data;
    ImGuiStorage::ImGuiStoragePair* last = data.Data + data.Size;
    size_t count = (size_t)(last - first);
    while (count > 0)
    {
        size_t count2 = count >> 1;
        ImGuiStorage::ImGuiStoragePair* mid = first + count2;
        if (mid->key < key)
        {
            first = ++mid;
            count -= count2 + 1;
        }
        else
        {
            count = count2;
        }
    }
    return first;
}

References ImGuiStorage::ImGuiStoragePair::key.

Referenced by ImGuiStorage::GetFloat(), ImGuiStorage::GetFloatRef(), ImGuiStorage::GetInt(), ImGuiStorage::GetIntRef(), ImGuiStorage::GetVoidPtr(), ImGuiStorage::GetVoidPtrRef(), ImGuiStorage::SetFloat(), ImGuiStorage::SetInt(), and ImGuiStorage::SetVoidPtr().

Here is the caller graph for this function:

MallocWrapper()

static void * MallocWrapper ( size_t  size, void *  user_data  )

static

{ IM_UNUSED(user_data); return malloc(size); }

References IM_UNUSED, and malloc().

Here is the call graph for this function:

MetricsHelpMarker()

static void MetricsHelpMarker ( const char *  desc )

static

{
    ImGui::TextDisabled("(?)");
    if (ImGui::IsItemHovered())
    {
        ImGui::BeginTooltip();
        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
        ImGui::TextUnformatted(desc);
        ImGui::PopTextWrapPos();
        ImGui::EndTooltip();
    }
}

References ImGui::BeginTooltip(), ImGui::EndTooltip(), ImGui::GetFontSize(), ImGui::IsItemHovered(), ImGui::PopTextWrapPos(), ImGui::PushTextWrapPos(), ImGui::TextDisabled(), and ImGui::TextUnformatted().

Referenced by ImGui::ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

NavClampRectToVisibleAreaForMoveDir()

static void NavClampRectToVisibleAreaForMoveDir ( ImGuiDir  move_dir, ImRect &  r, const ImRect &  clip_rect  )

inlinestatic

{
    if (move_dir == ImGuiDir_Left || move_dir == ImGuiDir_Right)
    {
        r.Min.y = ImClamp(r.Min.y, clip_rect.Min.y, clip_rect.Max.y);
        r.Max.y = ImClamp(r.Max.y, clip_rect.Min.y, clip_rect.Max.y);
    }
    else
    {
        r.Min.x = ImClamp(r.Min.x, clip_rect.Min.x, clip_rect.Max.x);
        r.Max.x = ImClamp(r.Max.x, clip_rect.Min.x, clip_rect.Max.x);
    }
}

References ImClamp(), ImGuiDir_Left, ImGuiDir_Right, ImRect::Max, ImRect::Min, ImVec2::x, and ImVec2::y.

Referenced by ImGui::NavScoreItem().

Here is the call graph for this function:

Here is the caller graph for this function:

NavScoreItemDistInterval()

static float NavScoreItemDistInterval ( float  a0, float  a1, float  b0, float  b1  )

inlinestatic

{
    if (a1 < b0)
        return a1 - b0;
    if (b1 < a0)
        return a0 - b1;
    return 0.0f;
}

Referenced by ImGui::NavScoreItem().

Here is the caller graph for this function:

NavUpdateWindowingHighlightWindow()

static void NavUpdateWindowingHighlightWindow ( int  focus_change_dir )

static

{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavWindowingTarget);
    if (g.NavWindowingTarget->Flags & ImGuiWindowFlags_Modal)
        return;
 
    const int i_current = ImGui::FindWindowFocusIndex(g.NavWindowingTarget);
    ImGuiWindow* window_target = FindWindowNavFocusable(i_current + focus_change_dir, -INT_MAX, focus_change_dir);
    if (!window_target)
        window_target = FindWindowNavFocusable((focus_change_dir < 0) ? (g.WindowsFocusOrder.Size - 1) : 0, i_current, focus_change_dir);
    if (window_target) // Don't reset windowing target if there's a single window in the list
        g.NavWindowingTarget = g.NavWindowingTargetAnim = window_target;
    g.NavWindowingToggleLayer = false;
}

References ImGui::FindWindowFocusIndex(), FindWindowNavFocusable(), ImGuiWindow::Flags, GImGui, IM_ASSERT, ImGuiWindowFlags_Modal, ImGuiContext::NavWindowingTarget, ImGuiContext::NavWindowingTargetAnim, ImGuiContext::NavWindowingToggleLayer, ImVector< T >::Size, and ImGuiContext::WindowsFocusOrder.

Referenced by ImGui::NavUpdateWindowing().

Here is the call graph for this function:

Here is the caller graph for this function:

RenderViewportsThumbnails()

static void RenderViewportsThumbnails ( )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    // We don't display full monitor bounds (we could, but it often looks awkward), instead we display just enough to cover all of our viewports.
    float SCALE = 1.0f / 8.0f;
    ImRect bb_full(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
    for (int n = 0; n < g.Viewports.Size; n++)
        bb_full.Add(g.Viewports[n]->GetMainRect());
    ImVec2 p = window->DC.CursorPos;
    ImVec2 off = p - bb_full.Min * SCALE;
    for (int n = 0; n < g.Viewports.Size; n++)
    {
        ImGuiViewportP* viewport = g.Viewports[n];
        ImRect viewport_draw_bb(off + (viewport->Pos) * SCALE, off + (viewport->Pos + viewport->Size) * SCALE);
        ImGui::DebugRenderViewportThumbnail(window->DrawList, viewport, viewport_draw_bb);
    }
    ImGui::Dummy(bb_full.GetSize() * SCALE);
}

References ImRect::Add(), ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGui::DebugRenderViewportThumbnail(), ImGuiWindow::DrawList, ImGui::Dummy(), ImRect::GetSize(), GImGui, ImRect::Min, ImGuiViewport::Pos, ImVector< T >::Size, ImGuiViewport::Size, and ImGuiContext::Viewports.

Referenced by ImGui::ShowMetricsWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

SetClipboardTextFn_DefaultImpl()

static void SetClipboardTextFn_DefaultImpl ( void *  user_data, const char *  text  )

static

{
    ImGuiContext& g = *GImGui;
    g.ClipboardHandlerData.clear();
    const char* text_end = text + strlen(text);
    g.ClipboardHandlerData.resize((int)(text_end - text) + 1);
    memcpy(&g.ClipboardHandlerData[0], text, (size_t)(text_end - text));
    g.ClipboardHandlerData[(int)(text_end - text)] = 0;
}

References ImVector< T >::clear(), ImGuiContext::ClipboardHandlerData, GImGui, and ImVector< T >::resize().

Referenced by ImGuiIO::ImGuiIO().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCurrentWindow()

static void SetCurrentWindow ( ImGuiWindow *  window )

static

{
    ImGuiContext& g = *GImGui;
    g.CurrentWindow = window;
    g.CurrentTable = window && window->DC.CurrentTableIdx != -1 ? g.Tables.GetByIndex(window->DC.CurrentTableIdx) : NULL;
    if (window)
        g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
}

References ImGuiWindow::CalcFontSize(), ImGuiContext::CurrentTable, ImGuiWindowTempData::CurrentTableIdx, ImGuiContext::CurrentWindow, ImGuiWindow::DC, ImGuiContext::DrawListSharedData, ImDrawListSharedData::FontSize, ImGuiContext::FontSize, ImPool< T >::GetByIndex(), GImGui, and ImGuiContext::Tables.

Referenced by ImGui::Begin(), and ImGui::End().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCursorPosYAndSetupForPrevLine()

static void SetCursorPosYAndSetupForPrevLine ( float  pos_y, float  line_height  )

static

{
    // Set cursor position and a few other things so that SetScrollHereY() and Columns() can work when seeking cursor.
    // FIXME: It is problematic that we have to do that here, because custom/equivalent end-user code would stumble on the same issue.
    // The clipper should probably have a 4th step to display the last item in a regular manner.
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float off_y = pos_y - window->DC.CursorPos.y;
    window->DC.CursorPos.y = pos_y;
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, pos_y);
    window->DC.CursorPosPrevLine.y = window->DC.CursorPos.y - line_height;  // Setting those fields so that SetScrollHereY() can properly function after the end of our clipper usage.
    window->DC.PrevLineSize.y = (line_height - g.Style.ItemSpacing.y);      // If we end up needing more accurate data (to e.g. use SameLine) we may as well make the clipper have a fourth step to let user process and display the last item in their list.
    if (ImGuiOldColumns* columns = window->DC.CurrentColumns)
        columns->LineMinY = window->DC.CursorPos.y;                         // Setting this so that cell Y position are set properly
    if (ImGuiTable* table = g.CurrentTable)
    {
        if (table->IsInsideRow)
            ImGui::TableEndRow(table);
        table->RowPosY2 = window->DC.CursorPos.y;
        const int row_increase = (int)((off_y / line_height) + 0.5f);
        //table->CurrentRow += row_increase; // Can't do without fixing TableEndRow()
        table->RowBgColorCounter += row_increase;
    }
}

References ImGuiWindowTempData::CurrentColumns, ImGuiContext::CurrentTable, ImGuiContext::CurrentWindow, ImGuiWindowTempData::CursorMaxPos, ImGuiWindowTempData::CursorPos, ImGuiWindowTempData::CursorPosPrevLine, ImGuiWindow::DC, GImGui, ImMax(), ImGuiStyle::ItemSpacing, ImGuiWindowTempData::PrevLineSize, ImGuiContext::Style, ImGui::TableEndRow(), and ImVec2::y.

Referenced by ImGuiListClipper::End(), and ImGuiListClipper::Step().

Here is the call graph for this function:

Here is the caller graph for this function:

SetupViewportDrawData()

static void SetupViewportDrawData ( ImGuiViewportP *  viewport, ImVector< ImDrawList * > *  draw_lists  )

static

{
    ImGuiIO& io = ImGui::GetIO();
    ImDrawData* draw_data = &viewport->DrawDataP;
    draw_data->Valid = true;
    draw_data->CmdLists = (draw_lists->Size > 0) ? draw_lists->Data : NULL;
    draw_data->CmdListsCount = draw_lists->Size;
    draw_data->TotalVtxCount = draw_data->TotalIdxCount = 0;
    draw_data->DisplayPos = viewport->Pos;
    draw_data->DisplaySize = viewport->Size;
    draw_data->FramebufferScale = io.DisplayFramebufferScale;
    for (int n = 0; n < draw_lists->Size; n++)
    {
        draw_data->TotalVtxCount += draw_lists->Data[n]->VtxBuffer.Size;
        draw_data->TotalIdxCount += draw_lists->Data[n]->IdxBuffer.Size;
    }
}

References ImDrawData::CmdLists, ImDrawData::CmdListsCount, ImVector< T >::Data, ImGuiIO::DisplayFramebufferScale, ImDrawData::DisplayPos, ImDrawData::DisplaySize, ImGuiViewportP::DrawDataP, ImDrawData::FramebufferScale, ImGui::GetIO(), ImGuiViewport::Pos, ImVector< T >::Size, ImGuiViewport::Size, ImDrawData::TotalIdxCount, ImDrawData::TotalVtxCount, and ImDrawData::Valid.

Referenced by ImGui::Render().

Here is the call graph for this function:

Here is the caller graph for this function:

SetWindowConditionAllowFlags()

static void SetWindowConditionAllowFlags ( ImGuiWindow *  window, ImGuiCond  flags, bool  enabled  )

static

{
    window->SetWindowPosAllowFlags       = enabled ? (window->SetWindowPosAllowFlags       | flags) : (window->SetWindowPosAllowFlags       & ~flags);
    window->SetWindowSizeAllowFlags      = enabled ? (window->SetWindowSizeAllowFlags      | flags) : (window->SetWindowSizeAllowFlags      & ~flags);
    window->SetWindowCollapsedAllowFlags = enabled ? (window->SetWindowCollapsedAllowFlags | flags) : (window->SetWindowCollapsedAllowFlags & ~flags);
}

References ImGuiWindow::SetWindowCollapsedAllowFlags, ImGuiWindow::SetWindowPosAllowFlags, and ImGuiWindow::SetWindowSizeAllowFlags.

Referenced by ImGui::Begin(), and CreateNewWindow().

Here is the caller graph for this function:

StartLockWheelingWindow()

static void StartLockWheelingWindow ( ImGuiWindow *  window )

static

{
    ImGuiContext& g = *GImGui;
    if (g.WheelingWindow == window)
        return;
    g.WheelingWindow = window;
    g.WheelingWindowRefMousePos = g.IO.MousePos;
    g.WheelingWindowTimer = WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER;
}

References GImGui, ImGuiContext::IO, ImGuiIO::MousePos, ImGuiContext::WheelingWindow, ImGuiContext::WheelingWindowRefMousePos, ImGuiContext::WheelingWindowTimer, and WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER.

Referenced by ImGui::UpdateMouseWheel().

Here is the caller graph for this function:

WindowSettingsHandler_ApplyAll()

static void WindowSettingsHandler_ApplyAll ( ImGuiContext *  ctx, ImGuiSettingsHandler *    )

static

{
    ImGuiContext& g = *ctx;
    for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
        if (settings->WantApply)
        {
            if (ImGuiWindow* window = ImGui::FindWindowByID(settings->ID))
                ApplyWindowSettings(window, settings);
            settings->WantApply = false;
        }
}

References ApplyWindowSettings(), ImChunkStream< T >::begin(), ImGui::FindWindowByID(), ImChunkStream< T >::next_chunk(), and ImGuiContext::SettingsWindows.

Referenced by ImGui::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

WindowSettingsHandler_ClearAll()

static void WindowSettingsHandler_ClearAll ( ImGuiContext *  ctx, ImGuiSettingsHandler *    )

static

{
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Windows.Size; i++)
        g.Windows[i]->SettingsOffset = -1;
    g.SettingsWindows.clear();
}

References ImChunkStream< T >::clear(), ImGuiContext::SettingsWindows, ImVector< T >::Size, and ImGuiContext::Windows.

Referenced by ImGui::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

WindowSettingsHandler_ReadLine()

static void WindowSettingsHandler_ReadLine ( ImGuiContext *  , ImGuiSettingsHandler *  , void *  entry, const char *  line  )

static

{
    ImGuiWindowSettings* settings = (ImGuiWindowSettings*)entry;
    int x, y;
    int i;
    if (sscanf(line, "Pos=%i,%i", &x, &y) == 2)         { settings->Pos = ImVec2ih((short)x, (short)y); }
    else if (sscanf(line, "Size=%i,%i", &x, &y) == 2)   { settings->Size = ImVec2ih((short)x, (short)y); }
    else if (sscanf(line, "Collapsed=%d", &i) == 1)     { settings->Collapsed = (i != 0); }
}

References ImGuiWindowSettings::Collapsed, ImGuiWindowSettings::Pos, and ImGuiWindowSettings::Size.

Referenced by ImGui::Initialize().

Here is the caller graph for this function:

WindowSettingsHandler_ReadOpen()

static void * WindowSettingsHandler_ReadOpen ( ImGuiContext *  , ImGuiSettingsHandler *  , const char *  name  )

static

{
    ImGuiWindowSettings* settings = ImGui::FindOrCreateWindowSettings(name);
    ImGuiID id = settings->ID;
    *settings = ImGuiWindowSettings(); // Clear existing if recycling previous entry
    settings->ID = id;
    settings->WantApply = true;
    return (void*)settings;
}

References ImGui::FindOrCreateWindowSettings(), ImGuiWindowSettings::ID, and ImGuiWindowSettings::WantApply.

Referenced by ImGui::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

WindowSettingsHandler_WriteAll()

static void WindowSettingsHandler_WriteAll ( ImGuiContext *  ctx, ImGuiSettingsHandler *  handler, ImGuiTextBuffer *  buf  )

static

{
    // Gather data from windows that were active during this session
    // (if a window wasn't opened in this session we preserve its settings)
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Windows.Size; i++)
    {
        ImGuiWindow* window = g.Windows[i];
        if (window->Flags & ImGuiWindowFlags_NoSavedSettings)
            continue;
 
        ImGuiWindowSettings* settings = (window->SettingsOffset != -1) ? g.SettingsWindows.ptr_from_offset(window->SettingsOffset) : ImGui::FindWindowSettings(window->ID);
        if (!settings)
        {
            settings = ImGui::CreateNewWindowSettings(window->Name);
            window->SettingsOffset = g.SettingsWindows.offset_from_ptr(settings);
        }
        IM_ASSERT(settings->ID == window->ID);
        settings->Pos = ImVec2ih((short)window->Pos.x, (short)window->Pos.y);
        settings->Size = ImVec2ih((short)window->SizeFull.x, (short)window->SizeFull.y);
        settings->Collapsed = window->Collapsed;
    }
 
    // Write to text buffer
    buf->reserve(buf->size() + g.SettingsWindows.size() * 6); // ballpark reserve
    for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
    {
        const char* settings_name = settings->GetName();
        buf->appendf("[%s][%s]\n", handler->TypeName, settings_name);
        buf->appendf("Pos=%d,%d\n", settings->Pos.x, settings->Pos.y);
        buf->appendf("Size=%d,%d\n", settings->Size.x, settings->Size.y);
        buf->appendf("Collapsed=%d\n", settings->Collapsed);
        buf->append("\n");
    }
}

References ImGuiTextBuffer::append(), ImGuiTextBuffer::appendf(), ImChunkStream< T >::begin(), ImGuiWindowSettings::Collapsed, ImGuiWindow::Collapsed, ImGui::CreateNewWindowSettings(), ImGui::FindWindowSettings(), ImGuiWindow::Flags, ImGuiWindowSettings::ID, ImGuiWindow::ID, IM_ASSERT, ImGuiWindowFlags_NoSavedSettings, ImGuiWindow::Name, ImChunkStream< T >::next_chunk(), ImChunkStream< T >::offset_from_ptr(), ImGuiWindowSettings::Pos, ImGuiWindow::Pos, ImChunkStream< T >::ptr_from_offset(), ImGuiTextBuffer::reserve(), ImGuiWindow::SettingsOffset, ImGuiContext::SettingsWindows, ImVector< T >::Size, ImGuiTextBuffer::size(), ImChunkStream< T >::size(), ImGuiWindowSettings::Size, ImGuiWindow::SizeFull, ImGuiSettingsHandler::TypeName, ImGuiContext::Windows, ImVec2::x, and ImVec2::y.

Referenced by ImGui::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

GCrc32LookupTable

const ImU32 GCrc32LookupTable[256]

static

Initial value:

=
{
    0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,
    0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,0x6DDDE4EB,0xF4D4B551,0x83D385C7,0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5,
    0x3B6E20C8,0x4C69105E,0xD56041E4,0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,0x35B5A8FA,0x42B2986C,0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,
    0x26D930AC,0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F,0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,0xB6662D3D,
    0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,0x9FBFE4A5,0xE8B8D433,0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,0x086D3D2D,0x91646C97,0xE6635C01,
    0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,0x65B0D9C6,0x12B7E950,0x8BBEB8EA,0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65,
    0x4DB26158,0x3AB551CE,0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,0xA4D1C46D,0xD3D6F4FB,0x4369E96A,0x346ED9FC,0xAD678846,0xDA60B8D0,0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9,
    0x5005713C,0x270241AA,0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,0xCE61E49F,0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,0xB7BD5C3B,0xC0BA6CAD,
    0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,0xEAD54739,0x9DD277AF,0x04DB2615,0x73DC1683,0xE3630B12,0x94643B84,0x0D6D6A3E,0x7A6A5AA8,0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1,
    0xF00F9344,0x8708A3D2,0x1E01F268,0x6906C2FE,0xF762575D,0x806567CB,0x196C3671,0x6E6B06E7,0xFED41B76,0x89D32BE0,0x10DA7A5A,0x67DD4ACC,0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5,
    0xD6D6A3E8,0xA1D1937E,0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B,0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,0x316E8EEF,0x4669BE79,
    0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,0xCC0C7795,0xBB0B4703,0x220216B9,0x5505262F,0xC5BA3BBE,0xB2BD0B28,0x2BB45A92,0x5CB36A04,0xC2D7FFA7,0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D,
    0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,0x9C0906A9,0xEB0E363F,0x72076785,0x05005713,0x95BF4A82,0xE2B87A14,0x7BB12BAE,0x0CB61B38,0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21,
    0x86D3D2D4,0xF1D4E242,0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777,0x88085AE6,0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,0x616BFFD3,0x166CCF45,
    0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,0xA7672661,0xD06016F7,0x4969474D,0x3E6E77DB,0xAED16A4A,0xD9D65ADC,0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,0x47B2CF7F,0x30B5FFE9,
    0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,0xCDD70693,0x54DE5729,0x23D967BF,0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D,
}

Referenced by ImHashData(), and ImHashStr().

GImAllocatorAllocFunc

ImGuiMemAllocFunc GImAllocatorAllocFunc = MallocWrapper

static

Referenced by ImGui::GetAllocatorFunctions(), ImGui::MemAlloc(), and ImGui::SetAllocatorFunctions().

GImAllocatorFreeFunc

ImGuiMemFreeFunc GImAllocatorFreeFunc = FreeWrapper

static

Referenced by ImGui::GetAllocatorFunctions(), ImGui::MemFree(), and ImGui::SetAllocatorFunctions().

GImAllocatorUserData

void* GImAllocatorUserData = NULL

static

Referenced by ImGui::GetAllocatorFunctions(), ImGui::MemAlloc(), ImGui::MemFree(), and ImGui::SetAllocatorFunctions().

GImGui

ImGuiContext* GImGui = NULL

Referenced by ImGui::AcceptDragDropPayload(), ImGui::ActivateItem(), AddWindowToDrawData(), ImGui::AlignTextToFramePadding(), ImGui::ArrowButtonEx(), ImGuiLastItemDataBackup::Backup(), ImGui::Begin(), ImGuiListClipper::Begin(), ImGui::BeginChildEx(), ImGui::BeginChildFrame(), ImGui::BeginColumns(), ImGui::BeginCombo(), ImGui::BeginDragDropSource(), ImGui::BeginDragDropTarget(), ImGui::BeginDragDropTargetCustom(), ImGui::BeginGroup(), ImGui::BeginListBox(), ImGui::BeginMainMenuBar(), ImGui::BeginMenu(), ImGui::BeginPopup(), ImGui::BeginPopupContextItem(), ImGui::BeginPopupContextVoid(), ImGui::BeginPopupContextWindow(), ImGui::BeginPopupEx(), ImGui::BeginPopupModal(), ImGui::BeginTabBar(), ImGui::BeginTabBarEx(), ImGui::BeginTabItem(), ImGui::BeginTableEx(), ImGui::BeginTooltipEx(), ImGui::BringWindowToDisplayBack(), ImGui::BringWindowToDisplayFront(), ImGui::BringWindowToFocusFront(), ImGui::Bullet(), ImGui::BulletTextV(), ImGui::ButtonBehavior(), ImGui::ButtonEx(), Slic3r::GUI::ImGuiWrapper::calc_button_size(), ImGuiWindow::CalcFontSize(), ImGui::CalcItemSize(), ImGui::CalcItemWidth(), ImGui::CalcListClipping(), CalcMaxPopupHeightFromItemCount(), ImGui::CalcTextSize(), CalcWindowAutoFitSize(), CalcWindowSizeAfterConstraint(), ImGui::CalcWrapWidthForPos(), ImGui::CaptureKeyboardFromApp(), ImGui::CaptureMouseFromApp(), ImGui::Checkbox(), ClampWindowRect(), ImGui::ClearDragDrop(), ImGui::ClearIniSettings(), ImGui::CloseButton(), ImGui::CloseCurrentPopup(), ImGui::ClosePopupsOverWindow(), ImGui::ClosePopupToLevel(), ImGui::CollapseButton(), ImGui::CollapsingHeader(), ImGui::ColorButton(), ImGui::ColorEdit4(), ImGui::ColorEditOptionsPopup(), ImGui::ColorPicker4(), ImGui::ColorPickerOptionsPopup(), ImGui::ColorTooltip(), ImGuiStackSizes::CompareWithCurrentState(), ImGui::CreateContext(), CreateNewWindow(), ImGui::CreateNewWindowSettings(), ImGui::DebugDrawItemRect(), ImGui::DebugNodeDrawList(), ImGui::DebugNodeWindow(), ImGui::DebugRenderViewportThumbnail(), ImGui::DebugStartItemPicker(), ImGui::DestroyContext(), Slic3r::GUI::ImGuiWrapper::disable_background_fadeout_animation(), ImGui::DragBehavior(), ImGui::DragFloatRange2(), ImGui::DragIntRange2(), ImGui::DragScalar(), ImGui::DragScalarN(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), ImGui::End(), ImGui::EndChild(), ImGui::EndColumns(), ImGui::EndDragDropSource(), ImGui::EndDragDropTarget(), ImGui::EndFrame(), ImGui::EndGroup(), ImGui::EndListBox(), ImGui::EndMainMenuBar(), ImGui::EndMenu(), ImGui::EndMenuBar(), ImGui::EndPopup(), ImGui::EndTabBar(), ImGui::EndTabItem(), ImGui::EndTable(), ImGui::ErrorCheckEndFrameRecover(), ImGui::ErrorCheckEndFrameSanityChecks(), ImGui::ErrorCheckNewFrameSanityChecks(), ImGui::FindBestWindowPosForPopup(), FindHoveredWindow(), ImGui::FindSettingsHandler(), ImGui::FindWindowByID(), ImGui::FindWindowFocusIndex(), FindWindowNavFocusable(), ImGui::FindWindowSettings(), ImGui::FocusTopMostWindowUnderOne(), ImGui::FocusWindow(), ImGui::GcCompactTransientMiscBuffers(), Slic3r::GUI::ImGuiWrapper::get_item_spacing(), Slic3r::GUI::ImGuiWrapper::get_slider_float_height(), ImGui::GetActiveID(), ImGui::GetBackgroundDrawList(), ImGui::GetClipboardText(), GetClipboardTextFn_DefaultImpl(), ImGui::GetColorU32(), ImGui::GetColorU32(), ImGui::GetColorU32(), ImGui::GetColumnWidth(), ImGui::GetContentRegionAvail(), ImGui::GetContentRegionMax(), ImGui::GetContentRegionMaxAbs(), ImGui::GetCurrentContext(), ImGui::GetCurrentTable(), ImGui::GetCurrentWindow(), ImGui::GetCurrentWindowRead(), ImGui::GetDefaultFont(), ImGui::GetDragDropPayload(), GetDraggedColumnOffset(), ImGui::GetDrawData(), ImGui::GetDrawListSharedData(), ImGui::GetFocusedFocusScope(), ImGui::GetFocusID(), ImGui::GetFocusScope(), ImGui::GetFont(), ImGui::GetFontSize(), ImGui::GetFontTexUvWhitePixel(), ImGui::GetForegroundDrawList(), ImGui::GetFrameCount(), ImGui::GetFrameHeight(), ImGui::GetFrameHeightWithSpacing(), ImGui::GetHoveredID(), ImGuiWindow::GetID(), ImGui::GetID(), ImGui::GetID(), ImGuiWindow::GetID(), ImGui::GetID(), ImGuiWindow::GetID(), ImGuiWindow::GetIDNoKeepAlive(), ImGuiWindow::GetIDNoKeepAlive(), ImGuiWindow::GetIDNoKeepAlive(), ImGui::GetIDWithSeed(), ImGui::GetInputTextState(), ImGui::GetIO(), ImGui::GetItemFlags(), ImGui::GetItemID(), ImGui::GetItemStatusFlags(), ImGui::GetKeyIndex(), ImGui::GetKeyPressedAmount(), ImGui::GetMainViewport(), ImGui::GetMergedKeyModFlags(), ImGui::GetMouseCursor(), ImGui::GetMouseDragDelta(), ImGui::GetMousePos(), ImGui::GetMousePosOnOpeningCurrentPopup(), ImGui::GetNavInputAmount(), ImGui::GetScrollMaxX(), ImGui::GetScrollMaxY(), ImGui::GetScrollX(), ImGui::GetScrollY(), GetSkipItemForListClipping(), ImGui::GetStateStorage(), ImGui::GetStyle(), ImGui::GetStyleColorVec4(), GetTabBarFromTabBarRef(), GetTabBarRefFromTabBar(), ImGui::GetTextLineHeight(), ImGui::GetTextLineHeightWithSpacing(), ImGui::GetTime(), ImGui::GetTopMostPopupModal(), ImGui::GetTreeNodeToLabelSpacing(), GetViewportDrawList(), ImGui::GetWindowAllowedExtentRect(), ImGui::GetWindowContentRegionMax(), ImGui::GetWindowContentRegionMin(), ImGui::GetWindowContentRegionWidth(), ImGui::GetWindowHeight(), ImGui::GetWindowPos(), ImGui::GetWindowWidth(), Slic3r::GUI::ImGuiWrapper::image_button(), Slic3r::GUI::image_button_ex(), ImGui::ImageButton(), ImGui::ImageButtonEx(), ImGui::Indent(), ImGui::InputScalar(), ImGui::InputScalarN(), InputTextCalcTextSizeW(), ImGui::InputTextEx(), InputTextFilterCharacter(), ImGuiInputTextCallbackData::InsertChars(), ImGui::IsActiveIdUsingKey(), ImGui::IsActiveIdUsingNavDir(), ImGui::IsActiveIdUsingNavInput(), ImGui::IsAnyItemActive(), ImGui::IsAnyItemFocused(), ImGui::IsAnyItemHovered(), ImGui::IsAnyMouseDown(), ImGui::IsClippedEx(), ImGui::IsDragDropPayloadBeingAccepted(), ImGui::IsItemActivated(), ImGui::IsItemActive(), ImGui::IsItemDeactivated(), ImGui::IsItemDeactivatedAfterEdit(), ImGui::IsItemFocused(), ImGui::IsItemHovered(), ImGui::IsItemToggledOpen(), ImGui::IsItemToggledSelection(), ImGui::IsKeyDown(), ImGui::IsKeyPressed(), ImGui::IsKeyPressedMap(), ImGui::IsKeyReleased(), ImGui::IsMouseClicked(), ImGui::IsMouseDoubleClicked(), ImGui::IsMouseDown(), ImGui::IsMouseDragging(), ImGui::IsMouseDragPastThreshold(), ImGui::IsMouseHoveringRect(), ImGui::IsMousePosValid(), ImGui::IsMouseReleased(), ImGui::IsNavInputDown(), ImGui::IsPopupOpen(), ImGui::IsPopupOpen(), ImGui::IsRectVisible(), ImGui::IsRectVisible(), ImGui::IsWindowAbove(), IsWindowContentHoverable(), ImGui::IsWindowFocused(), ImGui::IsWindowHovered(), ImGui::ItemAdd(), ImGui::ItemFocusable(), ImGui::ItemHoverable(), ImGui::ItemSize(), ImGui::KeepAliveID(), ImGui::LabelTextV(), ImGui::ListBoxHeader(), ImGui::LoadIniSettingsFromMemory(), ImGui::LogBegin(), ImGui::LogButtons(), ImGui::LogFinish(), ImGui::LogRenderedText(), ImGui::LogSetNextTextDecoration(), ImGui::LogText(), ImGui::LogTextV(), ImGui::LogToBuffer(), ImGui::LogToClipboard(), ImGui::LogToFile(), ImGui::LogToTTY(), ImGui::MarkIniSettingsDirty(), ImGui::MarkIniSettingsDirty(), ImGui::MarkItemEdited(), ImGui::MemAlloc(), ImGui::MemFree(), ImGuiWindow::MenuBarHeight(), ImGui::MenuItem(), ImGui::NavCalcPreferredRefPos(), ImGui::NavEndFrame(), ImGui::NavInitWindow(), ImGui::NavMoveRequestButNoResultYet(), ImGui::NavMoveRequestCancel(), ImGui::NavMoveRequestForward(), ImGui::NavMoveRequestTryWrapping(), ImGui::NavProcessItem(), ImGui::NavRestoreLayer(), ImGui::NavScoreItem(), ImGui::NavUpdate(), ImGui::NavUpdateAnyRequestFlag(), ImGui::NavUpdateInitResult(), ImGui::NavUpdateMoveResult(), ImGui::NavUpdatePageUpPageDown(), ImGui::NavUpdateWindowing(), NavUpdateWindowingHighlightWindow(), ImGui::NavUpdateWindowingOverlay(), ImGui::NewFrame(), ImGui::NewLine(), ImGui::NextColumn(), ImGui::OpenPopup(), ImGui::OpenPopupEx(), ImGui::OpenPopupOnItemClick(), PatchFormatStringFloatToInt(), ImGui::PlotEx(), ImGui::PopFocusScope(), ImGui::PopFont(), ImGui::PopID(), ImGui::PopItemFlag(), ImGui::PopStyleColor(), ImGui::PopStyleVar(), Slic3r::GUI::process_key_down(), ImGui::ProgressBar(), ImGui::PushFocusScope(), ImGui::PushFont(), ImGui::PushID(), ImGui::PushID(), ImGui::PushID(), ImGui::PushID(), ImGui::PushItemFlag(), ImGui::PushItemWidth(), ImGui::PushMultiItemsWidths(), ImGui::PushOverrideID(), ImGui::PushStyleColor(), ImGui::PushStyleColor(), ImGui::PushStyleVar(), ImGui::PushStyleVar(), ImGui::RadioButton(), ImGui::Render(), ImGui::RenderFrame(), ImGui::RenderFrameBorder(), ImGui::RenderNavHighlight(), ImGui::RenderText(), ImGui::RenderTextClipped(), ImGui::RenderTextEllipsis(), ImGui::RenderTextWrapped(), RenderViewportsThumbnails(), ImGui::RenderWindowDecorations(), ImGui::RenderWindowOuterBorders(), ImGui::RenderWindowTitleBarContents(), ImGui::ResetMouseDragDelta(), ImGuiLastItemDataBackup::Restore(), ImGui::SameLine(), ImGui::SaveIniSettingsToDisk(), ImGui::SaveIniSettingsToMemory(), Slic3r::GUI::scroll_down(), Slic3r::GUI::scroll_up(), Slic3r::GUI::scroll_y(), ImGui::Scrollbar(), ImGui::ScrollbarEx(), ImGui::ScrollToBringRectIntoView(), Slic3r::GUI::ImGuiWrapper::search_list(), Slic3r::GUI::selectable(), ImGui::Selectable(), ImGui::Separator(), ImGui::SeparatorEx(), ImGui::SetActiveID(), ImGui::SetClipboardText(), SetClipboardTextFn_DefaultImpl(), ImGui::SetColorEditOptions(), ImGui::SetColumnOffset(), ImGui::SetCurrentContext(), ImGui::SetCurrentFont(), SetCurrentWindow(), SetCursorPosYAndSetupForPrevLine(), ImGui::SetDragDropPayload(), ImGui::SetFocusID(), ImGui::SetHoveredID(), ImGui::SetItemAllowOverlap(), ImGui::SetItemDefaultFocus(), ImGui::SetItemUsingMouseWheel(), ImGui::SetKeyboardFocusHere(), ImGui::SetMouseCursor(), ImGui::SetNavID(), ImGui::SetNextItemOpen(), ImGui::SetNextItemWidth(), ImGui::SetNextWindowBgAlpha(), ImGui::SetNextWindowCollapsed(), ImGui::SetNextWindowContentSize(), ImGui::SetNextWindowFocus(), ImGui::SetNextWindowPos(), ImGui::SetNextWindowScroll(), ImGui::SetNextWindowSize(), ImGui::SetNextWindowSizeConstraints(), ImGui::SetScrollFromPosX(), ImGui::SetScrollFromPosY(), ImGui::SetScrollHereX(), ImGui::SetScrollHereY(), ImGui::SetScrollX(), ImGui::SetScrollY(), ImGui::SetStateStorage(), ImGui::SetTabItemClosed(), ImGuiStackSizes::SetToCurrentState(), ImGui::SetWindowCollapsed(), ImGui::SetWindowFocus(), ImGui::SetWindowFontScale(), ImGui::SetWindowSize(), ImGui::ShowMetricsWindow(), ImGui::Shutdown(), ImGui::SliderBehavior(), ImGui::SliderScalar(), ImGui::SliderScalarN(), ImGui::SmallButton(), ImGui::SplitterBehavior(), StartLockWheelingWindow(), ImGui::StartMouseMovingWindow(), ImStb::STB_TEXTEDIT_GETWIDTH(), ImGuiListClipper::Step(), ImGui::TabBarCalcMaxTabWidth(), ImGui::TabBarCalcTabID(), ImGui::TabBarLayout(), ImGui::TabBarQueueReorderFromMousePos(), ImGui::TabBarScrollingButtons(), ImGui::TabBarScrollToTab(), ImGui::TabBarTabListPopupButton(), ImGui::TabItemBackground(), ImGui::TabItemButton(), ImGui::TabItemCalcSize(), ImGui::TabItemEx(), ImGui::TabItemLabelAndCloseButton(), ImGui::TableBeginCell(), ImGui::TableDrawContextMenu(), ImGui::TableEndRow(), ImGui::TableFindByID(), ImGui::TableGcCompactSettings(), ImGui::TableGcCompactTransientBuffers(), ImGui::TableGetBoundSettings(), ImGui::TableGetColumnCount(), ImGui::TableGetColumnFlags(), ImGui::TableGetColumnIndex(), ImGui::TableGetColumnName(), ImGui::TableGetHoveredColumn(), ImGui::TableGetRowIndex(), ImGui::TableGetSortSpecs(), ImGui::TableHeader(), ImGui::TableHeadersRow(), ImGui::TableLoadSettings(), ImGui::TableMergeDrawChannels(), ImGui::TableNextColumn(), ImGui::TableNextRow(), ImGui::TableOpenContextMenu(), ImGui::TablePopBackgroundChannel(), ImGui::TablePushBackgroundChannel(), ImGui::TableRemove(), ImGui::TableSaveSettings(), ImGui::TableSetBgColor(), ImGui::TableSetColumnEnabled(), ImGui::TableSetColumnIndex(), ImGui::TableSetColumnSortDirection(), ImGui::TableSetColumnWidth(), ImGui::TableSettingsCreate(), ImGui::TableSettingsFindByID(), ImGui::TableSetupColumn(), ImGui::TableSetupScrollFreeze(), ImGui::TableUpdateBorders(), ImGui::TableUpdateLayout(), ImGui::TempInputIsActive(), ImGui::TempInputScalar(), ImGui::TempInputText(), ImGui::TextDisabledV(), ImGui::TextEx(), ImGui::TextV(), ImGui::TextWrappedV(), ImGuiWindow::TitleBarHeight(), ImGui::TreeNodeBehavior(), ImGui::TreeNodeBehaviorIsOpen(), ImGui::TreeNodeExV(), ImGui::TreeNodeExV(), ImGui::TreePop(), ImGui::TreePushOverrideID(), ImGui::Unindent(), ImGui::UpdateDebugToolItemPicker(), ImGui::UpdateHoveredWindowAndCaptureFlags(), ImGui::UpdateMouseInputs(), ImGui::UpdateMouseMovingWindowEndFrame(), ImGui::UpdateMouseMovingWindowNewFrame(), ImGui::UpdateMouseWheel(), ImGui::UpdateSettings(), ImGui::UpdateTabFocus(), ImGui::UpdateViewportsNewFrame(), ImGui::UpdateWindowManualResize(), and ImGui::VSliderScalar().

GStyleVarInfo

const ImGuiStyleVarInfo GStyleVarInfo[]

static

Initial value:

=
{
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, Alpha) },               
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, WindowPadding) },       
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, WindowRounding) },      
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, WindowBorderSize) },    
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, WindowMinSize) },       
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, WindowTitleAlign) },    
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, ChildRounding) },       
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, ChildBorderSize) },     
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, PopupRounding) },       
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, PopupBorderSize) },     
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, FramePadding) },        
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, FrameRounding) },       
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, FrameBorderSize) },     
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, ItemSpacing) },         
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, ItemInnerSpacing) },    
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, IndentSpacing) },       
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, CellPadding) },         
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, ScrollbarSize) },       
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, ScrollbarRounding) },   
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, GrabMinSize) },         
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, GrabRounding) },        
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImGuiStyle, TabRounding) },         
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, ButtonTextAlign) },     
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImGuiStyle, SelectableTextAlign) }, 
}

Referenced by GetStyleVarInfo().

NAV_WINDOWING_HIGHLIGHT_DELAY

const float NAV_WINDOWING_HIGHLIGHT_DELAY = 0.20f

static

Referenced by ImGui::NavUpdateWindowing().

NAV_WINDOWING_LIST_APPEAR_DELAY

const float NAV_WINDOWING_LIST_APPEAR_DELAY = 0.15f

static

Referenced by ImGui::NavUpdateWindowingOverlay().

resize_border_def

const ImGuiResizeBorderDef resize_border_def[4]

static

Initial value:

=
{
    { ImVec2(+1, 0), ImVec2(0, 1), ImVec2(0, 0), IM_PI * 1.00f }, 
    { ImVec2(-1, 0), ImVec2(1, 0), ImVec2(1, 1), IM_PI * 0.00f }, 
    { ImVec2(0, +1), ImVec2(0, 0), ImVec2(1, 0), IM_PI * 1.50f }, 
    { ImVec2(0, -1), ImVec2(1, 1), ImVec2(0, 1), IM_PI * 0.50f }  
}

Referenced by ImGui::RenderWindowOuterBorders(), and ImGui::UpdateWindowManualResize().

resize_grip_def

const ImGuiResizeGripDef resize_grip_def[4]

static

Initial value:

=
{
    { ImVec2(1, 1), ImVec2(-1, -1), 0, 3 },  
    { ImVec2(0, 1), ImVec2(+1, -1), 3, 6 },  
    { ImVec2(0, 0), ImVec2(+1, +1), 6, 9 },  
    { ImVec2(1, 0), ImVec2(-1, +1), 9, 12 }  
}

Referenced by ImGui::RenderWindowDecorations(), and ImGui::UpdateWindowManualResize().

WINDOWS_HOVER_PADDING

const float WINDOWS_HOVER_PADDING = 4.0f

static

Referenced by ImGui::UpdateHoveredWindowAndCaptureFlags(), and ImGui::UpdateWindowManualResize().

WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER

const float WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER = 2.00f

static

Referenced by StartLockWheelingWindow().

WINDOWS_RESIZE_FROM_EDGES_FEEDBACK_TIMER

const float WINDOWS_RESIZE_FROM_EDGES_FEEDBACK_TIMER = 0.04f

static

Referenced by ImGui::UpdateWindowManualResize().