imgui_widgets.cpp File Reference

#include "imgui.h"
#include "imgui_internal.h"
#include <locale.h>
#include <ctype.h>
#include <stdint.h>
#include "imstb_textedit.h"

Include dependency graph for imgui_widgets.cpp:

Go to the source code of this file.

Classes
struct	ImGuiPlotArrayGetterData
struct	ImGuiTabBarSection

Namespaces
namespace	ImStb
namespace	ImGui

Macros
#define	IMGUI_DEFINE_MATH_OPERATORS
#define	STB_TEXTEDIT_MOVEWORDLEFT   STB_TEXTEDIT_MOVEWORDLEFT_IMPL
#define	STB_TEXTEDIT_MOVEWORDRIGHT   STB_TEXTEDIT_MOVEWORDRIGHT_IMPL
#define	STB_TEXTEDIT_K_LEFT   0x200000
#define	STB_TEXTEDIT_K_RIGHT   0x200001
#define	STB_TEXTEDIT_K_UP   0x200002
#define	STB_TEXTEDIT_K_DOWN   0x200003
#define	STB_TEXTEDIT_K_LINESTART   0x200004
#define	STB_TEXTEDIT_K_LINEEND   0x200005
#define	STB_TEXTEDIT_K_TEXTSTART   0x200006
#define	STB_TEXTEDIT_K_TEXTEND   0x200007
#define	STB_TEXTEDIT_K_DELETE   0x200008
#define	STB_TEXTEDIT_K_BACKSPACE   0x200009
#define	STB_TEXTEDIT_K_UNDO   0x20000A
#define	STB_TEXTEDIT_K_REDO   0x20000B
#define	STB_TEXTEDIT_K_WORDLEFT   0x20000C
#define	STB_TEXTEDIT_K_WORDRIGHT   0x20000D
#define	STB_TEXTEDIT_K_PGUP   0x20000E
#define	STB_TEXTEDIT_K_PGDOWN   0x20000F
#define	STB_TEXTEDIT_K_SHIFT   0x400000
#define	STB_TEXTEDIT_IMPLEMENTATION

Functions
static bool	InputTextFilterCharacter (unsigned int *p_char, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void *user_data, ImGuiInputSource input_source)
static int	InputTextCalcTextLenAndLineCount (const char *text_begin, const char **out_text_end)
static ImVec2	InputTextCalcTextSizeW (const ImWchar *text_begin, const ImWchar *text_end, const ImWchar **remaining=NULL, ImVec2 *out_offset=NULL, bool stop_on_new_line=false)
static int IMGUI_CDECL	ShrinkWidthItemComparer (const void *lhs, const void *rhs)
static float	CalcMaxPopupHeightFromItemCount (int items_count)
static bool	Items_ArrayGetter (void *data, int idx, const char **out_text)
static bool	Items_SingleStringGetter (void *data, int idx, const char **out_text)
	IM_STATIC_ASSERT (IM_ARRAYSIZE(GDataTypeInfo)==ImGuiDataType_COUNT)
