imgui_tables.cpp File Reference

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

Include dependency graph for imgui_tables.cpp:

Go to the source code of this file.

Macros
#define	IMGUI_DEFINE_MATH_OPERATORS

Functions
ImGuiTableFlags	TableFixFlags (ImGuiTableFlags flags, ImGuiWindow *outer_window)
static void	TableSetupColumnFlags (ImGuiTable *table, ImGuiTableColumn *column, ImGuiTableColumnFlags flags_in)
static ImGuiSortDirection	TableGetColumnAvailSortDirection (ImGuiTableColumn *column, int n)
	IM_STATIC_ASSERT (ImGuiSortDirection_None==0 &&ImGuiSortDirection_Ascending==1 &&ImGuiSortDirection_Descending==2)
static void	TableSettingsInit (ImGuiTableSettings *settings, ImGuiID id, int columns_count, int columns_count_max)
static size_t	TableSettingsCalcChunkSize (int columns_count)
static void	TableSettingsHandler_ClearAll (ImGuiContext *ctx, ImGuiSettingsHandler *)
static void	TableSettingsHandler_ApplyAll (ImGuiContext *ctx, ImGuiSettingsHandler *)
static void *	TableSettingsHandler_ReadOpen (ImGuiContext *, ImGuiSettingsHandler *, const char *name)
static void	TableSettingsHandler_ReadLine (ImGuiContext *, ImGuiSettingsHandler *, void *entry, const char *line)
static void	TableSettingsHandler_WriteAll (ImGuiContext *ctx, ImGuiSettingsHandler *handler, ImGuiTextBuffer *buf)
static const char *	DebugNodeTableGetSizingPolicyDesc (ImGuiTableFlags sizing_policy)
static float	GetDraggedColumnOffset (ImGuiOldColumns *columns, int column_index)
static float	GetColumnWidthEx (ImGuiOldColumns *columns, int column_index, bool before_resize=false)

Variables
static const int	TABLE_DRAW_CHANNEL_BG0 = 0
static const int	TABLE_DRAW_CHANNEL_BG2_FROZEN = 1
static const int	TABLE_DRAW_CHANNEL_NOCLIP = 2
static const float	TABLE_BORDER_SIZE = 1.0f
static const float	TABLE_RESIZE_SEPARATOR_HALF_THICKNESS = 4.0f
static const float	TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER = 0.06f
static const float	COLUMNS_HIT_RECT_HALF_WIDTH = 4.0f

Macro Definition Documentation

IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

Function Documentation

DebugNodeTableGetSizingPolicyDesc()

static const char * DebugNodeTableGetSizingPolicyDesc ( ImGuiTableFlags  sizing_policy )

static

{
    sizing_policy &= ImGuiTableFlags_SizingMask_;
    if (sizing_policy == ImGuiTableFlags_SizingFixedFit)    { return "FixedFit"; }
    if (sizing_policy == ImGuiTableFlags_SizingFixedSame)   { return "FixedSame"; }
    if (sizing_policy == ImGuiTableFlags_SizingStretchProp) { return "StretchProp"; }
    if (sizing_policy == ImGuiTableFlags_SizingStretchSame) { return "StretchSame"; }
    return "N/A";
}

References ImGuiTableFlags_SizingFixedFit, ImGuiTableFlags_SizingFixedSame, ImGuiTableFlags_SizingMask_, ImGuiTableFlags_SizingStretchProp, and ImGuiTableFlags_SizingStretchSame.

Referenced by ImGui::DebugNodeTable().

Here is the caller graph for this function:

GetColumnWidthEx()

static float GetColumnWidthEx ( ImGuiOldColumns *  columns, int  column_index, bool  before_resize = false  )

static

{
    if (column_index < 0)
        column_index = columns->Current;
 
    float offset_norm;
    if (before_resize)
        offset_norm = columns->Columns[column_index + 1].OffsetNormBeforeResize - columns->Columns[column_index].OffsetNormBeforeResize;
    else
        offset_norm = columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm;
    return ImGui::GetColumnOffsetFromNorm(columns, offset_norm);
}

References ImGuiOldColumns::Columns, ImGuiOldColumns::Current, and ImGui::GetColumnOffsetFromNorm().

Referenced by ImGui::SetColumnOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDraggedColumnOffset()

static float GetDraggedColumnOffset ( ImGuiOldColumns *  columns, int  column_index  )

static

