pwmgr

// dear imgui, v1.91.5

// - In Visual Studio: CTRL+comma ("Edit.GoToAll") can follow symbols inside comments, whereas CTRL+F12 ("Edit.GoToImplementation") cannot.

// - In Visual Studio w/ Visual Assist installed: ALT+G ("VAssistX.GoToImplementation") can also follow symbols inside comments.

// - In VS Code, CLion, etc.: CTRL+click can follow symbols inside comments.

#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" // warning: 'xxx' is an unsafe pointer used for buffer access

#pragma clang diagnostic ignored "-Wnontrivial-memaccess" // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type

// FIXME: coarse clipping because access to table data causes two issues:

// - instance numbers varying/unstable. may not be a direct problem for users, but could make outside access broken or confusing, e.g. TestEngine.

// - can't implement support for ImGuiChildFlags_ResizeY as we need to somehow pull the height data from somewhere. this also needs stable instance numbers.

// The side-effects of accessing table data on coarse clip would be:

// - always reserving the pooled ImGuiTable data ahead for a fully clipped table (minor IMHO). Also the 'outer_window_is_measuring_size' criteria may already be defeating this in some situations.

// - always performing the GetOrAddByKey() O(log N) query in g.Tables.Map[].

const ImVec2 actual_outer_size = ImTrunc(CalcItemSize(outer_size, ImMax(avail_size.x, 1.0f), use_child_window ? ImMax(avail_size.y, 1.0f) : 0.0f));

ItemAdd(outer_rect, id);

const ImGuiTableFlags previous_flags = table->Flags;

if ((previous_flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) == 0)

ImGuiWindowFlags child_window_flags = (flags & ImGuiTableFlags_ScrollX) ? ImGuiWindowFlags_HorizontalScrollbar : ImGuiWindowFlags_None;

BeginChildEx(name, instance_id, outer_rect.GetSize(), ImGuiChildFlags_None, child_window_flags);

table->HasScrollbarYPrev = table->HasScrollbarYCurr = false;

// Make borders not overlap our contents by offsetting HostClipRect (#6765, #7428, #3752)

// FIXME: Because inner_window's Scrollbar doesn't know about border size, since it's not encoded in window->WindowBorderSize,

// it already overlaps it and doesn't need an extra offset. Ideally we should be able to pass custom border size with

// different x/y values to BeginChild().

{

if (inner_window->DecoOuterSizeX2 == 0.0f)

table->HostClipRect.Max.x = ImMax(table->HostClipRect.Max.x - TABLE_BORDER_SIZE, table->HostClipRect.Min.x);

}

{

if (inner_window->DecoOuterSizeY2 == 0.0f)

table->HostClipRect.Max.y = ImMax(table->HostClipRect.Max.y - TABLE_BORDER_SIZE, table->HostClipRect.Min.y);

}

table->InnerClipRect.Max.y = (flags & ImGuiTableFlags_NoHostExtendY) ? ImMin(table->InnerClipRect.Max.y, inner_window->WorkRect.Max.y) : table->HostClipRect.Max.y;

table->AngledHeadersHeight = 0.0f;

temp_data->AngledHeadersExtraWidth = 0.0f;

if ((previous_flags & ImGuiTableFlags_Reorderable) && (flags & ImGuiTableFlags_Reorderable) == 0)

if (!column->IsPreserveWidthAuto && table->InstanceCurrent == 0)

column->WidthMax = TableCalcMaxColumnWidth(table, column_n);

column->WidthGiven = ImMin(column->WidthGiven, column->WidthMax);

const float previous_instance_work_min_x = column->WorkMinX;

// Detect hovered column

if (is_hovering_table && mouse_skewed_x >= column->ClipRect.Min.x && mouse_skewed_x < column->ClipRect.Max.x)

{

table->HoveredColumnBody = (ImGuiTableColumnIdx)column_n;

}

if (table->InstanceCurrent == 0)

{

column->ContentMaxXFrozen = column->WorkMinX;

column->ContentMaxXUnfrozen = column->WorkMinX;

column->ContentMaxXHeadersUsed = column->WorkMinX;

column->ContentMaxXHeadersIdeal = column->WorkMinX;

}

else

{

// As we store an absolute value to make per-cell updates faster, we need to offset values used for width computation.

const float offset_from_previous_instance = column->WorkMinX - previous_instance_work_min_x;

column->ContentMaxXFrozen += offset_from_previous_instance;

column->ContentMaxXUnfrozen += offset_from_previous_instance;

column->ContentMaxXHeadersUsed += offset_from_previous_instance;

column->ContentMaxXHeadersIdeal += offset_from_previous_instance;

}