static const char *	PatchFormatStringFloatToInt (const char *fmt)
template<typename T >
static int	DataTypeCompareT (const T *lhs, const T *rhs)
template<typename T >
static bool	DataTypeClampT (T *v, const T *v_min, const T *v_max)
static float	GetMinimumStepAtDecimalPrecision (int decimal_precision)
template<typename TYPE >
static const char *	ImAtoi (const char *src, TYPE *output)
static void	SanitizeFormatString (const char *fmt, char *fmt_out, size_t fmt_out_size)
const char *	ImParseFormatFindStart (const char *fmt)
const char *	ImParseFormatFindEnd (const char *fmt)
const char *	ImParseFormatTrimDecorations (const char *fmt, char *buf, size_t buf_size)
int	ImParseFormatPrecision (const char *fmt, int default_precision)
static int	ImStb::STB_TEXTEDIT_STRINGLEN (const ImGuiInputTextState *obj)
static ImWchar	ImStb::STB_TEXTEDIT_GETCHAR (const ImGuiInputTextState *obj, int idx)
static float	ImStb::STB_TEXTEDIT_GETWIDTH (ImGuiInputTextState *obj, int line_start_idx, int char_idx)
static int	ImStb::STB_TEXTEDIT_KEYTOTEXT (int key)
static void	ImStb::STB_TEXTEDIT_LAYOUTROW (StbTexteditRow *r, ImGuiInputTextState *obj, int line_start_idx)
static bool	ImStb::is_separator (unsigned int c)
static int	ImStb::is_word_boundary_from_right (ImGuiInputTextState *obj, int idx)
static int	ImStb::STB_TEXTEDIT_MOVEWORDLEFT_IMPL (ImGuiInputTextState *obj, int idx)
static int	ImStb::STB_TEXTEDIT_MOVEWORDRIGHT_IMPL (ImGuiInputTextState *obj, int idx)
static void	ImStb::STB_TEXTEDIT_DELETECHARS (ImGuiInputTextState *obj, int pos, int n)
static bool	ImStb::STB_TEXTEDIT_INSERTCHARS (ImGuiInputTextState *obj, int pos, const ImWchar *new_text, int new_text_len)
static void	ImStb::stb_textedit_replace (ImGuiInputTextState *str, STB_TexteditState *state, const STB_TEXTEDIT_CHARTYPE *text, int text_len)
static void	RenderArrowsForVerticalBar (ImDrawList *draw_list, ImVec2 pos, ImVec2 half_sz, float bar_w, float alpha)
static float	Plot_ArrayGetter (void *data, int idx)
static void	ImGui::TabBarLayout (ImGuiTabBar *tab_bar)
static ImU32	ImGui::TabBarCalcTabID (ImGuiTabBar *tab_bar, const char *label)
static float	ImGui::TabBarCalcMaxTabWidth ()
static float	ImGui::TabBarScrollClamp (ImGuiTabBar *tab_bar, float scrolling)
static void	ImGui::TabBarScrollToTab (ImGuiTabBar *tab_bar, ImGuiID tab_id, ImGuiTabBarSection *sections)
static ImGuiTabItem *	ImGui::TabBarScrollingButtons (ImGuiTabBar *tab_bar)
static ImGuiTabItem *	ImGui::TabBarTabListPopupButton (ImGuiTabBar *tab_bar)
static int	TabItemGetSectionIdx (const ImGuiTabItem *tab)
static int IMGUI_CDECL	TabItemComparerBySection (const void *lhs, const void *rhs)
static int IMGUI_CDECL	TabItemComparerByBeginOrder (const void *lhs, const void *rhs)
static ImGuiTabBar *	GetTabBarFromTabBarRef (const ImGuiPtrOrIndex &ref)
static ImGuiPtrOrIndex	GetTabBarRefFromTabBar (ImGuiTabBar *tab_bar)

Variables
static const float	DRAGDROP_HOLD_TO_OPEN_TIMER = 0.70f
static const float	DRAG_MOUSE_THRESHOLD_FACTOR = 0.50f
static const signed char	IM_S8_MIN = -128
static const signed char	IM_S8_MAX = 127
static const unsigned char	IM_U8_MIN = 0
static const unsigned char	IM_U8_MAX = 0xFF
static const signed short	IM_S16_MIN = -32768
static const signed short	IM_S16_MAX = 32767
static const unsigned short	IM_U16_MIN = 0
static const unsigned short	IM_U16_MAX = 0xFFFF
static const ImS32	IM_S32_MIN = INT_MIN
static const ImS32	IM_S32_MAX = INT_MAX
static const ImU32	IM_U32_MIN = 0
static const ImU32	IM_U32_MAX = UINT_MAX
static const ImS64	IM_S64_MIN = -9223372036854775807LL - 1
static const ImS64	IM_S64_MAX = 9223372036854775807LL
static const ImU64	IM_U64_MIN = 0
static const ImU64	IM_U64_MAX = (2ULL * 9223372036854775807LL + 1)
static const ImGuiDataTypeInfo	GDataTypeInfo []
static ImWchar	ImStb::STB_TEXTEDIT_NEWLINE = '\n'

Macro Definition Documentation

IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

STB_TEXTEDIT_IMPLEMENTATION

#define STB_TEXTEDIT_IMPLEMENTATION

STB_TEXTEDIT_K_BACKSPACE

#define STB_TEXTEDIT_K_BACKSPACE   0x200009

STB_TEXTEDIT_K_DELETE

#define STB_TEXTEDIT_K_DELETE   0x200008

STB_TEXTEDIT_K_DOWN

#define STB_TEXTEDIT_K_DOWN   0x200003

STB_TEXTEDIT_K_LEFT

#define STB_TEXTEDIT_K_LEFT   0x200000

STB_TEXTEDIT_K_LINEEND