{
    // Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
    // window creates a feedback loop because we store normalized positions. So while dragging we enforce absolute positioning.
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(column_index > 0); // We are not supposed to drag column 0.
    IM_ASSERT(g.ActiveId == columns->ID + ImGuiID(column_index));
 
    float x = g.IO.MousePos.x - g.ActiveIdClickOffset.x + COLUMNS_HIT_RECT_HALF_WIDTH - window->Pos.x;
    x = ImMax(x, ImGui::GetColumnOffset(column_index - 1) + g.Style.ColumnsMinSpacing);
    if ((columns->Flags & ImGuiOldColumnFlags_NoPreserveWidths))
        x = ImMin(x, ImGui::GetColumnOffset(column_index + 1) - g.Style.ColumnsMinSpacing);
 
    return x;
}

References ImGuiContext::ActiveId, ImGuiContext::ActiveIdClickOffset, COLUMNS_HIT_RECT_HALF_WIDTH, ImGuiStyle::ColumnsMinSpacing, ImGuiContext::CurrentWindow, ImGuiOldColumns::Flags, ImGui::GetColumnOffset(), GImGui, ImGuiOldColumns::ID, IM_ASSERT, ImGuiOldColumnFlags_NoPreserveWidths, ImMax(), ImMin(), ImGuiContext::IO, ImGuiIO::MousePos, ImGuiWindow::Pos, ImGuiContext::Style, and ImVec2::x.

Referenced by ImGui::EndColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

IM_STATIC_ASSERT()

IM_STATIC_ASSERT

(

ImGuiSortDirection_None

= =0 &&ImGuiSortDirection_Ascending==1 &&ImGuiSortDirection_Descending==2

)

TableFixFlags()

ImGuiTableFlags TableFixFlags ( ImGuiTableFlags  flags, ImGuiWindow *  outer_window  )

inline

{
    // Adjust flags: set default sizing policy
    if ((flags & ImGuiTableFlags_SizingMask_) == 0)
        flags |= ((flags & ImGuiTableFlags_ScrollX) || (outer_window->Flags & ImGuiWindowFlags_AlwaysAutoResize)) ? ImGuiTableFlags_SizingFixedFit : ImGuiTableFlags_SizingStretchSame;
 
    // Adjust flags: enable NoKeepColumnsVisible when using ImGuiTableFlags_SizingFixedSame
    if ((flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedSame)
        flags |= ImGuiTableFlags_NoKeepColumnsVisible;
 
    // Adjust flags: enforce borders when resizable
    if (flags & ImGuiTableFlags_Resizable)
        flags |= ImGuiTableFlags_BordersInnerV;
 
    // Adjust flags: disable NoHostExtendX/NoHostExtendY if we have any scrolling going on
    if (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY))
        flags &= ~(ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_NoHostExtendY);
 
    // Adjust flags: NoBordersInBodyUntilResize takes priority over NoBordersInBody
    if (flags & ImGuiTableFlags_NoBordersInBodyUntilResize)
        flags &= ~ImGuiTableFlags_NoBordersInBody;
 
    // Adjust flags: disable saved settings if there's nothing to save
    if ((flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Hideable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Sortable)) == 0)
        flags |= ImGuiTableFlags_NoSavedSettings;
 
    // Inherit _NoSavedSettings from top-level window (child windows always have _NoSavedSettings set)
#ifdef IMGUI_HAS_DOCK
    ImGuiWindow* window_for_settings = outer_window->RootWindowDockStop;
#else
    ImGuiWindow* window_for_settings = outer_window->RootWindow;
#endif
    if (window_for_settings->Flags & ImGuiWindowFlags_NoSavedSettings)
        flags |= ImGuiTableFlags_NoSavedSettings;
 
    return flags;
}

References ImGuiWindow::Flags, ImGuiTableFlags_BordersInnerV, ImGuiTableFlags_Hideable, ImGuiTableFlags_NoBordersInBodyUntilResize, ImGuiTableFlags_NoHostExtendX, ImGuiTableFlags_NoHostExtendY, ImGuiTableFlags_NoKeepColumnsVisible, ImGuiTableFlags_NoSavedSettings, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImGuiTableFlags_ScrollX, ImGuiTableFlags_ScrollY, ImGuiTableFlags_SizingFixedFit, ImGuiTableFlags_SizingFixedSame, ImGuiTableFlags_SizingMask_, ImGuiTableFlags_SizingStretchSame, ImGuiTableFlags_Sortable, ImGuiWindowFlags_AlwaysAutoResize, ImGuiWindowFlags_NoSavedSettings, and ImGuiWindow::RootWindow.