if (table->HostSkipItems == false && table->InstanceCurrent == 0)

inner_window->DrawList->PushClipRect(inner_window->InnerClipRect.Min, inner_window->InnerClipRect.Max, false); // FIXME: use table->InnerClipRect?

const float hit_half_width = ImTrunc(TABLE_RESIZE_SEPARATOR_HALF_THICKNESS * g.CurrentDpiScale);

const float hit_y2_body = ImMax(table->OuterRect.Max.y, hit_y1 + table_instance->LastOuterHeight - table->AngledHeadersHeight);

table->InnerWindow->DC.CursorMaxPos.x = max_pos_x + table->TempData->AngledHeadersExtraWidth;

const float new_x2 = (g.IO.MousePos.x - g.ActiveIdClickOffset.x + ImTrunc(TABLE_RESIZE_SEPARATOR_HALF_THICKNESS * g.CurrentDpiScale));

short backup_nav_layers_active_mask = inner_window->DC.NavLayersActiveMask;

inner_window->DC.NavLayersActiveMask |= 1 << ImGuiNavLayer_Main; // So empty table don't appear to navigate differently.

g.CurrentTable = NULL; // To avoid error recovery recursing

g.CurrentTable = table;

inner_window->DC.NavLayersActiveMask = backup_nav_layers_active_mask;

// Some references for this: #7651 + tests "table_reported_size", "table_reported_size_outer" equivalent Y block

// - Checking for ImGuiTableFlags_ScrollX/ScrollY flag makes us a frame ahead when disabling those flags.

// - FIXME-TABLE: Would make sense to pre-compute expected scrollbar visibility/sizes to generally save a frame of feedback.

const float inner_content_max_x = table->OuterRect.Min.x + table->ColumnsAutoFitWidth; // Slightly misleading name but used for code symmetry with inner_content_max_y

const float decoration_size = table->TempData->AngledHeadersExtraWidth + ((table->Flags & ImGuiTableFlags_ScrollY) ? inner_window->ScrollbarSizes.x : 0.0f);

outer_window->DC.IdealMaxPos.x = ImMax(outer_window->DC.IdealMaxPos.x, inner_content_max_x + decoration_size - temp_data->UserOuterSize.x);

outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, ImMin(table->OuterRect.Max.x, inner_content_max_x + decoration_size));

const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.y : 0.0f;

outer_window->DC.CursorMaxPos.y = ImMax(backup_outer_max_pos.y, ImMin(table->OuterRect.Max.y, inner_content_max_y + decoration_size));

// FIXME: If we recorded the number of \n in names we could compute header row height

if (table->HoveredColumnBody != -1 && g.IO.MousePos.y >= bg_y1 && g.IO.MousePos.y < bg_y2 && table_instance->HoveredRowNext < 0)

if (cell_bg_rect.Min.y < cell_bg_rect.Max.y)

window->DrawList->AddRectFilled(cell_bg_rect.Min, cell_bg_rect.Max, cell_data->BgColor);

{

const float y0 = ImMax(table->RowPosY2 + 1, table->InnerClipRect.Min.y);

if (unfreeze_rows_actual)

IM_ASSERT(table->IsUnfrozenRows == false);

table->IsUnfrozenRows = true;

// BgClipRect starts as table->InnerClipRect, reduce it now and make BgClipRectForDrawCmd == BgClipRect

table->BgClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y = ImMin(y0, table->InnerClipRect.Max.y);

table->BgClipRect.Max.y = table->Bg2ClipRectForDrawCmd.Max.y = table->InnerClipRect.Max.y;

table->Bg2DrawChannelCurrent = table->Bg2DrawChannelUnfrozen;

IM_ASSERT(table->Bg2ClipRectForDrawCmd.Min.y <= table->Bg2ClipRectForDrawCmd.Max.y);

float row_height = table->RowPosY2 - table->RowPosY1;

table->RowPosY2 = window->DC.CursorPos.y = table->WorkRect.Min.y + table->RowPosY2 - table->OuterRect.Min.y;

table->RowPosY1 = table->RowPosY2 - row_height;

for (int column_n = 0; column_n < table->ColumnsCount; column_n++)

{

ImGuiTableColumn* column = &table->Columns[column_n];

column->DrawChannelCurrent = column->DrawChannelUnfrozen;

column->ClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y;

}

// Update cliprect ahead of TableBeginCell() so clipper can access to new ClipRect->Min.y

SetWindowClipRectBeforeSetChannel(window, table->Columns[0].ClipRect);

table->DrawSplitter->SetCurrentChannel(window->DrawList, table->Columns[0].DrawChannelCurrent);

}