#define STB_TEXTEDIT_K_LINEEND   0x200005

STB_TEXTEDIT_K_LINESTART

#define STB_TEXTEDIT_K_LINESTART   0x200004

STB_TEXTEDIT_K_PGDOWN

#define STB_TEXTEDIT_K_PGDOWN   0x20000F

STB_TEXTEDIT_K_PGUP

#define STB_TEXTEDIT_K_PGUP   0x20000E

STB_TEXTEDIT_K_REDO

#define STB_TEXTEDIT_K_REDO   0x20000B

STB_TEXTEDIT_K_RIGHT

#define STB_TEXTEDIT_K_RIGHT   0x200001

STB_TEXTEDIT_K_SHIFT

#define STB_TEXTEDIT_K_SHIFT   0x400000

STB_TEXTEDIT_K_TEXTEND

#define STB_TEXTEDIT_K_TEXTEND   0x200007

STB_TEXTEDIT_K_TEXTSTART

#define STB_TEXTEDIT_K_TEXTSTART   0x200006

STB_TEXTEDIT_K_UNDO

#define STB_TEXTEDIT_K_UNDO   0x20000A

STB_TEXTEDIT_K_UP

#define STB_TEXTEDIT_K_UP   0x200002

STB_TEXTEDIT_K_WORDLEFT

#define STB_TEXTEDIT_K_WORDLEFT   0x20000C

STB_TEXTEDIT_K_WORDRIGHT

#define STB_TEXTEDIT_K_WORDRIGHT   0x20000D

STB_TEXTEDIT_MOVEWORDLEFT

#define STB_TEXTEDIT_MOVEWORDLEFT   STB_TEXTEDIT_MOVEWORDLEFT_IMPL

STB_TEXTEDIT_MOVEWORDRIGHT

#define STB_TEXTEDIT_MOVEWORDRIGHT   STB_TEXTEDIT_MOVEWORDRIGHT_IMPL

Function Documentation

CalcMaxPopupHeightFromItemCount()

static float CalcMaxPopupHeightFromItemCount ( int  items_count )

static

{
    ImGuiContext& g = *GImGui;
    if (items_count <= 0)
        return FLT_MAX;
    return (g.FontSize + g.Style.ItemSpacing.y) * items_count - g.Style.ItemSpacing.y + (g.Style.WindowPadding.y * 2);
}

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

Referenced by ImGui::BeginCombo().

Here is the caller graph for this function:

DataTypeClampT()

template<typename T >

static bool DataTypeClampT ( T *  v, const T *  v_min, const T *  v_max  )

static

{
    // Clamp, both sides are optional, return true if modified
    if (v_min && *v < *v_min) { *v = *v_min; return true; }
    if (v_max && *v > *v_max) { *v = *v_max; return true; }
    return false;
}

DataTypeCompareT()

template<typename T >

static int DataTypeCompareT ( const T *  lhs, const T *  rhs  )

static

{
    if (*lhs < *rhs) return -1;
    if (*lhs > *rhs) return +1;
    return 0;
}

GetMinimumStepAtDecimalPrecision()

static float GetMinimumStepAtDecimalPrecision ( int  decimal_precision )

static

{
    static const float min_steps[10] = { 1.0f, 0.1f, 0.01f, 0.001f, 0.0001f, 0.00001f, 0.000001f, 0.0000001f, 0.00000001f, 0.000000001f };
    if (decimal_precision < 0)
        return FLT_MIN;
    return (decimal_precision < IM_ARRAYSIZE(min_steps)) ? min_steps[decimal_precision] : ImPow(10.0f, (float)-decimal_precision);
}

References IM_ARRAYSIZE, and ImPow().

Here is the call graph for this function:

GetTabBarFromTabBarRef()

static ImGuiTabBar * GetTabBarFromTabBarRef ( const ImGuiPtrOrIndex &  ref )

static

{
    ImGuiContext& g = *GImGui;
    return ref.Ptr ? (ImGuiTabBar*)ref.Ptr : g.TabBars.GetByIndex(ref.Index);
}

References ImPool< T >::GetByIndex(), GImGui, ImGuiPtrOrIndex::Index, ImGuiPtrOrIndex::Ptr, and ImGuiContext::TabBars.

Referenced by ImGui::EndTabBar().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTabBarRefFromTabBar()

static ImGuiPtrOrIndex GetTabBarRefFromTabBar ( ImGuiTabBar *  tab_bar )

static