Referenced by ImGui::BeginTableEx().

Here is the caller graph for this function:

TableGetColumnAvailSortDirection()

static ImGuiSortDirection TableGetColumnAvailSortDirection ( ImGuiTableColumn *  column, int  n  )

inlinestatic

{
    IM_ASSERT(n < column->SortDirectionsAvailCount);
    return (column->SortDirectionsAvailList >> (n << 1)) & 0x03;
}

References IM_ASSERT, and ImGuiTableColumn::SortDirectionsAvailList.

Referenced by ImGui::TableFixColumnSortDirection(), ImGui::TableGetColumnNextSortDirection(), and ImGui::TableSortSpecsSanitize().

Here is the caller graph for this function:

TableSettingsCalcChunkSize()

static size_t TableSettingsCalcChunkSize ( int  columns_count )

static

{
    return sizeof(ImGuiTableSettings) + (size_t)columns_count * sizeof(ImGuiTableColumnSettings);
}

Referenced by ImGui::TableGcCompactSettings(), and ImGui::TableSettingsCreate().

Here is the caller graph for this function:

TableSettingsHandler_ApplyAll()

static void TableSettingsHandler_ApplyAll ( ImGuiContext *  ctx, ImGuiSettingsHandler *    )

static

{
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Tables.GetSize(); i++)
    {
        ImGuiTable* table = g.Tables.GetByIndex(i);
        table->IsSettingsRequestLoad = true;
        table->SettingsOffset = -1;
    }
}

References ImPool< T >::GetByIndex(), ImPool< T >::GetSize(), ImGuiTable::IsSettingsRequestLoad, ImGuiTable::SettingsOffset, and ImGuiContext::Tables.

Referenced by ImGui::TableSettingsInstallHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

TableSettingsHandler_ClearAll()

static void TableSettingsHandler_ClearAll ( ImGuiContext *  ctx, ImGuiSettingsHandler *    )

static

{
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Tables.GetSize(); i++)
        g.Tables.GetByIndex(i)->SettingsOffset = -1;
    g.SettingsTables.clear();
}

References ImChunkStream< T >::clear(), ImPool< T >::GetByIndex(), ImPool< T >::GetSize(), ImGuiTable::SettingsOffset, ImGuiContext::SettingsTables, and ImGuiContext::Tables.

Referenced by ImGui::TableSettingsInstallHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

TableSettingsHandler_ReadLine()

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

static

{
    // "Column 0  UserID=0x42AD2D21 Width=100 Visible=1 Order=0 Sort=0v"
    ImGuiTableSettings* settings = (ImGuiTableSettings*)entry;
    float f = 0.0f;
    int column_n = 0, r = 0, n = 0;
 
    if (sscanf(line, "RefScale=%f", &f) == 1) { settings->RefScale = f; return; }
 
    if (sscanf(line, "Column %d%n", &column_n, &r) == 1)
    {
        if (column_n < 0 || column_n >= settings->ColumnsCount)
            return;
        line = ImStrSkipBlank(line + r);
        char c = 0;
        ImGuiTableColumnSettings* column = settings->GetColumnSettings() + column_n;
        column->Index = (ImGuiTableColumnIdx)column_n;
        if (sscanf(line, "UserID=0x%08X%n", (ImU32*)&n, &r)==1) { line = ImStrSkipBlank(line + r); column->UserID = (ImGuiID)n; }
        if (sscanf(line, "Width=%d%n", &n, &r) == 1)            { line = ImStrSkipBlank(line + r); column->WidthOrWeight = (float)n; column->IsStretch = 0; settings->SaveFlags |= ImGuiTableFlags_Resizable; }
        if (sscanf(line, "Weight=%f%n", &f, &r) == 1)           { line = ImStrSkipBlank(line + r); column->WidthOrWeight = f; column->IsStretch = 1; settings->SaveFlags |= ImGuiTableFlags_Resizable; }
        if (sscanf(line, "Visible=%d%n", &n, &r) == 1)          { line = ImStrSkipBlank(line + r); column->IsEnabled = (ImU8)n; settings->SaveFlags |= ImGuiTableFlags_Hideable; }
        if (sscanf(line, "Order=%d%n", &n, &r) == 1)            { line = ImStrSkipBlank(line + r); column->DisplayOrder = (ImGuiTableColumnIdx)n; settings->SaveFlags |= ImGuiTableFlags_Reorderable; }
        if (sscanf(line, "Sort=%d%c%n", &n, &c, &r) == 2)       { line = ImStrSkipBlank(line + r); column->SortOrder = (ImGuiTableColumnIdx)n; column->SortDirection = (c == '^') ? ImGuiSortDirection_Descending : ImGuiSortDirection_Ascending; settings->SaveFlags |= ImGuiTableFlags_Sortable; }
    }
}