// Note that actual columns widths are computed in TableUpdateLayout().

//-------------------------------------------------------------------------

// Maximum column content width given current layout. Use column->MinX so this value differs on a per-column basis.

float ImGui::TableCalcMaxColumnWidth(const ImGuiTable* table, int column_n)

const float max_width = ImMax(min_width, column_0->WidthMax); // Don't use TableCalcMaxColumnWidth() here as it would rely on MinX from last instance (#7933)

inner_drawlist->AddRect(outer_border.Min, outer_border.Max, outer_col, 0.0f, 0, border_size);

return (ImGuiSortDirection)((column->SortDirectionsAvailList >> (n << 1)) & 0x03);

// May be able to move all SortSpecs data from table (48 bytes) to ImGuiTableTempData if we decide to write it back on every BeginTable()

sort_spec->SortDirection = (ImGuiSortDirection)column->SortDirection;

// - TableGetHeaderAngledMaxLabelWidth() [Internal]

return width + g.Style.CellPadding.y * 2.0f; // Swap padding

// and can create their own! For example: TableHeader() may be preceded by Checkbox() or other custom widgets.

// This code is intentionally written to not make much use of internal functions, to give you better direction

// if you need to write your own.

// Call layout if not already done. This is automatically done by TableNextRow: we do it here _only_ to make

// it easier to debug-step in TableUpdateLayout(). Your own version of this function doesn't need this.

// Push an id to allow empty/unnamed headers. This is also idiomatic as it ensure there is a consistent ID path to access columns (for e.g. automation)

RenderNavCursor(bb, id, ImGuiNavRenderCursorFlags_Compact | ImGuiNavRenderCursorFlags_NoRounding);

ImGuiTable* table = g.CurrentTable;

ImGuiTableTempData* temp_data = table->TempData;

temp_data->AngledHeadersRequests.resize(0);

temp_data->AngledHeadersRequests.reserve(table->ColumnsEnabledCount);

// Which column needs highlight?

const ImGuiID row_id = GetID("##AngledHeaders");

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;

// Build up request

ImU32 col_header_bg = GetColorU32(ImGuiCol_TableHeaderBg);

ImU32 col_text = GetColorU32(ImGuiCol_Text);

for (int order_n = 0; order_n < table->ColumnsCount; order_n++)

if (IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))

{

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;

ImGuiTableHeaderData request = { (ImGuiTableColumnIdx)column_n, col_text, col_header_bg, (column_n == highlight_column_n) ? GetColorU32(ImGuiCol_Header) : 0 };

temp_data->AngledHeadersRequests.push_back(request);

}

// Render row

TableAngledHeadersRowEx(row_id, g.Style.TableAngledHeadersAngle, 0.0f, temp_data->AngledHeadersRequests.Data, temp_data->AngledHeadersRequests.Size);

// Important: data must be fed left to right

void ImGui::TableAngledHeadersRowEx(ImGuiID row_id, float angle, float max_label_width, const ImGuiTableHeaderData* data, int data_count)

const float header_height = g.FontSize + g.Style.CellPadding.x * 2.0f;

const float row_height = ImTrunc(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); // vector from bottom-left to top-left, and from bottom-right to top-right

const ImRect row_r(table->WorkRect.Min.x, table->BgClipRect.Min.y, table->WorkRect.Max.x, table->RowPosY2);

draw_list->AddRectFilled(ImVec2(table->BgClipRect.Min.x, row_r.Min.y), ImVec2(table->BgClipRect.Max.x, row_r.Max.y), GetColorU32(ImGuiCol_TableHeaderBg, 0.25f)); // FIXME-STYLE: Change row background with an arbitrary color.

const float ascent_scaled = g.Font->Ascent * g.FontScale; // FIXME: Standardize those scaling factors better

const float line_off_for_ascent_x = (ImMax((g.FontSize - ascent_scaled) * 0.5f, 0.0f) / -sin_a) * (flip_label ? -1.0f : 1.0f);

const ImVec2 padding = g.Style.CellPadding; // We will always use swapped component

const ImVec2 align = g.Style.TableAngledHeadersTextAlign;

// Draw background and labels in first pass, then all borders.

for (int order_n = 0; order_n < data_count; order_n++)

const ImGuiTableHeaderData* request = &data[order_n];

const int column_n = request->Index;

draw_list->AddQuadFilled(bg_shape[0], bg_shape[1], bg_shape[2], bg_shape[3], request->BgColor0);

draw_list->AddQuadFilled(bg_shape[0], bg_shape[1], bg_shape[2], bg_shape[3], request->BgColor1); // Optional highlight

// Draw label

