From 23c60b2814da9a4fb2b4b7ff1bcbcd5704256c67 Mon Sep 17 00:00:00 2001 From: omar Date: Thu, 14 May 2020 17:57:25 +0200 Subject: [PATCH] Tables: Renamed internal fields: Active->Visible, Visible->VisibleUnclipped to be less misleading. --- imgui.h | 2 +- imgui_internal.h | 32 ++++----- imgui_tables.cpp | 165 ++++++++++++++++++++++++----------------------- 3 files changed, 100 insertions(+), 99 deletions(-) diff --git a/imgui.h b/imgui.h index f559da62..122facf4 100644 --- a/imgui.h +++ b/imgui.h @@ -687,7 +687,7 @@ namespace ImGui // - Use TableSetupColumn() to specify label, resizing policy, default width, id, various other flags etc. // - The name passed to TableSetupColumn() is used by TableAutoHeaders() and by the context-menu // - Use TableAutoHeaders() to submit the whole header row, otherwise you may treat the header row as a regular row, manually call TableHeader() and other widgets. - // - Headers are required to perform some interactions: reordering, sorting, context menu // FIXME-TABLE: remove context from this list! + // - Headers are required to perform some interactions: reordering, sorting, context menu (FIXME-TABLE: context menu should work without!) IMGUI_API void TableSetupColumn(const char* label, ImGuiTableColumnFlags flags = 0, float init_width_or_weight = -1.0f, ImU32 user_id = 0); IMGUI_API void TableAutoHeaders(); // submit all headers cells based on data provided to TableSetupColumn() + submit context menu IMGUI_API void TableHeader(const char* label); // submit one header cell manually. diff --git a/imgui_internal.h b/imgui_internal.h index 1d5b7020..d8d05245 100644 --- a/imgui_internal.h +++ b/imgui_internal.h @@ -1888,7 +1888,7 @@ struct ImGuiTabBar #define IMGUI_TABLE_MAX_DRAW_CHANNELS (2 + 64 * 2) // See TableUpdateDrawChannels() // [Internal] sizeof() ~ 100 -// We use the terminology "Active" to refer to a column that is not Hidden by user or programmatically. We don't use the term "Visible" because it is ambiguous since an Active column can be non-visible because of scrolling. +// We use the terminology "Visible" to refer to a column that is not Hidden by user or settings. However it may still be out of view and clipped (see IsClipped). struct ImGuiTableColumn { ImRect ClipRect; // Clipping rectangle for the column @@ -1911,17 +1911,17 @@ struct ImGuiTableColumn ImS16 ContentWidthHeadersUsed; // TableHeader() automatically softclip itself + report ideal desired size, to avoid creating extraneous draw calls ImS16 ContentWidthHeadersIdeal; ImS16 NameOffset; // Offset into parent ColumnsNames[] - bool IsActive; // Is the column not marked Hidden by the user (regardless of clipping). We're not calling this "Visible" here because visibility also depends on clipping. - bool IsActiveNextFrame; - bool IsClipped; // Set when not overlapping the host window clipping rectangle. We don't use the opposite "!Visible" name because Clipped can be altered by events. + bool IsVisible; // Is the column not marked Hidden by the user? (could be clipped by scrolling, etc). + bool IsVisibleNextFrame; + bool IsClipped; // Set when not overlapping the host window clipping rectangle. bool SkipItems; ImS8 DisplayOrder; // Index within Table's IndexToDisplayOrder[] (column may be reordered by users) - ImS8 IndexWithinActiveSet; // Index within active/visible set (<= IndexToDisplayOrder) + ImS8 IndexWithinVisibleSet; // Index within visible set (<= IndexToDisplayOrder) ImS8 DrawChannelCurrent; // Index within DrawSplitter.Channels[] ImS8 DrawChannelRowsBeforeFreeze; ImS8 DrawChannelRowsAfterFreeze; - ImS8 PrevActiveColumn; // Index of prev active column within Columns[], -1 if first active column - ImS8 NextActiveColumn; // Index of next active column within Columns[], -1 if last active column + ImS8 PrevVisibleColumn; // Index of prev visible column within Columns[], -1 if first visible column + ImS8 NextVisibleColumn; // Index of next visible column within Columns[], -1 if last visible column ImS8 AutoFitQueue; // Queue of 8 values for the next 8 frames to request auto-fit ImS8 CannotSkipItemsQueue; // Queue of 8 values for the next 8 frames to disable Clipped/SkipItem ImS8 SortOrder; // -1: Not sorting on this column @@ -1932,10 +1932,10 @@ struct ImGuiTableColumn memset(this, 0, sizeof(*this)); ResizeWeight = WidthRequested = WidthGiven = -1.0f; NameOffset = -1; - IsActive = IsActiveNextFrame = true; - DisplayOrder = IndexWithinActiveSet = -1; + IsVisible = IsVisibleNextFrame = true; + DisplayOrder = IndexWithinVisibleSet = -1; DrawChannelCurrent = DrawChannelRowsBeforeFreeze = DrawChannelRowsAfterFreeze = -1; - PrevActiveColumn = NextActiveColumn = -1; + PrevVisibleColumn = NextVisibleColumn = -1; AutoFitQueue = CannotSkipItemsQueue = (1 << 3) - 1; // Skip for three frames SortOrder = -1; SortDirection = ImGuiSortDirection_Ascending; @@ -1949,14 +1949,14 @@ struct ImGuiTable ImVector RawData; ImSpan Columns; // Point within RawData[] ImSpan DisplayOrderToIndex; // Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1) - ImU64 ActiveMaskByIndex; // Column Index -> IsActive map (Active == not hidden by user/api) in a format adequate for iterating column without touching cold data - ImU64 ActiveMaskByDisplayOrder; // Column DisplayOrder -> IsActive map - ImU64 VisibleMaskByIndex; // Visible (== Active and not Clipped) + ImU64 VisibleMaskByIndex; // Column Index -> IsVisible map (== not hidden by user/api) in a format adequate for iterating column without touching cold data + ImU64 VisibleMaskByDisplayOrder; // Column DisplayOrder -> IsVisible map + ImU64 VisibleUnclippedMaskByIndex;// Visible and not Clipped, aka "actually visible" "not hidden by some scrolling" ImGuiTableFlags SettingsLoadedFlags; // Which data were loaded from the .ini file (e.g. when order is not altered we won't save order) int SettingsOffset; // Offset in g.SettingsTables int LastFrameActive; int ColumnsCount; // Number of columns declared in BeginTable() - int ColumnsActiveCount; // Number of non-hidden columns (<= ColumnsCount) + int ColumnsVisibleCount; // Number of non-hidden columns (<= ColumnsCount) int CurrentColumn; int CurrentRow; ImS16 InstanceCurrent; // Count of BeginTable() calls with same ID in the same frame (generally 0). This is a little bit similar to BeginCount for a window, but multiple table with same ID look are multiple tables, they are just synched. @@ -2007,7 +2007,7 @@ struct ImGuiTable ImS8 HeldHeaderColumn; // Index of column header being held. ImS8 ReorderColumn; // Index of column being reordered. (not cleared) ImS8 ReorderColumnDir; // -1 or +1 - ImS8 RightMostActiveColumn; // Index of right-most non-hidden column. + ImS8 RightMostVisibleColumn; // Index of right-most non-hidden column. ImS8 LeftMostStretchedColumnDisplayOrder; // Display order of left-most stretched column. ImS8 ContextPopupColumn; // Column right-clicked on, of -1 if opening context menu from a neutral/empty spot ImS8 DummyDrawChannel; // Redirect non-visible columns here. @@ -2049,7 +2049,7 @@ struct ImGuiTableColumnSettings ImS8 DisplayOrder; ImS8 SortOrder; ImS8 SortDirection : 7; - ImU8 Visible : 1; // This is called Active in ImGuiTableColumn, but in user-facing code we call this Visible (thus in .ini file) + ImU8 Visible : 1; ImGuiTableColumnSettings() { diff --git a/imgui_tables.cpp b/imgui_tables.cpp index 29b1c9b1..cec4ebb0 100644 --- a/imgui_tables.cpp +++ b/imgui_tables.cpp @@ -286,7 +286,7 @@ bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG table->DeclColumnsCount = 0; table->HoveredColumnBody = -1; table->HoveredColumnBorder = -1; - table->RightMostActiveColumn = -1; + table->RightMostVisibleColumn = -1; // Using opaque colors facilitate overlapping elements of the grid table->BorderColorStrong = GetColorU32(ImGuiCol_TableBorderStrong); @@ -333,7 +333,7 @@ bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG // Because we cannot safely assert in EndTable() when no rows have been created, this seems like our best option. inner_window->SkipItems = true; - // Update/lock which columns will be Active for the frame + // Update/lock which columns will be Visible for the frame TableBeginUpdateColumns(table); return true; @@ -371,7 +371,7 @@ void ImGui::TableBeginUpdateColumns(ImGuiTable* table) IM_ASSERT(reorder_dir == -1 || reorder_dir == +1); IM_ASSERT(table->Flags & ImGuiTableFlags_Reorderable); ImGuiTableColumn* src_column = &table->Columns[table->ReorderColumn]; - ImGuiTableColumn* dst_column = &table->Columns[(reorder_dir == -1) ? src_column->PrevActiveColumn : src_column->NextActiveColumn]; + ImGuiTableColumn* dst_column = &table->Columns[(reorder_dir == -1) ? src_column->PrevVisibleColumn : src_column->NextVisibleColumn]; IM_UNUSED(dst_column); const int src_order = src_column->DisplayOrder; const int dst_order = dst_column->DisplayOrder; @@ -398,10 +398,10 @@ void ImGui::TableBeginUpdateColumns(ImGuiTable* table) table->IsSettingsDirty = true; } - // Setup and lock Active state and order - table->ColumnsActiveCount = 0; + // Setup and lock Visible state and order + table->ColumnsVisibleCount = 0; table->IsDefaultDisplayOrder = true; - ImGuiTableColumn* last_active_column = NULL; + ImGuiTableColumn* last_visible_column = NULL; bool want_column_auto_fit = false; for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { @@ -411,12 +411,12 @@ void ImGui::TableBeginUpdateColumns(ImGuiTable* table) ImGuiTableColumn* column = &table->Columns[column_n]; column->NameOffset = -1; if (!(table->Flags & ImGuiTableFlags_Hideable) || (column->Flags & ImGuiTableColumnFlags_NoHide)) - column->IsActiveNextFrame = true; - if (column->IsActive != column->IsActiveNextFrame) + column->IsVisibleNextFrame = true; + if (column->IsVisible != column->IsVisibleNextFrame) { - column->IsActive = column->IsActiveNextFrame; + column->IsVisible = column->IsVisibleNextFrame; table->IsSettingsDirty = true; - if (!column->IsActive && column->SortOrder != -1) + if (!column->IsVisible && column->SortOrder != -1) table->IsSortSpecsDirty = true; } if (column->SortOrder > 0 && !(table->Flags & ImGuiTableFlags_MultiSortable)) @@ -426,30 +426,30 @@ void ImGui::TableBeginUpdateColumns(ImGuiTable* table) ImU64 index_mask = (ImU64)1 << column_n; ImU64 display_order_mask = (ImU64)1 << column->DisplayOrder; - if (column->IsActive) + if (column->IsVisible) { - column->PrevActiveColumn = column->NextActiveColumn = -1; - if (last_active_column) + column->PrevVisibleColumn = column->NextVisibleColumn = -1; + if (last_visible_column) { - last_active_column->NextActiveColumn = (ImS8)column_n; - column->PrevActiveColumn = (ImS8)table->Columns.index_from_ptr(last_active_column); + last_visible_column->NextVisibleColumn = (ImS8)column_n; + column->PrevVisibleColumn = (ImS8)table->Columns.index_from_ptr(last_visible_column); } - column->IndexWithinActiveSet = (ImS8)table->ColumnsActiveCount; - table->ColumnsActiveCount++; - table->ActiveMaskByIndex |= index_mask; - table->ActiveMaskByDisplayOrder |= display_order_mask; - last_active_column = column; + column->IndexWithinVisibleSet = (ImS8)table->ColumnsVisibleCount; + table->ColumnsVisibleCount++; + table->VisibleMaskByIndex |= index_mask; + table->VisibleMaskByDisplayOrder |= display_order_mask; + last_visible_column = column; } else { - column->IndexWithinActiveSet = -1; - table->ActiveMaskByIndex &= ~index_mask; - table->ActiveMaskByDisplayOrder &= ~display_order_mask; + column->IndexWithinVisibleSet = -1; + table->VisibleMaskByIndex &= ~index_mask; + table->VisibleMaskByDisplayOrder &= ~display_order_mask; } - IM_ASSERT(column->IndexWithinActiveSet <= column->DisplayOrder); + IM_ASSERT(column->IndexWithinVisibleSet <= column->DisplayOrder); } - table->VisibleMaskByIndex = table->ActiveMaskByIndex; // Columns will be masked out by TableUpdateLayout() when Clipped - table->RightMostActiveColumn = (ImS8)(last_active_column ? table->Columns.index_from_ptr(last_active_column) : -1); + table->VisibleUnclippedMaskByIndex = table->VisibleMaskByIndex; // Columns will be masked out by TableUpdateLayout() when Clipped + table->RightMostVisibleColumn = (ImS8)(last_visible_column ? table->Columns.index_from_ptr(last_visible_column) : -1); // Disable child window clipping while fitting columns. This is not strictly necessary but makes it possible to avoid // the column fitting to wait until the first visible frame of the child container (may or not be a good thing). @@ -473,9 +473,9 @@ void ImGui::TableUpdateDrawChannels(ImGuiTable* table) // - FreezeRows || FreezeColumns --> 1+N*2 (unless scrolling value is zero) // - FreezeRows && FreezeColunns --> 2+N*2 (unless scrolling value is zero) const int freeze_row_multiplier = (table->FreezeRowsCount > 0) ? 2 : 1; - const int channels_for_row = (table->Flags & ImGuiTableFlags_NoClipX) ? 1 : table->ColumnsActiveCount; + const int channels_for_row = (table->Flags & ImGuiTableFlags_NoClipX) ? 1 : table->ColumnsVisibleCount; const int channels_for_background = 1; - const int channels_for_dummy = (table->ColumnsActiveCount < table->ColumnsCount || table->VisibleMaskByIndex != table->ActiveMaskByIndex) ? +1 : 0; + const int channels_for_dummy = (table->ColumnsVisibleCount < table->ColumnsCount || table->VisibleUnclippedMaskByIndex != table->VisibleMaskByIndex) ? +1 : 0; const int channels_total = channels_for_background + (channels_for_row * freeze_row_multiplier) + channels_for_dummy; table->DrawSplitter.Split(table->InnerWindow->DrawList, channels_total); table->DummyDrawChannel = channels_for_dummy ? (ImS8)(channels_total - 1) : -1; @@ -568,7 +568,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) table->ColumnsAutoFitWidth = 0.0f; for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrderToIndex[order_n]; ImGuiTableColumn* column = &table->Columns[column_n]; @@ -626,11 +626,11 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) // CellSpacingX is >0.0f when there's no vertical border, in which case we add two extra CellSpacingX to make auto-fit look nice instead of cramped. // We may want to expose this somehow. - table->ColumnsAutoFitWidth += spacing_auto_x * (table->ColumnsActiveCount - 1); + table->ColumnsAutoFitWidth += spacing_auto_x * (table->ColumnsVisibleCount - 1); // Layout // Remove -1.0f to cancel out the +1.0f we are doing in EndTable() to make last column line visible - const float width_spacings = table->CellSpacingX * (table->ColumnsActiveCount - 1); + const float width_spacings = table->CellSpacingX * (table->ColumnsVisibleCount - 1); float width_avail; if ((table->Flags & ImGuiTableFlags_ScrollX) && table->InnerWidth == 0.0f) width_avail = table->InnerClipRect.GetWidth() - width_spacings - 1.0f; @@ -645,7 +645,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) table->ColumnsTotalWidth = width_spacings; for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; ImGuiTableColumn* column = &table->Columns[table->DisplayOrderToIndex[order_n]]; @@ -658,15 +658,15 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) // [Resize Rule 2] Resizing from right-side of a weighted column before a fixed column froward sizing // to left-side of fixed column. We also need to copy the NoResize flag.. - if (column->NextActiveColumn != -1) - if (ImGuiTableColumn* next_column = &table->Columns[column->NextActiveColumn]) + if (column->NextVisibleColumn != -1) + if (ImGuiTableColumn* next_column = &table->Columns[column->NextVisibleColumn]) if (next_column->Flags & ImGuiTableColumnFlags_WidthFixed) column->Flags |= (next_column->Flags & ImGuiTableColumnFlags_NoDirectResize_); } - // [Resize Rule 1] The right-most active column is not resizable if there is at least one Stretch column - // (see comments in TableResizeColumn().) - if (column->NextActiveColumn == -1 && table->LeftMostStretchedColumnDisplayOrder != -1) + // [Resize Rule 1] The right-most Visible column is not resizable if there is at least one Stretch column + // (see comments in TableResizeColumn()) + if (column->NextVisibleColumn == -1 && table->LeftMostStretchedColumnDisplayOrder != -1) column->Flags |= ImGuiTableColumnFlags_NoDirectResize_; if (!(column->Flags & ImGuiTableColumnFlags_NoResize)) @@ -684,15 +684,15 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) // Shrink widths when the total does not fit // FIXME-TABLE: This is working but confuses/conflicts with manual resizing. // FIXME-TABLE: Policy to shrink down below below ideal/requested width if there's no room? - g.ShrinkWidthBuffer.resize(table->ColumnsActiveCount); - for (int order_n = 0, active_n = 0; order_n < table->ColumnsCount; order_n++) + g.ShrinkWidthBuffer.resize(table->ColumnsVisibleCount); + for (int order_n = 0, visible_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrder[order_n]; - g.ShrinkWidthBuffer[active_n].Index = column_n; - g.ShrinkWidthBuffer[active_n].Width = table->Columns[column_n].WidthGiven; - active_n++; + g.ShrinkWidthBuffer[visible_n].Index = column_n; + g.ShrinkWidthBuffer[visible_n].Width = table->Columns[column_n].WidthGiven; + visible_n++; } ShrinkWidths(g.ShrinkWidthBuffer.Data, g.ShrinkWidthBuffer.Size, width_excess); for (int n = 0; n < g.ShrinkWidthBuffer.Size; n++) @@ -710,7 +710,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) if (width_remaining_for_stretched_columns >= 1.0f) for (int order_n = table->ColumnsCount - 1; total_weights > 0.0f && width_remaining_for_stretched_columns >= 1.0f && order_n >= 0; order_n--) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; ImGuiTableColumn* column = &table->Columns[table->DisplayOrderToIndex[order_n]]; if (!(column->Flags & ImGuiTableColumnFlags_WidthStretch)) @@ -721,7 +721,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) } // Setup final position, offset and clipping rectangles - int active_n = 0; + int visible_n = 0; float offset_x = (table->FreezeColumnsCount > 0) ? table->OuterRect.Min.x : work_rect.Min.x; ImRect host_clip_rect = table->InnerClipRect; for (int order_n = 0; order_n < table->ColumnsCount; order_n++) @@ -729,10 +729,10 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) const int column_n = table->DisplayOrderToIndex[order_n]; ImGuiTableColumn* column = &table->Columns[column_n]; - if (table->FreezeColumnsCount > 0 && table->FreezeColumnsCount == active_n) + if (table->FreezeColumnsCount > 0 && table->FreezeColumnsCount == visible_n) offset_x += work_rect.Min.x - table->OuterRect.Min.x; - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) { // Hidden column: clear a few fields and we are done with it for the remainder of the function. // We set a zero-width clip rect but set Min.y/Max.y properly to not interfere with the clipper. @@ -761,7 +761,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) // sure they are all visible. Because of this we also know that all of the columns will always fit in // table->WorkRect and therefore in table->InnerRect (because ScrollX is off) if (!(table->Flags & ImGuiTableFlags_NoKeepColumnsVisible)) - max_x = table->WorkRect.Max.x - (table->ColumnsActiveCount - (column->IndexWithinActiveSet + 1)) * min_column_width; + max_x = table->WorkRect.Max.x - (table->ColumnsVisibleCount - (column->IndexWithinVisibleSet + 1)) * min_column_width; } if (offset_x + column->WidthGiven > max_x) column->WidthGiven = ImMax(max_x - offset_x, min_column_width); @@ -781,7 +781,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) if (column->IsClipped) { // Columns with the _WidthAlwaysAutoResize sizing policy will never be updated then. - table->VisibleMaskByIndex &= ~((ImU64)1 << column_n); + table->VisibleUnclippedMaskByIndex &= ~((ImU64)1 << column_n); } else { @@ -810,11 +810,11 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) column->CannotSkipItemsQueue >>= 1; } - if (active_n < table->FreezeColumnsCount) + if (visible_n < table->FreezeColumnsCount) host_clip_rect.Min.x = ImMax(host_clip_rect.Min.x, column->MaxX + 2.0f); offset_x += column->WidthGiven + table->CellSpacingX; - active_n++; + visible_n++; } // Clear Resizable flag if none of our column are actually resizable (either via an explicit _NoResize flag, @@ -879,7 +879,7 @@ void ImGui::TableUpdateBorders(ImGuiTable* table) for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrderToIndex[order_n]; @@ -1033,7 +1033,7 @@ void ImGui::EndTable() column->ContentWidthHeadersIdeal = (ImS16)ImMax(0.0f, column->ContentMaxPosHeadersIdeal - ref_x_headers); // Add an extra 1 pixel so we can see the last column vertical line if it lies on the right-most edge. - if (table->ActiveMaskByIndex & ((ImU64)1 << column_n)) + if (table->VisibleMaskByIndex & ((ImU64)1 << column_n)) max_pos_x = ImMax(max_pos_x, column->MaxX + 1.0f); } @@ -1094,7 +1094,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table) { for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrderToIndex[order_n]; @@ -1103,7 +1103,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table) const bool is_resized = (table->ResizedColumn == column_n) && (table->InstanceInteracted == table->InstanceCurrent); const bool is_resizable = (column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_NoDirectResize_)) == 0; bool draw_right_border = (column->MaxX <= table->InnerClipRect.Max.x) || (is_resized || is_hovered); - if (column->NextActiveColumn == -1 && !is_resizable) + if (column->NextVisibleColumn == -1 && !is_resizable) draw_right_border = false; if (draw_right_border && column->MaxX > column->ClipRect.Min.x) // FIXME-TABLE FIXME-STYLE: Assume BorderSize==1, this is problematic if we want to increase the border size.. { @@ -1166,7 +1166,7 @@ static void TableUpdateColumnsWeightFromWidth(ImGuiTable* table) for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { ImGuiTableColumn* column = &table->Columns[column_n]; - if (!column->IsActive || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) + if (!column->IsVisible || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) continue; visible_weight += column->ResizeWeight; visible_width += column->WidthRequested; @@ -1177,7 +1177,7 @@ static void TableUpdateColumnsWeightFromWidth(ImGuiTable* table) for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { ImGuiTableColumn* column = &table->Columns[column_n]; - if (!column->IsActive || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) + if (!column->IsVisible || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) continue; column->ResizeWeight = (column->WidthRequested + 0.0f) / visible_width; } @@ -1201,14 +1201,14 @@ void ImGui::TableSetColumnWidth(ImGuiTable* table, ImGuiTableColumn* column_0, f float min_width = TableGetMinColumnWidth(); float max_width_0 = FLT_MAX; if (!(table->Flags & ImGuiTableFlags_ScrollX)) - max_width_0 = (table->WorkRect.Max.x - column_0->MinX) - (table->ColumnsActiveCount - (column_0->IndexWithinActiveSet + 1)) * min_width; + max_width_0 = (table->WorkRect.Max.x - column_0->MinX) - (table->ColumnsVisibleCount - (column_0->IndexWithinVisibleSet + 1)) * min_width; column_0_width = ImClamp(column_0_width, min_width, max_width_0); // Compare both requested and actual given width to avoid overwriting requested width when column is stuck (minimum size, bounded) if (column_0->WidthGiven == column_0_width || column_0->WidthRequested == column_0_width) return; - ImGuiTableColumn* column_1 = (column_0->NextActiveColumn != -1) ? &table->Columns[column_0->NextActiveColumn] : NULL; + ImGuiTableColumn* column_1 = (column_0->NextVisibleColumn != -1) ? &table->Columns[column_0->NextVisibleColumn] : NULL; // In this surprisingly not simple because of how we support mixing Fixed and Stretch columns. // When forwarding resize from Wn| to Fn+1| we need to be considerate of the _NoResize flag on Fn+1. @@ -1315,7 +1315,7 @@ void ImGui::TableDrawMergeChannels(ImGuiTable* table) // 1. Scan channels and take note of those which can be merged for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->ActiveMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrderToIndex[order_n]; ImGuiTableColumn* column = &table->Columns[column_n]; @@ -1485,7 +1485,7 @@ void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, { // Init default visibility/sort state if ((flags & ImGuiTableColumnFlags_DefaultHide) && (table->SettingsLoadedFlags & ImGuiTableFlags_Hideable) == 0) - column->IsActive = column->IsActiveNextFrame = false; + column->IsVisible = column->IsVisibleNextFrame = false; if (flags & ImGuiTableColumnFlags_DefaultSort && (table->SettingsLoadedFlags & ImGuiTableFlags_Sortable) == 0) { column->SortOrder = 0; // Multiple columns using _DefaultSort will be reordered when building the sort specs. @@ -1692,7 +1692,7 @@ void ImGui::TableBeginCell(ImGuiTable* table, int column_n) window->WorkRect.Max.x = column->MaxX - table->CellPaddingX2; // To allow ImGuiListClipper to function we propagate our row height - if (!column->IsActive) + if (!column->IsVisible) window->DC.CursorPos.y = ImMax(window->DC.CursorPos.y, table->RowPosY2); window->SkipItems = column->SkipItems; @@ -1752,7 +1752,7 @@ bool ImGui::TableNextCell() } int column_n = table->CurrentColumn; - return (table->VisibleMaskByIndex & ((ImU64)1 << column_n)) != 0; + return (table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_n)) != 0; } const char* ImGui::TableGetColumnName(int column_n) @@ -1766,6 +1766,7 @@ const char* ImGui::TableGetColumnName(int column_n) return TableGetColumnName(table, column_n); } +// We expose "Visible and Unclipped" to the user, vs our internal "Visible" state which is !Hidden bool ImGui::TableGetColumnIsVisible(int column_n) { ImGuiContext& g = *GImGui; @@ -1774,7 +1775,7 @@ bool ImGui::TableGetColumnIsVisible(int column_n) return false; if (column_n < 0) column_n = table->CurrentColumn; - return (table->VisibleMaskByIndex & ((ImU64)1 << column_n)) != 0; + return (table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_n)) != 0; } int ImGui::TableGetColumnIndex() @@ -1801,7 +1802,7 @@ bool ImGui::TableSetColumnIndex(int column_idx) TableBeginCell(table, column_idx); } - return (table->VisibleMaskByIndex & ((ImU64)1 << column_idx)) != 0; + return (table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_idx)) != 0; } // Return the cell rectangle based on currently known height. @@ -1876,7 +1877,7 @@ void ImGui::TableDrawContextMenu(ImGuiTable* table, int selected_column_n) { if (ImGuiTableColumn* selected_column = (selected_column_n != -1) ? &table->Columns[selected_column_n] : NULL) { - const bool can_resize = !(selected_column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthStretch)) && selected_column->IsActive; + const bool can_resize = !(selected_column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthStretch)) && selected_column->IsVisible; if (MenuItem("Size column to fit", NULL, false, can_resize)) TableSetColumnAutofit(table, selected_column_n); } @@ -1886,7 +1887,7 @@ void ImGui::TableDrawContextMenu(ImGuiTable* table, int selected_column_n) for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { ImGuiTableColumn* column = &table->Columns[column_n]; - if (column->IsActive) + if (column->IsVisible) TableSetColumnAutofit(table, column_n); } } @@ -1918,10 +1919,10 @@ void ImGui::TableDrawContextMenu(ImGuiTable* table, int selected_column_n) // Make sure we can't hide the last active column bool menu_item_active = (column->Flags & ImGuiTableColumnFlags_NoHide) ? false : true; - if (column->IsActive && table->ColumnsActiveCount <= 1) + if (column->IsVisible && table->ColumnsVisibleCount <= 1) menu_item_active = false; - if (MenuItem(name, NULL, column->IsActive, menu_item_active)) - column->IsActiveNextFrame = !column->IsActive; + if (MenuItem(name, NULL, column->IsVisible, menu_item_active)) + column->IsVisibleNextFrame = !column->IsVisible; } PopItemFlag(); } @@ -1995,8 +1996,8 @@ void ImGui::TableAutoHeaders() // FIXME-TABLE: This is not user-land code any more... perhaps instead we should expose hovered column. // and allow some sort of row-centric IsItemHovered() for full flexibility? float unused_x1 = table->WorkRect.Min.x; - if (table->RightMostActiveColumn != -1) - unused_x1 = ImMax(unused_x1, table->Columns[table->RightMostActiveColumn].MaxX); + if (table->RightMostVisibleColumn != -1) + unused_x1 = ImMax(unused_x1, table->Columns[table->RightMostVisibleColumn].MaxX); if (unused_x1 < table->WorkRect.Max.x) { // FIXME: We inherit ClipRect/SkipItem from last submitted column (active or not), let's temporarily override it. @@ -2091,14 +2092,14 @@ void ImGui::TableHeader(const char* label) // We don't reorder: through the frozen<>unfrozen line, or through a column that is marked with ImGuiTableColumnFlags_NoReorder. if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < cell_r.Min.x) - if (ImGuiTableColumn* prev_column = (column->PrevActiveColumn != -1) ? &table->Columns[column->PrevActiveColumn] : NULL) + if (ImGuiTableColumn* prev_column = (column->PrevVisibleColumn != -1) ? &table->Columns[column->PrevVisibleColumn] : NULL) if (!((column->Flags | prev_column->Flags) & ImGuiTableColumnFlags_NoReorder)) - if ((column->IndexWithinActiveSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinActiveSet < table->FreezeColumnsRequest)) + if ((column->IndexWithinVisibleSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinVisibleSet < table->FreezeColumnsRequest)) table->ReorderColumnDir = -1; if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > cell_r.Max.x) - if (ImGuiTableColumn* next_column = (column->NextActiveColumn != -1) ? &table->Columns[column->NextActiveColumn] : NULL) + if (ImGuiTableColumn* next_column = (column->NextVisibleColumn != -1) ? &table->Columns[column->NextVisibleColumn] : NULL) if (!((column->Flags | next_column->Flags) & ImGuiTableColumnFlags_NoReorder)) - if ((column->IndexWithinActiveSet < table->FreezeColumnsRequest) == (next_column->IndexWithinActiveSet < table->FreezeColumnsRequest)) + if ((column->IndexWithinVisibleSet < table->FreezeColumnsRequest) == (next_column->IndexWithinVisibleSet < table->FreezeColumnsRequest)) table->ReorderColumnDir = +1; } @@ -2257,7 +2258,7 @@ void ImGui::TableSortSpecsSanitize(ImGuiTable* table) for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { ImGuiTableColumn* column = &table->Columns[column_n]; - if (column->SortOrder != -1 && !column->IsActive) + if (column->SortOrder != -1 && !column->IsVisible) column->SortOrder = -1; if (column->SortOrder == -1) continue; @@ -2300,7 +2301,7 @@ void ImGui::TableSortSpecsSanitize(ImGuiTable* table) for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { ImGuiTableColumn* column = &table->Columns[column_n]; - if (!(column->Flags & ImGuiTableColumnFlags_NoSort) && column->IsActive) + if (!(column->Flags & ImGuiTableColumnFlags_NoSort) && column->IsVisible) { sort_order_count = 1; column->SortOrder = 0; @@ -2398,7 +2399,7 @@ void ImGui::TableSaveSettings(ImGuiTable* table) column_settings->DisplayOrder = column->DisplayOrder; column_settings->SortOrder = column->SortOrder; column_settings->SortDirection = column->SortDirection; - column_settings->Visible = column->IsActive; + column_settings->Visible = column->IsVisible; // We skip saving some data in the .ini file when they are unnecessary to restore our state // FIXME-TABLE: We don't have logic to easily compare SortOrder to DefaultSortOrder yet so it's always saved when present. @@ -2450,7 +2451,7 @@ void ImGui::TableLoadSettings(ImGuiTable* table) column->DisplayOrder = column_settings->DisplayOrder; else column->DisplayOrder = (ImS8)column_n; - column->IsActive = column->IsActiveNextFrame = column_settings->Visible; + column->IsVisible = column->IsVisibleNextFrame = column_settings->Visible; column->SortOrder = column_settings->SortOrder; column->SortDirection = column_settings->SortDirection; } @@ -2592,13 +2593,13 @@ void ImGui::DebugNodeTable(ImGuiTable* table) ImGuiTableColumn* column = &table->Columns[n]; const char* name = TableGetColumnName(table, n); BulletText("Column %d order %d name '%s': +%.1f to +%.1f\n" - "Active: %d, Clipped: %d, DrawChannels: %d,%d\n" + "Visible: %d, Clipped: %d, DrawChannels: %d,%d\n" "WidthGiven/Requested: %.1f/%.1f, Weight: %.2f\n" "ContentWidth: RowsFrozen %d, RowsUnfrozen %d, HeadersUsed/Ideal %d/%d\n" "SortOrder: %d, SortDir: %s\n" "UserID: 0x%08X, Flags: 0x%04X: %s%s%s%s..", n, column->DisplayOrder, name ? name : "NULL", column->MinX - table->WorkRect.Min.x, column->MaxX - table->WorkRect.Min.x, - column->IsActive, column->IsClipped, column->DrawChannelRowsBeforeFreeze, column->DrawChannelRowsAfterFreeze, + column->IsVisible, column->IsClipped, column->DrawChannelRowsBeforeFreeze, column->DrawChannelRowsAfterFreeze, column->WidthGiven, column->WidthRequested, column->ResizeWeight, column->ContentWidthRowsFrozen, column->ContentWidthRowsUnfrozen, column->ContentWidthHeadersUsed, column->ContentWidthHeadersIdeal, column->SortOrder, (column->SortDirection == ImGuiSortDirection_Ascending) ? "Ascending" : (column->SortDirection == ImGuiSortDirection_Descending) ? "Descending" : "None",