ImFont Struct Reference

#include <src/imgui/imgui.h>

Collaboration diagram for ImFont:

Public Member Functions
IMGUI_API	ImFont ()
IMGUI_API	~ImFont ()
IMGUI_API const ImFontGlyph *	FindGlyph (ImWchar c) const
IMGUI_API const ImFontGlyph *	FindGlyphNoFallback (ImWchar c) const
float	GetCharAdvance (ImWchar c) const
bool	IsLoaded () const
const char *	GetDebugName () const
IMGUI_API ImVec2	CalcTextSizeA (float size, float max_width, float wrap_width, const char *text_begin, const char *text_end=NULL, const char **remaining=NULL) const
IMGUI_API const char *	CalcWordWrapPositionA (float scale, const char *text, const char *text_end, float wrap_width) const
IMGUI_API void	RenderChar (ImDrawList *draw_list, float size, ImVec2 pos, ImU32 col, ImWchar c) const
IMGUI_API void	RenderText (ImDrawList *draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4 &clip_rect, const char *text_begin, const char *text_end, float wrap_width=0.0f, bool cpu_fine_clip=false) const
IMGUI_API void	BuildLookupTable ()
IMGUI_API void	ClearOutputData ()
IMGUI_API void	GrowIndex (int new_size)
IMGUI_API void	AddGlyph (const ImFontConfig *src_cfg, ImWchar c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
IMGUI_API void	AddRemapChar (ImWchar dst, ImWchar src, bool overwrite_dst=true)
IMGUI_API void	SetGlyphVisible (ImWchar c, bool visible)
IMGUI_API void	SetFallbackChar (ImWchar c)
IMGUI_API bool	IsGlyphRangeUnused (unsigned int c_begin, unsigned int c_last)

Public Attributes
ImVector< float >	IndexAdvanceX
float	FallbackAdvanceX
float	FontSize
ImVector< ImWchar >	IndexLookup
ImVector< ImFontGlyph >	Glyphs
const ImFontGlyph *	FallbackGlyph
ImFontAtlas *	ContainerAtlas
const ImFontConfig *	ConfigData
short	ConfigDataCount
ImWchar	FallbackChar
ImWchar	EllipsisChar
bool	DirtyLookupTables
float	Scale
float	Ascent
float	Descent
int	MetricsTotalSurface
ImU8	Used4kPagesMap [(IM_UNICODE_CODEPOINT_MAX+1)/4096/8]

Detailed Description

Constructor & Destructor Documentation

ImFont()

ImFont::ImFont

(

)

{
    FontSize = 0.0f;
    FallbackAdvanceX = 0.0f;
    FallbackChar = (ImWchar)'?';
    EllipsisChar = (ImWchar)-1;
    FallbackGlyph = NULL;
    ContainerAtlas = NULL;
    ConfigData = NULL;
    ConfigDataCount = 0;
    DirtyLookupTables = false;
    Scale = 1.0f;
    Ascent = Descent = 0.0f;
    MetricsTotalSurface = 0;
    memset(Used4kPagesMap, 0, sizeof(Used4kPagesMap));
}

References Ascent, ConfigData, ConfigDataCount, ContainerAtlas, Descent, DirtyLookupTables, EllipsisChar, FallbackAdvanceX, FallbackChar, FallbackGlyph, FontSize, MetricsTotalSurface, Scale, and Used4kPagesMap.

~ImFont()

ImFont::~ImFont

(

)

{
    ClearOutputData();
}

References ClearOutputData().

Here is the call graph for this function:

Member Function Documentation

AddGlyph()

void ImFont::AddGlyph	(	const ImFontConfig *	src_cfg,
		ImWchar	c,
		float	x0,
		float	y0,
		float	x1,
		float	y1,
		float	u0,
		float	v0,
		float	u1,
		float	v1,
		float	advance_x
	)

{
    if (cfg != NULL)
    {
        // Clamp & recenter if needed
        const float advance_x_original = advance_x;
        advance_x = ImClamp(advance_x, cfg->GlyphMinAdvanceX, cfg->GlyphMaxAdvanceX);
        if (advance_x != advance_x_original)
        {
            float char_off_x = cfg->PixelSnapH ? ImFloor((advance_x - advance_x_original) * 0.5f) : (advance_x - advance_x_original) * 0.5f;
            x0 += char_off_x;
            x1 += char_off_x;
        }
 
        // Snap to pixel
        if (cfg->PixelSnapH)
            advance_x = IM_ROUND(advance_x);
 
        // Bake spacing
        advance_x += cfg->GlyphExtraSpacing.x;
    }
 
    Glyphs.resize(Glyphs.Size + 1);
    ImFontGlyph& glyph = Glyphs.back();
    glyph.Codepoint = (unsigned int)codepoint;
    glyph.Visible = (x0 != x1) && (y0 != y1);
    glyph.Colored = false;
    glyph.X0 = x0;
    glyph.Y0 = y0;
    glyph.X1 = x1;
    glyph.Y1 = y1;
    glyph.U0 = u0;
    glyph.V0 = v0;
    glyph.U1 = u1;
    glyph.V1 = v1;
    glyph.AdvanceX = advance_x;
 
    // Compute rough surface usage metrics (+1 to account for average padding, +0.99 to round)
    // We use (U1-U0)*TexWidth instead of X1-X0 to account for oversampling.
    float pad = ContainerAtlas->TexGlyphPadding + 0.99f;
    DirtyLookupTables = true;
    MetricsTotalSurface += (int)((glyph.U1 - glyph.U0) * ContainerAtlas->TexWidth + pad) * (int)((glyph.V1 - glyph.V0) * ContainerAtlas->TexHeight + pad);
}

References ImFontGlyph::AdvanceX, ImVector< T >::back(), ImFontGlyph::Codepoint, ImFontGlyph::Colored, ContainerAtlas, DirtyLookupTables, ImFontConfig::GlyphExtraSpacing, ImFontConfig::GlyphMaxAdvanceX, ImFontConfig::GlyphMinAdvanceX, Glyphs, IM_ROUND, ImClamp(), ImFloor(), MetricsTotalSurface, ImFontConfig::PixelSnapH, ImVector< T >::resize(), ImVector< T >::Size, ImFontAtlas::TexGlyphPadding, ImFontAtlas::TexHeight, ImFontAtlas::TexWidth, ImFontGlyph::U0, ImFontGlyph::U1, ImFontGlyph::V0, ImFontGlyph::V1, ImFontGlyph::Visible, ImVec2::x, ImFontGlyph::X0, ImFontGlyph::X1, ImFontGlyph::Y0, and ImFontGlyph::Y1.

Referenced by ImFontAtlasBuildFinish(), and ImFontAtlasBuildWithStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

AddRemapChar()

void ImFont::AddRemapChar	(	ImWchar	dst,
		ImWchar	src,
		bool	overwrite_dst = true
	)

{
    IM_ASSERT(IndexLookup.Size > 0);    // Currently this can only be called AFTER the font has been built, aka after calling ImFontAtlas::GetTexDataAs*() function.
    unsigned int index_size = (unsigned int)IndexLookup.Size;
 
    if (dst < index_size && IndexLookup.Data[dst] == (ImWchar)-1 && !overwrite_dst) // 'dst' already exists
        return;
    if (src >= index_size && dst >= index_size) // both 'dst' and 'src' don't exist -> no-op
        return;
 
    GrowIndex(dst + 1);
    IndexLookup[dst] = (src < index_size) ? IndexLookup.Data[src] : (ImWchar)-1;
    IndexAdvanceX[dst] = (src < index_size) ? IndexAdvanceX.Data[src] : 1.0f;
}

References ImVector< T >::Data, GrowIndex(), IM_ASSERT, IndexAdvanceX, IndexLookup, and ImVector< T >::Size.

Here is the call graph for this function:

BuildLookupTable()

void ImFont::BuildLookupTable

(

)

{
    int max_codepoint = 0;
    for (int i = 0; i != Glyphs.Size; i++)
        max_codepoint = ImMax(max_codepoint, (int)Glyphs[i].Codepoint);
 
    // Build lookup table
    IM_ASSERT(Glyphs.Size < 0xFFFF); // -1 is reserved
    IndexAdvanceX.clear();
    IndexLookup.clear();
    DirtyLookupTables = false;
    memset(Used4kPagesMap, 0, sizeof(Used4kPagesMap));
    GrowIndex(max_codepoint + 1);
    for (int i = 0; i < Glyphs.Size; i++)
    {
        int codepoint = (int)Glyphs[i].Codepoint;
        IndexAdvanceX[codepoint] = Glyphs[i].AdvanceX;
        IndexLookup[codepoint] = (ImWchar)i;
 
        // Mark 4K page as used
        const int page_n = codepoint / 4096;
        Used4kPagesMap[page_n >> 3] |= 1 << (page_n & 7);
    }
 
    // Create a glyph to handle TAB
    // FIXME: Needs proper TAB handling but it needs to be contextualized (or we could arbitrary say that each string starts at "column 0" ?)
    if (FindGlyph((ImWchar)' '))
    {
        if (Glyphs.back().Codepoint != '\t')   // So we can call this function multiple times (FIXME: Flaky)
            Glyphs.resize(Glyphs.Size + 1);
        ImFontGlyph& tab_glyph = Glyphs.back();
        tab_glyph = *FindGlyph((ImWchar)' ');
        tab_glyph.Codepoint = '\t';
        tab_glyph.AdvanceX *= IM_TABSIZE;
        IndexAdvanceX[(int)tab_glyph.Codepoint] = (float)tab_glyph.AdvanceX;
        IndexLookup[(int)tab_glyph.Codepoint] = (ImWchar)(Glyphs.Size - 1);
    }
 
    // Mark special glyphs as not visible (note that AddGlyph already mark as non-visible glyphs with zero-size polygons)
    SetGlyphVisible((ImWchar)' ', false);
    SetGlyphVisible((ImWchar)'\t', false);
 
    // Setup fall-backs
    FallbackGlyph = FindGlyphNoFallback(FallbackChar);
    FallbackAdvanceX = FallbackGlyph ? FallbackGlyph->AdvanceX : 0.0f;
    for (int i = 0; i < max_codepoint + 1; i++)
        if (IndexAdvanceX[i] < 0.0f)
            IndexAdvanceX[i] = FallbackAdvanceX;
}

References ImFontGlyph::AdvanceX, ImVector< T >::back(), ImVector< T >::clear(), ImFontGlyph::Codepoint, DirtyLookupTables, FallbackAdvanceX, FallbackChar, FallbackGlyph, FindGlyph(), FindGlyphNoFallback(), Glyphs, GrowIndex(), IM_ASSERT, IM_TABSIZE, ImMax(), IndexAdvanceX, IndexLookup, ImVector< T >::resize(), SetGlyphVisible(), ImVector< T >::Size, and Used4kPagesMap.

Referenced by SetFallbackChar().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcTextSizeA()

ImVec2 ImFont::CalcTextSizeA	(	float	size,
		float	max_width,
		float	wrap_width,
		const char *	text_begin,
		const char *	text_end = NULL,
		const char **	remaining = NULL
	)		const

{
    if (!text_end)
        text_end = text_begin + strlen(text_begin); // FIXME-OPT: Need to avoid this.
 
    const float line_height = size;
    const float scale = size / FontSize;
 
    ImVec2 text_size = ImVec2(0, 0);
    float line_width = 0.0f;
 
    const bool word_wrap_enabled = (wrap_width > 0.0f);
    const char* word_wrap_eol = NULL;
 
    const char* s = text_begin;
    while (s < text_end)
    {
        if (word_wrap_enabled)
        {
            // Calculate how far we can render. Requires two passes on the string data but keeps the code simple and not intrusive for what's essentially an uncommon feature.
            if (!word_wrap_eol)
            {
                word_wrap_eol = CalcWordWrapPositionA(scale, s, text_end, wrap_width - line_width);
                if (word_wrap_eol == s) // Wrap_width is too small to fit anything. Force displaying 1 character to minimize the height discontinuity.
                    word_wrap_eol++;    // +1 may not be a character start point in UTF-8 but it's ok because we use s >= word_wrap_eol below
            }
 
            if (s >= word_wrap_eol)
            {
                if (text_size.x < line_width)
                    text_size.x = line_width;
                text_size.y += line_height;
                line_width = 0.0f;
                word_wrap_eol = NULL;
 
                // Wrapping skips upcoming blanks
                while (s < text_end)
                {
                    const char c = *s;
                    if (ImCharIsBlankA(c)) { s++; } else if (c == '\n') { s++; break; } else { break; }
                }
                continue;
            }
        }
 
        // Decode and advance source
        const char* prev_s = s;
        unsigned int c = (unsigned int)*s;
        if (c < 0x80)
        {
            s += 1;
        }
        else
        {
            s += ImTextCharFromUtf8(&c, s, text_end);
            if (c == 0) // Malformed UTF-8?
                break;
        }
 
        if (c < 32)
        {
            if (c == '\n')
            {
                text_size.x = ImMax(text_size.x, line_width);
                text_size.y += line_height;
                line_width = 0.0f;
                continue;
            }
            if (c == '\r')
                continue;
        }
 
        const float char_width = ((int)c < IndexAdvanceX.Size ? IndexAdvanceX.Data[c] : FallbackAdvanceX) * scale;
        if (line_width + char_width >= max_width)
        {
            s = prev_s;
            break;
        }
 
        line_width += char_width;
    }
 
    if (text_size.x < line_width)
        text_size.x = line_width;
 
    if (line_width > 0 || text_size.y == 0.0f)
        text_size.y += line_height;
 
    if (remaining)
        *remaining = s;
 
    return text_size;
}

References CalcWordWrapPositionA(), ImVector< T >::Data, FallbackAdvanceX, FontSize, ImCharIsBlankA(), ImMax(), ImTextCharFromUtf8(), IndexAdvanceX, scale(), ImVector< T >::Size, ImVec2::x, and ImVec2::y.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CalcWordWrapPositionA()

const char * ImFont::CalcWordWrapPositionA	(	float	scale,
		const char *	text,
		const char *	text_end,
		float	wrap_width
	)		const

{
    // Simple word-wrapping for English, not full-featured. Please submit failing cases!
    // FIXME: Much possible improvements (don't cut things like "word !", "word!!!" but cut within "word,,,,", more sensible support for punctuations, support for Unicode punctuations, etc.)
 
    // For references, possible wrap point marked with ^
    //  "aaa bbb, ccc,ddd. eee   fff. ggg!"
    //      ^    ^    ^   ^   ^__    ^    ^
 
    // List of hardcoded separators: .,;!?'"
 
    // Skip extra blanks after a line returns (that includes not counting them in width computation)
    // e.g. "Hello    world" --> "Hello" "World"
 
    // Cut words that cannot possibly fit within one line.
    // e.g.: "The tropical fish" with ~5 characters worth of width --> "The tr" "opical" "fish"
 
    float line_width = 0.0f;
    float word_width = 0.0f;
    float blank_width = 0.0f;
    wrap_width /= scale; // We work with unscaled widths to avoid scaling every characters
 
    const char* word_end = text;
    const char* prev_word_end = NULL;
    bool inside_word = true;
 
    const char* s = text;
    while (s < text_end)
    {
        unsigned int c = (unsigned int)*s;
        const char* next_s;
        if (c < 0x80)
            next_s = s + 1;
        else
            next_s = s + ImTextCharFromUtf8(&c, s, text_end);
        if (c == 0)
            break;
 
        if (c < 32)
        {
            if (c == '\n')
            {
                line_width = word_width = blank_width = 0.0f;
                inside_word = true;
                s = next_s;
                continue;
            }
            if (c == '\r')
            {
                s = next_s;
                continue;
            }
        }
 
        const float char_width = ((int)c < IndexAdvanceX.Size ? IndexAdvanceX.Data[c] : FallbackAdvanceX);
        if (ImCharIsBlankW(c))
        {
            if (inside_word)
            {
                line_width += blank_width;
                blank_width = 0.0f;
                word_end = s;
            }
            blank_width += char_width;
            inside_word = false;
        }
        else
        {
            word_width += char_width;
            if (inside_word)
            {
                word_end = next_s;
            }
            else
            {
                prev_word_end = word_end;
                line_width += word_width + blank_width;
                word_width = blank_width = 0.0f;
            }
 
            // Allow wrapping after punctuation.
            inside_word = (c != '.' && c != ',' && c != ';' && c != '!' && c != '?' && c != '\"');
        }
 
        // We ignore blank width at the end of the line (they can be skipped)
        if (line_width + word_width > wrap_width)
        {
            // Words that cannot possibly fit within an entire line will be cut anywhere.
            if (word_width < wrap_width)
                s = prev_word_end ? prev_word_end : word_end;
            break;
        }
 
        s = next_s;
    }
 
    return s;
}

References ImVector< T >::Data, FallbackAdvanceX, ImCharIsBlankW(), ImTextCharFromUtf8(), IndexAdvanceX, scale(), and ImVector< T >::Size.

Referenced by CalcTextSizeA(), and RenderText().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearOutputData()

void ImFont::ClearOutputData

(

)

{
    FontSize = 0.0f;
    FallbackAdvanceX = 0.0f;
    Glyphs.clear();
    IndexAdvanceX.clear();
    IndexLookup.clear();
    FallbackGlyph = NULL;
    ContainerAtlas = NULL;
    DirtyLookupTables = true;
    Ascent = Descent = 0.0f;
    MetricsTotalSurface = 0;
}

References Ascent, ImVector< T >::clear(), ContainerAtlas, Descent, DirtyLookupTables, FallbackAdvanceX, FallbackGlyph, FontSize, Glyphs, IndexAdvanceX, IndexLookup, and MetricsTotalSurface.

Referenced by ~ImFont(), and ImFontAtlasBuildSetupFont().

Here is the call graph for this function:

Here is the caller graph for this function:

FindGlyph()

const ImFontGlyph * ImFont::FindGlyph

(

ImWchar

c

)

const

{
    if (c >= (size_t)IndexLookup.Size)
        return FallbackGlyph;
    const ImWchar i = IndexLookup.Data[c];
    if (i == (ImWchar)-1)
        return FallbackGlyph;
    return &Glyphs.Data[i];
}

References ImVector< T >::Data, FallbackGlyph, Glyphs, IndexLookup, and ImVector< T >::Size.

Referenced by BuildLookupTable(), ImGui::InputTextEx(), RenderChar(), RenderText(), ImGui::RenderTextEllipsis(), and SetGlyphVisible().

Here is the caller graph for this function:

FindGlyphNoFallback()

const ImFontGlyph * ImFont::FindGlyphNoFallback

(

ImWchar

c

)

const

{
    if (c >= (size_t)IndexLookup.Size)
        return NULL;
    const ImWchar i = IndexLookup.Data[c];
    if (i == (ImWchar)-1)
        return NULL;
    return &Glyphs.Data[i];
}

References ImVector< T >::Data, Glyphs, IndexLookup, and ImVector< T >::Size.

Referenced by BuildLookupTable(), ImFontAtlasBuildFinish(), and ShowFont().

Here is the caller graph for this function:

GetCharAdvance()

float ImFont::GetCharAdvance ( ImWchar  c ) const

inline

{ return ((int)c < IndexAdvanceX.Size) ? IndexAdvanceX[(int)c] : FallbackAdvanceX; }

References ImVector< T >::Size.

Referenced by InputTextCalcTextSizeW(), ImGui::InputTextEx(), and ImStb::STB_TEXTEDIT_GETWIDTH().

Here is the caller graph for this function:

GetDebugName()

const char * ImFont::GetDebugName ( ) const

inline

{ return ConfigData ? ConfigData->Name : "<unknown>"; }

References ImFontConfig::Name.

Referenced by ImGui::ShowFontSelector().

Here is the caller graph for this function:

GrowIndex()

void ImFont::GrowIndex

(

int

new_size

)

{
    IM_ASSERT(IndexAdvanceX.Size == IndexLookup.Size);
    if (new_size <= IndexLookup.Size)
        return;
    IndexAdvanceX.resize(new_size, -1.0f);
    IndexLookup.resize(new_size, (ImWchar)-1);
}

References IM_ASSERT, IndexAdvanceX, IndexLookup, ImVector< T >::resize(), and ImVector< T >::Size.

Referenced by AddRemapChar(), and BuildLookupTable().

Here is the call graph for this function:

Here is the caller graph for this function:

IsGlyphRangeUnused()

bool ImFont::IsGlyphRangeUnused	(	unsigned int	c_begin,
		unsigned int	c_last
	)

{
    unsigned int page_begin = (c_begin / 4096);
    unsigned int page_last = (c_last / 4096);
    for (unsigned int page_n = page_begin; page_n <= page_last; page_n++)
        if ((page_n >> 3) < sizeof(Used4kPagesMap))
            if (Used4kPagesMap[page_n >> 3] & (1 << (page_n & 7)))
                return false;
    return true;
}

References Used4kPagesMap.

Referenced by ShowFont().

Here is the caller graph for this function:

IsLoaded()

bool ImFont::IsLoaded ( ) const

inline

{ return ContainerAtlas != NULL; }

Referenced by Slic3r::GUI::ImGuiWrapper::contain_all_glyphs(), Slic3r::GUI::Emboss::StyleManager::create_imgui_font(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), ImFontAtlasBuildWithStbTruetype(), ImGui::NewFrame(), and ImGui::SetCurrentFont().

Here is the caller graph for this function:

RenderChar()

void ImFont::RenderChar	(	ImDrawList *	draw_list,
		float	size,
		ImVec2	pos,
		ImU32	col,
		ImWchar	c
	)		const

{
    const ImFontGlyph* glyph = FindGlyph(c);
    if (!glyph || !glyph->Visible)
        return;
    if (glyph->Colored)
        col |= ~IM_COL32_A_MASK;
    float scale = (size >= 0.0f) ? (size / FontSize) : 1.0f;
    pos.x = IM_FLOOR(pos.x);
    pos.y = IM_FLOOR(pos.y);
    draw_list->PrimReserve(6, 4);
    draw_list->PrimRectUV(ImVec2(pos.x + glyph->X0 * scale, pos.y + glyph->Y0 * scale), ImVec2(pos.x + glyph->X1 * scale, pos.y + glyph->Y1 * scale), ImVec2(glyph->U0, glyph->V0), ImVec2(glyph->U1, glyph->V1), col);
}

References col(), ImFontGlyph::Colored, FindGlyph(), FontSize, IM_FLOOR, ImDrawList::PrimRectUV(), ImDrawList::PrimReserve(), scale(), ImFontGlyph::U0, ImFontGlyph::U1, ImFontGlyph::V0, ImFontGlyph::V1, ImFontGlyph::Visible, ImFontGlyph::X0, ImFontGlyph::X1, ImFontGlyph::Y0, and ImFontGlyph::Y1.

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

Here is the call graph for this function:

Here is the caller graph for this function:

RenderText()

void ImFont::RenderText	(	ImDrawList *	draw_list,
		float	size,
		ImVec2	pos,
		ImU32	col,
		const ImVec4 &	clip_rect,
		const char *	text_begin,
		const char *	text_end,
		float	wrap_width = 0.0f,
		bool	cpu_fine_clip = false
	)		const

{
    if (!text_end)
        text_end = text_begin + strlen(text_begin); // ImGui:: functions generally already provides a valid text_end, so this is merely to handle direct calls.
 
    // Align to be pixel perfect
    pos.x = IM_FLOOR(pos.x);
    pos.y = IM_FLOOR(pos.y);
    float x = pos.x;
    float y = pos.y;
    if (y > clip_rect.w)
        return;
 
    const float scale = size / FontSize;
    const float line_height = FontSize * scale;
    const bool word_wrap_enabled = (wrap_width > 0.0f);
    const char* word_wrap_eol = NULL;
 
    // Fast-forward to first visible line
    const char* s = text_begin;
    if (y + line_height < clip_rect.y && !word_wrap_enabled)
        while (y + line_height < clip_rect.y && s < text_end)
        {
            s = (const char*)memchr(s, '\n', text_end - s);
            s = s ? s + 1 : text_end;
            y += line_height;
        }
 
    // For large text, scan for the last visible line in order to avoid over-reserving in the call to PrimReserve()
    // Note that very large horizontal line will still be affected by the issue (e.g. a one megabyte string buffer without a newline will likely crash atm)
    if (text_end - s > 10000 && !word_wrap_enabled)
    {
        const char* s_end = s;
        float y_end = y;
        while (y_end < clip_rect.w && s_end < text_end)
        {
            s_end = (const char*)memchr(s_end, '\n', text_end - s_end);
            s_end = s_end ? s_end + 1 : text_end;
            y_end += line_height;
        }
        text_end = s_end;
    }
    if (s == text_end)
        return;
 
    // Reserve vertices for remaining worse case (over-reserving is useful and easily amortized)
    const int vtx_count_max = (int)(text_end - s) * 4;
    const int idx_count_max = (int)(text_end - s) * 6;
    const int idx_expected_size = draw_list->IdxBuffer.Size + idx_count_max;
    draw_list->PrimReserve(idx_count_max, vtx_count_max);
 
    ImDrawVert* vtx_write = draw_list->_VtxWritePtr;
    ImDrawIdx* idx_write = draw_list->_IdxWritePtr;
    unsigned int vtx_current_idx = draw_list->_VtxCurrentIdx;
 
    const ImU32 col_untinted = col | ~IM_COL32_A_MASK;
 
    ImU32 defaultCol = col;
    ImU32 highlighCol = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
    // if text is started with ColorMarkerHovered symbol, we should use another color for a highlighting
    if (*s == ImGui::ColorMarkerHovered) {
        highlighCol = ImGui::GetColorU32(ImGuiCol_FrameBg);
        s += 1;
    }
 
    while (s < text_end)
    {
        if (word_wrap_enabled)
        {
            // Calculate how far we can render. Requires two passes on the string data but keeps the code simple and not intrusive for what's essentially an uncommon feature.
            if (!word_wrap_eol)
            {
                word_wrap_eol = CalcWordWrapPositionA(scale, s, text_end, wrap_width - (x - pos.x));
                if (word_wrap_eol == s) // Wrap_width is too small to fit anything. Force displaying 1 character to minimize the height discontinuity.
                    word_wrap_eol++;    // +1 may not be a character start point in UTF-8 but it's ok because we use s >= word_wrap_eol below
            }
 
            if (s >= word_wrap_eol)
            {
                x = pos.x;
                y += line_height;
                word_wrap_eol = NULL;
 
                // Wrapping skips upcoming blanks
                while (s < text_end)
                {
                    const char c = *s;
                    if (ImCharIsBlankA(c)) { s++; } else if (c == '\n') { s++; break; } else { break; }
                }
                continue;
            }
        }
 
        if (*s == ImGui::ColorMarkerStart) {
            col = highlighCol;
            s += 1;
        }
        else if (*s == ImGui::ColorMarkerEnd) {
            col = defaultCol;
            s += 1;
            if (s == text_end)
                break;
        }
 
        // Decode and advance source
        unsigned int c = (unsigned int)*s;
        if (c < 0x80)
        {
            s += 1;
        }
        else
        {
            s += ImTextCharFromUtf8(&c, s, text_end);
            if (c == 0) // Malformed UTF-8?
                break;
        }
 
        if (c < 32)
        {
            if (c == '\n')
            {
                x = pos.x;
                y += line_height;
                if (y > clip_rect.w)
                    break; // break out of main loop
                continue;
            }
            if (c == '\r')
                continue;
        }
 
        const ImFontGlyph* glyph = FindGlyph((ImWchar)c);
        if (glyph == NULL)
            continue;
 
        float char_width = glyph->AdvanceX * scale;
        if (glyph->Visible)
        {
            // We don't do a second finer clipping test on the Y axis as we've already skipped anything before clip_rect.y and exit once we pass clip_rect.w
            float x1 = x + glyph->X0 * scale;
            float x2 = x + glyph->X1 * scale;
            float y1 = y + glyph->Y0 * scale;
            float y2 = y + glyph->Y1 * scale;
            if (x1 <= clip_rect.z && x2 >= clip_rect.x)
            {
                // Render a character
                float u1 = glyph->U0;
                float v1 = glyph->V0;
                float u2 = glyph->U1;
                float v2 = glyph->V1;
 
                // CPU side clipping used to fit text in their frame when the frame is too small. Only does clipping for axis aligned quads.
                if (cpu_fine_clip)
                {
                    if (x1 < clip_rect.x)
                    {
                        u1 = u1 + (1.0f - (x2 - clip_rect.x) / (x2 - x1)) * (u2 - u1);
                        x1 = clip_rect.x;
                    }
                    if (y1 < clip_rect.y)
                    {
                        v1 = v1 + (1.0f - (y2 - clip_rect.y) / (y2 - y1)) * (v2 - v1);
                        y1 = clip_rect.y;
                    }
                    if (x2 > clip_rect.z)
                    {
                        u2 = u1 + ((clip_rect.z - x1) / (x2 - x1)) * (u2 - u1);
                        x2 = clip_rect.z;
                    }
                    if (y2 > clip_rect.w)
                    {
                        v2 = v1 + ((clip_rect.w - y1) / (y2 - y1)) * (v2 - v1);
                        y2 = clip_rect.w;
                    }
                    if (y1 >= y2)
                    {
                        x += char_width;
                        continue;
                    }
                }
 
                // Support for untinted glyphs
                ImU32 glyph_col = glyph->Colored ? col_untinted : col;
 
                // We are NOT calling PrimRectUV() here because non-inlined causes too much overhead in a debug builds. Inlined here:
                {
                    idx_write[0] = (ImDrawIdx)(vtx_current_idx); idx_write[1] = (ImDrawIdx)(vtx_current_idx+1); idx_write[2] = (ImDrawIdx)(vtx_current_idx+2);
                    idx_write[3] = (ImDrawIdx)(vtx_current_idx); idx_write[4] = (ImDrawIdx)(vtx_current_idx+2); idx_write[5] = (ImDrawIdx)(vtx_current_idx+3);
                    vtx_write[0].pos.x = x1; vtx_write[0].pos.y = y1; vtx_write[0].col = glyph_col; vtx_write[0].uv.x = u1; vtx_write[0].uv.y = v1;
                    vtx_write[1].pos.x = x2; vtx_write[1].pos.y = y1; vtx_write[1].col = glyph_col; vtx_write[1].uv.x = u2; vtx_write[1].uv.y = v1;
                    vtx_write[2].pos.x = x2; vtx_write[2].pos.y = y2; vtx_write[2].col = glyph_col; vtx_write[2].uv.x = u2; vtx_write[2].uv.y = v2;
                    vtx_write[3].pos.x = x1; vtx_write[3].pos.y = y2; vtx_write[3].col = glyph_col; vtx_write[3].uv.x = u1; vtx_write[3].uv.y = v2;
                    vtx_write += 4;
                    vtx_current_idx += 4;
                    idx_write += 6;
                }
            }
        }
        x += char_width;
    }
 
    // Give back unused vertices (clipped ones, blanks) ~ this is essentially a PrimUnreserve() action.
    draw_list->VtxBuffer.Size = (int)(vtx_write - draw_list->VtxBuffer.Data); // Same as calling shrink()
    draw_list->IdxBuffer.Size = (int)(idx_write - draw_list->IdxBuffer.Data);
    draw_list->CmdBuffer[draw_list->CmdBuffer.Size - 1].ElemCount -= (idx_expected_size - draw_list->IdxBuffer.Size);
    draw_list->_VtxWritePtr = vtx_write;
    draw_list->_IdxWritePtr = idx_write;
    draw_list->_VtxCurrentIdx = vtx_current_idx;
}

References ImDrawList::_IdxWritePtr, ImDrawList::_VtxCurrentIdx, ImDrawList::_VtxWritePtr, ImFontGlyph::AdvanceX, CalcWordWrapPositionA(), ImDrawList::CmdBuffer, col(), ImDrawVert::col, ImFontGlyph::Colored, ImGui::ColorMarkerEnd, ImGui::ColorMarkerHovered, ImGui::ColorMarkerStart, ImVector< T >::Data, FindGlyph(), FontSize, ImGui::GetColorU32(), ImDrawList::IdxBuffer, IM_FLOOR, ImCharIsBlankA(), ImGuiCol_ButtonHovered, ImGuiCol_FrameBg, ImTextCharFromUtf8(), ImDrawVert::pos, ImDrawList::PrimReserve(), scale(), ImVector< T >::Size, ImFontGlyph::U0, ImFontGlyph::U1, ImDrawVert::uv, ImFontGlyph::V0, ImFontGlyph::V1, ImFontGlyph::Visible, ImDrawList::VtxBuffer, ImVec4::w, ImVec2::x, ImVec4::x, ImFontGlyph::X0, ImFontGlyph::X1, ImVec2::y, ImVec4::y, ImFontGlyph::Y0, ImFontGlyph::Y1, and ImVec4::z.

Referenced by ImDrawList::AddText().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFallbackChar()

void ImFont::SetFallbackChar

(

ImWchar

c

)

{
    FallbackChar = c;
    BuildLookupTable();
}

References BuildLookupTable(), and FallbackChar.

Here is the call graph for this function:

SetGlyphVisible()

void ImFont::SetGlyphVisible	(	ImWchar	c,
		bool	visible
	)

{
    if (ImFontGlyph* glyph = (ImFontGlyph*)(void*)FindGlyph((ImWchar)c))
        glyph->Visible = visible ? 1 : 0;
}

References FindGlyph().

Referenced by BuildLookupTable().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Ascent

float ImFont::Ascent

Referenced by ImFont(), ClearOutputData(), ImFontAtlasBuildSetupFont(), ImFontAtlasBuildWithStbTruetype(), ImGui::InputTextEx(), and ShowFont().

ConfigData

const ImFontConfig* ImFont::ConfigData

Referenced by ImFont(), Slic3r::GUI::ImGuiWrapper::contain_all_glyphs(), ImFontAtlasBuildSetupFont(), and ShowFont().

ConfigDataCount

short ImFont::ConfigDataCount

Referenced by ImFont(), ImFontAtlasBuildSetupFont(), and ShowFont().

ContainerAtlas

ImFontAtlas* ImFont::ContainerAtlas

Referenced by ImFont(), AddGlyph(), ImDrawList::AddPolyline(), ImDrawList::AddText(), ImGui::Begin(), ClearOutputData(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), ImFontAtlasBuildFinish(), ImFontAtlasBuildSetupFont(), ImFontAtlasBuildWithStbTruetype(), ImGui::InputTextEx(), ImGui::NewFrame(), ImGui::PushFont(), ImGui::RenderMouseCursor(), and ImGui::SetCurrentFont().

Descent

float ImFont::Descent

Referenced by ImFont(), ClearOutputData(), ImFontAtlasBuildSetupFont(), ImGui::InputTextEx(), and ShowFont().

DirtyLookupTables

bool ImFont::DirtyLookupTables

Referenced by ImFont(), AddGlyph(), BuildLookupTable(), and ClearOutputData().

EllipsisChar

ImWchar ImFont::EllipsisChar

Referenced by ImFont(), ImFontAtlas::AddFont(), ImFontAtlasBuildFinish(), ImGui::RenderTextEllipsis(), and ShowFont().

FallbackAdvanceX

float ImFont::FallbackAdvanceX

Referenced by ImFont(), BuildLookupTable(), CalcTextSizeA(), CalcWordWrapPositionA(), ClearOutputData(), and ImGui::InputTextEx().

FallbackChar

ImWchar ImFont::FallbackChar

Referenced by ImFont(), BuildLookupTable(), SetFallbackChar(), and ShowFont().

FallbackGlyph

const ImFontGlyph* ImFont::FallbackGlyph

Referenced by ImFont(), BuildLookupTable(), ClearOutputData(), FindGlyph(), and ImGui::InputTextEx().

FontSize

float ImFont::FontSize

Referenced by ImFont(), CalcTextSizeA(), ClearOutputData(), ImFontAtlasBuildSetupFont(), InputTextCalcTextSizeW(), ImGui::InputTextEx(), RenderChar(), RenderText(), ImGui::RenderTextEllipsis(), ImGui::SetCurrentFont(), ShowFont(), and ImStb::STB_TEXTEDIT_GETWIDTH().

Glyphs

ImVector<ImFontGlyph> ImFont::Glyphs

Referenced by AddGlyph(), BuildLookupTable(), ClearOutputData(), FindGlyph(), FindGlyphNoFallback(), ImGui::InputTextEx(), and ShowFont().

IndexAdvanceX

ImVector<float> ImFont::IndexAdvanceX

Referenced by AddRemapChar(), BuildLookupTable(), CalcTextSizeA(), CalcWordWrapPositionA(), ClearOutputData(), GrowIndex(), and ImGui::InputTextEx().

IndexLookup

ImVector<ImWchar> ImFont::IndexLookup

Referenced by AddRemapChar(), BuildLookupTable(), ClearOutputData(), FindGlyph(), FindGlyphNoFallback(), GrowIndex(), and ImGui::InputTextEx().

MetricsTotalSurface

int ImFont::MetricsTotalSurface

Referenced by ImFont(), AddGlyph(), ClearOutputData(), and ShowFont().

Scale

float ImFont::Scale

Referenced by ImFont(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), ImGui::InputTextEx(), ImGui::SetCurrentFont(), and ShowFont().

Used4kPagesMap

ImU8 ImFont::Used4kPagesMap[(IM_UNICODE_CODEPOINT_MAX+1)/4096/8]

Referenced by ImFont(), BuildLookupTable(), and IsGlyphRangeUnused().

---

The documentation for this struct was generated from the following files:

• src/imgui/imgui.h
• src/imgui/imgui_draw.cpp