References ImGuiTableSettings::ColumnsCount, ImGuiTableColumnSettings::DisplayOrder, ImGuiTableSettings::GetColumnSettings(), ImGuiSortDirection_Ascending, ImGuiSortDirection_Descending, ImGuiTableFlags_Hideable, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImGuiTableFlags_Sortable, ImStrSkipBlank(), ImGuiTableColumnSettings::Index, ImGuiTableColumnSettings::IsEnabled, ImGuiTableColumnSettings::IsStretch, ImGuiTableSettings::RefScale, ImGuiTableSettings::SaveFlags, ImGuiTableColumnSettings::SortDirection, ImGuiTableColumnSettings::SortOrder, ImGuiTableColumnSettings::UserID, and ImGuiTableColumnSettings::WidthOrWeight.

Referenced by ImGui::TableSettingsInstallHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

TableSettingsHandler_ReadOpen()

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

static

{
    ImGuiID id = 0;
    int columns_count = 0;
    if (sscanf(name, "0x%08X,%d", &id, &columns_count) < 2)
        return NULL;
 
    if (ImGuiTableSettings* settings = ImGui::TableSettingsFindByID(id))
    {
        if (settings->ColumnsCountMax >= columns_count)
        {
            TableSettingsInit(settings, id, columns_count, settings->ColumnsCountMax); // Recycle
            return settings;
        }
        settings->ID = 0; // Invalidate storage, we won't fit because of a count change
    }
    return ImGui::TableSettingsCreate(id, columns_count);
}

References ImGui::TableSettingsCreate(), ImGui::TableSettingsFindByID(), and TableSettingsInit().

Referenced by ImGui::TableSettingsInstallHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

TableSettingsHandler_WriteAll()

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

static

{
    ImGuiContext& g = *ctx;
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
    {
        if (settings->ID == 0) // Skip ditched settings
            continue;
 
        // TableSaveSettings() may clear some of those flags when we establish that the data can be stripped
        // (e.g. Order was unchanged)
        const bool save_size    = (settings->SaveFlags & ImGuiTableFlags_Resizable) != 0;
        const bool save_visible = (settings->SaveFlags & ImGuiTableFlags_Hideable) != 0;
        const bool save_order   = (settings->SaveFlags & ImGuiTableFlags_Reorderable) != 0;
        const bool save_sort    = (settings->SaveFlags & ImGuiTableFlags_Sortable) != 0;
        if (!save_size && !save_visible && !save_order && !save_sort)
            continue;
 
        buf->reserve(buf->size() + 30 + settings->ColumnsCount * 50); // ballpark reserve
        buf->appendf("[%s][0x%08X,%d]\n", handler->TypeName, settings->ID, settings->ColumnsCount);
        if (settings->RefScale != 0.0f)
            buf->appendf("RefScale=%g\n", settings->RefScale);
        ImGuiTableColumnSettings* column = settings->GetColumnSettings();
        for (int column_n = 0; column_n < settings->ColumnsCount; column_n++, column++)
        {
            // "Column 0  UserID=0x42AD2D21 Width=100 Visible=1 Order=0 Sort=0v"
            bool save_column = column->UserID != 0 || save_size || save_visible || save_order || (save_sort && column->SortOrder != -1);
            if (!save_column)
                continue;
            buf->appendf("Column %-2d", column_n);
            if (column->UserID != 0)                    buf->appendf(" UserID=%08X", column->UserID);
            if (save_size && column->IsStretch)         buf->appendf(" Weight=%.4f", column->WidthOrWeight);
            if (save_size && !column->IsStretch)        buf->appendf(" Width=%d", (int)column->WidthOrWeight);
            if (save_visible)                           buf->appendf(" Visible=%d", column->IsEnabled);
            if (save_order)                             buf->appendf(" Order=%d", column->DisplayOrder);
            if (save_sort && column->SortOrder != -1)   buf->appendf(" Sort=%d%c", column->SortOrder, (column->SortDirection == ImGuiSortDirection_Ascending) ? 'v' : '^');
            buf->append("\n");
        }
        buf->append("\n");
    }
}