{
    ImGuiContext& g = *GImGui;
    if (g.TabBars.Contains(tab_bar))
        return ImGuiPtrOrIndex(g.TabBars.GetIndex(tab_bar));
    return ImGuiPtrOrIndex(tab_bar);
}

References ImPool< T >::Contains(), ImPool< T >::GetIndex(), GImGui, and ImGuiContext::TabBars.

Referenced by ImGui::BeginTabBarEx().

Here is the call graph for this function:

Here is the caller graph for this function:

IM_STATIC_ASSERT()

IM_STATIC_ASSERT

(

IM_ARRAYSIZE(GDataTypeInfo)

= =ImGuiDataType_COUNT

)

ImAtoi()

template<typename TYPE >

static const char * ImAtoi ( const char *  src, TYPE *  output  )

static

{
    int negative = 0;
    if (*src == '-') { negative = 1; src++; }
    if (*src == '+') { src++; }
    TYPE v = 0;
    while (*src >= '0' && *src <= '9')
        v = (v * 10) + (*src++ - '0');
    *output = negative ? -v : v;
    return src;
}

ImParseFormatFindEnd()

const char * ImParseFormatFindEnd

(

const char *

fmt

)

{
    // Printf/scanf types modifiers: I/L/h/j/l/t/w/z. Other uppercase letters qualify as types aka end of the format.
    if (fmt[0] != '%')
        return fmt;
    const unsigned int ignored_uppercase_mask = (1 << ('I'-'A')) | (1 << ('L'-'A'));
    const unsigned int ignored_lowercase_mask = (1 << ('h'-'a')) | (1 << ('j'-'a')) | (1 << ('l'-'a')) | (1 << ('t'-'a')) | (1 << ('w'-'a')) | (1 << ('z'-'a'));
    for (char c; (c = *fmt) != 0; fmt++)
    {
        if (c >= 'A' && c <= 'Z' && ((1 << (c - 'A')) & ignored_uppercase_mask) == 0)
            return fmt + 1;
        if (c >= 'a' && c <= 'z' && ((1 << (c - 'a')) & ignored_lowercase_mask) == 0)
            return fmt + 1;
    }
    return fmt;
}

Referenced by ImParseFormatTrimDecorations(), PatchFormatStringFloatToInt(), and SanitizeFormatString().

Here is the caller graph for this function:

ImParseFormatFindStart()

const char * ImParseFormatFindStart

(

const char *

fmt

)

{
    while (char c = fmt[0])
    {
        if (c == '%' && fmt[1] != '%')
            return fmt;
        else if (c == '%')
            fmt++;
        fmt++;
    }
    return fmt;
}

Referenced by ImParseFormatPrecision(), ImParseFormatTrimDecorations(), and PatchFormatStringFloatToInt().

Here is the caller graph for this function:

ImParseFormatPrecision()

int ImParseFormatPrecision	(	const char *	fmt,
		int	default_precision
	)

{
    fmt = ImParseFormatFindStart(fmt);
    if (fmt[0] != '%')
        return default_precision;
    fmt++;
    while (*fmt >= '0' && *fmt <= '9')
        fmt++;
    int precision = INT_MAX;
    if (*fmt == '.')
    {
        fmt = ImAtoi<int>(fmt + 1, &precision);
        if (precision < 0 || precision > 99)
            precision = default_precision;
    }
    if (*fmt == 'e' || *fmt == 'E') // Maximum precision with scientific notation
        precision = -1;
    if ((*fmt == 'g' || *fmt == 'G') && precision == INT_MAX)
        precision = -1;
    return (precision == INT_MAX) ? default_precision : precision;
}

References ImParseFormatFindStart().

Here is the call graph for this function:

ImParseFormatTrimDecorations()

const char * ImParseFormatTrimDecorations	(	const char *	fmt,
		char *	buf,
		size_t	buf_size
	)

{
    const char* fmt_start = ImParseFormatFindStart(fmt);
    if (fmt_start[0] != '%')
        return fmt;
    const char* fmt_end = ImParseFormatFindEnd(fmt_start);
    if (fmt_end[0] == 0) // If we only have leading decoration, we don't need to copy the data.
        return fmt_start;
    ImStrncpy(buf, fmt_start, ImMin((size_t)(fmt_end - fmt_start) + 1, buf_size));
    return buf;
}

References ImMin(), ImParseFormatFindEnd(), ImParseFormatFindStart(), and ImStrncpy().

