From 79c9eaa78ef0dd36a8d1ddf2742b457913ce441a Mon Sep 17 00:00:00 2001 From: ocornut Date: Mon, 23 Nov 2020 23:19:08 +0100 Subject: [PATCH] Tables: Internals: renamed Visible to Enabled to avoid confusion with visibility checks. --- imgui_internal.h | 36 +++++------ imgui_tables.cpp | 165 +++++++++++++++++++++++------------------------ 2 files changed, 100 insertions(+), 101 deletions(-) diff --git a/imgui_internal.h b/imgui_internal.h index f0435efc..498319df 100644 --- a/imgui_internal.h +++ b/imgui_internal.h @@ -1917,15 +1917,15 @@ struct ImGuiTableColumn float ContentMaxXHeadersUsed; // Contents maximum position for headers rows (regardless of freezing). TableHeader() automatically softclip itself + report ideal desired size, to avoid creating extraneous draw calls float ContentMaxXHeadersIdeal; ImS16 NameOffset; // Offset into parent ColumnsNames[] - bool IsVisible; // Is the column not marked Hidden by the user? (even if off view, e.g. clipped by scrolling). - bool IsVisibleNextFrame; + bool IsEnabled; // Is the column not marked Hidden by the user? (even if off view, e.g. clipped by scrolling). + bool IsEnabledNextFrame; bool IsClipped; // Is not actually in view (e.g. not overlapping the host window clipping rectangle). bool IsSkipItems; // Do we want item submissions to this column to be ignored early on. ImS8 NavLayerCurrent; // ImGuiNavLayer in 1 byte ImS8 DisplayOrder; // Index within Table's IndexToDisplayOrder[] (column may be reordered by users) - ImS8 IndexWithinVisibleSet; // Index within visible set (<= IndexToDisplayOrder) - 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 IndexWithinEnabledSet; // Index within enabled/visible set (<= IndexToDisplayOrder) + ImS8 PrevEnabledColumn; // Index of prev enabled/visible column within Columns[], -1 if first enabled/visible column + ImS8 NextEnabledColumn; // Index of next enabled/visible column within Columns[], -1 if last enabled/visible column ImS8 SortOrder; // Index of this column within sort specs, -1 if not sorting on this column, 0 for single-sort, may be >0 on multi-sort ImS8 SortDirection; // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending ImU8 AutoFitQueue; // Queue of 8 values for the next 8 frames to request auto-fit @@ -1939,9 +1939,9 @@ struct ImGuiTableColumn memset(this, 0, sizeof(*this)); StretchWeight = WidthRequest = -1.0f; NameOffset = -1; - IsVisible = IsVisibleNextFrame = true; - DisplayOrder = IndexWithinVisibleSet = -1; - PrevVisibleColumn = NextVisibleColumn = -1; + IsEnabled = IsEnabledNextFrame = true; + DisplayOrder = IndexWithinEnabledSet = -1; + PrevEnabledColumn = NextEnabledColumn = -1; SortOrder = -1; SortDirection = ImGuiSortDirection_None; DrawChannelCurrent = DrawChannelFrozen = DrawChannelUnfrozen = (ImU8)-1; @@ -1964,9 +1964,9 @@ struct ImGuiTable ImSpan Columns; // Point within RawData[] ImSpan DisplayOrderToIndex; // Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1) ImSpan RowCellData; // Point within RawData[]. Store cells background requests for current row. - 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" + ImU64 EnabledMaskByIndex; // Column Index -> IsEnabled map (== not hidden by user/api) in a format adequate for iterating column without touching cold data + ImU64 EnabledMaskByDisplayOrder; // Column DisplayOrder -> IsEnabled map + ImU64 EnabledUnclippedMaskByIndex;// Enabled 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; @@ -2021,8 +2021,8 @@ struct ImGuiTable ImVector SortSpecsData; // FIXME-OPT: Fixed-size array / small-vector pattern, optimize for single sort spec ImGuiTableSortSpecs SortSpecs; // Public facing sorts specs, this is what we return in TableGetSortSpecs() ImS8 SortSpecsCount; - ImS8 ColumnsVisibleCount; // Number of non-hidden columns (<= ColumnsCount) - ImS8 ColumnsVisibleFixedCount; // Number of non-hidden columns (<= ColumnsCount) + ImS8 ColumnsEnabledCount; // Number of enabled columns (<= ColumnsCount) + ImS8 ColumnsEnabledFixedCount; // Number of enabled columns (<= ColumnsCount) ImS8 DeclColumnsCount; // Count calls to TableSetupColumn() ImS8 HoveredColumnBody; // Index of column whose visible region is being hovered. Important: == ColumnsCount when hovering empty region after the right-most column! ImS8 HoveredColumnBorder; // Index of column whose right-border is being hovered (for resizing). @@ -2032,7 +2032,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 RightMostVisibleColumn; // Index of right-most non-hidden column. + ImS8 RightMostEnabledColumn; // 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 FreezeRowsRequest; // Requested frozen rows count @@ -2070,7 +2070,7 @@ struct ImGuiTableColumnSettings ImS8 DisplayOrder; ImS8 SortOrder; ImU8 SortDirection : 2; - ImU8 IsVisible : 1; + ImU8 IsEnabled : 1; // "Visible" in ini file ImU8 IsStretch : 1; ImGuiTableColumnSettings() @@ -2080,7 +2080,7 @@ struct ImGuiTableColumnSettings Index = -1; DisplayOrder = SortOrder = -1; SortDirection = ImGuiSortDirection_None; - IsVisible = 1; + IsEnabled = 1; IsStretch = 0; } }; @@ -2273,8 +2273,8 @@ namespace ImGui // Tables: Candidates for public api IMGUI_API void TableOpenContextMenu(int column_n = -1); IMGUI_API void TableSetColumnWidth(int column_n, float width); - IMGUI_API bool TableGetColumnIsHidden(int column_n); - IMGUI_API void TableSetColumnIsHidden(int column_n, bool hidden); + IMGUI_API bool TableGetColumnIsEnabled(int column_n = -1); // Return false when column is disabled (hidden) by user (e.g. via context menu, or _DefaultHide flag) + IMGUI_API void TableSetColumnIsEnabled(int column_n, bool enabled); IMGUI_API void TableSetColumnSortDirection(int column_n, ImGuiSortDirection sort_direction, bool append_to_sort_specs); IMGUI_API void TablePushBackgroundChannel(); IMGUI_API void TablePopBackgroundChannel(); diff --git a/imgui_tables.cpp b/imgui_tables.cpp index f38e1b55..b1e6cffb 100644 --- a/imgui_tables.cpp +++ b/imgui_tables.cpp @@ -366,7 +366,7 @@ bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG table->FreezeColumnsRequest = table->FreezeColumnsCount = 0; table->IsUnfrozen = true; table->DeclColumnsCount = 0; - table->RightMostVisibleColumn = -1; + table->RightMostEnabledColumn = -1; // Using opaque colors facilitate overlapping elements of the grid table->BorderColorStrong = GetColorU32(ImGuiCol_TableBorderStrong); @@ -478,7 +478,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->PrevVisibleColumn : src_column->NextVisibleColumn]; + ImGuiTableColumn* dst_column = &table->Columns[(reorder_dir == -1) ? src_column->PrevEnabledColumn : src_column->NextEnabledColumn]; IM_UNUSED(dst_column); const int src_order = src_column->DisplayOrder; const int dst_order = dst_column->DisplayOrder; @@ -506,7 +506,7 @@ void ImGui::TableBeginUpdateColumns(ImGuiTable* table) } // Lock Visible state and Order - table->ColumnsVisibleCount = 0; + table->ColumnsEnabledCount = 0; table->IsDefaultDisplayOrder = true; ImGuiTableColumn* last_visible_column = NULL; bool want_column_auto_fit = false; @@ -518,12 +518,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->IsVisibleNextFrame = true; - if (column->IsVisible != column->IsVisibleNextFrame) + column->IsEnabledNextFrame = true; + if (column->IsEnabled != column->IsEnabledNextFrame) { - column->IsVisible = column->IsVisibleNextFrame; + column->IsEnabled = column->IsEnabledNextFrame; table->IsSettingsDirty = true; - if (!column->IsVisible && column->SortOrder != -1) + if (!column->IsEnabled && column->SortOrder != -1) table->IsSortSpecsDirty = true; } if (column->SortOrder > 0 && !(table->Flags & ImGuiTableFlags_MultiSortable)) @@ -533,30 +533,30 @@ void ImGui::TableBeginUpdateColumns(ImGuiTable* table) ImU64 index_mask = (ImU64)1 << column_n; ImU64 display_order_mask = (ImU64)1 << column->DisplayOrder; - if (column->IsVisible) + if (column->IsEnabled) { - column->PrevVisibleColumn = column->NextVisibleColumn = -1; + column->PrevEnabledColumn = column->NextEnabledColumn = -1; if (last_visible_column) { - last_visible_column->NextVisibleColumn = (ImS8)column_n; - column->PrevVisibleColumn = (ImS8)table->Columns.index_from_ptr(last_visible_column); + last_visible_column->NextEnabledColumn = (ImS8)column_n; + column->PrevEnabledColumn = (ImS8)table->Columns.index_from_ptr(last_visible_column); } - column->IndexWithinVisibleSet = table->ColumnsVisibleCount; - table->ColumnsVisibleCount++; - table->VisibleMaskByIndex |= index_mask; - table->VisibleMaskByDisplayOrder |= display_order_mask; + column->IndexWithinEnabledSet = table->ColumnsEnabledCount; + table->ColumnsEnabledCount++; + table->EnabledMaskByIndex |= index_mask; + table->EnabledMaskByDisplayOrder |= display_order_mask; last_visible_column = column; } else { - column->IndexWithinVisibleSet = -1; - table->VisibleMaskByIndex &= ~index_mask; - table->VisibleMaskByDisplayOrder &= ~display_order_mask; + column->IndexWithinEnabledSet = -1; + table->EnabledMaskByIndex &= ~index_mask; + table->EnabledMaskByDisplayOrder &= ~display_order_mask; } - IM_ASSERT(column->IndexWithinVisibleSet <= column->DisplayOrder); + IM_ASSERT(column->IndexWithinEnabledSet <= column->DisplayOrder); } - 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); + table->EnabledUnclippedMaskByIndex = table->EnabledMaskByIndex; // Columns will be masked out by TableUpdateLayout() when Clipped + table->RightMostEnabledColumn = (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). @@ -642,7 +642,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) table->LeftMostStretchedColumnDisplayOrder = -1; for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { - if (!(table->VisibleMaskByIndex & ((ImU64)1 << column_n))) + if (!(table->EnabledMaskByIndex & ((ImU64)1 << column_n))) continue; ImGuiTableColumn* column = &table->Columns[column_n]; @@ -704,7 +704,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) max_width_auto = ImMax(max_width_auto, width_auto); sum_width_fixed_requests += table->CellPaddingX * 2.0f; } - table->ColumnsVisibleFixedCount = (ImS8)count_fixed; + table->ColumnsEnabledFixedCount = (ImS8)count_fixed; // Apply "same widths" // - When all columns are fixed or columns are of mixed type: use the maximum auto width @@ -713,7 +713,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) if (table->Flags & ImGuiTableFlags_SameWidths) { for (int column_n = 0; column_n < table->ColumnsCount; column_n++) - if (table->VisibleMaskByIndex & ((ImU64)1 << column_n)) + if (table->EnabledMaskByIndex & ((ImU64)1 << column_n)) { ImGuiTableColumn* column = &table->Columns[column_n]; if (column->Flags & (ImGuiTableColumnFlags_WidthFixed | ImGuiTableColumnFlags_WidthAutoResize)) @@ -732,7 +732,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) } // Layout - const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsVisibleCount - 1); + const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1); const float width_avail = ((table->Flags & ImGuiTableFlags_ScrollX) && table->InnerWidth == 0.0f) ? table->InnerClipRect.GetWidth() : work_rect.GetWidth(); const float width_avail_for_stretched_columns = mixed_same_widths ? 0.0f : width_avail - width_spacings - sum_width_fixed_requests; float width_remaining_for_stretched_columns = width_avail_for_stretched_columns; @@ -744,7 +744,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) table->ColumnsAutoFitWidth = width_spacings; for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; ImGuiTableColumn* column = &table->Columns[table->DisplayOrderToIndex[order_n]]; @@ -761,15 +761,15 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) // [Resize Rule 2] Resizing from right-side of a stretch column preceding a fixed column // needs to forward resizing to left-side of fixed column. We also need to copy the NoResize flag.. - if (column->NextVisibleColumn != -1) - if (ImGuiTableColumn* next_column = &table->Columns[column->NextVisibleColumn]) + if (column->NextEnabledColumn != -1) + if (ImGuiTableColumn* next_column = &table->Columns[column->NextEnabledColumn]) if (next_column->Flags & ImGuiTableColumnFlags_WidthFixed) column->Flags |= (next_column->Flags & ImGuiTableColumnFlags_NoDirectResize_); } // [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) + if (column->NextEnabledColumn == -1 && table->LeftMostStretchedColumnDisplayOrder != -1) column->Flags |= ImGuiTableColumnFlags_NoDirectResize_; if (!(column->Flags & ImGuiTableColumnFlags_NoResize)) @@ -787,7 +787,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) if (width_remaining_for_stretched_columns >= 1.0f && !(table->Flags & ImGuiTableFlags_PreciseWidths)) for (int order_n = table->ColumnsCount - 1; sum_weights_stretched > 0.0f && width_remaining_for_stretched_columns >= 1.0f && order_n >= 0; order_n--) { - if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; ImGuiTableColumn* column = &table->Columns[table->DisplayOrderToIndex[order_n]]; if (!(column->Flags & ImGuiTableColumnFlags_WidthStretch)) @@ -818,7 +818,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) if (table->FreezeColumnsCount > 0 && table->FreezeColumnsCount == visible_n) offset_x += work_rect.Min.x - table->OuterRect.Min.x; - if ((table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n)) == 0) + if ((table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n)) == 0) { // 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. @@ -850,7 +850,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) // table->WorkRect and therefore in table->InnerRect (because ScrollX is off) // FIXME-TABLE: This is solved incorrectly but also quite a difficult problem to fix as we also want ClipRect width to match. // See "table_width_distrib" and "table_width_keep_visible" tests - max_width = table->WorkRect.Max.x - (table->ColumnsVisibleCount - column->IndexWithinVisibleSet - 1) * min_column_distance - offset_x; + max_width = table->WorkRect.Max.x - (table->ColumnsEnabledCount - column->IndexWithinEnabledSet - 1) * min_column_distance - offset_x; //max_width -= table->CellSpacingX1; max_width -= table->CellSpacingX2; max_width -= table->CellPaddingX * 2.0f; @@ -878,9 +878,9 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) column->IsClipped = (column->ClipRect.Max.x <= column->ClipRect.Min.x) && (column->AutoFitQueue & 1) == 0 && (column->CannotSkipItemsQueue & 1) == 0; if (column->IsClipped) - table->VisibleUnclippedMaskByIndex &= ~((ImU64)1 << column_n); // Columns with the _WidthAutoResize sizing policy will never be updated then. + table->EnabledUnclippedMaskByIndex &= ~((ImU64)1 << column_n); // Columns with the _WidthAutoResize sizing policy will never be updated then. - column->IsSkipItems = !column->IsVisible || table->HostSkipItems; + column->IsSkipItems = !column->IsEnabled || table->HostSkipItems; // Detect hovered column if (is_hovering_table && g.IO.MousePos.x >= column->ClipRect.Min.x && g.IO.MousePos.x < column->ClipRect.Max.x) @@ -917,8 +917,8 @@ void ImGui::TableUpdateLayout(ImGuiTable* table) if (is_hovering_table && table->HoveredColumnBody == -1) { float unused_x1 = table->WorkRect.Min.x; - if (table->RightMostVisibleColumn != -1) - unused_x1 = ImMax(unused_x1, table->Columns[table->RightMostVisibleColumn].ClipRect.Max.x); + if (table->RightMostEnabledColumn != -1) + unused_x1 = ImMax(unused_x1, table->Columns[table->RightMostEnabledColumn].ClipRect.Max.x); if (g.IO.MousePos.x >= unused_x1) table->HoveredColumnBody = (ImS8)table->ColumnsCount; } @@ -989,7 +989,7 @@ void ImGui::TableUpdateBorders(ImGuiTable* table) for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrderToIndex[order_n]; @@ -1086,8 +1086,8 @@ void ImGui::EndTable() const float backup_outer_max_pos_x = outer_window->DC.CursorMaxPos.x; const float backup_inner_max_pos_x = inner_window->DC.CursorMaxPos.x; float max_pos_x = backup_inner_max_pos_x; - if (table->RightMostVisibleColumn != -1) - max_pos_x = ImMax(max_pos_x, table->Columns[table->RightMostVisibleColumn].MaxX); + if (table->RightMostEnabledColumn != -1) + max_pos_x = ImMax(max_pos_x, table->Columns[table->RightMostEnabledColumn].MaxX); #if 0 // Strip out dummy channel draw calls @@ -1196,7 +1196,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table) { for (int order_n = 0; order_n < table->ColumnsCount; order_n++) { - if (!(table->VisibleMaskByDisplayOrder & ((ImU64)1 << order_n))) + if (!(table->EnabledMaskByDisplayOrder & ((ImU64)1 << order_n))) continue; const int column_n = table->DisplayOrderToIndex[order_n]; @@ -1207,7 +1207,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table) if (column->MaxX > table->InnerClipRect.Max.x && !is_resized)// && is_hovered) continue; - if (column->NextVisibleColumn == -1 && !is_resizable) + if (column->NextEnabledColumn == -1 && !is_resizable) continue; if (column->MaxX <= column->ClipRect.Min.x) // FIXME-TABLE FIXME-STYLE: Assume BorderSize==1, this is problematic if we want to increase the border size.. continue; @@ -1279,7 +1279,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->IsVisible || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) + if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) continue; visible_weight += column->StretchWeight; visible_width += column->WidthRequest; @@ -1290,7 +1290,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->IsVisible || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) + if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) continue; column->StretchWeight = ((column->WidthRequest + 0.0f) / visible_width) * visible_weight; } @@ -1310,14 +1310,14 @@ void ImGui::TableSetColumnWidth(int column_n, float width) const 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->ColumnsVisibleCount - (column_0->IndexWithinVisibleSet + 1)) * min_width; + max_width_0 = (table->WorkRect.Max.x - column_0->MinX) - (table->ColumnsEnabledCount - (column_0->IndexWithinEnabledSet + 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->WidthRequest == column_0_width) return; - ImGuiTableColumn* column_1 = (column_0->NextVisibleColumn != -1) ? &table->Columns[column_0->NextVisibleColumn] : NULL; + ImGuiTableColumn* column_1 = (column_0->NextEnabledColumn != -1) ? &table->Columns[column_0->NextEnabledColumn] : 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. @@ -1363,7 +1363,7 @@ void ImGui::TableSetColumnWidth(int column_n, float width) { // We can also use previous column if there's no next one if (column_1 == NULL) - column_1 = (column_0->PrevVisibleColumn != -1) ? &table->Columns[column_0->PrevVisibleColumn] : NULL; + column_1 = (column_0->PrevEnabledColumn != -1) ? &table->Columns[column_0->PrevEnabledColumn] : NULL; if (column_1 == NULL) return; @@ -1405,9 +1405,9 @@ void ImGui::TableSetColumnWidth(int column_n, float width) void ImGui::TableUpdateDrawChannels(ImGuiTable* table) { const int freeze_row_multiplier = (table->FreezeRowsCount > 0) ? 2 : 1; - const int channels_for_row = (table->Flags & ImGuiTableFlags_NoClip) ? 1 : table->ColumnsVisibleCount; + const int channels_for_row = (table->Flags & ImGuiTableFlags_NoClip) ? 1 : table->ColumnsEnabledCount; const int channels_for_bg = 1 + 1 * freeze_row_multiplier; - const int channels_for_dummy = (table->ColumnsVisibleCount < table->ColumnsCount || table->VisibleUnclippedMaskByIndex != table->VisibleMaskByIndex) ? +1 : 0; + const int channels_for_dummy = (table->ColumnsEnabledCount < table->ColumnsCount || table->EnabledUnclippedMaskByIndex != table->EnabledMaskByIndex) ? +1 : 0; const int channels_total = channels_for_bg + (channels_for_row * freeze_row_multiplier) + channels_for_dummy; table->DrawSplitter.Split(table->InnerWindow->DrawList, channels_total); table->DummyDrawChannel = (ImU8)((channels_for_dummy > 0) ? channels_total - 1 : -1); @@ -1483,7 +1483,7 @@ void ImGui::TableReorderDrawChannelsForMerge(ImGuiTable* table) // 1. Scan channels and take note of those which can be merged for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { - if (!(table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_n))) + if (!(table->EnabledUnclippedMaskByIndex & ((ImU64)1 << column_n))) continue; ImGuiTableColumn* column = &table->Columns[column_n]; @@ -1676,7 +1676,7 @@ void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, { // Init default visibility/sort state if ((flags & ImGuiTableColumnFlags_DefaultHide) && (table->SettingsLoadedFlags & ImGuiTableFlags_Hideable) == 0) - column->IsVisible = column->IsVisibleNextFrame = false; + column->IsEnabled = column->IsEnabledNextFrame = 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. @@ -1927,7 +1927,7 @@ void ImGui::TableBeginCell(ImGuiTable* table, int column_n) window->DC.ItemWidth = column->ItemWidth; // To allow ImGuiListClipper to function we propagate our row height - if (!column->IsVisible) + if (!column->IsEnabled) window->DC.CursorPos.y = ImMax(window->DC.CursorPos.y, table->RowPosY2); window->SkipItems = column->IsSkipItems; @@ -1988,7 +1988,7 @@ bool ImGui::TableNextColumn() // FIXME-TABLE: it is likely to alter layout if user skips a columns contents based on clipping. int column_n = table->CurrentColumn; - return (table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_n)) != 0; + return (table->EnabledUnclippedMaskByIndex & ((ImU64)1 << column_n)) != 0; } bool ImGui::TableSetColumnIndex(int column_n) @@ -2007,7 +2007,7 @@ bool ImGui::TableSetColumnIndex(int column_n) } // FIXME-TABLE: it is likely to alter layout if user skips a columns contents based on clipping. - return (table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_n)) != 0; + return (table->EnabledUnclippedMaskByIndex & ((ImU64)1 << column_n)) != 0; } int ImGui::TableGetColumnCount() @@ -2028,8 +2028,7 @@ const char* ImGui::TableGetColumnName(int column_n) return TableGetColumnName(table, column_n); } -// FIXME-TABLE: Also expose "Visible and Unclipped" to the user, vs our internal "Visible" state which is !Hidden -bool ImGui::TableGetColumnIsHidden(int column_n) +bool ImGui::TableGetColumnIsEnabled(int column_n) { ImGuiContext& g = *GImGui; ImGuiTable* table = g.CurrentTable; @@ -2037,10 +2036,10 @@ bool ImGui::TableGetColumnIsHidden(int column_n) return false; if (column_n < 0) column_n = table->CurrentColumn; - return (table->VisibleMaskByIndex & ((ImU64)1 << column_n)) == 0; + return (table->EnabledMaskByIndex & ((ImU64)1 << column_n)) == 0; } -void ImGui::TableSetColumnIsHidden(int column_n, bool hidden) +void ImGui::TableSetColumnIsEnabled(int column_n, bool hidden) { ImGuiContext& g = *GImGui; ImGuiTable* table = g.CurrentTable; @@ -2048,7 +2047,7 @@ void ImGui::TableSetColumnIsHidden(int column_n, bool hidden) if (column_n < 0) column_n = table->CurrentColumn; IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount); - table->Columns[column_n].IsVisibleNextFrame = !hidden; + table->Columns[column_n].IsEnabledNextFrame = !hidden; } int ImGui::TableGetColumnIndex() @@ -2080,9 +2079,9 @@ ImRect ImGui::TableGetCellBgRect(const ImGuiTable* table, int column_n) const ImGuiTableColumn* column = &table->Columns[column_n]; float x1 = column->MinX; float x2 = column->MaxX; - if (column->PrevVisibleColumn == -1) + if (column->PrevEnabledColumn == -1) x1 -= table->CellSpacingX1; - if (column->NextVisibleColumn == -1) + if (column->NextEnabledColumn == -1) x2 += table->CellSpacingX2; return ImRect(x1, table->RowPosY1, x2, table->RowPosY2); } @@ -2109,7 +2108,7 @@ void ImGui::TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n) { // Single auto width uses auto-fit ImGuiTableColumn* column = &table->Columns[column_n]; - if (!column->IsVisible) + if (!column->IsEnabled) return; column->CannotSkipItemsQueue = (1 << 0); column->AutoFitQueue = (1 << 1); @@ -2122,7 +2121,7 @@ void ImGui::TableSetColumnWidthAutoAll(ImGuiTable* table) for (int column_n = 0; column_n < table->ColumnsCount; column_n++) { ImGuiTableColumn* column = &table->Columns[column_n]; - if (!column->IsVisible) + if (!column->IsEnabled) continue; column->CannotSkipItemsQueue = (1 << 0); column->AutoFitQueue = (1 << 1); @@ -2171,15 +2170,15 @@ void ImGui::TableDrawContextMenu(ImGuiTable* table) { if (column != NULL) { - const bool can_resize = !(column->Flags & ImGuiTableColumnFlags_NoResize) && column->IsVisible; + const bool can_resize = !(column->Flags & ImGuiTableColumnFlags_NoResize) && column->IsEnabled; if (MenuItem("Size column to fit", NULL, false, can_resize)) TableSetColumnWidthAutoSingle(table, column_n); } const char* size_all_desc; - if (table->ColumnsVisibleFixedCount == table->ColumnsVisibleCount) + if (table->ColumnsEnabledFixedCount == table->ColumnsEnabledCount) size_all_desc = "Size all columns to fit"; // All fixed - else if (table->ColumnsVisibleFixedCount == 0) + else if (table->ColumnsEnabledFixedCount == 0) size_all_desc = "Size all columns to default"; // All stretch else size_all_desc = "Size all columns to fit/default"; // Mixed @@ -2230,10 +2229,10 @@ void ImGui::TableDrawContextMenu(ImGuiTable* table) // Make sure we can't hide the last active column bool menu_item_active = (other_column->Flags & ImGuiTableColumnFlags_NoHide) ? false : true; - if (other_column->IsVisible && table->ColumnsVisibleCount <= 1) + if (other_column->IsEnabled && table->ColumnsEnabledCount <= 1) menu_item_active = false; - if (MenuItem(name, NULL, other_column->IsVisible, menu_item_active)) - other_column->IsVisibleNextFrame = !other_column->IsVisible; + if (MenuItem(name, NULL, other_column->IsEnabled, menu_item_active)) + other_column->IsEnabledNextFrame = !other_column->IsEnabled; } PopItemFlag(); } @@ -2277,7 +2276,7 @@ void ImGui::TableHeadersRow() const float row_y1 = GetCursorScreenPos().y; const int columns_count = TableGetColumnCount(); for (int column_n = 0; column_n < columns_count; column_n++) - if (!TableGetColumnIsHidden(column_n)) + if (TableGetColumnIsEnabled(column_n)) row_height = ImMax(row_height, CalcTextSize(TableGetColumnName(column_n)).y); row_height += style.CellPadding.y * 2.0f; @@ -2387,14 +2386,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->PrevVisibleColumn != -1) ? &table->Columns[column->PrevVisibleColumn] : NULL) + if (ImGuiTableColumn* prev_column = (column->PrevEnabledColumn != -1) ? &table->Columns[column->PrevEnabledColumn] : NULL) if (!((column->Flags | prev_column->Flags) & ImGuiTableColumnFlags_NoReorder)) - if ((column->IndexWithinVisibleSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinVisibleSet < table->FreezeColumnsRequest)) + if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinEnabledSet < 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->NextVisibleColumn != -1) ? &table->Columns[column->NextVisibleColumn] : NULL) + if (ImGuiTableColumn* next_column = (column->NextEnabledColumn != -1) ? &table->Columns[column->NextEnabledColumn] : NULL) if (!((column->Flags | next_column->Flags) & ImGuiTableColumnFlags_NoReorder)) - if ((column->IndexWithinVisibleSet < table->FreezeColumnsRequest) == (next_column->IndexWithinVisibleSet < table->FreezeColumnsRequest)) + if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (next_column->IndexWithinEnabledSet < table->FreezeColumnsRequest)) table->ReorderColumnDir = +1; } @@ -2556,7 +2555,7 @@ void ImGui::TableSetBgColor(ImGuiTableBgTarget bg_target, ImU32 color, int colum return; if (column_n == -1) column_n = table->CurrentColumn; - if ((table->VisibleUnclippedMaskByIndex & ((ImU64)1 << column_n)) == 0) + if ((table->EnabledUnclippedMaskByIndex & ((ImU64)1 << column_n)) == 0) return; if (table->RowCellDataCurrent < 0 || table->RowCellData[table->RowCellDataCurrent].Column != column_n) table->RowCellDataCurrent++; @@ -2590,7 +2589,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->IsVisible) + if (column->SortOrder != -1 && !column->IsEnabled) column->SortOrder = -1; if (column->SortOrder == -1) continue; @@ -2634,7 +2633,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->IsVisible && !(column->Flags & ImGuiTableColumnFlags_NoSort)) + if (column->IsEnabled && !(column->Flags & ImGuiTableColumnFlags_NoSort)) { sort_order_count = 1; column->SortOrder = 0; @@ -2769,7 +2768,7 @@ void ImGui::TableSaveSettings(ImGuiTable* table) column_settings->DisplayOrder = column->DisplayOrder; column_settings->SortOrder = column->SortOrder; column_settings->SortDirection = column->SortDirection; - column_settings->IsVisible = column->IsVisible; + column_settings->IsEnabled = column->IsEnabled; column_settings->IsStretch = (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? 1 : 0; if ((column->Flags & ImGuiTableColumnFlags_WidthStretch) == 0) save_ref_scale = true; @@ -2783,7 +2782,7 @@ void ImGui::TableSaveSettings(ImGuiTable* table) settings->SaveFlags |= ImGuiTableFlags_Reorderable; if (column->SortOrder != -1) settings->SaveFlags |= ImGuiTableFlags_Sortable; - if (column->IsVisible != ((column->Flags & ImGuiTableColumnFlags_DefaultHide) == 0)) + if (column->IsEnabled != ((column->Flags & ImGuiTableColumnFlags_DefaultHide) == 0)) settings->SaveFlags |= ImGuiTableFlags_Hideable; } settings->SaveFlags &= table->Flags; @@ -2839,7 +2838,7 @@ void ImGui::TableLoadSettings(ImGuiTable* table) column->DisplayOrder = column_settings->DisplayOrder; else column->DisplayOrder = (ImS8)column_n; - column->IsVisible = column->IsVisibleNextFrame = column_settings->IsVisible; + column->IsEnabled = column->IsEnabledNextFrame = column_settings->IsEnabled; column->SortOrder = column_settings->SortOrder; column->SortDirection = column_settings->SortDirection; } @@ -2908,7 +2907,7 @@ static void TableSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, 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->IsVisible = (ImU8)n; settings->SaveFlags |= ImGuiTableFlags_Hideable; } + 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 = (ImS8)n; settings->SaveFlags |= ImGuiTableFlags_Reorderable; } if (sscanf(line, "Sort=%d%c%n", &n, &c, &r) == 2) { line = ImStrSkipBlank(line + r); column->SortOrder = (ImS8)n; column->SortDirection = (c == '^') ? ImGuiSortDirection_Descending : ImGuiSortDirection_Ascending; settings->SaveFlags |= ImGuiTableFlags_Sortable; } } @@ -2943,7 +2942,7 @@ static void TableSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandle 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->IsVisible); + 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"); @@ -3057,7 +3056,7 @@ void ImGui::DebugNodeTable(ImGuiTable* table) "ContentWidth: %.1f,%.1f, HeadersUsed/Ideal %.1f/%.1f\n" "Sort: %d%s, UserID: 0x%08X, Flags: 0x%04X: %s%s%s%s..", n, column->DisplayOrder, name, column->MinX - table->WorkRect.Min.x, column->MaxX - table->WorkRect.Min.x, - column->IsVisible, column->IsClipped, column->IsSkipItems, column->DrawChannelFrozen, column->DrawChannelUnfrozen, + column->IsEnabled, column->IsClipped, column->IsSkipItems, column->DrawChannelFrozen, column->DrawChannelUnfrozen, column->WidthGiven, column->WidthRequest, column->WidthAuto, column->StretchWeight, column->MinX, column->MaxX, column->MaxX - column->MinX, column->ClipRect.Min.x, column->ClipRect.Max.x, column->ClipRect.Max.x - column->ClipRect.Min.x, column->ContentMaxXFrozen - column->WorkMinX, column->ContentMaxXUnfrozen - column->WorkMinX, column->ContentMaxXHeadersUsed - column->WorkMinX, column->ContentMaxXHeadersIdeal - column->WorkMinX, @@ -3092,7 +3091,7 @@ void ImGui::DebugNodeTableSettings(ImGuiTableSettings* settings) BulletText("Column %d Order %d SortOrder %d %s Vis %d %s %7.3f UserID 0x%08X", n, column_settings->DisplayOrder, column_settings->SortOrder, (sort_dir == ImGuiSortDirection_Ascending) ? "Asc" : (sort_dir == ImGuiSortDirection_Descending) ? "Des" : "---", - column_settings->IsVisible, column_settings->IsStretch ? "Weight" : "Width ", column_settings->WidthOrWeight, column_settings->UserID); + column_settings->IsEnabled, column_settings->IsStretch ? "Weight" : "Width ", column_settings->WidthOrWeight, column_settings->UserID); } TreePop(); }