References ImGuiTextBuffer::append(), ImGuiTextBuffer::appendf(), ImChunkStream< T >::begin(), ImGuiTableColumnSettings::DisplayOrder, ImGuiSortDirection_Ascending, ImGuiTableFlags_Hideable, ImGuiTableFlags_Reorderable, ImGuiTableFlags_Resizable, ImGuiTableFlags_Sortable, ImGuiTableColumnSettings::IsEnabled, ImGuiTableColumnSettings::IsStretch, ImChunkStream< T >::next_chunk(), ImGuiTextBuffer::reserve(), ImGuiContext::SettingsTables, ImGuiTextBuffer::size(), ImGuiTableColumnSettings::SortDirection, ImGuiTableColumnSettings::SortOrder, ImGuiSettingsHandler::TypeName, ImGuiTableColumnSettings::UserID, and ImGuiTableColumnSettings::WidthOrWeight.

Referenced by ImGui::TableSettingsInstallHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

TableSettingsInit()

static void TableSettingsInit ( ImGuiTableSettings *  settings, ImGuiID  id, int  columns_count, int  columns_count_max  )

static

{
    IM_PLACEMENT_NEW(settings) ImGuiTableSettings();
    ImGuiTableColumnSettings* settings_column = settings->GetColumnSettings();
    for (int n = 0; n < columns_count_max; n++, settings_column++)
        IM_PLACEMENT_NEW(settings_column) ImGuiTableColumnSettings();
    settings->ID = id;
    settings->ColumnsCount = (ImGuiTableColumnIdx)columns_count;
    settings->ColumnsCountMax = (ImGuiTableColumnIdx)columns_count_max;
    settings->WantApply = true;
}

References ImGuiTableSettings::ColumnsCount, ImGuiTableSettings::ColumnsCountMax, ImGuiTableSettings::GetColumnSettings(), ImGuiTableSettings::ID, IM_PLACEMENT_NEW, and ImGuiTableSettings::WantApply.

Referenced by ImGui::TableSettingsCreate(), and TableSettingsHandler_ReadOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

TableSetupColumnFlags()

static void TableSetupColumnFlags ( ImGuiTable *  table, ImGuiTableColumn *  column, ImGuiTableColumnFlags  flags_in  )

static

{
    ImGuiTableColumnFlags flags = flags_in;
 
    // Sizing Policy
    if ((flags & ImGuiTableColumnFlags_WidthMask_) == 0)
    {
        const ImGuiTableFlags table_sizing_policy = (table->Flags & ImGuiTableFlags_SizingMask_);
        if (table_sizing_policy == ImGuiTableFlags_SizingFixedFit || table_sizing_policy == ImGuiTableFlags_SizingFixedSame)
            flags |= ImGuiTableColumnFlags_WidthFixed;
        else
            flags |= ImGuiTableColumnFlags_WidthStretch;
    }
    else
    {
        IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiTableColumnFlags_WidthMask_)); // Check that only 1 of each set is used.
    }
 
    // Resize
    if ((table->Flags & ImGuiTableFlags_Resizable) == 0)
        flags |= ImGuiTableColumnFlags_NoResize;
 
    // Sorting
    if ((flags & ImGuiTableColumnFlags_NoSortAscending) && (flags & ImGuiTableColumnFlags_NoSortDescending))
        flags |= ImGuiTableColumnFlags_NoSort;
 
    // Indentation
    if ((flags & ImGuiTableColumnFlags_IndentMask_) == 0)
        flags |= (table->Columns.index_from_ptr(column) == 0) ? ImGuiTableColumnFlags_IndentEnable : ImGuiTableColumnFlags_IndentDisable;
 
    // Alignment
    //if ((flags & ImGuiTableColumnFlags_AlignMask_) == 0)
    //    flags |= ImGuiTableColumnFlags_AlignCenter;
    //IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiTableColumnFlags_AlignMask_)); // Check that only 1 of each set is used.
 
    // Preserve status flags
    column->Flags = flags | (column->Flags & ImGuiTableColumnFlags_StatusMask_);
 
    // Build an ordered list of available sort directions
    column->SortDirectionsAvailCount = column->SortDirectionsAvailMask = column->SortDirectionsAvailList = 0;
    if (table->Flags & ImGuiTableFlags_Sortable)
    {
        int count = 0, mask = 0, list = 0;
        if ((flags & ImGuiTableColumnFlags_PreferSortAscending)  != 0 && (flags & ImGuiTableColumnFlags_NoSortAscending)  == 0) { mask |= 1 << ImGuiSortDirection_Ascending;  list |= ImGuiSortDirection_Ascending  << (count << 1); count++; }
        if ((flags & ImGuiTableColumnFlags_PreferSortDescending) != 0 && (flags & ImGuiTableColumnFlags_NoSortDescending) == 0) { mask |= 1 << ImGuiSortDirection_Descending; list |= ImGuiSortDirection_Descending << (count << 1); count++; }
        if ((flags & ImGuiTableColumnFlags_PreferSortAscending)  == 0 && (flags & ImGuiTableColumnFlags_NoSortAscending)  == 0) { mask |= 1 << ImGuiSortDirection_Ascending;  list |= ImGuiSortDirection_Ascending  << (count << 1); count++; }
        if ((flags & ImGuiTableColumnFlags_PreferSortDescending) == 0 && (flags & ImGuiTableColumnFlags_NoSortDescending) == 0) { mask |= 1 << ImGuiSortDirection_Descending; list |= ImGuiSortDirection_Descending << (count << 1); count++; }
        if ((table->Flags & ImGuiTableFlags_SortTristate) || count == 0) { mask |= 1 << ImGuiSortDirection_None; count++; }
        column->SortDirectionsAvailList = (ImU8)list;
        column->SortDirectionsAvailMask = (ImU8)mask;
        column->SortDirectionsAvailCount = (ImU8)count;
        ImGui::TableFixColumnSortDirection(table, column);
    }
}