Referenced by ImGui::TempInputScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

InputTextCalcTextLenAndLineCount()

static int InputTextCalcTextLenAndLineCount ( const char *  text_begin, const char **  out_text_end  )

static

{
    int line_count = 0;
    const char* s = text_begin;
    while (char c = *s++) // We are only matching for \n so we can ignore UTF-8 decoding
        if (c == '\n')
            line_count++;
    s--;
    if (s[0] != '\n' && s[0] != '\r')
        line_count++;
    *out_text_end = s;
    return line_count;
}

Referenced by ImGui::InputTextEx().

Here is the caller graph for this function:

InputTextCalcTextSizeW()

static ImVec2 InputTextCalcTextSizeW ( const ImWchar *  text_begin, const ImWchar *  text_end, const ImWchar **  remaining = NULL, ImVec2 *  out_offset = NULL, bool  stop_on_new_line = false  )

static

{
    ImGuiContext& g = *GImGui;
    ImFont* font = g.Font;
    const float line_height = g.FontSize;
    const float scale = line_height / font->FontSize;
 
    ImVec2 text_size = ImVec2(0, 0);
    float line_width = 0.0f;
 
    const ImWchar* s = text_begin;
    while (s < text_end)
    {
        unsigned int c = (unsigned int)(*s++);
        if (c == '\n')
        {
            text_size.x = ImMax(text_size.x, line_width);
            text_size.y += line_height;
            line_width = 0.0f;
            if (stop_on_new_line)
                break;
            continue;
        }
        if (c == '\r')
            continue;
 
        const float char_width = font->GetCharAdvance((ImWchar)c) * scale;
        line_width += char_width;
    }
 
    if (text_size.x < line_width)
        text_size.x = line_width;
 
    if (out_offset)
        *out_offset = ImVec2(line_width, text_size.y + line_height);  // offset allow for the possibility of sitting after a trailing \n
 
    if (line_width > 0 || text_size.y == 0.0f)                        // whereas size.y will ignore the trailing \n
        text_size.y += line_height;
 
    if (remaining)
        *remaining = s;
 
    return text_size;
}

References ImGuiContext::Font, ImFont::FontSize, ImGuiContext::FontSize, ImFont::GetCharAdvance(), GImGui, ImMax(), scale(), ImVec2::x, and ImVec2::y.

Referenced by ImGui::InputTextEx(), and ImStb::STB_TEXTEDIT_LAYOUTROW().

Here is the call graph for this function:

Here is the caller graph for this function:

InputTextFilterCharacter()

static bool InputTextFilterCharacter ( unsigned int *  p_char, ImGuiInputTextFlags  flags, ImGuiInputTextCallback  callback, void *  user_data, ImGuiInputSource  input_source  )

static