// - First draw at an offset where RenderTextXXX() function won't meddle with applying current ClipRect, then transform to final offset.

// - Handle multiple lines manually, as we want each lines to follow on the horizontal border, rather than see a whole block rotated.

const char* label_name_end = FindRenderedTextEnd(label_name);

const float line_off_step_x = (g.FontSize / -sin_a);

const int label_lines = ImTextCountLines(label_name, label_name_end);

// Left<>Right alignment

float line_off_curr_x = flip_label ? (label_lines - 1) * line_off_step_x : 0.0f;

float line_off_for_align_x = ImMax((((column->MaxX - column->MinX) - padding.x * 2.0f) - (label_lines * line_off_step_x)), 0.0f) * align.x;

line_off_curr_x += line_off_for_align_x - line_off_for_ascent_x;

// Register header width

column->ContentMaxXHeadersUsed = column->ContentMaxXHeadersIdeal = column->WorkMinX + ImCeil(label_lines * line_off_step_x - line_off_for_align_x);

while (label_name < label_name_end)

{

const char* label_name_eol = strchr(label_name, '\n');

if (label_name_eol == NULL)

label_name_eol = label_name_end;

// FIXME: Individual line clipping for right-most column is broken for negative angles.

ImVec2 label_size = CalcTextSize(label_name, label_name_eol);

float clip_width = max_label_width - padding.y; // Using padding.y*2.0f would be symmetrical but hide more text.

float clip_height = ImMin(label_size.y, column->ClipRect.Max.x - column->WorkMinX - line_off_curr_x);

ImRect clip_r(window->ClipRect.Min, window->ClipRect.Min + ImVec2(clip_width, clip_height));

int vtx_idx_begin = draw_list->_VtxCurrentIdx;

PushStyleColor(ImGuiCol_Text, request->TextColor);

RenderTextEllipsis(draw_list, clip_r.Min, clip_r.Max, clip_r.Max.x, clip_r.Max.x, label_name, label_name_eol, &label_size);

PopStyleColor();

int vtx_idx_end = draw_list->_VtxCurrentIdx;

// Up<>Down alignment

const float available_space = ImMax(clip_width - label_size.x + ImAbs(padding.x * cos_a) * 2.0f - ImAbs(padding.y * sin_a) * 2.0f, 0.0f);

const float vertical_offset = available_space * align.y * (flip_label ? -1.0f : 1.0f);

// Rotate and offset label

ImVec2 pivot_in = ImVec2(window->ClipRect.Min.x - vertical_offset, window->ClipRect.Min.y + label_size.y);

ImVec2 pivot_out = ImVec2(column->WorkMinX, row_r.Max.y);

line_off_curr_x += flip_label ? -line_off_step_x : line_off_step_x;

pivot_out += unit_right * padding.y;

if (flip_label)

pivot_out += unit_right * (clip_width - ImMax(0.0f, clip_width - label_size.x));

pivot_out.x += flip_label ? line_off_curr_x + line_off_step_x : line_off_curr_x;

ShadeVertsTransformPos(draw_list, vtx_idx_begin, vtx_idx_end, pivot_in, label_cos_a, label_sin_a, pivot_out); // Rotate and offset

//if (g.IO.KeyShift) { ImDrawList* fg_dl = GetForegroundDrawList(); vtx_idx_begin = fg_dl->_VtxCurrentIdx; fg_dl->AddRect(clip_r.Min, clip_r.Max, IM_COL32(0, 255, 0, 255), 0.0f, 0, 1.0f); ShadeVertsTransformPos(fg_dl, vtx_idx_begin, fg_dl->_VtxCurrentIdx, pivot_in, label_cos_a, label_sin_a, pivot_out); }

label_name = label_name_eol + 1;

}

table->TempData->AngledHeadersExtraWidth = ImMax(0.0f, max_x - table->Columns[table->RightMostEnabledColumn].MaxX);

PushItemFlag(ImGuiItemFlags_AutoClosePopups, false);

static const float COLUMNS_HIT_RECT_HALF_THICKNESS = 4.0f;

float x = g.IO.MousePos.x - g.ActiveIdClickOffset.x + ImTrunc(COLUMNS_HIT_RECT_HALF_THICKNESS * g.CurrentDpiScale) - window->Pos.x;

const float column_hit_hw = ImTrunc(COLUMNS_HIT_RECT_HALF_THICKNESS * g.CurrentDpiScale);

SetMouseCursor(ImGuiMouseCursor_ResizeEW);

void ImGui::Columns(int columns_count, const char* id, bool borders)

ImGuiOldColumnFlags flags = (borders ? 0 : ImGuiOldColumnFlags_NoBorder);