References ImGuiTable::Columns, ImGuiTableColumn::Flags, ImGuiTable::Flags, IM_ASSERT, ImGuiSortDirection_Ascending, ImGuiSortDirection_Descending, ImGuiSortDirection_None, ImGuiTableColumnFlags_IndentDisable, ImGuiTableColumnFlags_IndentEnable, ImGuiTableColumnFlags_IndentMask_, ImGuiTableColumnFlags_NoResize, ImGuiTableColumnFlags_NoSort, ImGuiTableColumnFlags_NoSortAscending, ImGuiTableColumnFlags_NoSortDescending, ImGuiTableColumnFlags_PreferSortAscending, ImGuiTableColumnFlags_PreferSortDescending, ImGuiTableColumnFlags_StatusMask_, ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_WidthMask_, ImGuiTableColumnFlags_WidthStretch, ImGuiTableFlags_Resizable, ImGuiTableFlags_SizingFixedFit, ImGuiTableFlags_SizingFixedSame, ImGuiTableFlags_SizingMask_, ImGuiTableFlags_Sortable, ImGuiTableFlags_SortTristate, ImIsPowerOfTwo(), ImSpan< T >::index_from_ptr(), ImGuiTableColumn::SortDirectionsAvailCount, ImGuiTableColumn::SortDirectionsAvailList, ImGuiTableColumn::SortDirectionsAvailMask, and ImGui::TableFixColumnSortDirection().

Referenced by ImGui::TableSetupColumn(), and ImGui::TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

COLUMNS_HIT_RECT_HALF_WIDTH

const float COLUMNS_HIT_RECT_HALF_WIDTH = 4.0f

static

Referenced by ImGui::EndColumns(), and GetDraggedColumnOffset().

TABLE_BORDER_SIZE

const float TABLE_BORDER_SIZE = 1.0f

static

Referenced by ImGui::BeginTableEx(), ImGui::EndTable(), ImGui::TableDrawBorders(), ImGui::TableEndRow(), and ImGui::TableUpdateLayout().

TABLE_DRAW_CHANNEL_BG0

const int TABLE_DRAW_CHANNEL_BG0 = 0

static

Referenced by ImGui::TableDrawBorders(), and ImGui::TableEndRow().

TABLE_DRAW_CHANNEL_BG2_FROZEN

const int TABLE_DRAW_CHANNEL_BG2_FROZEN = 1

static

Referenced by ImGui::TableMergeDrawChannels(), and ImGui::TableSetupDrawChannels().

TABLE_DRAW_CHANNEL_NOCLIP

const int TABLE_DRAW_CHANNEL_NOCLIP = 2

static

Referenced by ImGui::TableBeginCell(), and ImGui::TableUpdateLayout().

TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER

const float TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER = 0.06f

static

Referenced by ImGui::TableUpdateBorders().

TABLE_RESIZE_SEPARATOR_HALF_THICKNESS

const float TABLE_RESIZE_SEPARATOR_HALF_THICKNESS = 4.0f

static

Referenced by ImGui::EndTable(), and ImGui::TableUpdateBorders().