{
    IM_ASSERT(input_source == ImGuiInputSource_Keyboard || input_source == ImGuiInputSource_Clipboard);
    unsigned int c = *p_char;
 
    // Filter non-printable (NB: isprint is unreliable! see #2467)
    if (c < 0x20)
    {
        bool pass = false;
        pass |= (c == '\n' && (flags & ImGuiInputTextFlags_Multiline));
        pass |= (c == '\t' && (flags & ImGuiInputTextFlags_AllowTabInput));
        if (!pass)
            return false;
    }
 
    if (input_source != ImGuiInputSource_Clipboard)
    {
        // We ignore Ascii representation of delete (emitted from Backspace on OSX, see #2578, #2817)
        if (c == 127)
            return false;
 
        // Filter private Unicode range. GLFW on OSX seems to send private characters for special keys like arrow keys (FIXME)
        if (c >= 0xE000 && c <= 0xF8FF)
            return false;
    }
 
    // Filter Unicode ranges we are not handling in this build
    if (c > IM_UNICODE_CODEPOINT_MAX)
        return false;
 
    // Generic named filters
    if (flags & (ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase | ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_CharsScientific))
    {
        // The libc allows overriding locale, with e.g. 'setlocale(LC_NUMERIC, "de_DE.UTF-8");' which affect the output/input of printf/scanf.
        // The standard mandate that programs starts in the "C" locale where the decimal point is '.'.
        // We don't really intend to provide widespread support for it, but out of empathy for people stuck with using odd API, we support the bare minimum aka overriding the decimal point.
        // Change the default decimal_point with:
        ImGui::GetCurrentContext()->PlatformLocaleDecimalPoint = *localeconv()->decimal_point;
        ImGuiContext& g = *GImGui;
        const unsigned c_decimal_point = (unsigned int)g.PlatformLocaleDecimalPoint;
 
        // Allow 0-9 . - + * /
        if (flags & ImGuiInputTextFlags_CharsDecimal)
            if (!(c >= '0' && c <= '9') && (c != c_decimal_point) && (c != '-') && (c != '+') && (c != '*') && (c != '/'))
                return false;
 
        // Allow 0-9 . - + * / e E
        if (flags & ImGuiInputTextFlags_CharsScientific)
            if (!(c >= '0' && c <= '9') && (c != c_decimal_point) && (c != '-') && (c != '+') && (c != '*') && (c != '/') && (c != 'e') && (c != 'E'))
                return false;
 
        // Allow 0-9 a-F A-F
        if (flags & ImGuiInputTextFlags_CharsHexadecimal)
            if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F'))
                return false;
 
        // Turn a-z into A-Z
        if (flags & ImGuiInputTextFlags_CharsUppercase)
            if (c >= 'a' && c <= 'z')
                *p_char = (c += (unsigned int)('A' - 'a'));
 
        if (flags & ImGuiInputTextFlags_CharsNoBlank)
            if (ImCharIsBlankW(c))
                return false;
    }
 
    // Custom callback filter
    if (flags & ImGuiInputTextFlags_CallbackCharFilter)
    {
        ImGuiInputTextCallbackData callback_data;
        memset(&callback_data, 0, sizeof(ImGuiInputTextCallbackData));
        callback_data.EventFlag = ImGuiInputTextFlags_CallbackCharFilter;
        callback_data.EventChar = (ImWchar)c;
        callback_data.Flags = flags;
        callback_data.UserData = user_data;
        if (callback(&callback_data) != 0)
            return false;
        *p_char = callback_data.EventChar;
        if (!callback_data.EventChar)
            return false;
    }
 
    return true;
}

References ImGuiInputTextCallbackData::EventChar, ImGuiInputTextCallbackData::EventFlag, ImGuiInputTextCallbackData::Flags, ImGui::GetCurrentContext(), GImGui, IM_ASSERT, IM_UNICODE_CODEPOINT_MAX, ImCharIsBlankW(), ImGuiInputSource_Clipboard, ImGuiInputSource_Keyboard, ImGuiInputTextFlags_AllowTabInput, ImGuiInputTextFlags_CallbackCharFilter, ImGuiInputTextFlags_CharsDecimal, ImGuiInputTextFlags_CharsHexadecimal, ImGuiInputTextFlags_CharsNoBlank, ImGuiInputTextFlags_CharsScientific, ImGuiInputTextFlags_CharsUppercase, ImGuiInputTextFlags_Multiline, ImGuiContext::PlatformLocaleDecimalPoint, and ImGuiInputTextCallbackData::UserData.

Referenced by ImGui::InputTextEx().

Here is the call graph for this function:

Here is the caller graph for this function:

Items_ArrayGetter()

static bool Items_ArrayGetter ( void *  data, int  idx, const char **  out_text  )

static

{
    const char* const* items = (const char* const*)data;
    if (out_text)
        *out_text = items[idx];
    return true;
}

Referenced by ImGui::Combo(), and ImGui::ListBox().

Here is the caller graph for this function:

Items_SingleStringGetter()

static bool Items_SingleStringGetter ( void *  data, int  idx, const char **  out_text  )

static

{
    // FIXME-OPT: we could pre-compute the indices to fasten this. But only 1 active combo means the waste is limited.
    const char* items_separated_by_zeros = (const char*)data;
    int items_count = 0;
    const char* p = items_separated_by_zeros;
    while (*p)
    {
        if (idx == items_count)
            break;
        p += strlen(p) + 1;
        items_count++;
    }
    if (!*p)
        return false;
    if (out_text)
        *out_text = p;
    return true;
}

Referenced by ImGui::Combo().

Here is the caller graph for this function:

PatchFormatStringFloatToInt()

static const char * PatchFormatStringFloatToInt ( const char *  fmt )

static

