|
|
@@ -346,7 +346,8 @@ bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
|
|
|
flags = TableFixFlags(flags, outer_window);
|
|
|
|
|
|
// Initialize
|
|
|
- const int instance_no = (table->LastFrameActive != g.FrameCount) ? 0 : table->InstanceCurrent + 1;
|
|
|
+ const int previous_frame_active = table->LastFrameActive;
|
|
|
+ const int instance_no = (previous_frame_active != g.FrameCount) ? 0 : table->InstanceCurrent + 1;
|
|
|
table->ID = id;
|
|
|
table->Flags = flags;
|
|
|
table->LastFrameActive = g.FrameCount;
|
|
|
@@ -477,7 +478,10 @@ bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
|
|
|
table->FreezeRowsRequest = table->FreezeRowsCount = 0; // This will be setup by TableSetupScrollFreeze(), if any
|
|
|
table->FreezeColumnsRequest = table->FreezeColumnsCount = 0;
|
|
|
table->IsUnfrozenRows = true;
|
|
|
- table->DeclColumnsCount = 0;
|
|
|
+ table->DeclColumnsCount = table->AngledHeadersCount = 0;
|
|
|
+ if (previous_frame_active + 1 < g.FrameCount)
|
|
|
+ table->IsActiveIdInTable = false;
|
|
|
+ temp_data->AngledheadersExtraWidth = 0.0f;
|
|
|
|
|
|
// Using opaque colors facilitate overlapping lines of the grid, otherwise we'd need to improve TableDrawBorders()
|
|
|
table->BorderColorStrong = GetColorU32(ImGuiCol_TableBorderStrong);
|
|
|
@@ -974,14 +978,19 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
|
|
|
ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, table->InstanceCurrent);
|
|
|
table_instance->HoveredRowLast = table_instance->HoveredRowNext;
|
|
|
table_instance->HoveredRowNext = -1;
|
|
|
- table->HoveredColumnBody = -1;
|
|
|
- table->HoveredColumnBorder = -1;
|
|
|
+ table->HoveredColumnBody = table->HoveredColumnBorder = -1;
|
|
|
const ImRect mouse_hit_rect(table->OuterRect.Min.x, table->OuterRect.Min.y, table->OuterRect.Max.x, ImMax(table->OuterRect.Max.y, table->OuterRect.Min.y + table_instance->LastOuterHeight));
|
|
|
const ImGuiID backup_active_id = g.ActiveId;
|
|
|
g.ActiveId = 0;
|
|
|
const bool is_hovering_table = ItemHoverable(mouse_hit_rect, 0, ImGuiItemFlags_None);
|
|
|
g.ActiveId = backup_active_id;
|
|
|
|
|
|
+ // Determine skewed MousePos.x to support angled headers.
|
|
|
+ float mouse_skewed_x = g.IO.MousePos.x;
|
|
|
+ if (table->AngledHeadersHeight > 0.0f)
|
|
|
+ if (g.IO.MousePos.y >= table->OuterRect.Min.y && g.IO.MousePos.y <= table->OuterRect.Min.y + table->AngledHeadersHeight)
|
|
|
+ mouse_skewed_x += ImTrunc((table->OuterRect.Min.y + table->AngledHeadersHeight - g.IO.MousePos.y) * table->AngledHeadersSlope);
|
|
|
+
|
|
|
// [Part 6] Setup final position, offset, skip/clip states and clipping rectangles, detect hovered column
|
|
|
// Process columns in their visible orders as we are comparing the visible order and adjusting host_clip_rect while looping.
|
|
|
int visible_n = 0;
|
|
|
@@ -1023,7 +1032,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
|
|
|
}
|
|
|
|
|
|
// Detect hovered column
|
|
|
- if (is_hovering_table && g.IO.MousePos.x >= column->ClipRect.Min.x && g.IO.MousePos.x < column->ClipRect.Max.x)
|
|
|
+ if (is_hovering_table && mouse_skewed_x >= column->ClipRect.Min.x && mouse_skewed_x < column->ClipRect.Max.x)
|
|
|
table->HoveredColumnBody = (ImGuiTableColumnIdx)column_n;
|
|
|
|
|
|
// Lock start position
|
|
|
@@ -1122,13 +1131,13 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
|
|
|
// because of using _WidthAuto/_WidthStretch). This will hide the resizing option from the context menu.
|
|
|
const float unused_x1 = ImMax(table->WorkRect.Min.x, table->Columns[table->RightMostEnabledColumn].ClipRect.Max.x);
|
|
|
if (is_hovering_table && table->HoveredColumnBody == -1)
|
|
|
- {
|
|
|
- if (g.IO.MousePos.x >= unused_x1)
|
|
|
+ if (mouse_skewed_x >= unused_x1)
|
|
|
table->HoveredColumnBody = (ImGuiTableColumnIdx)table->ColumnsCount;
|
|
|
- }
|
|
|
if (has_resizable == false && (table->Flags & ImGuiTableFlags_Resizable))
|
|
|
table->Flags &= ~ImGuiTableFlags_Resizable;
|
|
|
|
|
|
+ table->IsActiveIdAliveBeforeTable = (g.ActiveIdIsAlive != 0);
|
|
|
+
|
|
|
// [Part 8] Lock actual OuterRect/WorkRect right-most position.
|
|
|
// This is done late to handle the case of fixed-columns tables not claiming more widths that they need.
|
|
|
// Because of this we are careful with uses of WorkRect and InnerClipRect before this point.
|
|
|
@@ -1157,10 +1166,18 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
|
|
|
// [Part 10] Hit testing on borders
|
|
|
if (table->Flags & ImGuiTableFlags_Resizable)
|
|
|
TableUpdateBorders(table);
|
|
|
- table_instance->LastFirstRowHeight = 0.0f;
|
|
|
+ table_instance->LastTopHeadersRowHeight = 0.0f;
|
|
|
table->IsLayoutLocked = true;
|
|
|
table->IsUsingHeaders = false;
|
|
|
|
|
|
+ // Highlight header
|
|
|
+ table->HighlightColumnHeader = -1;
|
|
|
+ if (table->IsContextPopupOpen && table->ContextPopupColumn != -1 && table->InstanceInteracted == table->InstanceCurrent)
|
|
|
+ table->HighlightColumnHeader = table->ContextPopupColumn;
|
|
|
+ else if ((table->Flags & ImGuiTableFlags_HighlightHoveredColumn) && table->HoveredColumnBody != -1 && table->HoveredColumnBody != table->ColumnsCount && table->HoveredColumnBorder == -1)
|
|
|
+ if (g.ActiveId == 0 || (table->IsActiveIdInTable || g.DragDropActive))
|
|
|
+ table->HighlightColumnHeader = table->HoveredColumnBody;
|
|
|
+
|
|
|
// [Part 11] Context menu
|
|
|
if (TableBeginContextMenuPopup(table))
|
|
|
{
|
|
|
@@ -1201,9 +1218,9 @@ void ImGui::TableUpdateBorders(ImGuiTable* table)
|
|
|
// Actual columns highlight/render will be performed in EndTable() and not be affected.
|
|
|
ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, table->InstanceCurrent);
|
|
|
const float hit_half_width = TABLE_RESIZE_SEPARATOR_HALF_THICKNESS;
|
|
|
- const float hit_y1 = table->OuterRect.Min.y;
|
|
|
+ const float hit_y1 = (table->FreezeRowsCount >= 1 ? table->OuterRect.Min.y : table->WorkRect.Min.y) + table->AngledHeadersHeight;
|
|
|
const float hit_y2_body = ImMax(table->OuterRect.Max.y, hit_y1 + table_instance->LastOuterHeight);
|
|
|
- const float hit_y2_head = hit_y1 + table_instance->LastFirstRowHeight;
|
|
|
+ const float hit_y2_head = hit_y1 + table_instance->LastTopHeadersRowHeight;
|
|
|
|
|
|
for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
|
|
|
{
|
|
|
@@ -1234,7 +1251,7 @@ void ImGui::TableUpdateBorders(ImGuiTable* table)
|
|
|
{
|
|
|
TableSetColumnWidthAutoSingle(table, column_n);
|
|
|
ClearActiveID();
|
|
|
- held = hovered = false;
|
|
|
+ held = false;
|
|
|
}
|
|
|
if (held)
|
|
|
{
|
|
|
@@ -1306,7 +1323,7 @@ void ImGui::EndTable()
|
|
|
max_pos_x = ImMax(max_pos_x, table->Columns[table->RightMostEnabledColumn].WorkMaxX + table->CellPaddingX + table->OuterPaddingX - outer_padding_for_border);
|
|
|
if (table->ResizedColumn != -1)
|
|
|
max_pos_x = ImMax(max_pos_x, table->ResizeLockMinContentsX2);
|
|
|
- table->InnerWindow->DC.CursorMaxPos.x = max_pos_x;
|
|
|
+ table->InnerWindow->DC.CursorMaxPos.x = max_pos_x + table->TempData->AngledheadersExtraWidth;
|
|
|
}
|
|
|
|
|
|
// Pop clipping rect
|
|
|
@@ -1382,6 +1399,8 @@ void ImGui::EndTable()
|
|
|
table->ResizedColumnNextWidth = new_width;
|
|
|
}
|
|
|
|
|
|
+ table->IsActiveIdInTable = (g.ActiveIdIsAlive != 0 && table->IsActiveIdAliveBeforeTable == false);
|
|
|
+
|
|
|
// Pop from id stack
|
|
|
IM_ASSERT_USER_ERROR(inner_window->IDStack.back() == table_instance->TableInstanceID, "Mismatching PushID/PopID!");
|
|
|
IM_ASSERT_USER_ERROR(outer_window->DC.ItemWidthStack.Size >= temp_data->HostBackupItemWidthStackSize, "Too many PopItemWidth!");
|
|
|
@@ -1422,7 +1441,7 @@ void ImGui::EndTable()
|
|
|
}
|
|
|
else if (temp_data->UserOuterSize.x <= 0.0f)
|
|
|
{
|
|
|
- const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.x : 0.0f;
|
|
|
+ const float decoration_size = table->TempData->AngledheadersExtraWidth + ((table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.x : 0.0f);
|
|
|
outer_window->DC.IdealMaxPos.x = ImMax(outer_window->DC.IdealMaxPos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth + decoration_size - temp_data->UserOuterSize.x);
|
|
|
outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, ImMin(table->OuterRect.Max.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth));
|
|
|
}
|
|
|
@@ -1461,7 +1480,7 @@ void ImGui::EndTable()
|
|
|
NavUpdateCurrentWindowIsScrollPushableX();
|
|
|
}
|
|
|
|
|
|
-// See "COLUMN SIZING POLICIES" comments at the top of this file
|
|
|
+// See "COLUMNS SIZING POLICIES" comments at the top of this file
|
|
|
// If (init_width_or_weight <= 0.0f) it is ignored
|
|
|
void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, float init_width_or_weight, ImGuiID user_id)
|
|
|
{
|
|
|
@@ -1489,6 +1508,11 @@ void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, flo
|
|
|
if ((flags & ImGuiTableColumnFlags_WidthMask_) == 0 && init_width_or_weight > 0.0f)
|
|
|
if ((table->Flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedFit || (table->Flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedSame)
|
|
|
flags |= ImGuiTableColumnFlags_WidthFixed;
|
|
|
+ if (flags & ImGuiTableColumnFlags_AngledHeader)
|
|
|
+ {
|
|
|
+ flags |= ImGuiTableColumnFlags_NoHeaderLabel;
|
|
|
+ table->AngledHeadersCount++;
|
|
|
+ }
|
|
|
|
|
|
TableSetupColumnFlags(table, column, flags);
|
|
|
column->UserID = user_id;
|
|
|
@@ -1836,15 +1860,16 @@ void ImGui::TableEndRow(ImGuiTable* table)
|
|
|
const float bg_y2 = table->RowPosY2;
|
|
|
const bool unfreeze_rows_actual = (table->CurrentRow + 1 == table->FreezeRowsCount);
|
|
|
const bool unfreeze_rows_request = (table->CurrentRow + 1 == table->FreezeRowsRequest);
|
|
|
- if (table->CurrentRow == 0)
|
|
|
- TableGetInstanceData(table, table->InstanceCurrent)->LastFirstRowHeight = bg_y2 - bg_y1;
|
|
|
+ ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, table->InstanceCurrent);
|
|
|
+ if ((table->RowFlags & ImGuiTableRowFlags_Headers) && (table->CurrentRow == 0 || (table->LastRowFlags & ImGuiTableRowFlags_Headers)))
|
|
|
+ table_instance->LastTopHeadersRowHeight += bg_y2 - bg_y1;
|
|
|
|
|
|
const bool is_visible = (bg_y2 >= table->InnerClipRect.Min.y && bg_y1 <= table->InnerClipRect.Max.y);
|
|
|
if (is_visible)
|
|
|
{
|
|
|
// Update data for TableGetHoveredRow()
|
|
|
if (table->HoveredColumnBody != -1 && g.IO.MousePos.y >= bg_y1 && g.IO.MousePos.y < bg_y2)
|
|
|
- TableGetInstanceData(table, table->InstanceCurrent)->HoveredRowNext = table->CurrentRow;
|
|
|
+ table_instance->HoveredRowNext = table->CurrentRow;
|
|
|
|
|
|
// Decide of background color for the row
|
|
|
ImU32 bg_col0 = 0;
|
|
|
@@ -1922,7 +1947,7 @@ void ImGui::TableEndRow(ImGuiTable* table)
|
|
|
IM_ASSERT(table->IsUnfrozenRows == false);
|
|
|
const float y0 = ImMax(table->RowPosY2 + 1, window->InnerClipRect.Min.y);
|
|
|
table->IsUnfrozenRows = true;
|
|
|
- TableGetInstanceData(table, table->InstanceCurrent)->LastFrozenHeight = y0 - table->OuterRect.Min.y;
|
|
|
+ table_instance->LastFrozenHeight = y0 - table->OuterRect.Min.y;
|
|
|
|
|
|
// BgClipRect starts as table->InnerClipRect, reduce it now and make BgClipRectForDrawCmd == BgClipRect
|
|
|
table->BgClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y = ImMin(y0, window->InnerClipRect.Max.y);
|
|
|
@@ -2300,6 +2325,7 @@ void ImGui::TableUpdateColumnsWeightFromWidth(ImGuiTable* table)
|
|
|
// - TablePopBackgroundChannel() [Internal]
|
|
|
// - TableSetupDrawChannels() [Internal]
|
|
|
// - TableMergeDrawChannels() [Internal]
|
|
|
+// - TableGetColumnBorderCol() [Internal]
|
|
|
// - TableDrawBorders() [Internal]
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
@@ -2583,6 +2609,18 @@ void ImGui::TableMergeDrawChannels(ImGuiTable* table)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+static ImU32 TableGetColumnBorderCol(ImGuiTable* table, int order_n, int column_n)
|
|
|
+{
|
|
|
+ const bool is_hovered = (table->HoveredColumnBorder == column_n);
|
|
|
+ const bool is_resized = (table->ResizedColumn == column_n) && (table->InstanceInteracted == table->InstanceCurrent);
|
|
|
+ const bool is_frozen_separator = (table->FreezeColumnsCount == order_n + 1);
|
|
|
+ if (is_resized || is_hovered)
|
|
|
+ return ImGui::GetColorU32(is_resized ? ImGuiCol_SeparatorActive : ImGuiCol_SeparatorHovered);
|
|
|
+ if (is_frozen_separator || (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)))
|
|
|
+ return table->BorderColorStrong;
|
|
|
+ return table->BorderColorLight;
|
|
|
+}
|
|
|
+
|
|
|
// FIXME-TABLE: This is a mess, need to redesign how we render borders (as some are also done in TableEndRow)
|
|
|
void ImGui::TableDrawBorders(ImGuiTable* table)
|
|
|
{
|
|
|
@@ -2597,9 +2635,9 @@ void ImGui::TableDrawBorders(ImGuiTable* table)
|
|
|
// Draw inner border and resizing feedback
|
|
|
ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, table->InstanceCurrent);
|
|
|
const float border_size = TABLE_BORDER_SIZE;
|
|
|
- const float draw_y1 = table->InnerRect.Min.y + ((table->Flags & ImGuiTableFlags_BordersOuterH) ? 1.0f : 0.0f);
|
|
|
+ const float draw_y1 = ImMax(table->InnerRect.Min.y, (table->FreezeRowsCount >= 1 ? table->InnerRect.Min.y : table->WorkRect.Min.y) + table->AngledHeadersHeight) + ((table->Flags & ImGuiTableFlags_BordersOuterH) ? 1.0f : 0.0f);
|
|
|
const float draw_y2_body = table->InnerRect.Max.y;
|
|
|
- const float draw_y2_head = table->IsUsingHeaders ? ImMin(table->InnerRect.Max.y, (table->FreezeRowsCount >= 1 ? table->InnerRect.Min.y : table->WorkRect.Min.y) + table_instance->LastFirstRowHeight) : draw_y1;
|
|
|
+ const float draw_y2_head = table->IsUsingHeaders ? ImMin(table->InnerRect.Max.y, (table->FreezeRowsCount >= 1 ? table->InnerRect.Min.y : table->WorkRect.Min.y) + table_instance->LastTopHeadersRowHeight) : draw_y1;
|
|
|
if (table->Flags & ImGuiTableFlags_BordersInnerV)
|
|
|
{
|
|
|
for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
|
|
|
@@ -2625,21 +2663,9 @@ void ImGui::TableDrawBorders(ImGuiTable* table)
|
|
|
|
|
|
// Draw in outer window so right-most column won't be clipped
|
|
|
// Always draw full height border when being resized/hovered, or on the delimitation of frozen column scrolling.
|
|
|
- ImU32 col;
|
|
|
- float draw_y2;
|
|
|
- if (is_hovered || is_resized || is_frozen_separator)
|
|
|
- {
|
|
|
- draw_y2 = draw_y2_body;
|
|
|
- col = is_resized ? GetColorU32(ImGuiCol_SeparatorActive) : is_hovered ? GetColorU32(ImGuiCol_SeparatorHovered) : table->BorderColorStrong;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- draw_y2 = (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)) ? draw_y2_head : draw_y2_body;
|
|
|
- col = (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)) ? table->BorderColorStrong : table->BorderColorLight;
|
|
|
- }
|
|
|
-
|
|
|
+ float draw_y2 = (is_hovered || is_resized || is_frozen_separator || (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)) == 0) ? draw_y2_body : draw_y2_head;
|
|
|
if (draw_y2 > draw_y1)
|
|
|
- inner_drawlist->AddLine(ImVec2(column->MaxX, draw_y1), ImVec2(column->MaxX, draw_y2), col, border_size);
|
|
|
+ inner_drawlist->AddLine(ImVec2(column->MaxX, draw_y1), ImVec2(column->MaxX, draw_y2), TableGetColumnBorderCol(table, order_n, column_n), border_size);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -2882,6 +2908,8 @@ void ImGui::TableSortSpecsBuild(ImGuiTable* table)
|
|
|
// - TableGetHeaderRowHeight() [Internal]
|
|
|
// - TableHeadersRow()
|
|
|
// - TableHeader()
|
|
|
+// - TableAngledHeadersRow()
|
|
|
+// - TableAngledHeadersRowEx() [Internal]
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
float ImGui::TableGetHeaderRowHeight()
|
|
|
@@ -2890,16 +2918,26 @@ float ImGui::TableGetHeaderRowHeight()
|
|
|
// Calculate row height, for the unlikely case that some labels may be taller than others.
|
|
|
// If we didn't do that, uneven header height would highlight but smaller one before the tallest wouldn't catch input for all height.
|
|
|
// In your custom header row you may omit this all together and just call TableNextRow() without a height...
|
|
|
- float row_height = GetTextLineHeight();
|
|
|
- int columns_count = TableGetColumnCount();
|
|
|
- for (int column_n = 0; column_n < columns_count; column_n++)
|
|
|
- {
|
|
|
- ImGuiTableColumnFlags flags = TableGetColumnFlags(column_n);
|
|
|
- if ((flags & ImGuiTableColumnFlags_IsEnabled) && !(flags & ImGuiTableColumnFlags_NoHeaderLabel))
|
|
|
- row_height = ImMax(row_height, CalcTextSize(TableGetColumnName(column_n)).y);
|
|
|
- }
|
|
|
- row_height += GetStyle().CellPadding.y * 2.0f;
|
|
|
- return row_height;
|
|
|
+ ImGuiContext& g = *GImGui;
|
|
|
+ ImGuiTable* table = g.CurrentTable;
|
|
|
+ float row_height = g.FontSize;
|
|
|
+ for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
|
|
|
+ if (IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
|
|
|
+ if ((table->Columns[column_n].Flags & ImGuiTableColumnFlags_NoHeaderLabel) == 0)
|
|
|
+ row_height = ImMax(row_height, CalcTextSize(TableGetColumnName(table, column_n)).y);
|
|
|
+ return row_height + g.Style.CellPadding.y * 2.0f;
|
|
|
+}
|
|
|
+
|
|
|
+float ImGui::TableGetHeaderAngledMaxLabelWidth()
|
|
|
+{
|
|
|
+ ImGuiContext& g = *GImGui;
|
|
|
+ ImGuiTable* table = g.CurrentTable;
|
|
|
+ float width = 0.0f;
|
|
|
+ for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
|
|
|
+ if (IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
|
|
|
+ if (table->Columns[column_n].Flags & ImGuiTableColumnFlags_AngledHeader)
|
|
|
+ width = ImMax(width, CalcTextSize(TableGetColumnName(table, column_n), NULL, true).x);
|
|
|
+ return width + g.Style.CellPadding.x * 2.0f;
|
|
|
}
|
|
|
|
|
|
// [Public] This is a helper to output TableHeader() calls based on the column names declared in TableSetupColumn().
|
|
|
@@ -2919,9 +2957,9 @@ void ImGui::TableHeadersRow()
|
|
|
TableUpdateLayout(table);
|
|
|
|
|
|
// Open row
|
|
|
- const float row_y1 = GetCursorScreenPos().y;
|
|
|
const float row_height = TableGetHeaderRowHeight();
|
|
|
TableNextRow(ImGuiTableRowFlags_Headers, row_height);
|
|
|
+ const float row_y1 = GetCursorScreenPos().y;
|
|
|
if (table->HostSkipItems) // Merely an optimization, you may skip in your own code.
|
|
|
return;
|
|
|
|
|
|
@@ -2943,7 +2981,7 @@ void ImGui::TableHeadersRow()
|
|
|
ImVec2 mouse_pos = ImGui::GetMousePos();
|
|
|
if (IsMouseReleased(1) && TableGetHoveredColumn() == columns_count)
|
|
|
if (mouse_pos.y >= row_y1 && mouse_pos.y < row_y1 + row_height)
|
|
|
- TableOpenContextMenu(-1); // Will open a non-column-specific popup.
|
|
|
+ TableOpenContextMenu(columns_count); // Will open a non-column-specific popup.
|
|
|
}
|
|
|
|
|
|
// Emit a column header (text + optional sort order)
|
|
|
@@ -2995,7 +3033,6 @@ void ImGui::TableHeader(const char* label)
|
|
|
column->ContentMaxXHeadersIdeal = ImMax(column->ContentMaxXHeadersIdeal, max_pos_x);
|
|
|
|
|
|
// Keep header highlighted when context menu is open.
|
|
|
- const bool selected = (table->IsContextPopupOpen && table->ContextPopupColumn == column_n && table->InstanceInteracted == table->InstanceCurrent);
|
|
|
ImGuiID id = window->GetID(label);
|
|
|
ImRect bb(cell_r.Min.x, cell_r.Min.y, cell_r.Max.x, ImMax(cell_r.Max.y, cell_r.Min.y + label_height + g.Style.CellPadding.y * 2.0f));
|
|
|
ItemSize(ImVec2(0.0f, label_height)); // Don't declare unclipped width, it'll be fed ContentMaxPosHeadersIdeal
|
|
|
@@ -3006,9 +3043,10 @@ void ImGui::TableHeader(const char* label)
|
|
|
//GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]
|
|
|
|
|
|
// Using AllowOverlap mode because we cover the whole cell, and we want user to be able to submit subsequent items.
|
|
|
+ const bool highlight = (table->HighlightColumnHeader == column_n);
|
|
|
bool hovered, held;
|
|
|
bool pressed = ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_AllowOverlap);
|
|
|
- if (held || hovered || selected)
|
|
|
+ if (held || hovered || highlight)
|
|
|
{
|
|
|
const ImU32 col = GetColorU32(held ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
|
|
|
//RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
|
|
|
@@ -3086,6 +3124,115 @@ void ImGui::TableHeader(const char* label)
|
|
|
TableOpenContextMenu(column_n);
|
|
|
}
|
|
|
|
|
|
+// Unlike TableHeadersRow() it is not expected that you can reimplement or customize this with custom widgets.
|
|
|
+// FIXME: highlight without ImGuiTableFlags_HighlightHoveredColumn
|
|
|
+// FIXME: No hit-testing/button on the angled header.
|
|
|
+void ImGui::TableAngledHeadersRow()
|
|
|
+{
|
|
|
+ ImGuiContext& g = *GImGui;
|
|
|
+ TableAngledHeadersRowEx(g.Style.TableAngledHeadersAngle, 0.0f);
|
|
|
+}
|
|
|
+
|
|
|
+void ImGui::TableAngledHeadersRowEx(float angle, float max_label_width)
|
|
|
+{
|
|
|
+ ImGuiContext& g = *GImGui;
|
|
|
+ ImGuiTable* table = g.CurrentTable;
|
|
|
+ ImGuiWindow* window = g.CurrentWindow;
|
|
|
+ ImDrawList* draw_list = window->DrawList;
|
|
|
+ IM_ASSERT(table != NULL && "Need to call TableHeadersRow() after BeginTable()!");
|
|
|
+ IM_ASSERT(table->CurrentRow == -1 && "Must be first row");
|
|
|
+
|
|
|
+ if (max_label_width == 0.0f)
|
|
|
+ max_label_width = TableGetHeaderAngledMaxLabelWidth();
|
|
|
+
|
|
|
+ // Angle argument expressed in (-IM_PI/2 .. +IM_PI/2) as it is easier to think about for user.
|
|
|
+ const bool flip_label = (angle < 0.0f);
|
|
|
+ angle -= IM_PI * 0.5f;
|
|
|
+ const float cos_a = ImCos(angle);
|
|
|
+ const float sin_a = ImSin(angle);
|
|
|
+ const float label_cos_a = flip_label ? ImCos(angle + IM_PI) : cos_a;
|
|
|
+ const float label_sin_a = flip_label ? ImSin(angle + IM_PI) : sin_a;
|
|
|
+ const ImVec2 unit_right = ImVec2(cos_a, sin_a);
|
|
|
+
|
|
|
+ // Calculate our base metrics and set angled headers data _before_ the first call to TableNextRow()
|
|
|
+ // FIXME-STYLE: Would it be better for user to submit 'max_label_width' or 'row_height' ? One can be derived from the other.
|
|
|
+ const float header_height = table->RowCellPaddingY * 2.0f + g.FontSize;
|
|
|
+ const float row_height = ImFabs(ImRotate(ImVec2(max_label_width, flip_label ? +header_height : -header_height), cos_a, sin_a).y);
|
|
|
+ const ImVec2 header_angled_vector = unit_right * (row_height / -sin_a);
|
|
|
+ table->AngledHeadersHeight = row_height;
|
|
|
+ table->AngledHeadersSlope = (sin_a != 0.0f) ? (cos_a / sin_a) : 0.0f;
|
|
|
+
|
|
|
+ // Declare row, override and draw our own background
|
|
|
+ TableNextRow(ImGuiTableRowFlags_Headers, row_height);
|
|
|
+ TableNextColumn();
|
|
|
+ table->DrawSplitter->SetCurrentChannel(draw_list, TABLE_DRAW_CHANNEL_BG0);
|
|
|
+ PushClipRect(table->BgClipRect.Min, table->BgClipRect.Max, false); // Span all columns
|
|
|
+ TableSetBgColor(ImGuiTableBgTarget_RowBg0, 0); // Cancel
|
|
|
+ draw_list->AddRectFilled(table->BgClipRect.Min, table->BgClipRect.Max, GetColorU32(ImGuiCol_TableHeaderBg, 0.25f)); // FIXME-STYLE: Change row background with an arbitrary color.
|
|
|
+
|
|
|
+ const ImRect row_r(table->WorkRect.Min.x, table->BgClipRect.Min.y, table->WorkRect.Max.x, window->DC.CursorPos.y + row_height);
|
|
|
+ const ImGuiID row_id = GetID("##AngledHeaders");
|
|
|
+ ButtonBehavior(row_r, row_id, NULL, NULL);
|
|
|
+ KeepAliveID(row_id);
|
|
|
+
|
|
|
+ ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, table->InstanceCurrent);
|
|
|
+ int highlight_column_n = table->HighlightColumnHeader;
|
|
|
+ if (highlight_column_n == -1 && table->HoveredColumnBody != -1)
|
|
|
+ if (table_instance->HoveredRowLast == 0 && table->HoveredColumnBorder == -1 && (g.ActiveId == 0 || g.ActiveId == row_id || (table->IsActiveIdInTable || g.DragDropActive)))
|
|
|
+ highlight_column_n = table->HoveredColumnBody;
|
|
|
+
|
|
|
+ float max_x = 0.0f;
|
|
|
+ for (int pass = 0; pass < 2; pass++)
|
|
|
+ for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
|
|
|
+ {
|
|
|
+ if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))
|
|
|
+ continue;
|
|
|
+ const int column_n = table->DisplayOrderToIndex[order_n];
|
|
|
+ ImGuiTableColumn* column = &table->Columns[column_n];
|
|
|
+ if ((column->Flags & ImGuiTableColumnFlags_AngledHeader) == 0) // Note: can't rely on ImGuiTableColumnFlags_IsVisible test here.
|
|
|
+ continue;
|
|
|
+
|
|
|
+ ImVec2 bg_shape[4];
|
|
|
+ bg_shape[0] = ImVec2(column->MaxX, row_r.Max.y);
|
|
|
+ bg_shape[1] = ImVec2(column->MinX, row_r.Max.y);
|
|
|
+ bg_shape[2] = bg_shape[1] + header_angled_vector;
|
|
|
+ bg_shape[3] = bg_shape[0] + header_angled_vector;
|
|
|
+ if (pass == 0)
|
|
|
+ {
|
|
|
+ // Draw shape
|
|
|
+ draw_list->AddQuadFilled(bg_shape[0], bg_shape[1], bg_shape[2], bg_shape[3], GetColorU32(ImGuiCol_TableHeaderBg));
|
|
|
+ if (column_n == highlight_column_n)
|
|
|
+ draw_list->AddQuadFilled(bg_shape[0], bg_shape[1], bg_shape[2], bg_shape[3], GetColorU32(ImGuiCol_Header)); // Highlight on hover
|
|
|
+ //draw_list->AddQuad(bg_shape[0], bg_shape[1], bg_shape[2], bg_shape[3], GetColorU32(ImGuiCol_TableBorderLight), 1.0f);
|
|
|
+ max_x = ImMax(max_x, bg_shape[3].x);
|
|
|
+
|
|
|
+ // Draw label (first draw at an offset where RenderTextXXX() function won't meddle with applying current ClipRect, then transform to final offset)
|
|
|
+ // FIXME: May be worth tidying up all those operations to make them easier to understand.
|
|
|
+ const char* label_name = TableGetColumnName(table, column_n);
|
|
|
+ const float clip_width = max_label_width - (sin_a * table->RowCellPaddingY);
|
|
|
+ ImRect label_r(window->ClipRect.Min, window->ClipRect.Min + ImVec2(clip_width + (flip_label ? 0.0f : table->CellPaddingX), header_height + table->RowCellPaddingY));
|
|
|
+ ImVec2 label_size = CalcTextSize(label_name, NULL, true);
|
|
|
+ ImVec2 label_off = ImVec2(flip_label ? ImMax(0.0f, max_label_width - label_size.x - table->CellPaddingX) : table->CellPaddingX, table->RowCellPaddingY);
|
|
|
+ int vtx_idx_begin = draw_list->_VtxCurrentIdx;
|
|
|
+ RenderTextEllipsis(draw_list, label_r.Min + label_off, label_r.Max, label_r.Max.x, label_r.Max.x, label_name, NULL, &label_size);
|
|
|
+ //if (g.IO.KeyShift) { draw_list->AddRect(label_r.Min, label_r.Max, IM_COL32(0, 255, 0, 255), 0.0f, 0, 2.0f); }
|
|
|
+ int vtx_idx_end = draw_list->_VtxCurrentIdx;
|
|
|
+
|
|
|
+ // Rotate and offset label
|
|
|
+ ImVec2 pivot_in = label_r.GetBL();
|
|
|
+ ImVec2 pivot_out = ImVec2(column->WorkMinX, row_r.Max.y) + (flip_label ? (unit_right * clip_width) : ImVec2(header_height, 0.0f));
|
|
|
+ ShadeVertsTransformPos(draw_list, vtx_idx_begin, vtx_idx_end, pivot_in, label_cos_a, label_sin_a, pivot_out); // Rotate and offset
|
|
|
+ }
|
|
|
+ if (pass == 1)
|
|
|
+ {
|
|
|
+ // Draw border
|
|
|
+ draw_list->AddLine(bg_shape[0], bg_shape[3], TableGetColumnBorderCol(table, order_n, column_n));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ PopClipRect();
|
|
|
+ table->TempData->AngledheadersExtraWidth = ImMax(0.0f, max_x - table->Columns[table->RightMostEnabledColumn].MaxX);
|
|
|
+}
|
|
|
+
|
|
|
//-------------------------------------------------------------------------
|
|
|
// [SECTION] Tables: Context Menu
|
|
|
//-------------------------------------------------------------------------
|
ocornut