{
    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '0' && fmt[3] == 'f' && fmt[4] == 0) // Fast legacy path for "%.0f" which is expected to be the most common case.
        return "%d";
    const char* fmt_start = ImParseFormatFindStart(fmt);    // Find % (if any, and ignore %%)
    const char* fmt_end = ImParseFormatFindEnd(fmt_start);  // Find end of format specifier, which itself is an exercise of confidence/recklessness (because snprintf is dependent on libc or user).
    if (fmt_end > fmt_start && fmt_end[-1] == 'f')
    {
#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
        if (fmt_start == fmt && fmt_end[0] == 0)
            return "%d";
        ImGuiContext& g = *GImGui;
        ImFormatString(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), "%.*s%%d%s", (int)(fmt_start - fmt), fmt, fmt_end); // Honor leading and trailing decorations, but lose alignment/precision.
        return g.TempBuffer;
#else
        IM_ASSERT(0 && "DragInt(): Invalid format string!"); // Old versions used a default parameter of "%.0f", please replace with e.g. "%d"
#endif
    }
    return fmt;
}

References GImGui, IM_ARRAYSIZE, IM_ASSERT, ImFormatString(), ImParseFormatFindEnd(), ImParseFormatFindStart(), and ImGuiContext::TempBuffer.

Referenced by ImGui::DragScalar(), ImGui::SliderScalar(), and ImGui::VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

Plot_ArrayGetter()

static float Plot_ArrayGetter ( void *  data, int  idx  )

static

{
    ImGuiPlotArrayGetterData* plot_data = (ImGuiPlotArrayGetterData*)data;
    const float v = *(const float*)(const void*)((const unsigned char*)plot_data->Values + (size_t)idx * plot_data->Stride);
    return v;
}

References ImGuiPlotArrayGetterData::Stride, and ImGuiPlotArrayGetterData::Values.

Referenced by ImGui::PlotHistogram(), and ImGui::PlotLines().

Here is the caller graph for this function:

RenderArrowsForVerticalBar()

static void RenderArrowsForVerticalBar ( ImDrawList *  draw_list, ImVec2  pos, ImVec2  half_sz, float  bar_w, float  alpha  )

static

{
    ImU32 alpha8 = IM_F32_TO_INT8_SAT(alpha);
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + half_sz.x + 1,         pos.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Right, IM_COL32(0,0,0,alpha8));
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + half_sz.x,             pos.y), half_sz,                              ImGuiDir_Right, IM_COL32(255,255,255,alpha8));
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + bar_w - half_sz.x - 1, pos.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Left,  IM_COL32(0,0,0,alpha8));
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + bar_w - half_sz.x,     pos.y), half_sz,                              ImGuiDir_Left,  IM_COL32(255,255,255,alpha8));
}

References IM_COL32, IM_F32_TO_INT8_SAT, ImGuiDir_Left, ImGuiDir_Right, ImGui::RenderArrowPointingAt(), ImVec2::x, and ImVec2::y.

Referenced by ImGui::ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

SanitizeFormatString()

static void SanitizeFormatString ( const char *  fmt, char *  fmt_out, size_t  fmt_out_size  )

static

{
    IM_UNUSED(fmt_out_size);
    const char* fmt_end = ImParseFormatFindEnd(fmt);
    IM_ASSERT((size_t)(fmt_end - fmt + 1) < fmt_out_size); // Format is too long, let us know if this happens to you!
    while (fmt < fmt_end)
    {
        char c = *(fmt++);
        if (c != '\'' && c != '$' && c != '_') // Custom flags provided by stb_sprintf.h. POSIX 2008 also supports '.
            *(fmt_out++) = c;
    }
    *fmt_out = 0; // Zero-terminate
}

References IM_ASSERT, IM_UNUSED, and ImParseFormatFindEnd().

Here is the call graph for this function:

ShrinkWidthItemComparer()

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

static

{
    const ImGuiShrinkWidthItem* a = (const ImGuiShrinkWidthItem*)lhs;
    const ImGuiShrinkWidthItem* b = (const ImGuiShrinkWidthItem*)rhs;
    if (int d = (int)(b->Width - a->Width))
        return d;
    return (b->Index - a->Index);
}

Referenced by ImGui::ShrinkWidths().

Here is the caller graph for this function:

TabItemComparerByBeginOrder()

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

static

{
    const ImGuiTabItem* a = (const ImGuiTabItem*)lhs;
    const ImGuiTabItem* b = (const ImGuiTabItem*)rhs;
    return (int)(a->BeginOrder - b->BeginOrder);
}

Referenced by ImGui::BeginTabBarEx().

Here is the caller graph for this function:

TabItemComparerBySection()

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

static

{
    const ImGuiTabItem* a = (const ImGuiTabItem*)lhs;
    const ImGuiTabItem* b = (const ImGuiTabItem*)rhs;
    const int a_section = TabItemGetSectionIdx(a);
    const int b_section = TabItemGetSectionIdx(b);
    if (a_section != b_section)
        return a_section - b_section;
    return (int)(a->IndexDuringLayout - b->IndexDuringLayout);
}

References TabItemGetSectionIdx().

Referenced by ImGui::TabBarLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

TabItemGetSectionIdx()

static int TabItemGetSectionIdx ( const ImGuiTabItem *  tab )

inlinestatic

{
    return (tab->Flags & ImGuiTabItemFlags_Leading) ? 0 : (tab->Flags & ImGuiTabItemFlags_Trailing) ? 2 : 1;
}

References ImGuiTabItem::Flags, ImGuiTabItemFlags_Leading, and ImGuiTabItemFlags_Trailing.

Referenced by ImGui::TabBarLayout(), and TabItemComparerBySection().

Here is the caller graph for this function:

Variable Documentation

DRAG_MOUSE_THRESHOLD_FACTOR

const float DRAG_MOUSE_THRESHOLD_FACTOR = 0.50f

static

Referenced by ImGui::DragScalar().

DRAGDROP_HOLD_TO_OPEN_TIMER

const float DRAGDROP_HOLD_TO_OPEN_TIMER = 0.70f

static

Referenced by ImGui::ButtonBehavior().

GDataTypeInfo

const ImGuiDataTypeInfo GDataTypeInfo[]

static

Initial value:

=
{
    { sizeof(char),             "S8",   "%d",   "%d"    },  
    { sizeof(unsigned char),    "U8",   "%u",   "%u"    },
    { sizeof(short),            "S16",  "%d",   "%d"    },  
    { sizeof(unsigned short),   "U16",  "%u",   "%u"    },
    { sizeof(int),              "S32",  "%d",   "%d"    },  
    { sizeof(unsigned int),     "U32",  "%u",   "%u"    },
 
 
 
 
    { sizeof(ImS64),            "S64",  "%lld", "%lld"  },  
    { sizeof(ImU64),            "U64",  "%llu", "%llu"  },
 
    { sizeof(float),            "float", "%.3f","%f"    },  
    { sizeof(double),           "double","%f",  "%lf"   },  
}

Referenced by ImGui::DataTypeGetInfo(), ImGui::DragScalarN(), ImGui::InputScalarN(), and ImGui::SliderScalarN().

IM_S16_MAX

const signed short IM_S16_MAX = 32767

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_S16_MIN

const signed short IM_S16_MIN = -32768

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_S32_MAX

const ImS32 IM_S32_MAX = INT_MAX

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DragBehavior(), and ImGui::SliderBehavior().

IM_S32_MIN

const ImS32 IM_S32_MIN = INT_MIN

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DragBehavior(), and ImGui::SliderBehavior().

IM_S64_MAX

const ImS64 IM_S64_MAX = 9223372036854775807LL

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DragBehavior(), and ImGui::SliderBehavior().

IM_S64_MIN

const ImS64 IM_S64_MIN = -9223372036854775807LL - 1

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DragBehavior(), and ImGui::SliderBehavior().

IM_S8_MAX

const signed char IM_S8_MAX = 127

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_S8_MIN

const signed char IM_S8_MIN = -128

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_U16_MAX

const unsigned short IM_U16_MAX = 0xFFFF

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_U16_MIN

const unsigned short IM_U16_MIN = 0

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_U32_MAX

const ImU32 IM_U32_MAX = UINT_MAX

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DragBehavior(), and ImGui::SliderBehavior().

IM_U32_MIN

const ImU32 IM_U32_MIN = 0

static

Referenced by ImGui::DataTypeApplyOp(), and ImGui::DragBehavior().

IM_U64_MAX

const ImU64 IM_U64_MAX = (2ULL * 9223372036854775807LL + 1)

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DragBehavior(), and ImGui::SliderBehavior().

IM_U64_MIN

const ImU64 IM_U64_MIN = 0

static

Referenced by ImGui::DataTypeApplyOp(), and ImGui::DragBehavior().

IM_U8_MAX

const unsigned char IM_U8_MAX = 0xFF

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().

IM_U8_MIN

const unsigned char IM_U8_MIN = 0

static

Referenced by ImGui::DataTypeApplyOp(), ImGui::DataTypeApplyOpFromText(), and ImGui::DragBehavior().