1	// dear imgui, v1.92.2b
2	// (tables and columns code)
3
4	/*
5
6	Index of this file:
7
8	// [SECTION] Commentary
9	// [SECTION] Header mess
10	// [SECTION] Tables: Main code
11	// [SECTION] Tables: Simple accessors
12	// [SECTION] Tables: Row changes
13	// [SECTION] Tables: Columns changes
14	// [SECTION] Tables: Columns width management
15	// [SECTION] Tables: Drawing
16	// [SECTION] Tables: Sorting
17	// [SECTION] Tables: Headers
18	// [SECTION] Tables: Context Menu
19	// [SECTION] Tables: Settings (.ini data)
20	// [SECTION] Tables: Garbage Collection
21	// [SECTION] Tables: Debugging
22	// [SECTION] Columns, BeginColumns, EndColumns, etc.
23
24	*/
25
26	// Navigating this file:
27	// - In Visual Studio: CTRL+comma ("Edit.GoToAll") can follow symbols inside comments, whereas CTRL+F12 ("Edit.GoToImplementation") cannot.
28	// - In Visual Studio w/ Visual Assist installed: ALT+G ("VAssistX.GoToImplementation") can also follow symbols inside comments.
29	// - In VS Code, CLion, etc.: CTRL+click can follow symbols inside comments.
30
31	//-----------------------------------------------------------------------------
32	// [SECTION] Commentary
33	//-----------------------------------------------------------------------------
34
35	//-----------------------------------------------------------------------------
36	// Typical tables call flow: (root level is generally public API):
37	//-----------------------------------------------------------------------------
38	// - BeginTable() user begin into a table
39	// | BeginChild() - (if ScrollX/ScrollY is set)
40	// | TableBeginInitMemory() - first time table is used
41	// | TableResetSettings() - on settings reset
42	// | TableLoadSettings() - on settings load
43	// | TableBeginApplyRequests() - apply queued resizing/reordering/hiding requests
44	// | - TableSetColumnWidth() - apply resizing width (for mouse resize, often requested by previous frame)
45	// | - TableUpdateColumnsWeightFromWidth()- recompute columns weights (of stretch columns) from their respective width
46	// - TableSetupColumn() user submit columns details (optional)
47	// - TableSetupScrollFreeze() user submit scroll freeze information (optional)
48	//-----------------------------------------------------------------------------
49	// - TableUpdateLayout() [Internal] followup to BeginTable(): setup everything: widths, columns positions, clipping rectangles. Automatically called by the FIRST call to TableNextRow() or TableHeadersRow().
50	// | TableSetupDrawChannels() - setup ImDrawList channels
51	// | TableUpdateBorders() - detect hovering columns for resize, ahead of contents submission
52	// | TableBeginContextMenuPopup()
53	// | - TableDrawDefaultContextMenu() - draw right-click context menu contents
54	//-----------------------------------------------------------------------------
55	// - TableHeadersRow() or TableHeader() user submit a headers row (optional)
56	// | TableSortSpecsClickColumn() - when left-clicked: alter sort order and sort direction
57	// | TableOpenContextMenu() - when right-clicked: trigger opening of the default context menu
58	// - TableGetSortSpecs() user queries updated sort specs (optional, generally after submitting headers)
59	// - TableNextRow() user begin into a new row (also automatically called by TableHeadersRow())
60	// | TableEndRow() - finish existing row
61	// | TableBeginRow() - add a new row
62	// - TableSetColumnIndex() / TableNextColumn() user begin into a cell
63	// | TableEndCell() - close existing column/cell
64	// | TableBeginCell() - enter into current column/cell
65	// - [...] user emit contents
66	//-----------------------------------------------------------------------------
67	// - EndTable() user ends the table
68	// | TableDrawBorders() - draw outer borders, inner vertical borders
69	// | TableMergeDrawChannels() - merge draw channels if clipping isn't required
70	// | EndChild() - (if ScrollX/ScrollY is set)
71	//-----------------------------------------------------------------------------
72
73	//-----------------------------------------------------------------------------
74	// TABLE SIZING
75	//-----------------------------------------------------------------------------
76	// (Read carefully because this is subtle but it does make sense!)
77	//-----------------------------------------------------------------------------
78	// About 'outer_size':
79	// Its meaning needs to differ slightly depending on if we are using ScrollX/ScrollY flags.
80	// Default value is ImVec2(0.0f, 0.0f).
81	// X
82	// - outer_size.x <= 0.0f -> Right-align from window/work-rect right-most edge. With -FLT_MIN or 0.0f will align exactly on right-most edge.
83	// - outer_size.x > 0.0f -> Set Fixed width.
84	// Y with ScrollX/ScrollY disabled: we output table directly in current window
85	// - outer_size.y < 0.0f -> Bottom-align (but will auto extend, unless _NoHostExtendY is set). Not meaningful if parent window can vertically scroll.
86	// - outer_size.y = 0.0f -> No minimum height (but will auto extend, unless _NoHostExtendY is set)
87	// - outer_size.y > 0.0f -> Set Minimum height (but will auto extend, unless _NoHostExtendY is set)
88	// Y with ScrollX/ScrollY enabled: using a child window for scrolling
89	// - outer_size.y < 0.0f -> Bottom-align. Not meaningful if parent window can vertically scroll.
90	// - outer_size.y = 0.0f -> Bottom-align, consistent with BeginChild(). Not recommended unless table is last item in parent window.
91	// - outer_size.y > 0.0f -> Set Exact height. Recommended when using Scrolling on any axis.
92	//-----------------------------------------------------------------------------
93	// Outer size is also affected by the NoHostExtendX/NoHostExtendY flags.
94	// Important to note how the two flags have slightly different behaviors!
95	// - ImGuiTableFlags_NoHostExtendX -> Make outer width auto-fit to columns (overriding outer_size.x value). Only available when ScrollX/ScrollY are disabled and Stretch columns are not used.
96	// - ImGuiTableFlags_NoHostExtendY -> Make outer height stop exactly at outer_size.y (prevent auto-extending table past the limit). Only available when ScrollX/ScrollY is disabled. Data below the limit will be clipped and not visible.
97	// In theory ImGuiTableFlags_NoHostExtendY could be the default and any non-scrolling tables with outer_size.y != 0.0f would use exact height.
98	// This would be consistent but perhaps less useful and more confusing (as vertically clipped items are not useful and not easily noticeable).
99	//-----------------------------------------------------------------------------
100	// About 'inner_width':
101	// With ScrollX disabled:
102	// - inner_width -> *ignored*
103	// With ScrollX enabled:
104	// - inner_width < 0.0f -> *illegal* fit in known width (right align from outer_size.x) <-- weird
105	// - inner_width = 0.0f -> fit in outer_width: Fixed size columns will take space they need (if avail, otherwise shrink down), Stretch columns becomes Fixed columns.
106	// - inner_width > 0.0f -> override scrolling width, generally to be larger than outer_size.x. Fixed column take space they need (if avail, otherwise shrink down), Stretch columns share remaining space!
107	//-----------------------------------------------------------------------------
108	// Details:
109	// - If you want to use Stretch columns with ScrollX, you generally need to specify 'inner_width' otherwise the concept
110	// of "available space" doesn't make sense.
111	// - Even if not really useful, we allow 'inner_width < outer_size.x' for consistency and to facilitate understanding
112	// of what the value does.
113	//-----------------------------------------------------------------------------
114
115	//-----------------------------------------------------------------------------
116	// COLUMNS SIZING POLICIES
117	// (Reference: ImGuiTableFlags_SizingXXX flags and ImGuiTableColumnFlags_WidthXXX flags)
118	//-----------------------------------------------------------------------------
119	// About overriding column sizing policy and width/weight with TableSetupColumn():
120	// We use a default parameter of -1 for 'init_width'/'init_weight'.
121	// - with ImGuiTableColumnFlags_WidthFixed, init_width <= 0 (default) --> width is automatic
122	// - with ImGuiTableColumnFlags_WidthFixed, init_width > 0 (explicit) --> width is custom
123	// - with ImGuiTableColumnFlags_WidthStretch, init_weight <= 0 (default) --> weight is 1.0f
124	// - with ImGuiTableColumnFlags_WidthStretch, init_weight > 0 (explicit) --> weight is custom
125	// Widths are specified _without_ CellPadding. If you specify a width of 100.0f, the column will be cover (100.0f + Padding * 2.0f)
126	// and you can fit a 100.0f wide item in it without clipping and with padding honored.
127	//-----------------------------------------------------------------------------
128	// About default sizing policy (if you don't specify a ImGuiTableColumnFlags_WidthXXXX flag)
129	// - with Table policy ImGuiTableFlags_SizingFixedFit --> default Column policy is ImGuiTableColumnFlags_WidthFixed, default Width is equal to contents width
130	// - with Table policy ImGuiTableFlags_SizingFixedSame --> default Column policy is ImGuiTableColumnFlags_WidthFixed, default Width is max of all contents width
131	// - with Table policy ImGuiTableFlags_SizingStretchSame --> default Column policy is ImGuiTableColumnFlags_WidthStretch, default Weight is 1.0f
132	// - with Table policy ImGuiTableFlags_SizingStretchWeight --> default Column policy is ImGuiTableColumnFlags_WidthStretch, default Weight is proportional to contents
133	// Default Width and default Weight can be overridden when calling TableSetupColumn().
134	//-----------------------------------------------------------------------------
135	// About mixing Fixed/Auto and Stretch columns together:
136	// - the typical use of mixing sizing policies is: any number of LEADING Fixed columns, followed by one or two TRAILING Stretch columns.
137	// - using mixed policies with ScrollX does not make much sense, as using Stretch columns with ScrollX does not make much sense in the first place!
138	// that is, unless 'inner_width' is passed to BeginTable() to explicitly provide a total width to layout columns in.
139	// - when using ImGuiTableFlags_SizingFixedSame with mixed columns, only the Fixed/Auto columns will match their widths to the width of the maximum contents.
140	// - when using ImGuiTableFlags_SizingStretchSame with mixed columns, only the Stretch columns will match their weights/widths.
141	//-----------------------------------------------------------------------------
142	// About using column width:
143	// If a column is manually resizable or has a width specified with TableSetupColumn():
144	// - you may use GetContentRegionAvail().x to query the width available in a given column.
145	// - right-side alignment features such as SetNextItemWidth(-x) or PushItemWidth(-x) will rely on this width.
146	// If the column is not resizable and has no width specified with TableSetupColumn():
147	// - its width will be automatic and be set to the max of items submitted.
148	// - therefore you generally cannot have ALL items of the columns use e.g. SetNextItemWidth(-FLT_MIN).
149	// - but if the column has one or more items of known/fixed size, this will become the reference width used by SetNextItemWidth(-FLT_MIN).
150	//-----------------------------------------------------------------------------
151
152
153	//-----------------------------------------------------------------------------
154	// TABLES CLIPPING/CULLING
155	//-----------------------------------------------------------------------------
156	// About clipping/culling of Rows in Tables:
157	// - For large numbers of rows, it is recommended you use ImGuiListClipper to submit only visible rows.
158	// ImGuiListClipper is reliant on the fact that rows are of equal height.
159	// See 'Demo->Tables->Vertical Scrolling' or 'Demo->Tables->Advanced' for a demo of using the clipper.
160	// - Note that auto-resizing columns don't play well with using the clipper.
161	// By default a table with _ScrollX but without _Resizable will have column auto-resize.
162	// So, if you want to use the clipper, make sure to either enable _Resizable, either setup columns width explicitly with _WidthFixed.
163	//-----------------------------------------------------------------------------
164	// About clipping/culling of Columns in Tables:
165	// - Both TableSetColumnIndex() and TableNextColumn() return true when the column is visible or performing
166	// width measurements. Otherwise, you may skip submitting the contents of a cell/column, BUT ONLY if you know
167	// it is not going to contribute to row height.
168	// In many situations, you may skip submitting contents for every column but one (e.g. the first one).
169	// - Case A: column is not hidden by user, and at least partially in sight (most common case).
170	// - Case B: column is clipped / out of sight (because of scrolling or parent ClipRect): TableNextColumn() return false as a hint but we still allow layout output.
171	// - Case C: column is hidden explicitly by the user (e.g. via the context menu, or _DefaultHide column flag, etc.).
172	//
173	// [A] [B] [C]
174	// TableNextColumn(): true false false -> [userland] when TableNextColumn() / TableSetColumnIndex() returns false, user can skip submitting items but only if the column doesn't contribute to row height.
175	// SkipItems: false false true -> [internal] when SkipItems is true, most widgets will early out if submitted, resulting is no layout output.
176	// ClipRect: normal zero-width zero-width -> [internal] when ClipRect is zero, ItemAdd() will return false and most widgets will early out mid-way.
177	// ImDrawList output: normal dummy dummy -> [internal] when using the dummy channel, ImDrawList submissions (if any) will be wasted (because cliprect is zero-width anyway).
178	//
179	// - We need to distinguish those cases because non-hidden columns that are clipped outside of scrolling bounds should still contribute their height to the row.
180	// However, in the majority of cases, the contribution to row height is the same for all columns, or the tallest cells are known by the programmer.
181	//-----------------------------------------------------------------------------
182	// About clipping/culling of whole Tables:
183	// - Scrolling tables with a known outer size can be clipped earlier as BeginTable() will return false.
184	//-----------------------------------------------------------------------------
185
186	//-----------------------------------------------------------------------------
187	// [SECTION] Header mess
188	//-----------------------------------------------------------------------------
189
190	#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
191	#define _CRT_SECURE_NO_WARNINGS
192	#endif
193
194	#ifndef IMGUI_DEFINE_MATH_OPERATORS
195	#define IMGUI_DEFINE_MATH_OPERATORS
196	#endif
197
198	#include "imgui.h"
199	#ifndef IMGUI_DISABLE
200	#include "imgui_internal.h"
201
202	// System includes
203	#include <stdint.h> // intptr_t
204
205	// Visual Studio warnings
206	#ifdef _MSC_VER
207	#pragma warning (disable: 4127) // condition expression is constant
208	#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
209	#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later
210	#pragma warning (disable: 5054) // operator '|': deprecated between enumerations of different types
211	#endif
212	#pragma warning (disable: 26451) // [Static Analyzer] Arithmetic overflow : Using operator 'xxx' on a 4 byte value and then casting the result to a 8 byte value. Cast the value to the wider type before calling operator 'xxx' to avoid overflow(io.2).
213	#pragma warning (disable: 26812) // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
214	#endif
215
216	// Clang/GCC warnings with -Weverything
217	#if defined(__clang__)
218	#if __has_warning("-Wunknown-warning-option")
219	#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx' // not all warnings are known by all Clang versions and they tend to be rename-happy.. so ignoring warnings triggers new warnings on some configuration. Great!
220	#endif
221	#pragma clang diagnostic ignored "-Wunknown-pragmas" // warning: unknown warning group 'xxx'
222	#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast // yes, they are more terse.
223	#pragma clang diagnostic ignored "-Wfloat-equal" // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants (typically 0.0f) is ok.
224	#pragma clang diagnostic ignored "-Wformat" // warning: format specifies type 'int' but the argument has type 'unsigned int'
225	#pragma clang diagnostic ignored "-Wformat-nonliteral" // warning: format string is not a string literal // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.
226	#pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
227	#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning: zero as null pointer constant // some standard header variations use #define NULL 0
228	#pragma clang diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function // using printf() is a misery with this as C++ va_arg ellipsis changes float to double.
229	#pragma clang diagnostic ignored "-Wenum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_')
230	#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"// warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated
231	#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision
232	#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" // warning: 'xxx' is an unsafe pointer used for buffer access
233	#pragma clang diagnostic ignored "-Wnontrivial-memaccess" // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type
234	#pragma clang diagnostic ignored "-Wswitch-default" // warning: 'switch' missing 'default' label
235	#elif defined(__GNUC__)
236	#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind
237	#pragma GCC diagnostic ignored "-Wfloat-equal" // warning: comparing floating-point with '==' or '!=' is unsafe
238	#pragma GCC diagnostic ignored "-Wformat-nonliteral" // warning: format not a string literal, format string not checked
239	#pragma GCC diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function
240	#pragma GCC diagnostic ignored "-Wformat" // warning: format '%p' expects argument of type 'int'/'void*', but argument X has type 'unsigned int'/'ImGuiWindow*'
241	#pragma GCC diagnostic ignored "-Wstrict-overflow"
242	#pragma GCC diagnostic ignored "-Wclass-memaccess" // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
243	#endif
244
245	//-----------------------------------------------------------------------------
246	// [SECTION] Tables: Main code
247	//-----------------------------------------------------------------------------
248	// - TableFixFlags() [Internal]
249	// - TableFindByID() [Internal]
250	// - BeginTable()
251	// - BeginTableEx() [Internal]
252	// - TableBeginInitMemory() [Internal]
253	// - TableBeginApplyRequests() [Internal]
254	// - TableSetupColumnFlags() [Internal]
255	// - TableUpdateLayout() [Internal]
256	// - TableUpdateBorders() [Internal]
257	// - EndTable()
258	// - TableSetupColumn()
259	// - TableSetupScrollFreeze()
260	//-----------------------------------------------------------------------------
261
262	// Configuration
263	static const int TABLE_DRAW_CHANNEL_BG0 = 0;
264	static const int TABLE_DRAW_CHANNEL_BG2_FROZEN = 1;
265	static const int TABLE_DRAW_CHANNEL_NOCLIP = 2; // When using ImGuiTableFlags_NoClip (this becomes the last visible channel)
266	static const float TABLE_BORDER_SIZE = 1.0f; // FIXME-TABLE: Currently hard-coded because of clipping assumptions with outer borders rendering.
267	static const float TABLE_RESIZE_SEPARATOR_HALF_THICKNESS = 4.0f; // Extend outside inner borders.
268	static const float TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER = 0.06f; // Delay/timer before making the hover feedback (color+cursor) visible because tables/columns tends to be more cramped.
269
270	// Helper
271	inline ImGuiTableFlags TableFixFlags(ImGuiTableFlags flags, ImGuiWindow* outer_window)
272	{
273	// Adjust flags: set default sizing policy
274	if ((flags & ImGuiTableFlags_SizingMask_) == 0)
275	flags |= ((flags & ImGuiTableFlags_ScrollX) || (outer_window->Flags & ImGuiWindowFlags_AlwaysAutoResize)) ? ImGuiTableFlags_SizingFixedFit : ImGuiTableFlags_SizingStretchSame;
276
277	// Adjust flags: enable NoKeepColumnsVisible when using ImGuiTableFlags_SizingFixedSame
278	if ((flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedSame)
279	flags |= ImGuiTableFlags_NoKeepColumnsVisible;
280
281	// Adjust flags: enforce borders when resizable
282	if (flags & ImGuiTableFlags_Resizable)
283	flags |= ImGuiTableFlags_BordersInnerV;
284
285	// Adjust flags: disable NoHostExtendX/NoHostExtendY if we have any scrolling going on
286	if (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY))
287	flags &= ~(ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_NoHostExtendY);
288
289	// Adjust flags: NoBordersInBodyUntilResize takes priority over NoBordersInBody
290	if (flags & ImGuiTableFlags_NoBordersInBodyUntilResize)
291	flags &= ~ImGuiTableFlags_NoBordersInBody;
292
293	// Adjust flags: disable saved settings if there's nothing to save
294	if ((flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Hideable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Sortable)) == 0)
295	flags |= ImGuiTableFlags_NoSavedSettings;
296
297	// Inherit _NoSavedSettings from top-level window (child windows always have _NoSavedSettings set)
298	if (outer_window->RootWindow->Flags & ImGuiWindowFlags_NoSavedSettings)
299	flags |= ImGuiTableFlags_NoSavedSettings;
300
301	return flags;
302	}
303
304	ImGuiTable* ImGui::TableFindByID(ImGuiID id)
305	{
306	ImGuiContext& g = *GImGui;
307	return g.Tables.GetByKey(key: id);
308	}
309
310	// Read about "TABLE SIZING" at the top of this file.
311	bool ImGui::BeginTable(const char* str_id, int columns_count, ImGuiTableFlags flags, const ImVec2& outer_size, float inner_width)
312	{
313	ImGuiID id = GetID(str_id);
314	return BeginTableEx(name: str_id, id, columns_count, flags, outer_size, inner_width);
315	}
316
317	bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, const ImVec2& outer_size, float inner_width)
318	{
319	ImGuiContext& g = *GImGui;
320	ImGuiWindow* outer_window = GetCurrentWindow();
321	if (outer_window->SkipItems) // Consistent with other tables + beneficial side effect that assert on miscalling EndTable() will be more visible.
322	return false;
323
324	// Sanity checks
325	IM_ASSERT(columns_count > 0 && columns_count < IMGUI_TABLE_MAX_COLUMNS);
326	if (flags & ImGuiTableFlags_ScrollX)
327	IM_ASSERT(inner_width >= 0.0f);
328
329	// If an outer size is specified ahead we will be able to early out when not visible. Exact clipping criteria may evolve.
330	// FIXME: coarse clipping because access to table data causes two issues:
331	// - instance numbers varying/unstable. may not be a direct problem for users, but could make outside access broken or confusing, e.g. TestEngine.
332	// - can't implement support for ImGuiChildFlags_ResizeY as we need to somehow pull the height data from somewhere. this also needs stable instance numbers.
333	// The side-effects of accessing table data on coarse clip would be:
334	// - 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.
335	// - always performing the GetOrAddByKey() O(log N) query in g.Tables.Map[].
336	const bool use_child_window = (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) != 0;
337	const ImVec2 avail_size = GetContentRegionAvail();
338	const ImVec2 actual_outer_size = ImTrunc(v: CalcItemSize(size: outer_size, default_w: ImMax(lhs: avail_size.x, rhs: 1.0f), default_h: use_child_window ? ImMax(lhs: avail_size.y, rhs: 1.0f) : 0.0f));
339	const ImRect outer_rect(outer_window->DC.CursorPos, outer_window->DC.CursorPos + actual_outer_size);
340	const bool outer_window_is_measuring_size = (outer_window->AutoFitFramesX > 0) || (outer_window->AutoFitFramesY > 0); // Doesn't apply to AlwaysAutoResize windows!
341	if (use_child_window && IsClippedEx(bb: outer_rect, id: 0) && !outer_window_is_measuring_size)
342	{
343	ItemSize(bb: outer_rect);
344	ItemAdd(bb: outer_rect, id);
345	g.NextWindowData.ClearFlags();
346	return false;
347	}
348
349	// [DEBUG] Debug break requested by user
350	if (g.DebugBreakInTable == id)
351	IM_DEBUG_BREAK();
352
353	// Acquire storage for the table
354	ImGuiTable* table = g.Tables.GetOrAddByKey(key: id);
355
356	// Acquire temporary buffers
357	const int table_idx = g.Tables.GetIndex(p: table);
358	if (++g.TablesTempDataStacked > g.TablesTempData.Size)
359	g.TablesTempData.resize(new_size: g.TablesTempDataStacked, v: ImGuiTableTempData());
360	ImGuiTableTempData* temp_data = table->TempData = &g.TablesTempData[g.TablesTempDataStacked - 1];
361	temp_data->TableIndex = table_idx;
362	table->DrawSplitter = &table->TempData->DrawSplitter;
363	table->DrawSplitter->Clear();
364
365	// Fix flags
366	table->IsDefaultSizingPolicy = (flags & ImGuiTableFlags_SizingMask_) == 0;
367	flags = TableFixFlags(flags, outer_window);
368
369	// Initialize
370	const int previous_frame_active = table->LastFrameActive;
371	const int instance_no = (previous_frame_active != g.FrameCount) ? 0 : table->InstanceCurrent + 1;
372	const ImGuiTableFlags previous_flags = table->Flags;
373	table->ID = id;
374	table->Flags = flags;
375	table->LastFrameActive = g.FrameCount;
376	table->OuterWindow = table->InnerWindow = outer_window;
377	table->ColumnsCount = columns_count;
378	table->IsLayoutLocked = false;
379	table->InnerWidth = inner_width;
380	table->NavLayer = (ImS8)outer_window->DC.NavLayerCurrent;
381	temp_data->UserOuterSize = outer_size;
382
383	// Instance data (for instance 0, TableID == TableInstanceID)
384	ImGuiID instance_id;
385	table->InstanceCurrent = (ImS16)instance_no;
386	if (instance_no > 0)
387	{
388	IM_ASSERT(table->ColumnsCount == columns_count && "BeginTable(): Cannot change columns count mid-frame while preserving same ID");
389	if (table->InstanceDataExtra.Size < instance_no)
390	table->InstanceDataExtra.push_back(v: ImGuiTableInstanceData());
391	instance_id = GetIDWithSeed(n: instance_no, seed: GetIDWithSeed(str_id_begin: "##Instances", NULL, seed: id)); // Push "##Instances" followed by (int)instance_no in ID stack.
392	}
393	else
394	{
395	instance_id = id;
396	}
397	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
398	table_instance->TableInstanceID = instance_id;
399
400	// When not using a child window, WorkRect.Max will grow as we append contents.
401	if (use_child_window)
402	{
403	// Ensure no vertical scrollbar appears if we only want horizontal one, to make flag consistent
404	// (we have no other way to disable vertical scrollbar of a window while keeping the horizontal one showing)
405	ImVec2 override_content_size(FLT_MAX, FLT_MAX);
406	if ((flags & ImGuiTableFlags_ScrollX) && !(flags & ImGuiTableFlags_ScrollY))
407	override_content_size.y = FLT_MIN;
408
409	// Ensure specified width (when not specified, Stretched columns will act as if the width == OuterWidth and
410	// never lead to any scrolling). We don't handle inner_width < 0.0f, we could potentially use it to right-align
411	// based on the right side of the child window work rect, which would require knowing ahead if we are going to
412	// have decoration taking horizontal spaces (typically a vertical scrollbar).
413	if ((flags & ImGuiTableFlags_ScrollX) && inner_width > 0.0f)
414	override_content_size.x = inner_width;
415
416	if (override_content_size.x != FLT_MAX || override_content_size.y != FLT_MAX)
417	SetNextWindowContentSize(ImVec2(override_content_size.x != FLT_MAX ? override_content_size.x : 0.0f, override_content_size.y != FLT_MAX ? override_content_size.y : 0.0f));
418
419	// Reset scroll if we are reactivating it
420	if ((previous_flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) == 0)
421	if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasScroll) == 0)
422	SetNextWindowScroll(ImVec2(0.0f, 0.0f));
423
424	// Create scrolling region (without border and zero window padding)
425	ImGuiChildFlags child_child_flags = (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasChildFlags) ? g.NextWindowData.ChildFlags : ImGuiChildFlags_None;
426	ImGuiWindowFlags child_window_flags = (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasWindowFlags) ? g.NextWindowData.WindowFlags : ImGuiWindowFlags_None;
427	if (flags & ImGuiTableFlags_ScrollX)
428	child_window_flags |= ImGuiWindowFlags_HorizontalScrollbar;
429	BeginChildEx(name, id: instance_id, size_arg: outer_rect.GetSize(), child_flags: child_child_flags, window_flags: child_window_flags);
430	table->InnerWindow = g.CurrentWindow;
431	table->WorkRect = table->InnerWindow->WorkRect;
432	table->OuterRect = table->InnerWindow->Rect();
433	table->InnerRect = table->InnerWindow->InnerRect;
434	IM_ASSERT(table->InnerWindow->WindowPadding.x == 0.0f && table->InnerWindow->WindowPadding.y == 0.0f && table->InnerWindow->WindowBorderSize == 0.0f);
435
436	// Allow submitting when host is measuring
437	if (table->InnerWindow->SkipItems && outer_window_is_measuring_size)
438	table->InnerWindow->SkipItems = false;
439
440	// When using multiple instances, ensure they have the same amount of horizontal decorations (aka vertical scrollbar) so stretched columns can be aligned)
441	if (instance_no == 0)
442	{
443	table->HasScrollbarYPrev = table->HasScrollbarYCurr;
444	table->HasScrollbarYCurr = false;
445	}
446	table->HasScrollbarYCurr |= table->InnerWindow->ScrollbarY;
447	}
448	else
449	{
450	// For non-scrolling tables, WorkRect == OuterRect == InnerRect.
451	// But at this point we do NOT have a correct value for .Max.y (unless a height has been explicitly passed in). It will only be updated in EndTable().
452	table->WorkRect = table->OuterRect = table->InnerRect = outer_rect;
453	table->HasScrollbarYPrev = table->HasScrollbarYCurr = false;
454	table->InnerWindow->DC.TreeDepth++; // This is designed to always linking ImGuiTreeNodeFlags_DrawLines linking accross a table
455	}
456
457	// Push a standardized ID for both child-using and not-child-using tables
458	PushOverrideID(id);
459	if (instance_no > 0)
460	PushOverrideID(id: instance_id); // FIXME: Somehow this is not resolved by stack-tool, even tho GetIDWithSeed() submitted the symbol.
461
462	// Backup a copy of host window members we will modify
463	ImGuiWindow* inner_window = table->InnerWindow;
464	table->HostIndentX = inner_window->DC.Indent.x;
465	table->HostClipRect = inner_window->ClipRect;
466	table->HostSkipItems = inner_window->SkipItems;
467	temp_data->HostBackupWorkRect = inner_window->WorkRect;
468	temp_data->HostBackupParentWorkRect = inner_window->ParentWorkRect;
469	temp_data->HostBackupColumnsOffset = outer_window->DC.ColumnsOffset;
470	temp_data->HostBackupPrevLineSize = inner_window->DC.PrevLineSize;
471	temp_data->HostBackupCurrLineSize = inner_window->DC.CurrLineSize;
472	temp_data->HostBackupCursorMaxPos = inner_window->DC.CursorMaxPos;
473	temp_data->HostBackupItemWidth = outer_window->DC.ItemWidth;
474	temp_data->HostBackupItemWidthStackSize = outer_window->DC.ItemWidthStack.Size;
475	inner_window->DC.PrevLineSize = inner_window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
476
477	// Make borders not overlap our contents by offsetting HostClipRect (#6765, #7428, #3752)
478	// (we normally shouldn't alter HostClipRect as we rely on TableMergeDrawChannels() expanding non-clipped column toward the
479	// limits of that rectangle, in order for ImDrawListSplitter::Merge() to merge the draw commands. However since the overlap
480	// problem only affect scrolling tables in this case we can get away with doing it without extra cost).
481	if (inner_window != outer_window)
482	{
483	// FIXME: Because inner_window's Scrollbar doesn't know about border size, since it's not encoded in window->WindowBorderSize,
484	// it already overlaps it and doesn't need an extra offset. Ideally we should be able to pass custom border size with
485	// different x/y values to BeginChild().
486	if (flags & ImGuiTableFlags_BordersOuterV)
487	{
488	table->HostClipRect.Min.x = ImMin(lhs: table->HostClipRect.Min.x + TABLE_BORDER_SIZE, rhs: table->HostClipRect.Max.x);
489	if (inner_window->DecoOuterSizeX2 == 0.0f)
490	table->HostClipRect.Max.x = ImMax(lhs: table->HostClipRect.Max.x - TABLE_BORDER_SIZE, rhs: table->HostClipRect.Min.x);
491	}
492	if (flags & ImGuiTableFlags_BordersOuterH)
493	{
494	table->HostClipRect.Min.y = ImMin(lhs: table->HostClipRect.Min.y + TABLE_BORDER_SIZE, rhs: table->HostClipRect.Max.y);
495	if (inner_window->DecoOuterSizeY2 == 0.0f)
496	table->HostClipRect.Max.y = ImMax(lhs: table->HostClipRect.Max.y - TABLE_BORDER_SIZE, rhs: table->HostClipRect.Min.y);
497	}
498	}
499
500	// Padding and Spacing
501	// - None ........Content..... Pad .....Content........
502	// - PadOuter | Pad ..Content..... Pad .....Content.. Pad |
503	// - PadInner ........Content.. Pad | Pad ..Content........
504	// - PadOuter+PadInner | Pad ..Content.. Pad | Pad ..Content.. Pad |
505	const bool pad_outer_x = (flags & ImGuiTableFlags_NoPadOuterX) ? false : (flags & ImGuiTableFlags_PadOuterX) ? true : (flags & ImGuiTableFlags_BordersOuterV) != 0;
506	const bool pad_inner_x = (flags & ImGuiTableFlags_NoPadInnerX) ? false : true;
507	const float inner_spacing_for_border = (flags & ImGuiTableFlags_BordersInnerV) ? TABLE_BORDER_SIZE : 0.0f;
508	const float inner_spacing_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) == 0) ? g.Style.CellPadding.x : 0.0f;
509	const float inner_padding_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) != 0) ? g.Style.CellPadding.x : 0.0f;
510	table->CellSpacingX1 = inner_spacing_explicit + inner_spacing_for_border;
511	table->CellSpacingX2 = inner_spacing_explicit;
512	table->CellPaddingX = inner_padding_explicit;
513
514	const float outer_padding_for_border = (flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
515	const float outer_padding_explicit = pad_outer_x ? g.Style.CellPadding.x : 0.0f;
516	table->OuterPaddingX = (outer_padding_for_border + outer_padding_explicit) - table->CellPaddingX;
517
518	table->CurrentColumn = -1;
519	table->CurrentRow = -1;
520	table->RowBgColorCounter = 0;
521	table->LastRowFlags = ImGuiTableRowFlags_None;
522	table->InnerClipRect = (inner_window == outer_window) ? table->WorkRect : inner_window->ClipRect;
523	table->InnerClipRect.ClipWith(r: table->WorkRect); // We need this to honor inner_width
524	table->InnerClipRect.ClipWithFull(r: table->HostClipRect);
525	table->InnerClipRect.Max.y = (flags & ImGuiTableFlags_NoHostExtendY) ? ImMin(lhs: table->InnerClipRect.Max.y, rhs: inner_window->WorkRect.Max.y) : table->HostClipRect.Max.y;
526
527	table->RowPosY1 = table->RowPosY2 = table->WorkRect.Min.y; // This is needed somehow
528	table->RowTextBaseline = 0.0f; // This will be cleared again by TableBeginRow()
529	table->RowCellPaddingY = 0.0f;
530	table->FreezeRowsRequest = table->FreezeRowsCount = 0; // This will be setup by TableSetupScrollFreeze(), if any
531	table->FreezeColumnsRequest = table->FreezeColumnsCount = 0;
532	table->IsUnfrozenRows = true;
533	table->DeclColumnsCount = table->AngledHeadersCount = 0;
534	if (previous_frame_active + 1 < g.FrameCount)
535	table->IsActiveIdInTable = false;
536	table->AngledHeadersHeight = 0.0f;
537	temp_data->AngledHeadersExtraWidth = 0.0f;
538
539	// Using opaque colors facilitate overlapping lines of the grid, otherwise we'd need to improve TableDrawBorders()
540	table->BorderColorStrong = GetColorU32(idx: ImGuiCol_TableBorderStrong);
541	table->BorderColorLight = GetColorU32(idx: ImGuiCol_TableBorderLight);
542
543	// Make table current
544	g.CurrentTable = table;
545	inner_window->DC.NavIsScrollPushableX = false; // Shortcut for NavUpdateCurrentWindowIsScrollPushableX();
546	outer_window->DC.CurrentTableIdx = table_idx;
547	if (inner_window != outer_window) // So EndChild() within the inner window can restore the table properly.
548	inner_window->DC.CurrentTableIdx = table_idx;
549
550	if ((previous_flags & ImGuiTableFlags_Reorderable) && (flags & ImGuiTableFlags_Reorderable) == 0)
551	table->IsResetDisplayOrderRequest = true;
552
553	// Mark as used to avoid GC
554	if (table_idx >= g.TablesLastTimeActive.Size)
555	g.TablesLastTimeActive.resize(new_size: table_idx + 1, v: -1.0f);
556	g.TablesLastTimeActive[table_idx] = (float)g.Time;
557	temp_data->LastTimeActive = (float)g.Time;
558	table->MemoryCompacted = false;
559
560	// Setup memory buffer (clear data if columns count changed)
561	ImGuiTableColumn* old_columns_to_preserve = NULL;
562	void* old_columns_raw_data = NULL;
563	const int old_columns_count = table->Columns.size();
564	if (old_columns_count != 0 && old_columns_count != columns_count)
565	{
566	// Attempt to preserve width on column count change (#4046)
567	old_columns_to_preserve = table->Columns.Data;
568	old_columns_raw_data = table->RawData;
569	table->RawData = NULL;
570	}
571	if (table->RawData == NULL)
572	{
573	TableBeginInitMemory(table, columns_count);
574	table->IsInitializing = table->IsSettingsRequestLoad = true;
575	}
576	if (table->IsResetAllRequest)
577	TableResetSettings(table);
578	if (table->IsInitializing)
579	{
580	// Initialize
581	table->SettingsOffset = -1;
582	table->IsSortSpecsDirty = true;
583	table->IsSettingsDirty = true; // Records itself into .ini file even when in default state (#7934)
584	table->InstanceInteracted = -1;
585	table->ContextPopupColumn = -1;
586	table->ReorderColumn = table->ResizedColumn = table->LastResizedColumn = -1;
587	table->AutoFitSingleColumn = -1;
588	table->HoveredColumnBody = table->HoveredColumnBorder = -1;
589	for (int n = 0; n < columns_count; n++)
590	{
591	ImGuiTableColumn* column = &table->Columns[n];
592	if (old_columns_to_preserve && n < old_columns_count)
593	{
594	// FIXME: We don't attempt to preserve column order in this path.
595	*column = old_columns_to_preserve[n];
596	}
597	else
598	{
599	float width_auto = column->WidthAuto;
600	*column = ImGuiTableColumn();
601	column->WidthAuto = width_auto;
602	column->IsPreserveWidthAuto = true; // Preserve WidthAuto when reinitializing a live table: not technically necessary but remove a visible flicker
603	column->IsEnabled = column->IsUserEnabled = column->IsUserEnabledNextFrame = true;
604	}
605	column->DisplayOrder = table->DisplayOrderToIndex[n] = (ImGuiTableColumnIdx)n;
606	}
607	}
608	if (old_columns_raw_data)
609	IM_FREE(old_columns_raw_data);
610
611	// Load settings
612	if (table->IsSettingsRequestLoad)
613	TableLoadSettings(table);
614
615	// Handle DPI/font resize
616	// This is designed to facilitate DPI changes with the assumption that e.g. style.CellPadding has been scaled as well.
617	// It will also react to changing fonts with mixed results. It doesn't need to be perfect but merely provide a decent transition.
618	// FIXME-DPI: Provide consistent standards for reference size. Perhaps using g.CurrentDpiScale would be more self explanatory.
619	// This is will lead us to non-rounded WidthRequest in columns, which should work but is a poorly tested path.
620	const float new_ref_scale_unit = g.FontSize; // g.Font->GetCharAdvance('A') ?
621	if (table->RefScale != 0.0f && table->RefScale != new_ref_scale_unit)
622	{
623	const float scale_factor = new_ref_scale_unit / table->RefScale;
624	//IMGUI_DEBUG_PRINT("[table] %08X RefScaleUnit %.3f -> %.3f, scaling width by %.3f\n", table->ID, table->RefScaleUnit, new_ref_scale_unit, scale_factor);
625	for (int n = 0; n < columns_count; n++)
626	table->Columns[n].WidthRequest = table->Columns[n].WidthRequest * scale_factor;
627	}
628	table->RefScale = new_ref_scale_unit;
629
630	// Disable output until user calls TableNextRow() or TableNextColumn() leading to the TableUpdateLayout() call..
631	// This is not strictly necessary but will reduce cases were "out of table" output will be misleading to the user.
632	// Because we cannot safely assert in EndTable() when no rows have been created, this seems like our best option.
633	inner_window->SkipItems = true;
634
635	// Clear names
636	// At this point the ->NameOffset field of each column will be invalid until TableUpdateLayout() or the first call to TableSetupColumn()
637	if (table->ColumnsNames.Buf.Size > 0)
638	table->ColumnsNames.Buf.resize(new_size: 0);
639
640	// Apply queued resizing/reordering/hiding requests
641	TableBeginApplyRequests(table);
642
643	return true;
644	}
645
646	// For reference, the average total _allocation count_ for a table is:
647	// + 0 (for ImGuiTable instance, we are pooling allocations in g.Tables[])
648	// + 1 (for table->RawData allocated below)
649	// + 1 (for table->ColumnsNames, if names are used)
650	// Shared allocations for the maximum number of simultaneously nested tables (generally a very small number)
651	// + 1 (for table->Splitter._Channels)
652	// + 2 * active_channels_count (for ImDrawCmd and ImDrawIdx buffers inside channels)
653	// Where active_channels_count is variable but often == columns_count or == columns_count + 1, see TableSetupDrawChannels() for details.
654	// Unused channels don't perform their +2 allocations.
655	void ImGui::TableBeginInitMemory(ImGuiTable* table, int columns_count)
656	{
657	// Allocate single buffer for our arrays
658	const int columns_bit_array_size = (int)ImBitArrayGetStorageSizeInBytes(bitcount: columns_count);
659	ImSpanAllocator<6> span_allocator;
660	span_allocator.Reserve(n: 0, sz: columns_count * sizeof(ImGuiTableColumn));
661	span_allocator.Reserve(n: 1, sz: columns_count * sizeof(ImGuiTableColumnIdx));
662	span_allocator.Reserve(n: 2, sz: columns_count * sizeof(ImGuiTableCellData), a: 4);
663	for (int n = 3; n < 6; n++)
664	span_allocator.Reserve(n, sz: columns_bit_array_size);
665	table->RawData = IM_ALLOC(span_allocator.GetArenaSizeInBytes());
666	memset(s: table->RawData, c: 0, n: span_allocator.GetArenaSizeInBytes());
667	span_allocator.SetArenaBasePtr(table->RawData);
668	span_allocator.GetSpan(n: 0, span: &table->Columns);
669	span_allocator.GetSpan(n: 1, span: &table->DisplayOrderToIndex);
670	span_allocator.GetSpan(n: 2, span: &table->RowCellData);
671	table->EnabledMaskByDisplayOrder = (ImU32*)span_allocator.GetSpanPtrBegin(n: 3);
672	table->EnabledMaskByIndex = (ImU32*)span_allocator.GetSpanPtrBegin(n: 4);
673	table->VisibleMaskByIndex = (ImU32*)span_allocator.GetSpanPtrBegin(n: 5);
674	}
675
676	// Apply queued resizing/reordering/hiding requests
677	void ImGui::TableBeginApplyRequests(ImGuiTable* table)
678	{
679	// Handle resizing request
680	// (We process this in the TableBegin() of the first instance of each table)
681	// FIXME-TABLE: Contains columns if our work area doesn't allow for scrolling?
682	if (table->InstanceCurrent == 0)
683	{
684	if (table->ResizedColumn != -1 && table->ResizedColumnNextWidth != FLT_MAX)
685	TableSetColumnWidth(column_n: table->ResizedColumn, width: table->ResizedColumnNextWidth);
686	table->LastResizedColumn = table->ResizedColumn;
687	table->ResizedColumnNextWidth = FLT_MAX;
688	table->ResizedColumn = -1;
689
690	// Process auto-fit for single column, which is a special case for stretch columns and fixed columns with FixedSame policy.
691	// FIXME-TABLE: Would be nice to redistribute available stretch space accordingly to other weights, instead of giving it all to siblings.
692	if (table->AutoFitSingleColumn != -1)
693	{
694	TableSetColumnWidth(column_n: table->AutoFitSingleColumn, width: table->Columns[table->AutoFitSingleColumn].WidthAuto);
695	table->AutoFitSingleColumn = -1;
696	}
697	}
698
699	// Handle reordering request
700	// Note: we don't clear ReorderColumn after handling the request.
701	if (table->InstanceCurrent == 0)
702	{
703	if (table->HeldHeaderColumn == -1 && table->ReorderColumn != -1)
704	table->ReorderColumn = -1;
705	table->HeldHeaderColumn = -1;
706	if (table->ReorderColumn != -1 && table->ReorderColumnDir != 0)
707	{
708	// We need to handle reordering across hidden columns.
709	// In the configuration below, moving C to the right of E will lead to:
710	// ... C [D] E ---> ... [D] E C (Column name/index)
711	// ... 2 3 4 ... 2 3 4 (Display order)
712	const int reorder_dir = table->ReorderColumnDir;
713	IM_ASSERT(reorder_dir == -1 || reorder_dir == +1);
714	IM_ASSERT(table->Flags & ImGuiTableFlags_Reorderable);
715	ImGuiTableColumn* src_column = &table->Columns[table->ReorderColumn];
716	ImGuiTableColumn* dst_column = &table->Columns[(reorder_dir == -1) ? src_column->PrevEnabledColumn : src_column->NextEnabledColumn];
717	IM_UNUSED(dst_column);
718	const int src_order = src_column->DisplayOrder;
719	const int dst_order = dst_column->DisplayOrder;
720	src_column->DisplayOrder = (ImGuiTableColumnIdx)dst_order;
721	for (int order_n = src_order + reorder_dir; order_n != dst_order + reorder_dir; order_n += reorder_dir)
722	table->Columns[table->DisplayOrderToIndex[order_n]].DisplayOrder -= (ImGuiTableColumnIdx)reorder_dir;
723	IM_ASSERT(dst_column->DisplayOrder == dst_order - reorder_dir);
724
725	// Display order is stored in both columns->IndexDisplayOrder and table->DisplayOrder[]. Rebuild later from the former.
726	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
727	table->DisplayOrderToIndex[table->Columns[column_n].DisplayOrder] = (ImGuiTableColumnIdx)column_n;
728	table->ReorderColumnDir = 0;
729	table->IsSettingsDirty = true;
730	}
731	}
732
733	// Handle display order reset request
734	if (table->IsResetDisplayOrderRequest)
735	{
736	for (int n = 0; n < table->ColumnsCount; n++)
737	table->DisplayOrderToIndex[n] = table->Columns[n].DisplayOrder = (ImGuiTableColumnIdx)n;
738	table->IsResetDisplayOrderRequest = false;
739	table->IsSettingsDirty = true;
740	}
741	}
742
743	// Adjust flags: default width mode + stretch columns are not allowed when auto extending
744	static void TableSetupColumnFlags(ImGuiTable* table, ImGuiTableColumn* column, ImGuiTableColumnFlags flags_in)
745	{
746	ImGuiTableColumnFlags flags = flags_in;
747
748	// Sizing Policy
749	if ((flags & ImGuiTableColumnFlags_WidthMask_) == 0)
750	{
751	const ImGuiTableFlags table_sizing_policy = (table->Flags & ImGuiTableFlags_SizingMask_);
752	if (table_sizing_policy == ImGuiTableFlags_SizingFixedFit || table_sizing_policy == ImGuiTableFlags_SizingFixedSame)
753	flags |= ImGuiTableColumnFlags_WidthFixed;
754	else
755	flags |= ImGuiTableColumnFlags_WidthStretch;
756	}
757	else
758	{
759	IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiTableColumnFlags_WidthMask_)); // Check that only 1 of each set is used.
760	}
761
762	// Resize
763	if ((table->Flags & ImGuiTableFlags_Resizable) == 0)
764	flags |= ImGuiTableColumnFlags_NoResize;
765
766	// Sorting
767	if ((flags & ImGuiTableColumnFlags_NoSortAscending) && (flags & ImGuiTableColumnFlags_NoSortDescending))
768	flags |= ImGuiTableColumnFlags_NoSort;
769
770	// Indentation
771	if ((flags & ImGuiTableColumnFlags_IndentMask_) == 0)
772	flags |= (table->Columns.index_from_ptr(it: column) == 0) ? ImGuiTableColumnFlags_IndentEnable : ImGuiTableColumnFlags_IndentDisable;
773
774	// Alignment
775	//if ((flags & ImGuiTableColumnFlags_AlignMask_) == 0)
776	// flags |= ImGuiTableColumnFlags_AlignCenter;
777	//IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiTableColumnFlags_AlignMask_)); // Check that only 1 of each set is used.
778
779	// Preserve status flags
780	column->Flags = flags | (column->Flags & ImGuiTableColumnFlags_StatusMask_);
781
782	// Build an ordered list of available sort directions
783	column->SortDirectionsAvailCount = column->SortDirectionsAvailMask = column->SortDirectionsAvailList = 0;
784	if (table->Flags & ImGuiTableFlags_Sortable)
785	{
786	int count = 0, mask = 0, list = 0;
787	if ((flags & ImGuiTableColumnFlags_PreferSortAscending) != 0 && (flags & ImGuiTableColumnFlags_NoSortAscending) == 0) { mask |= 1 << ImGuiSortDirection_Ascending; list |= ImGuiSortDirection_Ascending << (count << 1); count++; }
788	if ((flags & ImGuiTableColumnFlags_PreferSortDescending) != 0 && (flags & ImGuiTableColumnFlags_NoSortDescending) == 0) { mask |= 1 << ImGuiSortDirection_Descending; list |= ImGuiSortDirection_Descending << (count << 1); count++; }
789	if ((flags & ImGuiTableColumnFlags_PreferSortAscending) == 0 && (flags & ImGuiTableColumnFlags_NoSortAscending) == 0) { mask |= 1 << ImGuiSortDirection_Ascending; list |= ImGuiSortDirection_Ascending << (count << 1); count++; }
790	if ((flags & ImGuiTableColumnFlags_PreferSortDescending) == 0 && (flags & ImGuiTableColumnFlags_NoSortDescending) == 0) { mask |= 1 << ImGuiSortDirection_Descending; list |= ImGuiSortDirection_Descending << (count << 1); count++; }
791	if ((table->Flags & ImGuiTableFlags_SortTristate) || count == 0) { mask |= 1 << ImGuiSortDirection_None; count++; }
792	column->SortDirectionsAvailList = (ImU8)list;
793	column->SortDirectionsAvailMask = (ImU8)mask;
794	column->SortDirectionsAvailCount = (ImU8)count;
795	ImGui::TableFixColumnSortDirection(table, column);
796	}
797	}
798
799	// Layout columns for the frame. This is in essence the followup to BeginTable() and this is our largest function.
800	// Runs on the first call to TableNextRow(), to give a chance for TableSetupColumn() and other TableSetupXXXXX() functions to be called first.
801	// FIXME-TABLE: Our width (and therefore our WorkRect) will be minimal in the first frame for _WidthAuto columns.
802	// Increase feedback side-effect with widgets relying on WorkRect.Max.x... Maybe provide a default distribution for _WidthAuto columns?
803	void ImGui::TableUpdateLayout(ImGuiTable* table)
804	{
805	ImGuiContext& g = *GImGui;
806	IM_ASSERT(table->IsLayoutLocked == false);
807
808	const ImGuiTableFlags table_sizing_policy = (table->Flags & ImGuiTableFlags_SizingMask_);
809	table->IsDefaultDisplayOrder = true;
810	table->ColumnsEnabledCount = 0;
811	ImBitArrayClearAllBits(arr: table->EnabledMaskByIndex, bitcount: table->ColumnsCount);
812	ImBitArrayClearAllBits(arr: table->EnabledMaskByDisplayOrder, bitcount: table->ColumnsCount);
813	table->LeftMostEnabledColumn = -1;
814	table->MinColumnWidth = ImMax(lhs: 1.0f, rhs: g.Style.FramePadding.x * 1.0f); // g.Style.ColumnsMinSpacing; // FIXME-TABLE
815
816	// [Part 1] Apply/lock Enabled and Order states. Calculate auto/ideal width for columns. Count fixed/stretch columns.
817	// Process columns in their visible orders as we are building the Prev/Next indices.
818	int count_fixed = 0; // Number of columns that have fixed sizing policies
819	int count_stretch = 0; // Number of columns that have stretch sizing policies
820	int prev_visible_column_idx = -1;
821	bool has_auto_fit_request = false;
822	bool has_resizable = false;
823	float stretch_sum_width_auto = 0.0f;
824	float fixed_max_width_auto = 0.0f;
825	for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
826	{
827	const int column_n = table->DisplayOrderToIndex[order_n];
828	if (column_n != order_n)
829	table->IsDefaultDisplayOrder = false;
830	ImGuiTableColumn* column = &table->Columns[column_n];
831
832	// Clear column setup if not submitted by user. Currently we make it mandatory to call TableSetupColumn() every frame.
833	// It would easily work without but we're not ready to guarantee it since e.g. names need resubmission anyway.
834	// We take a slight shortcut but in theory we could be calling TableSetupColumn() here with dummy values, it should yield the same effect.
835	if (table->DeclColumnsCount <= column_n)
836	{
837	TableSetupColumnFlags(table, column, flags_in: ImGuiTableColumnFlags_None);
838	column->NameOffset = -1;
839	column->UserID = 0;
840	column->InitStretchWeightOrWidth = -1.0f;
841	}
842
843	// Update Enabled state, mark settings and sort specs dirty
844	if (!(table->Flags & ImGuiTableFlags_Hideable) || (column->Flags & ImGuiTableColumnFlags_NoHide))
845	column->IsUserEnabledNextFrame = true;
846	if (column->IsUserEnabled != column->IsUserEnabledNextFrame)
847	{
848	column->IsUserEnabled = column->IsUserEnabledNextFrame;
849	table->IsSettingsDirty = true;
850	}
851	column->IsEnabled = column->IsUserEnabled && (column->Flags & ImGuiTableColumnFlags_Disabled) == 0;
852
853	if (column->SortOrder != -1 && !column->IsEnabled)
854	table->IsSortSpecsDirty = true;
855	if (column->SortOrder > 0 && !(table->Flags & ImGuiTableFlags_SortMulti))
856	table->IsSortSpecsDirty = true;
857
858	// Auto-fit unsized columns
859	const bool start_auto_fit = (column->Flags & ImGuiTableColumnFlags_WidthFixed) ? (column->WidthRequest < 0.0f) : (column->StretchWeight < 0.0f);
860	if (start_auto_fit)
861	column->AutoFitQueue = column->CannotSkipItemsQueue = (1 << 3) - 1; // Fit for three frames
862
863	if (!column->IsEnabled)
864	{
865	column->IndexWithinEnabledSet = -1;
866	continue;
867	}
868
869	// Mark as enabled and link to previous/next enabled column
870	column->PrevEnabledColumn = (ImGuiTableColumnIdx)prev_visible_column_idx;
871	column->NextEnabledColumn = -1;
872	if (prev_visible_column_idx != -1)
873	table->Columns[prev_visible_column_idx].NextEnabledColumn = (ImGuiTableColumnIdx)column_n;
874	else
875	table->LeftMostEnabledColumn = (ImGuiTableColumnIdx)column_n;
876	column->IndexWithinEnabledSet = table->ColumnsEnabledCount++;
877	ImBitArraySetBit(arr: table->EnabledMaskByIndex, n: column_n);
878	ImBitArraySetBit(arr: table->EnabledMaskByDisplayOrder, n: column->DisplayOrder);
879	prev_visible_column_idx = column_n;
880	IM_ASSERT(column->IndexWithinEnabledSet <= column->DisplayOrder);
881
882	// Calculate ideal/auto column width (that's the width required for all contents to be visible without clipping)
883	// Combine width from regular rows + width from headers unless requested not to.
884	if (!column->IsPreserveWidthAuto && table->InstanceCurrent == 0)
885	column->WidthAuto = TableGetColumnWidthAuto(table, column);
886
887	// Non-resizable columns keep their requested width (apply user value regardless of IsPreserveWidthAuto)
888	const bool column_is_resizable = (column->Flags & ImGuiTableColumnFlags_NoResize) == 0;
889	if (column_is_resizable)
890	has_resizable = true;
891	if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && column->InitStretchWeightOrWidth > 0.0f && !column_is_resizable)
892	column->WidthAuto = column->InitStretchWeightOrWidth;
893
894	if (column->AutoFitQueue != 0x00)
895	has_auto_fit_request = true;
896	if (column->Flags & ImGuiTableColumnFlags_WidthStretch)
897	{
898	stretch_sum_width_auto += column->WidthAuto;
899	count_stretch++;
900	}
901	else
902	{
903	fixed_max_width_auto = ImMax(lhs: fixed_max_width_auto, rhs: column->WidthAuto);
904	count_fixed++;
905	}
906	}
907	if ((table->Flags & ImGuiTableFlags_Sortable) && table->SortSpecsCount == 0 && !(table->Flags & ImGuiTableFlags_SortTristate))
908	table->IsSortSpecsDirty = true;
909	table->RightMostEnabledColumn = (ImGuiTableColumnIdx)prev_visible_column_idx;
910	IM_ASSERT(table->LeftMostEnabledColumn >= 0 && table->RightMostEnabledColumn >= 0);
911
912	// [Part 2] Disable child window clipping while fitting columns. This is not strictly necessary but makes it possible to avoid
913	// the column fitting having to wait until the first visible frame of the child container (may or not be a good thing). Also see #6510.
914	// FIXME-TABLE: for always auto-resizing columns may not want to do that all the time.
915	if (has_auto_fit_request && table->OuterWindow != table->InnerWindow)
916	table->InnerWindow->SkipItems = false;
917	if (has_auto_fit_request)
918	table->IsSettingsDirty = true;
919
920	// [Part 3] Fix column flags and record a few extra information.
921	float sum_width_requests = 0.0f; // Sum of all width for fixed and auto-resize columns, excluding width contributed by Stretch columns but including spacing/padding.
922	float stretch_sum_weights = 0.0f; // Sum of all weights for stretch columns.
923	table->LeftMostStretchedColumn = table->RightMostStretchedColumn = -1;
924	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
925	{
926	if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
927	continue;
928	ImGuiTableColumn* column = &table->Columns[column_n];
929
930	const bool column_is_resizable = (column->Flags & ImGuiTableColumnFlags_NoResize) == 0;
931	if (column->Flags & ImGuiTableColumnFlags_WidthFixed)
932	{
933	// Apply same widths policy
934	float width_auto = column->WidthAuto;
935	if (table_sizing_policy == ImGuiTableFlags_SizingFixedSame && (column->AutoFitQueue != 0x00 || !column_is_resizable))
936	width_auto = fixed_max_width_auto;
937
938	// Apply automatic width
939	// Latch initial size for fixed columns and update it constantly for auto-resizing column (unless clipped!)
940	if (column->AutoFitQueue != 0x00)
941	column->WidthRequest = width_auto;
942	else if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && !column_is_resizable && column->IsRequestOutput)
943	column->WidthRequest = width_auto;
944
945	// FIXME-TABLE: Increase minimum size during init frame to avoid biasing auto-fitting widgets
946	// (e.g. TextWrapped) too much. Otherwise what tends to happen is that TextWrapped would output a very
947	// large height (= first frame scrollbar display very off + clipper would skip lots of items).
948	// This is merely making the side-effect less extreme, but doesn't properly fixes it.
949	// FIXME: Move this to ->WidthGiven to avoid temporary lossyless?
950	// FIXME: This break IsPreserveWidthAuto from not flickering if the stored WidthAuto was smaller.
951	if (column->AutoFitQueue > 0x01 && table->IsInitializing && !column->IsPreserveWidthAuto)
952	column->WidthRequest = ImMax(lhs: column->WidthRequest, rhs: table->MinColumnWidth * 4.0f); // FIXME-TABLE: Another constant/scale?
953	sum_width_requests += column->WidthRequest;
954	}
955	else
956	{
957	// Initialize stretch weight
958	if (column->AutoFitQueue != 0x00 || column->StretchWeight < 0.0f || !column_is_resizable)
959	{
960	if (column->InitStretchWeightOrWidth > 0.0f)
961	column->StretchWeight = column->InitStretchWeightOrWidth;
962	else if (table_sizing_policy == ImGuiTableFlags_SizingStretchProp)
963	column->StretchWeight = (column->WidthAuto / stretch_sum_width_auto) * count_stretch;
964	else
965	column->StretchWeight = 1.0f;
966	}
967
968	stretch_sum_weights += column->StretchWeight;
969	if (table->LeftMostStretchedColumn == -1 || table->Columns[table->LeftMostStretchedColumn].DisplayOrder > column->DisplayOrder)
970	table->LeftMostStretchedColumn = (ImGuiTableColumnIdx)column_n;
971	if (table->RightMostStretchedColumn == -1 || table->Columns[table->RightMostStretchedColumn].DisplayOrder < column->DisplayOrder)
972	table->RightMostStretchedColumn = (ImGuiTableColumnIdx)column_n;
973	}
974	column->IsPreserveWidthAuto = false;
975	sum_width_requests += table->CellPaddingX * 2.0f;
976	}
977	table->ColumnsEnabledFixedCount = (ImGuiTableColumnIdx)count_fixed;
978	table->ColumnsStretchSumWeights = stretch_sum_weights;
979
980	// [Part 4] Apply final widths based on requested widths
981	const ImRect work_rect = table->WorkRect;
982	const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1);
983	const float width_removed = (table->HasScrollbarYPrev && !table->InnerWindow->ScrollbarY) ? g.Style.ScrollbarSize : 0.0f; // To synchronize decoration width of synced tables with mismatching scrollbar state (#5920)
984	const float width_avail = ImMax(lhs: 1.0f, rhs: (((table->Flags & ImGuiTableFlags_ScrollX) && table->InnerWidth == 0.0f) ? table->InnerClipRect.GetWidth() : work_rect.GetWidth()) - width_removed);
985	const float width_avail_for_stretched_columns = width_avail - width_spacings - sum_width_requests;
986	float width_remaining_for_stretched_columns = width_avail_for_stretched_columns;
987	table->ColumnsGivenWidth = width_spacings + (table->CellPaddingX * 2.0f) * table->ColumnsEnabledCount;
988	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
989	{
990	if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
991	continue;
992	ImGuiTableColumn* column = &table->Columns[column_n];
993
994	// Allocate width for stretched/weighted columns (StretchWeight gets converted into WidthRequest)
995	if (column->Flags & ImGuiTableColumnFlags_WidthStretch)
996	{
997	float weight_ratio = column->StretchWeight / stretch_sum_weights;
998	column->WidthRequest = IM_TRUNC(ImMax(width_avail_for_stretched_columns * weight_ratio, table->MinColumnWidth) + 0.01f);
999	width_remaining_for_stretched_columns -= column->WidthRequest;
1000	}
1001
1002	// [Resize Rule 1] The right-most Visible column is not resizable if there is at least one Stretch column
1003	// See additional comments in TableSetColumnWidth().
1004	if (column->NextEnabledColumn == -1 && table->LeftMostStretchedColumn != -1)
1005	column->Flags |= ImGuiTableColumnFlags_NoDirectResize_;
1006
1007	// Assign final width, record width in case we will need to shrink
1008	column->WidthGiven = ImTrunc(f: ImMax(lhs: column->WidthRequest, rhs: table->MinColumnWidth));
1009	table->ColumnsGivenWidth += column->WidthGiven;
1010	}
1011
1012	// [Part 5] Redistribute stretch remainder width due to rounding (remainder width is < 1.0f * number of Stretch column).
1013	// Using right-to-left distribution (more likely to match resizing cursor).
1014	if (width_remaining_for_stretched_columns >= 1.0f && !(table->Flags & ImGuiTableFlags_PreciseWidths))
1015	for (int order_n = table->ColumnsCount - 1; stretch_sum_weights > 0.0f && width_remaining_for_stretched_columns >= 1.0f && order_n >= 0; order_n--)
1016	{
1017	if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))
1018	continue;
1019	ImGuiTableColumn* column = &table->Columns[table->DisplayOrderToIndex[order_n]];
1020	if (!(column->Flags & ImGuiTableColumnFlags_WidthStretch))
1021	continue;
1022	column->WidthRequest += 1.0f;
1023	column->WidthGiven += 1.0f;
1024	width_remaining_for_stretched_columns -= 1.0f;
1025	}
1026
1027	// Determine if table is hovered which will be used to flag columns as hovered.
1028	// - In principle we'd like to use the equivalent of IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem),
1029	// but because our item is partially submitted at this point we use ItemHoverable() and a workaround (temporarily
1030	// clear ActiveId, which is equivalent to the change provided by _AllowWhenBLockedByActiveItem).
1031	// - This allows columns to be marked as hovered when e.g. clicking a button inside the column, or using drag and drop.
1032	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
1033	table_instance->HoveredRowLast = table_instance->HoveredRowNext;
1034	table_instance->HoveredRowNext = -1;
1035	table->HoveredColumnBody = table->HoveredColumnBorder = -1;
1036	const ImRect mouse_hit_rect(table->OuterRect.Min.x, table->OuterRect.Min.y, table->OuterRect.Max.x, ImMax(lhs: table->OuterRect.Max.y, rhs: table->OuterRect.Min.y + table_instance->LastOuterHeight));
1037	const ImGuiID backup_active_id = g.ActiveId;
1038	g.ActiveId = 0;
1039	const bool is_hovering_table = ItemHoverable(bb: mouse_hit_rect, id: 0, item_flags: ImGuiItemFlags_None);
1040	g.ActiveId = backup_active_id;
1041
1042	// Determine skewed MousePos.x to support angled headers.
1043	float mouse_skewed_x = g.IO.MousePos.x;
1044	if (table->AngledHeadersHeight > 0.0f)
1045	if (g.IO.MousePos.y >= table->OuterRect.Min.y && g.IO.MousePos.y <= table->OuterRect.Min.y + table->AngledHeadersHeight)
1046	mouse_skewed_x += ImTrunc(f: (table->OuterRect.Min.y + table->AngledHeadersHeight - g.IO.MousePos.y) * table->AngledHeadersSlope);
1047
1048	// [Part 6] Setup final position, offset, skip/clip states and clipping rectangles, detect hovered column
1049	// Process columns in their visible orders as we are comparing the visible order and adjusting host_clip_rect while looping.
1050	int visible_n = 0;
1051	bool has_at_least_one_column_requesting_output = false;
1052	bool offset_x_frozen = (table->FreezeColumnsCount > 0);
1053	float offset_x = ((table->FreezeColumnsCount > 0) ? table->OuterRect.Min.x : work_rect.Min.x) + table->OuterPaddingX - table->CellSpacingX1;
1054	ImRect host_clip_rect = table->InnerClipRect;
1055	//host_clip_rect.Max.x += table->CellPaddingX + table->CellSpacingX2;
1056	ImBitArrayClearAllBits(arr: table->VisibleMaskByIndex, bitcount: table->ColumnsCount);
1057	for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
1058	{
1059	const int column_n = table->DisplayOrderToIndex[order_n];
1060	ImGuiTableColumn* column = &table->Columns[column_n];
1061
1062	// Initial nav layer: using FreezeRowsCount, NOT FreezeRowsRequest, so Header line changes layer when frozen
1063	column->NavLayerCurrent = (ImS8)(table->FreezeRowsCount > 0 ? ImGuiNavLayer_Menu : (ImGuiNavLayer)table->NavLayer);
1064
1065	if (offset_x_frozen && table->FreezeColumnsCount == visible_n)
1066	{
1067	offset_x += work_rect.Min.x - table->OuterRect.Min.x;
1068	offset_x_frozen = false;
1069	}
1070
1071	// Clear status flags
1072	column->Flags &= ~ImGuiTableColumnFlags_StatusMask_;
1073
1074	if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))
1075	{
1076	// Hidden column: clear a few fields and we are done with it for the remainder of the function.
1077	// We set a zero-width clip rect but set Min.y/Max.y properly to not interfere with the clipper.
1078	column->MinX = column->MaxX = column->WorkMinX = column->ClipRect.Min.x = column->ClipRect.Max.x = offset_x;
1079	column->WidthGiven = 0.0f;
1080	column->ClipRect.Min.y = work_rect.Min.y;
1081	column->ClipRect.Max.y = FLT_MAX;
1082	column->ClipRect.ClipWithFull(r: host_clip_rect);
1083	column->IsVisibleX = column->IsVisibleY = column->IsRequestOutput = false;
1084	column->IsSkipItems = true;
1085	column->ItemWidth = 1.0f;
1086	continue;
1087	}
1088
1089	// Lock start position
1090	column->MinX = offset_x;
1091
1092	// Lock width based on start position and minimum/maximum width for this position
1093	column->WidthMax = TableCalcMaxColumnWidth(table, column_n);
1094	column->WidthGiven = ImMin(lhs: column->WidthGiven, rhs: column->WidthMax);
1095	column->WidthGiven = ImMax(lhs: column->WidthGiven, rhs: ImMin(lhs: column->WidthRequest, rhs: table->MinColumnWidth));
1096	column->MaxX = offset_x + column->WidthGiven + table->CellSpacingX1 + table->CellSpacingX2 + table->CellPaddingX * 2.0f;
1097
1098	// Lock other positions
1099	// - ClipRect.Min.x: Because merging draw commands doesn't compare min boundaries, we make ClipRect.Min.x match left bounds to be consistent regardless of merging.
1100	// - ClipRect.Max.x: using WorkMaxX instead of MaxX (aka including padding) makes things more consistent when resizing down, tho slightly detrimental to visibility in very-small column.
1101	// - ClipRect.Max.x: using MaxX makes it easier for header to receive hover highlight with no discontinuity and display sorting arrow.
1102	// - FIXME-TABLE: We want equal width columns to have equal (ClipRect.Max.x - WorkMinX) width, which means ClipRect.max.x cannot stray off host_clip_rect.Max.x else right-most column may appear shorter.
1103	const float previous_instance_work_min_x = column->WorkMinX;
1104	column->WorkMinX = column->MinX + table->CellPaddingX + table->CellSpacingX1;
1105	column->WorkMaxX = column->MaxX - table->CellPaddingX - table->CellSpacingX2; // Expected max
1106	column->ItemWidth = ImTrunc(f: column->WidthGiven * 0.65f);
1107	column->ClipRect.Min.x = column->MinX;
1108	column->ClipRect.Min.y = work_rect.Min.y;
1109	column->ClipRect.Max.x = column->MaxX; //column->WorkMaxX;
1110	column->ClipRect.Max.y = FLT_MAX;
1111	column->ClipRect.ClipWithFull(r: host_clip_rect);
1112
1113	// Mark column as Clipped (not in sight)
1114	// Note that scrolling tables (where inner_window != outer_window) handle Y clipped earlier in BeginTable() so IsVisibleY really only applies to non-scrolling tables.
1115	// FIXME-TABLE: Because InnerClipRect.Max.y is conservatively ==outer_window->ClipRect.Max.y, we never can mark columns _Above_ the scroll line as not IsVisibleY.
1116	// Taking advantage of LastOuterHeight would yield good results there...
1117	// FIXME-TABLE: Y clipping is disabled because it effectively means not submitting will reduce contents width which is fed to outer_window->DC.CursorMaxPos.x,
1118	// and this may be used (e.g. typically by outer_window using AlwaysAutoResize or outer_window's horizontal scrollbar, but could be something else).
1119	// Possible solution to preserve last known content width for clipped column. Test 'table_reported_size' fails when enabling Y clipping and window is resized small.
1120	column->IsVisibleX = (column->ClipRect.Max.x > column->ClipRect.Min.x);
1121	column->IsVisibleY = true; // (column->ClipRect.Max.y > column->ClipRect.Min.y);
1122	const bool is_visible = column->IsVisibleX; //&& column->IsVisibleY;
1123	if (is_visible)
1124	ImBitArraySetBit(arr: table->VisibleMaskByIndex, n: column_n);
1125
1126	// Mark column as requesting output from user. Note that fixed + non-resizable sets are auto-fitting at all times and therefore always request output.
1127	column->IsRequestOutput = is_visible || column->AutoFitQueue != 0 || column->CannotSkipItemsQueue != 0;
1128
1129	// Mark column as SkipItems (ignoring all items/layout)
1130	// (table->HostSkipItems is a copy of inner_window->SkipItems before we cleared it above in Part 2)
1131	column->IsSkipItems = !column->IsEnabled || table->HostSkipItems;
1132	if (column->IsSkipItems)
1133	IM_ASSERT(!is_visible);
1134	if (column->IsRequestOutput && !column->IsSkipItems)
1135	has_at_least_one_column_requesting_output = true;
1136
1137	// Update status flags
1138	column->Flags |= ImGuiTableColumnFlags_IsEnabled;
1139	if (is_visible)
1140	column->Flags |= ImGuiTableColumnFlags_IsVisible;
1141	if (column->SortOrder != -1)
1142	column->Flags |= ImGuiTableColumnFlags_IsSorted;
1143
1144	// Detect hovered column
1145	if (is_hovering_table && mouse_skewed_x >= column->ClipRect.Min.x && mouse_skewed_x < column->ClipRect.Max.x)
1146	{
1147	column->Flags |= ImGuiTableColumnFlags_IsHovered;
1148	table->HoveredColumnBody = (ImGuiTableColumnIdx)column_n;
1149	}
1150
1151	// Alignment
1152	// FIXME-TABLE: This align based on the whole column width, not per-cell, and therefore isn't useful in
1153	// many cases (to be able to honor this we might be able to store a log of cells width, per row, for
1154	// visible rows, but nav/programmatic scroll would have visible artifacts.)
1155	//if (column->Flags & ImGuiTableColumnFlags_AlignRight)
1156	// column->WorkMinX = ImMax(column->WorkMinX, column->MaxX - column->ContentWidthRowsUnfrozen);
1157	//else if (column->Flags & ImGuiTableColumnFlags_AlignCenter)
1158	// column->WorkMinX = ImLerp(column->WorkMinX, ImMax(column->StartX, column->MaxX - column->ContentWidthRowsUnfrozen), 0.5f);
1159
1160	// Reset content width variables
1161	if (table->InstanceCurrent == 0)
1162	{
1163	column->ContentMaxXFrozen = column->WorkMinX;
1164	column->ContentMaxXUnfrozen = column->WorkMinX;
1165	column->ContentMaxXHeadersUsed = column->WorkMinX;
1166	column->ContentMaxXHeadersIdeal = column->WorkMinX;
1167	}
1168	else
1169	{
1170	// As we store an absolute value to make per-cell updates faster, we need to offset values used for width computation.
1171	const float offset_from_previous_instance = column->WorkMinX - previous_instance_work_min_x;
1172	column->ContentMaxXFrozen += offset_from_previous_instance;
1173	column->ContentMaxXUnfrozen += offset_from_previous_instance;
1174	column->ContentMaxXHeadersUsed += offset_from_previous_instance;
1175	column->ContentMaxXHeadersIdeal += offset_from_previous_instance;
1176	}
1177
1178	// Don't decrement auto-fit counters until container window got a chance to submit its items
1179	if (table->HostSkipItems == false && table->InstanceCurrent == 0)
1180	{
1181	column->AutoFitQueue >>= 1;
1182	column->CannotSkipItemsQueue >>= 1;
1183	}
1184
1185	if (visible_n < table->FreezeColumnsCount)
1186	host_clip_rect.Min.x = ImClamp(v: column->MaxX + TABLE_BORDER_SIZE, mn: host_clip_rect.Min.x, mx: host_clip_rect.Max.x);
1187
1188	offset_x += column->WidthGiven + table->CellSpacingX1 + table->CellSpacingX2 + table->CellPaddingX * 2.0f;
1189	visible_n++;
1190	}
1191
1192	// In case the table is visible (e.g. decorations) but all columns clipped, we keep a column visible.
1193	// Else if give no chance to a clipper-savy user to submit rows and therefore total contents height used by scrollbar.
1194	if (has_at_least_one_column_requesting_output == false)
1195	{
1196	table->Columns[table->LeftMostEnabledColumn].IsRequestOutput = true;
1197	table->Columns[table->LeftMostEnabledColumn].IsSkipItems = false;
1198	}
1199
1200	// [Part 7] Detect/store when we are hovering the unused space after the right-most column (so e.g. context menus can react on it)
1201	// Clear Resizable flag if none of our column are actually resizable (either via an explicit _NoResize flag, either
1202	// because of using _WidthAuto/_WidthStretch). This will hide the resizing option from the context menu.
1203	const float unused_x1 = ImMax(lhs: table->WorkRect.Min.x, rhs: table->Columns[table->RightMostEnabledColumn].ClipRect.Max.x);
1204	if (is_hovering_table && table->HoveredColumnBody == -1)
1205	if (mouse_skewed_x >= unused_x1)
1206	table->HoveredColumnBody = (ImGuiTableColumnIdx)table->ColumnsCount;
1207	if (has_resizable == false && (table->Flags & ImGuiTableFlags_Resizable))
1208	table->Flags &= ~ImGuiTableFlags_Resizable;
1209
1210	table->IsActiveIdAliveBeforeTable = (g.ActiveIdIsAlive != 0);
1211
1212	// [Part 8] Lock actual OuterRect/WorkRect right-most position.
1213	// This is done late to handle the case of fixed-columns tables not claiming more widths that they need.
1214	// Because of this we are careful with uses of WorkRect and InnerClipRect before this point.
1215	if (table->RightMostStretchedColumn != -1)
1216	table->Flags &= ~ImGuiTableFlags_NoHostExtendX;
1217	if (table->Flags & ImGuiTableFlags_NoHostExtendX)
1218	{
1219	table->OuterRect.Max.x = table->WorkRect.Max.x = unused_x1;
1220	table->InnerClipRect.Max.x = ImMin(lhs: table->InnerClipRect.Max.x, rhs: unused_x1);
1221	}
1222	table->InnerWindow->ParentWorkRect = table->WorkRect;
1223	table->BorderX1 = table->InnerClipRect.Min.x;
1224	table->BorderX2 = table->InnerClipRect.Max.x;
1225
1226	// Setup window's WorkRect.Max.y for GetContentRegionAvail(). Other values will be updated in each TableBeginCell() call.
1227	float window_content_max_y;
1228	if (table->Flags & ImGuiTableFlags_NoHostExtendY)
1229	window_content_max_y = table->OuterRect.Max.y;
1230	else
1231	window_content_max_y = ImMax(lhs: table->InnerWindow->ContentRegionRect.Max.y, rhs: (table->Flags & ImGuiTableFlags_ScrollY) ? 0.0f : table->OuterRect.Max.y);
1232	table->InnerWindow->WorkRect.Max.y = ImClamp(v: window_content_max_y - g.Style.CellPadding.y, mn: table->InnerWindow->WorkRect.Min.y, mx: table->InnerWindow->WorkRect.Max.y);
1233
1234	// [Part 9] Allocate draw channels and setup background cliprect
1235	TableSetupDrawChannels(table);
1236
1237	// [Part 10] Hit testing on borders
1238	if (table->Flags & ImGuiTableFlags_Resizable)
1239	TableUpdateBorders(table);
1240	table_instance->LastTopHeadersRowHeight = 0.0f;
1241	table->IsLayoutLocked = true;
1242	table->IsUsingHeaders = false;
1243
1244	// Highlight header
1245	table->HighlightColumnHeader = -1;
1246	if (table->IsContextPopupOpen && table->ContextPopupColumn != -1 && table->InstanceInteracted == table->InstanceCurrent)
1247	table->HighlightColumnHeader = table->ContextPopupColumn;
1248	else if ((table->Flags & ImGuiTableFlags_HighlightHoveredColumn) && table->HoveredColumnBody != -1 && table->HoveredColumnBody != table->ColumnsCount && table->HoveredColumnBorder == -1)
1249	if (g.ActiveId == 0 || (table->IsActiveIdInTable || g.DragDropActive))
1250	table->HighlightColumnHeader = table->HoveredColumnBody;
1251
1252	// [Part 11] Default context menu
1253	// - To append to this menu: you can call TableBeginContextMenuPopup()/.../EndPopup().
1254	// - To modify or replace this: set table->DisableDefaultContextMenu = true, then call TableBeginContextMenuPopup()/.../EndPopup().
1255	// - You may call TableDrawDefaultContextMenu() with selected flags to display specific sections of the default menu,
1256	// e.g. TableDrawDefaultContextMenu(table, table->Flags & ~ImGuiTableFlags_Hideable) will display everything EXCEPT columns visibility options.
1257	if (table->DisableDefaultContextMenu == false && TableBeginContextMenuPopup(table))
1258	{
1259	TableDrawDefaultContextMenu(table, flags_for_section_to_display: table->Flags);
1260	EndPopup();
1261	}
1262
1263	// [Part 12] Sanitize and build sort specs before we have a chance to use them for display.
1264	// This path will only be exercised when sort specs are modified before header rows (e.g. init or visibility change)
1265	if (table->IsSortSpecsDirty && (table->Flags & ImGuiTableFlags_Sortable))
1266	TableSortSpecsBuild(table);
1267
1268	// [Part 13] Setup inner window decoration size (for scrolling / nav tracking to properly take account of frozen rows/columns)
1269	if (table->FreezeColumnsRequest > 0)
1270	table->InnerWindow->DecoInnerSizeX1 = table->Columns[table->DisplayOrderToIndex[table->FreezeColumnsRequest - 1]].MaxX - table->OuterRect.Min.x;
1271	if (table->FreezeRowsRequest > 0)
1272	table->InnerWindow->DecoInnerSizeY1 = table_instance->LastFrozenHeight;
1273	table_instance->LastFrozenHeight = 0.0f;
1274
1275	// Initial state
1276	ImGuiWindow* inner_window = table->InnerWindow;
1277	if (table->Flags & ImGuiTableFlags_NoClip)
1278	table->DrawSplitter->SetCurrentChannel(draw_list: inner_window->DrawList, channel_idx: TABLE_DRAW_CHANNEL_NOCLIP);
1279	else
1280	inner_window->DrawList->PushClipRect(clip_rect_min: inner_window->InnerClipRect.Min, clip_rect_max: inner_window->InnerClipRect.Max, intersect_with_current_clip_rect: false); // FIXME: use table->InnerClipRect?
1281	}
1282
1283	// Process hit-testing on resizing borders. Actual size change will be applied in EndTable()
1284	// - Set table->HoveredColumnBorder with a short delay/timer to reduce visual feedback noise.
1285	void ImGui::TableUpdateBorders(ImGuiTable* table)
1286	{
1287	ImGuiContext& g = *GImGui;
1288	IM_ASSERT(table->Flags & ImGuiTableFlags_Resizable);
1289
1290	// At this point OuterRect height may be zero or under actual final height, so we rely on temporal coherency and
1291	// use the final height from last frame. Because this is only affecting _interaction_ with columns, it is not
1292	// really problematic (whereas the actual visual will be displayed in EndTable() and using the current frame height).
1293	// Actual columns highlight/render will be performed in EndTable() and not be affected.
1294	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
1295	const float hit_half_width = ImTrunc(f: TABLE_RESIZE_SEPARATOR_HALF_THICKNESS * g.CurrentDpiScale);
1296	const float hit_y1 = (table->FreezeRowsCount >= 1 ? table->OuterRect.Min.y : table->WorkRect.Min.y) + table->AngledHeadersHeight;
1297	const float hit_y2_body = ImMax(lhs: table->OuterRect.Max.y, rhs: hit_y1 + table_instance->LastOuterHeight - table->AngledHeadersHeight);
1298	const float hit_y2_head = hit_y1 + table_instance->LastTopHeadersRowHeight;
1299
1300	for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
1301	{
1302	if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))
1303	continue;
1304
1305	const int column_n = table->DisplayOrderToIndex[order_n];
1306	ImGuiTableColumn* column = &table->Columns[column_n];
1307	if (column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_NoDirectResize_))
1308	continue;
1309
1310	// ImGuiTableFlags_NoBordersInBodyUntilResize will be honored in TableDrawBorders()
1311	const float border_y2_hit = (table->Flags & ImGuiTableFlags_NoBordersInBody) ? hit_y2_head : hit_y2_body;
1312	if ((table->Flags & ImGuiTableFlags_NoBordersInBody) && table->IsUsingHeaders == false)
1313	continue;
1314
1315	if (!column->IsVisibleX && table->LastResizedColumn != column_n)
1316	continue;
1317
1318	ImGuiID column_id = TableGetColumnResizeID(table, column_n, instance_no: table->InstanceCurrent);
1319	ImRect hit_rect(column->MaxX - hit_half_width, hit_y1, column->MaxX + hit_half_width, border_y2_hit);
1320	ItemAdd(bb: hit_rect, id: column_id, NULL, extra_flags: ImGuiItemFlags_NoNav);
1321	//GetForegroundDrawList()->AddRect(hit_rect.Min, hit_rect.Max, IM_COL32(255, 0, 0, 100));
1322
1323	bool hovered = false, held = false;
1324	bool pressed = ButtonBehavior(bb: hit_rect, id: column_id, out_hovered: &hovered, out_held: &held, flags: ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_NoNavFocus);
1325	if (pressed && IsMouseDoubleClicked(button: 0))
1326	{
1327	TableSetColumnWidthAutoSingle(table, column_n);
1328	ClearActiveID();
1329	held = false;
1330	}
1331	if (held)
1332	{
1333	if (table->LastResizedColumn == -1)
1334	table->ResizeLockMinContentsX2 = table->RightMostEnabledColumn != -1 ? table->Columns[table->RightMostEnabledColumn].MaxX : -FLT_MAX;
1335	table->ResizedColumn = (ImGuiTableColumnIdx)column_n;
1336	table->InstanceInteracted = table->InstanceCurrent;
1337	}
1338	if ((hovered && g.HoveredIdTimer > TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER) || held)
1339	{
1340	table->HoveredColumnBorder = (ImGuiTableColumnIdx)column_n;
1341	SetMouseCursor(ImGuiMouseCursor_ResizeEW);
1342	}
1343	}
1344	}
1345
1346	void ImGui::EndTable()
1347	{
1348	ImGuiContext& g = *GImGui;
1349	ImGuiTable* table = g.CurrentTable;
1350	if (table == NULL)
1351	{
1352	IM_ASSERT_USER_ERROR(table != NULL, "EndTable() call should only be done while in BeginTable() scope!");
1353	return;
1354	}
1355
1356	// This assert would be very useful to catch a common error... unfortunately it would probably trigger in some
1357	// cases, and for consistency user may sometimes output empty tables (and still benefit from e.g. outer border)
1358	//IM_ASSERT(table->IsLayoutLocked && "Table unused: never called TableNextRow(), is that the intent?");
1359
1360	// If the user never got to call TableNextRow() or TableNextColumn(), we call layout ourselves to ensure all our
1361	// code paths are consistent (instead of just hoping that TableBegin/TableEnd will work), get borders drawn, etc.
1362	if (!table->IsLayoutLocked)
1363	TableUpdateLayout(table);
1364
1365	const ImGuiTableFlags flags = table->Flags;
1366	ImGuiWindow* inner_window = table->InnerWindow;
1367	ImGuiWindow* outer_window = table->OuterWindow;
1368	ImGuiTableTempData* temp_data = table->TempData;
1369	IM_ASSERT(inner_window == g.CurrentWindow);
1370	IM_ASSERT(outer_window == inner_window || outer_window == inner_window->ParentWindow);
1371
1372	if (table->IsInsideRow)
1373	TableEndRow(table);
1374
1375	// Context menu in columns body
1376	if (flags & ImGuiTableFlags_ContextMenuInBody)
1377	if (table->HoveredColumnBody != -1 && !IsAnyItemHovered() && IsMouseReleased(button: ImGuiMouseButton_Right))
1378	TableOpenContextMenu(column_n: (int)table->HoveredColumnBody);
1379
1380	// Finalize table height
1381	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
1382	inner_window->DC.PrevLineSize = temp_data->HostBackupPrevLineSize;
1383	inner_window->DC.CurrLineSize = temp_data->HostBackupCurrLineSize;
1384	inner_window->DC.CursorMaxPos = temp_data->HostBackupCursorMaxPos;
1385	const float inner_content_max_y = table->RowPosY2;
1386	IM_ASSERT(table->RowPosY2 == inner_window->DC.CursorPos.y);
1387	if (inner_window != outer_window)
1388	inner_window->DC.CursorMaxPos.y = inner_content_max_y;
1389	else if (!(flags & ImGuiTableFlags_NoHostExtendY))
1390	table->OuterRect.Max.y = table->InnerRect.Max.y = ImMax(lhs: table->OuterRect.Max.y, rhs: inner_content_max_y); // Patch OuterRect/InnerRect height
1391	table->WorkRect.Max.y = ImMax(lhs: table->WorkRect.Max.y, rhs: table->OuterRect.Max.y);
1392	table_instance->LastOuterHeight = table->OuterRect.GetHeight();
1393
1394	// Setup inner scrolling range
1395	// FIXME: This ideally should be done earlier, in BeginTable() SetNextWindowContentSize call, just like writing to inner_window->DC.CursorMaxPos.y,
1396	// but since the later is likely to be impossible to do we'd rather update both axes together.
1397	if (table->Flags & ImGuiTableFlags_ScrollX)
1398	{
1399	const float outer_padding_for_border = (table->Flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
1400	float max_pos_x = table->InnerWindow->DC.CursorMaxPos.x;
1401	if (table->RightMostEnabledColumn != -1)
1402	max_pos_x = ImMax(lhs: max_pos_x, rhs: table->Columns[table->RightMostEnabledColumn].WorkMaxX + table->CellPaddingX + table->OuterPaddingX - outer_padding_for_border);
1403	if (table->ResizedColumn != -1)
1404	max_pos_x = ImMax(lhs: max_pos_x, rhs: table->ResizeLockMinContentsX2);
1405	table->InnerWindow->DC.CursorMaxPos.x = max_pos_x + table->TempData->AngledHeadersExtraWidth;
1406	}
1407
1408	// Pop clipping rect
1409	if (!(flags & ImGuiTableFlags_NoClip))
1410	inner_window->DrawList->PopClipRect();
1411	inner_window->ClipRect = inner_window->DrawList->_ClipRectStack.back();
1412
1413	// Draw borders
1414	if ((flags & ImGuiTableFlags_Borders) != 0)
1415	TableDrawBorders(table);
1416
1417	#if 0
1418	// Strip out dummy channel draw calls
1419	// We have no way to prevent user submitting direct ImDrawList calls into a hidden column (but ImGui:: calls will be clipped out)
1420	// Pros: remove draw calls which will have no effect. since they'll have zero-size cliprect they may be early out anyway.
1421	// Cons: making it harder for users watching metrics/debugger to spot the wasted vertices.
1422	if (table->DummyDrawChannel != (ImGuiTableColumnIdx)-1)
1423	{
1424	ImDrawChannel* dummy_channel = &table->DrawSplitter._Channels[table->DummyDrawChannel];
1425	dummy_channel->_CmdBuffer.resize(0);
1426	dummy_channel->_IdxBuffer.resize(0);
1427	}
1428	#endif
1429
1430	// Flatten channels and merge draw calls
1431	ImDrawListSplitter* splitter = table->DrawSplitter;
1432	splitter->SetCurrentChannel(draw_list: inner_window->DrawList, channel_idx: 0);
1433	if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
1434	TableMergeDrawChannels(table);
1435	splitter->Merge(draw_list: inner_window->DrawList);
1436
1437	// Update ColumnsAutoFitWidth to get us ahead for host using our size to auto-resize without waiting for next BeginTable()
1438	float auto_fit_width_for_fixed = 0.0f;
1439	float auto_fit_width_for_stretched = 0.0f;
1440	float auto_fit_width_for_stretched_min = 0.0f;
1441	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
1442	if (IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
1443	{
1444	ImGuiTableColumn* column = &table->Columns[column_n];
1445	float column_width_request = ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && !(column->Flags & ImGuiTableColumnFlags_NoResize)) ? column->WidthRequest : TableGetColumnWidthAuto(table, column);
1446	if (column->Flags & ImGuiTableColumnFlags_WidthFixed)
1447	auto_fit_width_for_fixed += column_width_request;
1448	else
1449	auto_fit_width_for_stretched += column_width_request;
1450	if ((column->Flags & ImGuiTableColumnFlags_WidthStretch) && (column->Flags & ImGuiTableColumnFlags_NoResize) != 0)
1451	auto_fit_width_for_stretched_min = ImMax(lhs: auto_fit_width_for_stretched_min, rhs: column_width_request / (column->StretchWeight / table->ColumnsStretchSumWeights));
1452	}
1453	const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1);
1454	table->ColumnsAutoFitWidth = width_spacings + (table->CellPaddingX * 2.0f) * table->ColumnsEnabledCount + auto_fit_width_for_fixed + ImMax(lhs: auto_fit_width_for_stretched, rhs: auto_fit_width_for_stretched_min);
1455
1456	// Update scroll
1457	if ((table->Flags & ImGuiTableFlags_ScrollX) == 0 && inner_window != outer_window)
1458	{
1459	inner_window->Scroll.x = 0.0f;
1460	}
1461	else if (table->LastResizedColumn != -1 && table->ResizedColumn == -1 && inner_window->ScrollbarX && table->InstanceInteracted == table->InstanceCurrent)
1462	{
1463	// When releasing a column being resized, scroll to keep the resulting column in sight
1464	const float neighbor_width_to_keep_visible = table->MinColumnWidth + table->CellPaddingX * 2.0f;
1465	ImGuiTableColumn* column = &table->Columns[table->LastResizedColumn];
1466	if (column->MaxX < table->InnerClipRect.Min.x)
1467	SetScrollFromPosX(window: inner_window, local_x: column->MaxX - inner_window->Pos.x - neighbor_width_to_keep_visible, center_x_ratio: 1.0f);
1468	else if (column->MaxX > table->InnerClipRect.Max.x)
1469	SetScrollFromPosX(window: inner_window, local_x: column->MaxX - inner_window->Pos.x + neighbor_width_to_keep_visible, center_x_ratio: 1.0f);
1470	}
1471
1472	// Apply resizing/dragging at the end of the frame
1473	if (table->ResizedColumn != -1 && table->InstanceCurrent == table->InstanceInteracted)
1474	{
1475	ImGuiTableColumn* column = &table->Columns[table->ResizedColumn];
1476	const float new_x2 = (g.IO.MousePos.x - g.ActiveIdClickOffset.x + ImTrunc(f: TABLE_RESIZE_SEPARATOR_HALF_THICKNESS * g.CurrentDpiScale));
1477	const float new_width = ImTrunc(f: new_x2 - column->MinX - table->CellSpacingX1 - table->CellPaddingX * 2.0f);
1478	table->ResizedColumnNextWidth = new_width;
1479	}
1480
1481	table->IsActiveIdInTable = (g.ActiveIdIsAlive != 0 && table->IsActiveIdAliveBeforeTable == false);
1482
1483	// Pop from id stack
1484	IM_ASSERT_USER_ERROR(inner_window->IDStack.back() == table_instance->TableInstanceID, "Mismatching PushID/PopID!");
1485	IM_ASSERT_USER_ERROR(outer_window->DC.ItemWidthStack.Size >= temp_data->HostBackupItemWidthStackSize, "Too many PopItemWidth!");
1486	if (table->InstanceCurrent > 0)
1487	PopID();
1488	PopID();
1489
1490	// Restore window data that we modified
1491	const ImVec2 backup_outer_max_pos = outer_window->DC.CursorMaxPos;
1492	inner_window->WorkRect = temp_data->HostBackupWorkRect;
1493	inner_window->ParentWorkRect = temp_data->HostBackupParentWorkRect;
1494	inner_window->SkipItems = table->HostSkipItems;
1495	outer_window->DC.CursorPos = table->OuterRect.Min;
1496	outer_window->DC.ItemWidth = temp_data->HostBackupItemWidth;
1497	outer_window->DC.ItemWidthStack.Size = temp_data->HostBackupItemWidthStackSize;
1498	outer_window->DC.ColumnsOffset = temp_data->HostBackupColumnsOffset;
1499
1500	// Layout in outer window
1501	// (FIXME: To allow auto-fit and allow desirable effect of SameLine() we dissociate 'used' vs 'ideal' size by overriding
1502	// CursorPosPrevLine and CursorMaxPos manually. That should be a more general layout feature, see same problem e.g. #3414)
1503	if (inner_window != outer_window)
1504	{
1505	short backup_nav_layers_active_mask = inner_window->DC.NavLayersActiveMask;
1506	inner_window->DC.NavLayersActiveMask |= 1 << table->NavLayer; // So empty table don't appear to navigate differently.
1507	g.CurrentTable = NULL; // To avoid error recovery recursing
1508	EndChild();
1509	g.CurrentTable = table;
1510	inner_window->DC.NavLayersActiveMask = backup_nav_layers_active_mask;
1511	}
1512	else
1513	{
1514	table->InnerWindow->DC.TreeDepth--;
1515	ItemSize(size: table->OuterRect.GetSize());
1516	ItemAdd(bb: table->OuterRect, id: 0);
1517	}
1518
1519	// Override declared contents width/height to enable auto-resize while not needlessly adding a scrollbar
1520	if (table->Flags & ImGuiTableFlags_NoHostExtendX)
1521	{
1522	// FIXME-TABLE: Could we remove this section?
1523	// ColumnsAutoFitWidth may be one frame ahead here since for Fixed+NoResize is calculated from latest contents
1524	IM_ASSERT((table->Flags & ImGuiTableFlags_ScrollX) == 0);
1525	outer_window->DC.CursorMaxPos.x = ImMax(lhs: backup_outer_max_pos.x, rhs: table->OuterRect.Min.x + table->ColumnsAutoFitWidth);
1526	}
1527	else if (temp_data->UserOuterSize.x <= 0.0f)
1528	{
1529	// Some references for this: #7651 + tests "table_reported_size", "table_reported_size_outer" equivalent Y block
1530	// - Checking for ImGuiTableFlags_ScrollX/ScrollY flag makes us a frame ahead when disabling those flags.
1531	// - FIXME-TABLE: Would make sense to pre-compute expected scrollbar visibility/sizes to generally save a frame of feedback.
1532	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
1533	const float decoration_size = table->TempData->AngledHeadersExtraWidth + ((table->Flags & ImGuiTableFlags_ScrollY) ? inner_window->ScrollbarSizes.x : 0.0f);
1534	outer_window->DC.IdealMaxPos.x = ImMax(lhs: outer_window->DC.IdealMaxPos.x, rhs: inner_content_max_x + decoration_size - temp_data->UserOuterSize.x);
1535	outer_window->DC.CursorMaxPos.x = ImMax(lhs: backup_outer_max_pos.x, rhs: ImMin(lhs: table->OuterRect.Max.x, rhs: inner_content_max_x + decoration_size));
1536	}
1537	else
1538	{
1539	outer_window->DC.CursorMaxPos.x = ImMax(lhs: backup_outer_max_pos.x, rhs: table->OuterRect.Max.x);
1540	}
1541	if (temp_data->UserOuterSize.y <= 0.0f)
1542	{
1543	const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.y : 0.0f;
1544	outer_window->DC.IdealMaxPos.y = ImMax(lhs: outer_window->DC.IdealMaxPos.y, rhs: inner_content_max_y + decoration_size - temp_data->UserOuterSize.y);
1545	outer_window->DC.CursorMaxPos.y = ImMax(lhs: backup_outer_max_pos.y, rhs: ImMin(lhs: table->OuterRect.Max.y, rhs: inner_content_max_y + decoration_size));
1546	}
1547	else
1548	{
1549	// OuterRect.Max.y may already have been pushed downward from the initial value (unless ImGuiTableFlags_NoHostExtendY is set)
1550	outer_window->DC.CursorMaxPos.y = ImMax(lhs: backup_outer_max_pos.y, rhs: table->OuterRect.Max.y);
1551	}
1552
1553	// Save settings
1554	if (table->IsSettingsDirty)
1555	TableSaveSettings(table);
1556	table->IsInitializing = false;
1557
1558	// Clear or restore current table, if any
1559	IM_ASSERT(g.CurrentWindow == outer_window && g.CurrentTable == table);
1560	IM_ASSERT(g.TablesTempDataStacked > 0);
1561	temp_data = (--g.TablesTempDataStacked > 0) ? &g.TablesTempData[g.TablesTempDataStacked - 1] : NULL;
1562	g.CurrentTable = temp_data ? g.Tables.GetByIndex(n: temp_data->TableIndex) : NULL;
1563	if (g.CurrentTable)
1564	{
1565	g.CurrentTable->TempData = temp_data;
1566	g.CurrentTable->DrawSplitter = &temp_data->DrawSplitter;
1567	}
1568	outer_window->DC.CurrentTableIdx = g.CurrentTable ? g.Tables.GetIndex(p: g.CurrentTable) : -1;
1569	NavUpdateCurrentWindowIsScrollPushableX();
1570	}
1571
1572	// Called in TableSetupColumn() when initializing and in TableLoadSettings() for defaults before applying stored settings.
1573	// 'init_mask' specify which fields to initialize.
1574	static void TableInitColumnDefaults(ImGuiTable* table, ImGuiTableColumn* column, ImGuiTableColumnFlags init_mask)
1575	{
1576	ImGuiTableColumnFlags flags = column->Flags;
1577	if (init_mask & ImGuiTableFlags_Resizable)
1578	{
1579	float init_width_or_weight = column->InitStretchWeightOrWidth;
1580	column->WidthRequest = ((flags & ImGuiTableColumnFlags_WidthFixed) && init_width_or_weight > 0.0f) ? init_width_or_weight : -1.0f;
1581	column->StretchWeight = (init_width_or_weight > 0.0f && (flags & ImGuiTableColumnFlags_WidthStretch)) ? init_width_or_weight : -1.0f;
1582	if (init_width_or_weight > 0.0f) // Disable auto-fit if an explicit width/weight has been specified
1583	column->AutoFitQueue = 0x00;
1584	}
1585	if (init_mask & ImGuiTableFlags_Reorderable)
1586	column->DisplayOrder = (ImGuiTableColumnIdx)table->Columns.index_from_ptr(it: column);
1587	if (init_mask & ImGuiTableFlags_Hideable)
1588	column->IsUserEnabled = column->IsUserEnabledNextFrame = (flags & ImGuiTableColumnFlags_DefaultHide) ? 0 : 1;
1589	if (init_mask & ImGuiTableFlags_Sortable)
1590	{
1591	// Multiple columns using _DefaultSort will be reassigned unique SortOrder values when building the sort specs.
1592	column->SortOrder = (flags & ImGuiTableColumnFlags_DefaultSort) ? 0 : -1;
1593	column->SortDirection = (flags & ImGuiTableColumnFlags_DefaultSort) ? ((flags & ImGuiTableColumnFlags_PreferSortDescending) ? (ImS8)ImGuiSortDirection_Descending : (ImU8)(ImGuiSortDirection_Ascending)) : (ImS8)ImGuiSortDirection_None;
1594	}
1595	}
1596
1597	// See "COLUMNS SIZING POLICIES" comments at the top of this file
1598	// If (init_width_or_weight <= 0.0f) it is ignored
1599	void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, float init_width_or_weight, ImGuiID user_id)
1600	{
1601	ImGuiContext& g = *GImGui;
1602	ImGuiTable* table = g.CurrentTable;
1603	if (table == NULL)
1604	{
1605	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
1606	return;
1607	}
1608	IM_ASSERT(table->IsLayoutLocked == false && "Need to call TableSetupColumn() before first row!");
1609	IM_ASSERT((flags & ImGuiTableColumnFlags_StatusMask_) == 0 && "Illegal to pass StatusMask values to TableSetupColumn()");
1610	if (table->DeclColumnsCount >= table->ColumnsCount)
1611	{
1612	IM_ASSERT_USER_ERROR(table->DeclColumnsCount < table->ColumnsCount, "Called TableSetupColumn() too many times!");
1613	return;
1614	}
1615
1616	ImGuiTableColumn* column = &table->Columns[table->DeclColumnsCount];
1617	table->DeclColumnsCount++;
1618
1619	// Assert when passing a width or weight if policy is entirely left to default, to avoid storing width into weight and vice-versa.
1620	// Give a grace to users of ImGuiTableFlags_ScrollX.
1621	if (table->IsDefaultSizingPolicy && (flags & ImGuiTableColumnFlags_WidthMask_) == 0 && (flags & ImGuiTableFlags_ScrollX) == 0)
1622	IM_ASSERT(init_width_or_weight <= 0.0f && "Can only specify width/weight if sizing policy is set explicitly in either Table or Column.");
1623
1624	// When passing a width automatically enforce WidthFixed policy
1625	// (whereas TableSetupColumnFlags would default to WidthAuto if table is not resizable)
1626	if ((flags & ImGuiTableColumnFlags_WidthMask_) == 0 && init_width_or_weight > 0.0f)
1627	if ((table->Flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedFit || (table->Flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedSame)
1628	flags |= ImGuiTableColumnFlags_WidthFixed;
1629	if (flags & ImGuiTableColumnFlags_AngledHeader)
1630	{
1631	flags |= ImGuiTableColumnFlags_NoHeaderLabel;
1632	table->AngledHeadersCount++;
1633	}
1634
1635	TableSetupColumnFlags(table, column, flags_in: flags);
1636	column->UserID = user_id;
1637	flags = column->Flags;
1638
1639	// Initialize defaults
1640	column->InitStretchWeightOrWidth = init_width_or_weight;
1641	if (table->IsInitializing)
1642	{
1643	ImGuiTableFlags init_flags = ~table->SettingsLoadedFlags;
1644	if (column->WidthRequest < 0.0f && column->StretchWeight < 0.0f)
1645	init_flags |= ImGuiTableFlags_Resizable;
1646	TableInitColumnDefaults(table, column, init_mask: init_flags);
1647	}
1648
1649	// Store name (append with zero-terminator in contiguous buffer)
1650	// FIXME: If we recorded the number of \n in names we could compute header row height
1651	column->NameOffset = -1;
1652	if (label != NULL && label[0] != 0)
1653	{
1654	column->NameOffset = (ImS16)table->ColumnsNames.size();
1655	table->ColumnsNames.append(str: label, str_end: label + ImStrlen(s: label) + 1);
1656	}
1657	}
1658
1659	// [Public]
1660	void ImGui::TableSetupScrollFreeze(int columns, int rows)
1661	{
1662	ImGuiContext& g = *GImGui;
1663	ImGuiTable* table = g.CurrentTable;
1664	if (table == NULL)
1665	{
1666	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
1667	return;
1668	}
1669	IM_ASSERT(table->IsLayoutLocked == false && "Need to call TableSetupColumn() before first row!");
1670	IM_ASSERT(columns >= 0 && columns < IMGUI_TABLE_MAX_COLUMNS);
1671	IM_ASSERT(rows >= 0 && rows < 128); // Arbitrary limit
1672
1673	table->FreezeColumnsRequest = (table->Flags & ImGuiTableFlags_ScrollX) ? (ImGuiTableColumnIdx)ImMin(lhs: columns, rhs: table->ColumnsCount) : 0;
1674	table->FreezeColumnsCount = (table->InnerWindow->Scroll.x != 0.0f) ? table->FreezeColumnsRequest : 0;
1675	table->FreezeRowsRequest = (table->Flags & ImGuiTableFlags_ScrollY) ? (ImGuiTableColumnIdx)rows : 0;
1676	table->FreezeRowsCount = (table->InnerWindow->Scroll.y != 0.0f) ? table->FreezeRowsRequest : 0;
1677	table->IsUnfrozenRows = (table->FreezeRowsCount == 0); // Make sure this is set before TableUpdateLayout() so ImGuiListClipper can benefit from it.b
1678
1679	// Ensure frozen columns are ordered in their section. We still allow multiple frozen columns to be reordered.
1680	// FIXME-TABLE: This work for preserving 2143 into 21|43. How about 4321 turning into 21|43? (preserve relative order in each section)
1681	for (int column_n = 0; column_n < table->FreezeColumnsRequest; column_n++)
1682	{
1683	int order_n = table->DisplayOrderToIndex[column_n];
1684	if (order_n != column_n && order_n >= table->FreezeColumnsRequest)
1685	{
1686	ImSwap(a&: table->Columns[table->DisplayOrderToIndex[order_n]].DisplayOrder, b&: table->Columns[table->DisplayOrderToIndex[column_n]].DisplayOrder);
1687	ImSwap(a&: table->DisplayOrderToIndex[order_n], b&: table->DisplayOrderToIndex[column_n]);
1688	}
1689	}
1690	}
1691
1692	//-----------------------------------------------------------------------------
1693	// [SECTION] Tables: Simple accessors
1694	//-----------------------------------------------------------------------------
1695	// - TableGetColumnCount()
1696	// - TableGetColumnName()
1697	// - TableGetColumnName() [Internal]
1698	// - TableSetColumnEnabled()
1699	// - TableGetColumnFlags()
1700	// - TableGetCellBgRect() [Internal]
1701	// - TableGetColumnResizeID() [Internal]
1702	// - TableGetHoveredColumn() [Internal]
1703	// - TableGetHoveredRow() [Internal]
1704	// - TableSetBgColor()
1705	//-----------------------------------------------------------------------------
1706
1707	int ImGui::TableGetColumnCount()
1708	{
1709	ImGuiContext& g = *GImGui;
1710	ImGuiTable* table = g.CurrentTable;
1711	return table ? table->ColumnsCount : 0;
1712	}
1713
1714	const char* ImGui::TableGetColumnName(int column_n)
1715	{
1716	ImGuiContext& g = *GImGui;
1717	ImGuiTable* table = g.CurrentTable;
1718	if (!table)
1719	return NULL;
1720	if (column_n < 0)
1721	column_n = table->CurrentColumn;
1722	return TableGetColumnName(table, column_n);
1723	}
1724
1725	const char* ImGui::TableGetColumnName(const ImGuiTable* table, int column_n)
1726	{
1727	if (table->IsLayoutLocked == false && column_n >= table->DeclColumnsCount)
1728	return ""; // NameOffset is invalid at this point
1729	const ImGuiTableColumn* column = &table->Columns[column_n];
1730	if (column->NameOffset == -1)
1731	return "";
1732	return &table->ColumnsNames.Buf[column->NameOffset];
1733	}
1734
1735	// Change user accessible enabled/disabled state of a column (often perceived as "showing/hiding" from users point of view)
1736	// Note that end-user can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)
1737	// - Require table to have the ImGuiTableFlags_Hideable flag because we are manipulating user accessible state.
1738	// - Request will be applied during next layout, which happens on the first call to TableNextRow() after BeginTable().
1739	// - For the getter you can test (TableGetColumnFlags() & ImGuiTableColumnFlags_IsEnabled) != 0.
1740	// - Alternative: the ImGuiTableColumnFlags_Disabled is an overriding/master disable flag which will also hide the column from context menu.
1741	void ImGui::TableSetColumnEnabled(int column_n, bool enabled)
1742	{
1743	ImGuiContext& g = *GImGui;
1744	ImGuiTable* table = g.CurrentTable;
1745	if (table == NULL)
1746	{
1747	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
1748	return;
1749	}
1750	IM_ASSERT(table->Flags & ImGuiTableFlags_Hideable); // See comments above
1751	if (column_n < 0)
1752	column_n = table->CurrentColumn;
1753	IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
1754	ImGuiTableColumn* column = &table->Columns[column_n];
1755	column->IsUserEnabledNextFrame = enabled;
1756	}
1757
1758	// We allow querying for an extra column in order to poll the IsHovered state of the right-most section
1759	ImGuiTableColumnFlags ImGui::TableGetColumnFlags(int column_n)
1760	{
1761	ImGuiContext& g = *GImGui;
1762	ImGuiTable* table = g.CurrentTable;
1763	if (!table)
1764	return ImGuiTableColumnFlags_None;
1765	if (column_n < 0)
1766	column_n = table->CurrentColumn;
1767	if (column_n == table->ColumnsCount)
1768	return (table->HoveredColumnBody == column_n) ? ImGuiTableColumnFlags_IsHovered : ImGuiTableColumnFlags_None;
1769	return table->Columns[column_n].Flags;
1770	}
1771
1772	// Return the cell rectangle based on currently known height.
1773	// - Important: we generally don't know our row height until the end of the row, so Max.y will be incorrect in many situations.
1774	// The only case where this is correct is if we provided a min_row_height to TableNextRow() and don't go below it, or in TableEndRow() when we locked that height.
1775	// - Important: if ImGuiTableFlags_PadOuterX is set but ImGuiTableFlags_PadInnerX is not set, the outer-most left and right
1776	// columns report a small offset so their CellBgRect can extend up to the outer border.
1777	// FIXME: But the rendering code in TableEndRow() nullifies that with clamping required for scrolling.
1778	ImRect ImGui::TableGetCellBgRect(const ImGuiTable* table, int column_n)
1779	{
1780	const ImGuiTableColumn* column = &table->Columns[column_n];
1781	float x1 = column->MinX;
1782	float x2 = column->MaxX;
1783	//if (column->PrevEnabledColumn == -1)
1784	// x1 -= table->OuterPaddingX;
1785	//if (column->NextEnabledColumn == -1)
1786	// x2 += table->OuterPaddingX;
1787	x1 = ImMax(lhs: x1, rhs: table->WorkRect.Min.x);
1788	x2 = ImMin(lhs: x2, rhs: table->WorkRect.Max.x);
1789	return ImRect(x1, table->RowPosY1, x2, table->RowPosY2);
1790	}
1791
1792	// Return the resizing ID for the right-side of the given column.
1793	ImGuiID ImGui::TableGetColumnResizeID(ImGuiTable* table, int column_n, int instance_no)
1794	{
1795	IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
1796	ImGuiID instance_id = TableGetInstanceID(table, instance_no);
1797	return instance_id + 1 + column_n; // FIXME: #6140: still not ideal
1798	}
1799
1800	// Return -1 when table is not hovered. return columns_count if hovering the unused space at the right of the right-most visible column.
1801	int ImGui::TableGetHoveredColumn()
1802	{
1803	ImGuiContext& g = *GImGui;
1804	ImGuiTable* table = g.CurrentTable;
1805	if (!table)
1806	return -1;
1807	return (int)table->HoveredColumnBody;
1808	}
1809
1810	// Return -1 when table is not hovered. Return maxrow+1 if in table but below last submitted row.
1811	// *IMPORTANT* Unlike TableGetHoveredColumn(), this has a one frame latency in updating the value.
1812	// This difference with is the reason why this is not public yet.
1813	int ImGui::TableGetHoveredRow()
1814	{
1815	ImGuiContext& g = *GImGui;
1816	ImGuiTable* table = g.CurrentTable;
1817	if (!table)
1818	return -1;
1819	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
1820	return (int)table_instance->HoveredRowLast;
1821	}
1822
1823	void ImGui::TableSetBgColor(ImGuiTableBgTarget target, ImU32 color, int column_n)
1824	{
1825	ImGuiContext& g = *GImGui;
1826	ImGuiTable* table = g.CurrentTable;
1827	IM_ASSERT(target != ImGuiTableBgTarget_None);
1828	if (table == NULL)
1829	{
1830	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
1831	return;
1832	}
1833
1834	if (color == IM_COL32_DISABLE)
1835	color = 0;
1836
1837	// We cannot draw neither the cell or row background immediately as we don't know the row height at this point in time.
1838	switch (target)
1839	{
1840	case ImGuiTableBgTarget_CellBg:
1841	{
1842	if (table->RowPosY1 > table->InnerClipRect.Max.y) // Discard
1843	return;
1844	if (column_n == -1)
1845	column_n = table->CurrentColumn;
1846	if (!IM_BITARRAY_TESTBIT(table->VisibleMaskByIndex, column_n))
1847	return;
1848	if (table->RowCellDataCurrent < 0 || table->RowCellData[table->RowCellDataCurrent].Column != column_n)
1849	table->RowCellDataCurrent++;
1850	ImGuiTableCellData* cell_data = &table->RowCellData[table->RowCellDataCurrent];
1851	cell_data->BgColor = color;
1852	cell_data->Column = (ImGuiTableColumnIdx)column_n;
1853	break;
1854	}
1855	case ImGuiTableBgTarget_RowBg0:
1856	case ImGuiTableBgTarget_RowBg1:
1857	{
1858	if (table->RowPosY1 > table->InnerClipRect.Max.y) // Discard
1859	return;
1860	IM_ASSERT(column_n == -1);
1861	int bg_idx = (target == ImGuiTableBgTarget_RowBg1) ? 1 : 0;
1862	table->RowBgColor[bg_idx] = color;
1863	break;
1864	}
1865	default:
1866	IM_ASSERT(0);
1867	}
1868	}
1869
1870	//-------------------------------------------------------------------------
1871	// [SECTION] Tables: Row changes
1872	//-------------------------------------------------------------------------
1873	// - TableGetRowIndex()
1874	// - TableNextRow()
1875	// - TableBeginRow() [Internal]
1876	// - TableEndRow() [Internal]
1877	//-------------------------------------------------------------------------
1878
1879	// [Public] Note: for row coloring we use ->RowBgColorCounter which is the same value without counting header rows
1880	int ImGui::TableGetRowIndex()
1881	{
1882	ImGuiContext& g = *GImGui;
1883	ImGuiTable* table = g.CurrentTable;
1884	if (!table)
1885	return 0;
1886	return table->CurrentRow;
1887	}
1888
1889	// [Public] Starts into the first cell of a new row
1890	void ImGui::TableNextRow(ImGuiTableRowFlags row_flags, float row_min_height)
1891	{
1892	ImGuiContext& g = *GImGui;
1893	ImGuiTable* table = g.CurrentTable;
1894
1895	if (!table->IsLayoutLocked)
1896	TableUpdateLayout(table);
1897	if (table->IsInsideRow)
1898	TableEndRow(table);
1899
1900	table->LastRowFlags = table->RowFlags;
1901	table->RowFlags = row_flags;
1902	table->RowCellPaddingY = g.Style.CellPadding.y;
1903	table->RowMinHeight = row_min_height;
1904	TableBeginRow(table);
1905
1906	// We honor min_row_height requested by user, but cannot guarantee per-row maximum height,
1907	// because that would essentially require a unique clipping rectangle per-cell.
1908	table->RowPosY2 += table->RowCellPaddingY * 2.0f;
1909	table->RowPosY2 = ImMax(lhs: table->RowPosY2, rhs: table->RowPosY1 + row_min_height);
1910
1911	// Disable output until user calls TableNextColumn()
1912	table->InnerWindow->SkipItems = true;
1913	}
1914
1915	// [Internal] Only called by TableNextRow()
1916	void ImGui::TableBeginRow(ImGuiTable* table)
1917	{
1918	ImGuiWindow* window = table->InnerWindow;
1919	IM_ASSERT(!table->IsInsideRow);
1920
1921	// New row
1922	table->CurrentRow++;
1923	table->CurrentColumn = -1;
1924	table->RowBgColor[0] = table->RowBgColor[1] = IM_COL32_DISABLE;
1925	table->RowCellDataCurrent = -1;
1926	table->IsInsideRow = true;
1927
1928	// Begin frozen rows
1929	float next_y1 = table->RowPosY2;
1930	if (table->CurrentRow == 0 && table->FreezeRowsCount > 0)
1931	next_y1 = window->DC.CursorPos.y = table->OuterRect.Min.y;
1932
1933	table->RowPosY1 = table->RowPosY2 = next_y1;
1934	table->RowTextBaseline = 0.0f;
1935	table->RowIndentOffsetX = window->DC.Indent.x - table->HostIndentX; // Lock indent
1936
1937	window->DC.PrevLineTextBaseOffset = 0.0f;
1938	window->DC.CursorPosPrevLine = ImVec2(window->DC.CursorPos.x, window->DC.CursorPos.y + table->RowCellPaddingY); // This allows users to call SameLine() to share LineSize between columns.
1939	window->DC.PrevLineSize = window->DC.CurrLineSize = ImVec2(0.0f, 0.0f); // This allows users to call SameLine() to share LineSize between columns, and to call it from first column too.
1940	window->DC.IsSameLine = window->DC.IsSetPos = false;
1941	window->DC.CursorMaxPos.y = next_y1;
1942
1943	// Making the header BG color non-transparent will allow us to overlay it multiple times when handling smooth dragging.
1944	if (table->RowFlags & ImGuiTableRowFlags_Headers)
1945	{
1946	TableSetBgColor(target: ImGuiTableBgTarget_RowBg0, color: GetColorU32(idx: ImGuiCol_TableHeaderBg));
1947	if (table->CurrentRow == 0)
1948	table->IsUsingHeaders = true;
1949	}
1950	}
1951
1952	// [Internal] Called by TableNextRow()
1953	void ImGui::TableEndRow(ImGuiTable* table)
1954	{
1955	ImGuiContext& g = *GImGui;
1956	ImGuiWindow* window = g.CurrentWindow;
1957	IM_ASSERT(window == table->InnerWindow);
1958	IM_ASSERT(table->IsInsideRow);
1959
1960	if (table->CurrentColumn != -1)
1961	{
1962	TableEndCell(table);
1963	table->CurrentColumn = -1;
1964	}
1965
1966	// Logging
1967	if (g.LogEnabled)
1968	LogRenderedText(NULL, text: "|");
1969
1970	// Position cursor at the bottom of our row so it can be used for e.g. clipping calculation. However it is
1971	// likely that the next call to TableBeginCell() will reposition the cursor to take account of vertical padding.
1972	window->DC.CursorPos.y = table->RowPosY2;
1973
1974	// Row background fill
1975	const float bg_y1 = table->RowPosY1;
1976	const float bg_y2 = table->RowPosY2;
1977	const bool unfreeze_rows_actual = (table->CurrentRow + 1 == table->FreezeRowsCount);
1978	const bool unfreeze_rows_request = (table->CurrentRow + 1 == table->FreezeRowsRequest);
1979	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
1980	if ((table->RowFlags & ImGuiTableRowFlags_Headers) && (table->CurrentRow == 0 || (table->LastRowFlags & ImGuiTableRowFlags_Headers)))
1981	table_instance->LastTopHeadersRowHeight += bg_y2 - bg_y1;
1982
1983	const bool is_visible = (bg_y2 >= table->InnerClipRect.Min.y && bg_y1 <= table->InnerClipRect.Max.y);
1984	if (is_visible)
1985	{
1986	// Update data for TableGetHoveredRow()
1987	if (table->HoveredColumnBody != -1 && g.IO.MousePos.y >= bg_y1 && g.IO.MousePos.y < bg_y2 && table_instance->HoveredRowNext < 0)
1988	table_instance->HoveredRowNext = table->CurrentRow;
1989
1990	// Decide of background color for the row
1991	ImU32 bg_col0 = 0;
1992	ImU32 bg_col1 = 0;
1993	if (table->RowBgColor[0] != IM_COL32_DISABLE)
1994	bg_col0 = table->RowBgColor[0];
1995	else if (table->Flags & ImGuiTableFlags_RowBg)
1996	bg_col0 = GetColorU32(idx: (table->RowBgColorCounter & 1) ? ImGuiCol_TableRowBgAlt : ImGuiCol_TableRowBg);
1997	if (table->RowBgColor[1] != IM_COL32_DISABLE)
1998	bg_col1 = table->RowBgColor[1];
1999
2000	// Decide of top border color
2001	ImU32 top_border_col = 0;
2002	const float border_size = TABLE_BORDER_SIZE;
2003	if (table->CurrentRow > 0 && (table->Flags & ImGuiTableFlags_BordersInnerH))
2004	top_border_col = (table->LastRowFlags & ImGuiTableRowFlags_Headers) ? table->BorderColorStrong : table->BorderColorLight;
2005
2006	const bool draw_cell_bg_color = table->RowCellDataCurrent >= 0;
2007	const bool draw_strong_bottom_border = unfreeze_rows_actual;
2008	if ((bg_col0 | bg_col1 | top_border_col) != 0 || draw_strong_bottom_border || draw_cell_bg_color)
2009	{
2010	// In theory we could call SetWindowClipRectBeforeSetChannel() but since we know TableEndRow() is
2011	// always followed by a change of clipping rectangle we perform the smallest overwrite possible here.
2012	if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
2013	window->DrawList->_CmdHeader.ClipRect = table->Bg0ClipRectForDrawCmd.ToVec4();
2014	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: TABLE_DRAW_CHANNEL_BG0);
2015	}
2016
2017	// Draw row background
2018	// We soft/cpu clip this so all backgrounds and borders can share the same clipping rectangle
2019	if (bg_col0 || bg_col1)
2020	{
2021	ImRect row_rect(table->WorkRect.Min.x, bg_y1, table->WorkRect.Max.x, bg_y2);
2022	row_rect.ClipWith(r: table->BgClipRect);
2023	if (bg_col0 != 0 && row_rect.Min.y < row_rect.Max.y)
2024	window->DrawList->AddRectFilled(p_min: row_rect.Min, p_max: row_rect.Max, col: bg_col0);
2025	if (bg_col1 != 0 && row_rect.Min.y < row_rect.Max.y)
2026	window->DrawList->AddRectFilled(p_min: row_rect.Min, p_max: row_rect.Max, col: bg_col1);
2027	}
2028
2029	// Draw cell background color
2030	if (draw_cell_bg_color)
2031	{
2032	ImGuiTableCellData* cell_data_end = &table->RowCellData[table->RowCellDataCurrent];
2033	for (ImGuiTableCellData* cell_data = &table->RowCellData[0]; cell_data <= cell_data_end; cell_data++)
2034	{
2035	// As we render the BG here we need to clip things (for layout we would not)
2036	// FIXME: This cancels the OuterPadding addition done by TableGetCellBgRect(), need to keep it while rendering correctly while scrolling.
2037	const ImGuiTableColumn* column = &table->Columns[cell_data->Column];
2038	ImRect cell_bg_rect = TableGetCellBgRect(table, column_n: cell_data->Column);
2039	cell_bg_rect.ClipWith(r: table->BgClipRect);
2040	cell_bg_rect.Min.x = ImMax(lhs: cell_bg_rect.Min.x, rhs: column->ClipRect.Min.x); // So that first column after frozen one gets clipped when scrolling
2041	cell_bg_rect.Max.x = ImMin(lhs: cell_bg_rect.Max.x, rhs: column->MaxX);
2042	if (cell_bg_rect.Min.y < cell_bg_rect.Max.y)
2043	window->DrawList->AddRectFilled(p_min: cell_bg_rect.Min, p_max: cell_bg_rect.Max, col: cell_data->BgColor);
2044	}
2045	}
2046
2047	// Draw top border
2048	if (top_border_col && bg_y1 >= table->BgClipRect.Min.y && bg_y1 < table->BgClipRect.Max.y)
2049	window->DrawList->AddLine(p1: ImVec2(table->BorderX1, bg_y1), p2: ImVec2(table->BorderX2, bg_y1), col: top_border_col, thickness: border_size);
2050
2051	// Draw bottom border at the row unfreezing mark (always strong)
2052	if (draw_strong_bottom_border && bg_y2 >= table->BgClipRect.Min.y && bg_y2 < table->BgClipRect.Max.y)
2053	window->DrawList->AddLine(p1: ImVec2(table->BorderX1, bg_y2), p2: ImVec2(table->BorderX2, bg_y2), col: table->BorderColorStrong, thickness: border_size);
2054	}
2055
2056	// End frozen rows (when we are past the last frozen row line, teleport cursor and alter clipping rectangle)
2057	// We need to do that in TableEndRow() instead of TableBeginRow() so the list clipper can mark end of row and
2058	// get the new cursor position.
2059	if (unfreeze_rows_request)
2060	{
2061	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2062	table->Columns[column_n].NavLayerCurrent = table->NavLayer;
2063	const float y0 = ImMax(lhs: table->RowPosY2 + 1, rhs: table->InnerClipRect.Min.y);
2064	table_instance->LastFrozenHeight = y0 - table->OuterRect.Min.y;
2065
2066	if (unfreeze_rows_actual)
2067	{
2068	IM_ASSERT(table->IsUnfrozenRows == false);
2069	table->IsUnfrozenRows = true;
2070
2071	// BgClipRect starts as table->InnerClipRect, reduce it now and make BgClipRectForDrawCmd == BgClipRect
2072	table->BgClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y = ImMin(lhs: y0, rhs: table->InnerClipRect.Max.y);
2073	table->BgClipRect.Max.y = table->Bg2ClipRectForDrawCmd.Max.y = table->InnerClipRect.Max.y;
2074	table->Bg2DrawChannelCurrent = table->Bg2DrawChannelUnfrozen;
2075	IM_ASSERT(table->Bg2ClipRectForDrawCmd.Min.y <= table->Bg2ClipRectForDrawCmd.Max.y);
2076
2077	float row_height = table->RowPosY2 - table->RowPosY1;
2078	table->RowPosY2 = window->DC.CursorPos.y = table->WorkRect.Min.y + table->RowPosY2 - table->OuterRect.Min.y;
2079	table->RowPosY1 = table->RowPosY2 - row_height;
2080	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2081	{
2082	ImGuiTableColumn* column = &table->Columns[column_n];
2083	column->DrawChannelCurrent = column->DrawChannelUnfrozen;
2084	column->ClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y;
2085	}
2086
2087	// Update cliprect ahead of TableBeginCell() so clipper can access to new ClipRect->Min.y
2088	SetWindowClipRectBeforeSetChannel(window, clip_rect: table->Columns[0].ClipRect);
2089	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: table->Columns[0].DrawChannelCurrent);
2090	}
2091	}
2092
2093	if (!(table->RowFlags & ImGuiTableRowFlags_Headers))
2094	table->RowBgColorCounter++;
2095	table->IsInsideRow = false;
2096	}
2097
2098	//-------------------------------------------------------------------------
2099	// [SECTION] Tables: Columns changes
2100	//-------------------------------------------------------------------------
2101	// - TableGetColumnIndex()
2102	// - TableSetColumnIndex()
2103	// - TableNextColumn()
2104	// - TableBeginCell() [Internal]
2105	// - TableEndCell() [Internal]
2106	//-------------------------------------------------------------------------
2107
2108	int ImGui::TableGetColumnIndex()
2109	{
2110	ImGuiContext& g = *GImGui;
2111	ImGuiTable* table = g.CurrentTable;
2112	if (!table)
2113	return 0;
2114	return table->CurrentColumn;
2115	}
2116
2117	// [Public] Append into a specific column
2118	bool ImGui::TableSetColumnIndex(int column_n)
2119	{
2120	ImGuiContext& g = *GImGui;
2121	ImGuiTable* table = g.CurrentTable;
2122	if (!table)
2123	return false;
2124
2125	if (table->CurrentColumn != column_n)
2126	{
2127	if (table->CurrentColumn != -1)
2128	TableEndCell(table);
2129	if ((column_n >= 0 && column_n < table->ColumnsCount) == false)
2130	{
2131	IM_ASSERT_USER_ERROR(column_n >= 0 && column_n < table->ColumnsCount, "TableSetColumnIndex() invalid column index!");
2132	return false;
2133	}
2134	TableBeginCell(table, column_n);
2135	}
2136
2137	// Return whether the column is visible. User may choose to skip submitting items based on this return value,
2138	// however they shouldn't skip submitting for columns that may have the tallest contribution to row height.
2139	return table->Columns[column_n].IsRequestOutput;
2140	}
2141
2142	// [Public] Append into the next column, wrap and create a new row when already on last column
2143	bool ImGui::TableNextColumn()
2144	{
2145	ImGuiContext& g = *GImGui;
2146	ImGuiTable* table = g.CurrentTable;
2147	if (!table)
2148	return false;
2149
2150	if (table->IsInsideRow && table->CurrentColumn + 1 < table->ColumnsCount)
2151	{
2152	if (table->CurrentColumn != -1)
2153	TableEndCell(table);
2154	TableBeginCell(table, column_n: table->CurrentColumn + 1);
2155	}
2156	else
2157	{
2158	TableNextRow();
2159	TableBeginCell(table, column_n: 0);
2160	}
2161
2162	// Return whether the column is visible. User may choose to skip submitting items based on this return value,
2163	// however they shouldn't skip submitting for columns that may have the tallest contribution to row height.
2164	return table->Columns[table->CurrentColumn].IsRequestOutput;
2165	}
2166
2167
2168	// [Internal] Called by TableSetColumnIndex()/TableNextColumn()
2169	// This is called very frequently, so we need to be mindful of unnecessary overhead.
2170	// FIXME-TABLE FIXME-OPT: Could probably shortcut some things for non-active or clipped columns.
2171	void ImGui::TableBeginCell(ImGuiTable* table, int column_n)
2172	{
2173	ImGuiContext& g = *GImGui;
2174	ImGuiTableColumn* column = &table->Columns[column_n];
2175	ImGuiWindow* window = table->InnerWindow;
2176	table->CurrentColumn = column_n;
2177
2178	// Start position is roughly ~~ CellRect.Min + CellPadding + Indent
2179	float start_x = column->WorkMinX;
2180	if (column->Flags & ImGuiTableColumnFlags_IndentEnable)
2181	start_x += table->RowIndentOffsetX; // ~~ += window.DC.Indent.x - table->HostIndentX, except we locked it for the row.
2182
2183	window->DC.CursorPos.x = start_x;
2184	window->DC.CursorPos.y = table->RowPosY1 + table->RowCellPaddingY;
2185	window->DC.CursorMaxPos.x = window->DC.CursorPos.x;
2186	window->DC.ColumnsOffset.x = start_x - window->Pos.x - window->DC.Indent.x; // FIXME-WORKRECT
2187	window->DC.CursorPosPrevLine.x = window->DC.CursorPos.x; // PrevLine.y is preserved. This allows users to call SameLine() to share LineSize between columns.
2188	window->DC.CurrLineTextBaseOffset = table->RowTextBaseline;
2189	window->DC.NavLayerCurrent = (ImGuiNavLayer)column->NavLayerCurrent;
2190
2191	// Note how WorkRect.Max.y is only set once during layout
2192	window->WorkRect.Min.y = window->DC.CursorPos.y;
2193	window->WorkRect.Min.x = column->WorkMinX;
2194	window->WorkRect.Max.x = column->WorkMaxX;
2195	window->DC.ItemWidth = column->ItemWidth;
2196
2197	window->SkipItems = column->IsSkipItems;
2198	if (column->IsSkipItems)
2199	{
2200	g.LastItemData.ID = 0;
2201	g.LastItemData.StatusFlags = 0;
2202	}
2203
2204	// Also see TablePushColumnChannel()
2205	if (table->Flags & ImGuiTableFlags_NoClip)
2206	{
2207	// FIXME: if we end up drawing all borders/bg in EndTable, could remove this and just assert that channel hasn't changed.
2208	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: TABLE_DRAW_CHANNEL_NOCLIP);
2209	//IM_ASSERT(table->DrawSplitter._Current == TABLE_DRAW_CHANNEL_NOCLIP);
2210	}
2211	else
2212	{
2213	// FIXME-TABLE: Could avoid this if draw channel is dummy channel?
2214	SetWindowClipRectBeforeSetChannel(window, clip_rect: column->ClipRect);
2215	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: column->DrawChannelCurrent);
2216	}
2217
2218	// Logging
2219	if (g.LogEnabled && !column->IsSkipItems)
2220	{
2221	LogRenderedText(ref_pos: &window->DC.CursorPos, text: "|");
2222	g.LogLinePosY = FLT_MAX;
2223	}
2224	}
2225
2226	// [Internal] Called by TableNextRow()/TableSetColumnIndex()/TableNextColumn()
2227	void ImGui::TableEndCell(ImGuiTable* table)
2228	{
2229	ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
2230	ImGuiWindow* window = table->InnerWindow;
2231
2232	if (window->DC.IsSetPos)
2233	ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
2234
2235	// Report maximum position so we can infer content size per column.
2236	float* p_max_pos_x;
2237	if (table->RowFlags & ImGuiTableRowFlags_Headers)
2238	p_max_pos_x = &column->ContentMaxXHeadersUsed; // Useful in case user submit contents in header row that is not a TableHeader() call
2239	else
2240	p_max_pos_x = table->IsUnfrozenRows ? &column->ContentMaxXUnfrozen : &column->ContentMaxXFrozen;
2241	*p_max_pos_x = ImMax(lhs: *p_max_pos_x, rhs: window->DC.CursorMaxPos.x);
2242	if (column->IsEnabled)
2243	table->RowPosY2 = ImMax(lhs: table->RowPosY2, rhs: window->DC.CursorMaxPos.y + table->RowCellPaddingY);
2244	column->ItemWidth = window->DC.ItemWidth;
2245
2246	// Propagate text baseline for the entire row
2247	// FIXME-TABLE: Here we propagate text baseline from the last line of the cell.. instead of the first one.
2248	table->RowTextBaseline = ImMax(lhs: table->RowTextBaseline, rhs: window->DC.PrevLineTextBaseOffset);
2249	}
2250
2251	//-------------------------------------------------------------------------
2252	// [SECTION] Tables: Columns width management
2253	//-------------------------------------------------------------------------
2254	// - TableGetMaxColumnWidth() [Internal]
2255	// - TableGetColumnWidthAuto() [Internal]
2256	// - TableSetColumnWidth()
2257	// - TableSetColumnWidthAutoSingle() [Internal]
2258	// - TableSetColumnWidthAutoAll() [Internal]
2259	// - TableUpdateColumnsWeightFromWidth() [Internal]
2260	//-------------------------------------------------------------------------
2261	// Note that actual columns widths are computed in TableUpdateLayout().
2262	//-------------------------------------------------------------------------
2263
2264	// Maximum column content width given current layout. Use column->MinX so this value differs on a per-column basis.
2265	float ImGui::TableCalcMaxColumnWidth(const ImGuiTable* table, int column_n)
2266	{
2267	const ImGuiTableColumn* column = &table->Columns[column_n];
2268	float max_width = FLT_MAX;
2269	const float min_column_distance = table->MinColumnWidth + table->CellPaddingX * 2.0f + table->CellSpacingX1 + table->CellSpacingX2;
2270	if (table->Flags & ImGuiTableFlags_ScrollX)
2271	{
2272	// Frozen columns can't reach beyond visible width else scrolling will naturally break.
2273	// (we use DisplayOrder as within a set of multiple frozen column reordering is possible)
2274	if (column->DisplayOrder < table->FreezeColumnsRequest)
2275	{
2276	max_width = (table->InnerClipRect.Max.x - (table->FreezeColumnsRequest - column->DisplayOrder) * min_column_distance) - column->MinX;
2277	max_width = max_width - table->OuterPaddingX - table->CellPaddingX - table->CellSpacingX2;
2278	}
2279	}
2280	else if ((table->Flags & ImGuiTableFlags_NoKeepColumnsVisible) == 0)
2281	{
2282	// If horizontal scrolling if disabled, we apply a final lossless shrinking of columns in order to make
2283	// sure they are all visible. Because of this we also know that all of the columns will always fit in
2284	// table->WorkRect and therefore in table->InnerRect (because ScrollX is off)
2285	// FIXME-TABLE: This is solved incorrectly but also quite a difficult problem to fix as we also want ClipRect width to match.
2286	// See "table_width_distrib" and "table_width_keep_visible" tests
2287	max_width = table->WorkRect.Max.x - (table->ColumnsEnabledCount - column->IndexWithinEnabledSet - 1) * min_column_distance - column->MinX;
2288	//max_width -= table->CellSpacingX1;
2289	max_width -= table->CellSpacingX2;
2290	max_width -= table->CellPaddingX * 2.0f;
2291	max_width -= table->OuterPaddingX;
2292	}
2293	return max_width;
2294	}
2295
2296	// Note this is meant to be stored in column->WidthAuto, please generally use the WidthAuto field
2297	float ImGui::TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column)
2298	{
2299	const float content_width_body = ImMax(lhs: column->ContentMaxXFrozen, rhs: column->ContentMaxXUnfrozen) - column->WorkMinX;
2300	const float content_width_headers = column->ContentMaxXHeadersIdeal - column->WorkMinX;
2301	float width_auto = content_width_body;
2302	if (!(column->Flags & ImGuiTableColumnFlags_NoHeaderWidth))
2303	width_auto = ImMax(lhs: width_auto, rhs: content_width_headers);
2304
2305	// Non-resizable fixed columns preserve their requested width
2306	if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && column->InitStretchWeightOrWidth > 0.0f)
2307	if (!(table->Flags & ImGuiTableFlags_Resizable) || (column->Flags & ImGuiTableColumnFlags_NoResize))
2308	width_auto = column->InitStretchWeightOrWidth;
2309
2310	return ImMax(lhs: width_auto, rhs: table->MinColumnWidth);
2311	}
2312
2313	// 'width' = inner column width, without padding
2314	void ImGui::TableSetColumnWidth(int column_n, float width)
2315	{
2316	ImGuiContext& g = *GImGui;
2317	ImGuiTable* table = g.CurrentTable;
2318	IM_ASSERT(table != NULL && table->IsLayoutLocked == false);
2319	IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
2320	ImGuiTableColumn* column_0 = &table->Columns[column_n];
2321	float column_0_width = width;
2322
2323	// Apply constraints early
2324	// Compare both requested and actual given width to avoid overwriting requested width when column is stuck (minimum size, bounded)
2325	IM_ASSERT(table->MinColumnWidth > 0.0f);
2326	const float min_width = table->MinColumnWidth;
2327	const float max_width = ImMax(lhs: min_width, rhs: column_0->WidthMax); // Don't use TableCalcMaxColumnWidth() here as it would rely on MinX from last instance (#7933)
2328	column_0_width = ImClamp(v: column_0_width, mn: min_width, mx: max_width);
2329	if (column_0->WidthGiven == column_0_width || column_0->WidthRequest == column_0_width)
2330	return;
2331
2332	//IMGUI_DEBUG_PRINT("TableSetColumnWidth(%d, %.1f->%.1f)\n", column_0_idx, column_0->WidthGiven, column_0_width);
2333	ImGuiTableColumn* column_1 = (column_0->NextEnabledColumn != -1) ? &table->Columns[column_0->NextEnabledColumn] : NULL;
2334
2335	// In this surprisingly not simple because of how we support mixing Fixed and multiple Stretch columns.
2336	// - All fixed: easy.
2337	// - All stretch: easy.
2338	// - One or more fixed + one stretch: easy.
2339	// - One or more fixed + more than one stretch: tricky.
2340	// Qt when manual resize is enabled only supports a single _trailing_ stretch column, we support more cases here.
2341
2342	// When forwarding resize from Wn| to Fn+1| we need to be considerate of the _NoResize flag on Fn+1.
2343	// FIXME-TABLE: Find a way to rewrite all of this so interactions feel more consistent for the user.
2344	// Scenarios:
2345	// - F1 F2 F3 resize from F1| or F2| --> ok: alter ->WidthRequested of Fixed column. Subsequent columns will be offset.
2346	// - F1 F2 F3 resize from F3| --> ok: alter ->WidthRequested of Fixed column. If active, ScrollX extent can be altered.
2347	// - F1 F2 W3 resize from F1| or F2| --> ok: alter ->WidthRequested of Fixed column. If active, ScrollX extent can be altered, but it doesn't make much sense as the Stretch column will always be minimal size.
2348	// - F1 F2 W3 resize from W3| --> ok: no-op (disabled by Resize Rule 1)
2349	// - W1 W2 W3 resize from W1| or W2| --> ok
2350	// - W1 W2 W3 resize from W3| --> ok: no-op (disabled by Resize Rule 1)
2351	// - W1 F2 F3 resize from F3| --> ok: no-op (disabled by Resize Rule 1)
2352	// - W1 F2 resize from F2| --> ok: no-op (disabled by Resize Rule 1)
2353	// - W1 W2 F3 resize from W1| or W2| --> ok
2354	// - W1 F2 W3 resize from W1| or F2| --> ok
2355	// - F1 W2 F3 resize from W2| --> ok
2356	// - F1 W3 F2 resize from W3| --> ok
2357	// - W1 F2 F3 resize from W1| --> ok: equivalent to resizing |F2. F3 will not move.
2358	// - W1 F2 F3 resize from F2| --> ok
2359	// All resizes from a Wx columns are locking other columns.
2360
2361	// Possible improvements:
2362	// - W1 W2 W3 resize W1| --> to not be stuck, both W2 and W3 would stretch down. Seems possible to fix. Would be most beneficial to simplify resize of all-weighted columns.
2363	// - W3 F1 F2 resize W3| --> to not be stuck past F1|, both F1 and F2 would need to stretch down, which would be lossy or ambiguous. Seems hard to fix.
2364
2365	// [Resize Rule 1] Can't resize from right of right-most visible column if there is any Stretch column. Implemented in TableUpdateLayout().
2366
2367	// If we have all Fixed columns OR resizing a Fixed column that doesn't come after a Stretch one, we can do an offsetting resize.
2368	// This is the preferred resize path
2369	if (column_0->Flags & ImGuiTableColumnFlags_WidthFixed)
2370	if (!column_1 || table->LeftMostStretchedColumn == -1 || table->Columns[table->LeftMostStretchedColumn].DisplayOrder >= column_0->DisplayOrder)
2371	{
2372	column_0->WidthRequest = column_0_width;
2373	table->IsSettingsDirty = true;
2374	return;
2375	}
2376
2377	// We can also use previous column if there's no next one (this is used when doing an auto-fit on the right-most stretch column)
2378	if (column_1 == NULL)
2379	column_1 = (column_0->PrevEnabledColumn != -1) ? &table->Columns[column_0->PrevEnabledColumn] : NULL;
2380	if (column_1 == NULL)
2381	return;
2382
2383	// Resizing from right-side of a Stretch column before a Fixed column forward sizing to left-side of fixed column.
2384	// (old_a + old_b == new_a + new_b) --> (new_a == old_a + old_b - new_b)
2385	float column_1_width = ImMax(lhs: column_1->WidthRequest - (column_0_width - column_0->WidthRequest), rhs: min_width);
2386	column_0_width = column_0->WidthRequest + column_1->WidthRequest - column_1_width;
2387	IM_ASSERT(column_0_width > 0.0f && column_1_width > 0.0f);
2388	column_0->WidthRequest = column_0_width;
2389	column_1->WidthRequest = column_1_width;
2390	if ((column_0->Flags | column_1->Flags) & ImGuiTableColumnFlags_WidthStretch)
2391	TableUpdateColumnsWeightFromWidth(table);
2392	table->IsSettingsDirty = true;
2393	}
2394
2395	// Disable clipping then auto-fit, will take 2 frames
2396	// (we don't take a shortcut for unclipped columns to reduce inconsistencies when e.g. resizing multiple columns)
2397	void ImGui::TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n)
2398	{
2399	// Single auto width uses auto-fit
2400	ImGuiTableColumn* column = &table->Columns[column_n];
2401	if (!column->IsEnabled)
2402	return;
2403	column->CannotSkipItemsQueue = (1 << 0);
2404	table->AutoFitSingleColumn = (ImGuiTableColumnIdx)column_n;
2405	}
2406
2407	void ImGui::TableSetColumnWidthAutoAll(ImGuiTable* table)
2408	{
2409	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2410	{
2411	ImGuiTableColumn* column = &table->Columns[column_n];
2412	if (!column->IsEnabled && !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) // Cannot reset weight of hidden stretch column
2413	continue;
2414	column->CannotSkipItemsQueue = (1 << 0);
2415	column->AutoFitQueue = (1 << 1);
2416	}
2417	}
2418
2419	void ImGui::TableUpdateColumnsWeightFromWidth(ImGuiTable* table)
2420	{
2421	IM_ASSERT(table->LeftMostStretchedColumn != -1 && table->RightMostStretchedColumn != -1);
2422
2423	// Measure existing quantities
2424	float visible_weight = 0.0f;
2425	float visible_width = 0.0f;
2426	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2427	{
2428	ImGuiTableColumn* column = &table->Columns[column_n];
2429	if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch))
2430	continue;
2431	IM_ASSERT(column->StretchWeight > 0.0f);
2432	visible_weight += column->StretchWeight;
2433	visible_width += column->WidthRequest;
2434	}
2435	IM_ASSERT(visible_weight > 0.0f && visible_width > 0.0f);
2436
2437	// Apply new weights
2438	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2439	{
2440	ImGuiTableColumn* column = &table->Columns[column_n];
2441	if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch))
2442	continue;
2443	column->StretchWeight = (column->WidthRequest / visible_width) * visible_weight;
2444	IM_ASSERT(column->StretchWeight > 0.0f);
2445	}
2446	}
2447
2448	//-------------------------------------------------------------------------
2449	// [SECTION] Tables: Drawing
2450	//-------------------------------------------------------------------------
2451	// - TablePushBackgroundChannel() [Internal]
2452	// - TablePopBackgroundChannel() [Internal]
2453	// - TableSetupDrawChannels() [Internal]
2454	// - TableMergeDrawChannels() [Internal]
2455	// - TableGetColumnBorderCol() [Internal]
2456	// - TableDrawBorders() [Internal]
2457	//-------------------------------------------------------------------------
2458
2459	// Bg2 is used by Selectable (and possibly other widgets) to render to the background.
2460	// Unlike our Bg0/1 channel which we uses for RowBg/CellBg/Borders and where we guarantee all shapes to be CPU-clipped, the Bg2 channel being widgets-facing will rely on regular ClipRect.
2461	void ImGui::TablePushBackgroundChannel()
2462	{
2463	ImGuiContext& g = *GImGui;
2464	ImGuiWindow* window = g.CurrentWindow;
2465	ImGuiTable* table = g.CurrentTable;
2466
2467	// Optimization: avoid SetCurrentChannel() + PushClipRect()
2468	table->HostBackupInnerClipRect = window->ClipRect;
2469	SetWindowClipRectBeforeSetChannel(window, clip_rect: table->Bg2ClipRectForDrawCmd);
2470	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: table->Bg2DrawChannelCurrent);
2471	}
2472
2473	void ImGui::TablePopBackgroundChannel()
2474	{
2475	ImGuiContext& g = *GImGui;
2476	ImGuiWindow* window = g.CurrentWindow;
2477	ImGuiTable* table = g.CurrentTable;
2478
2479	// Optimization: avoid PopClipRect() + SetCurrentChannel()
2480	SetWindowClipRectBeforeSetChannel(window, clip_rect: table->HostBackupInnerClipRect);
2481	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: table->Columns[table->CurrentColumn].DrawChannelCurrent);
2482	}
2483
2484	// Also see TableBeginCell()
2485	void ImGui::TablePushColumnChannel(int column_n)
2486	{
2487	ImGuiContext& g = *GImGui;
2488	ImGuiTable* table = g.CurrentTable;
2489
2490	// Optimization: avoid SetCurrentChannel() + PushClipRect()
2491	if (table->Flags & ImGuiTableFlags_NoClip)
2492	return;
2493	ImGuiWindow* window = g.CurrentWindow;
2494	const ImGuiTableColumn* column = &table->Columns[column_n];
2495	SetWindowClipRectBeforeSetChannel(window, clip_rect: column->ClipRect);
2496	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: column->DrawChannelCurrent);
2497	}
2498
2499	void ImGui::TablePopColumnChannel()
2500	{
2501	ImGuiContext& g = *GImGui;
2502	ImGuiTable* table = g.CurrentTable;
2503
2504	// Optimization: avoid PopClipRect() + SetCurrentChannel()
2505	if ((table->Flags & ImGuiTableFlags_NoClip) || (table->CurrentColumn == -1)) // Calling TreePop() after TableNextRow() is supported.
2506	return;
2507	ImGuiWindow* window = g.CurrentWindow;
2508	const ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
2509	SetWindowClipRectBeforeSetChannel(window, clip_rect: column->ClipRect);
2510	table->DrawSplitter->SetCurrentChannel(draw_list: window->DrawList, channel_idx: column->DrawChannelCurrent);
2511	}
2512
2513	// Allocate draw channels. Called by TableUpdateLayout()
2514	// - We allocate them following storage order instead of display order so reordering columns won't needlessly
2515	// increase overall dormant memory cost.
2516	// - We isolate headers draw commands in their own channels instead of just altering clip rects.
2517	// This is in order to facilitate merging of draw commands.
2518	// - After crossing FreezeRowsCount, all columns see their current draw channel changed to a second set of channels.
2519	// - We only use the dummy draw channel so we can push a null clipping rectangle into it without affecting other
2520	// channels, while simplifying per-row/per-cell overhead. It will be empty and discarded when merged.
2521	// - We allocate 1 or 2 background draw channels. This is because we know TablePushBackgroundChannel() is only used for
2522	// horizontal spanning. If we allowed vertical spanning we'd need one background draw channel per merge group (1-4).
2523	// Draw channel allocation (before merging):
2524	// - NoClip --> 2+D+1 channels: bg0/1 + bg2 + foreground (same clip rect == always 1 draw call)
2525	// - Clip --> 2+D+N channels
2526	// - FreezeRows --> 2+D+N*2 (unless scrolling value is zero)
2527	// - FreezeRows || FreezeColunns --> 3+D+N*2 (unless scrolling value is zero)
2528	// Where D is 1 if any column is clipped or hidden (dummy channel) otherwise 0.
2529	void ImGui::TableSetupDrawChannels(ImGuiTable* table)
2530	{
2531	const int freeze_row_multiplier = (table->FreezeRowsCount > 0) ? 2 : 1;
2532	const int channels_for_row = (table->Flags & ImGuiTableFlags_NoClip) ? 1 : table->ColumnsEnabledCount;
2533	const int channels_for_bg = 1 + 1 * freeze_row_multiplier;
2534	const int channels_for_dummy = (table->ColumnsEnabledCount < table->ColumnsCount || (memcmp(s1: table->VisibleMaskByIndex, s2: table->EnabledMaskByIndex, n: ImBitArrayGetStorageSizeInBytes(bitcount: table->ColumnsCount)) != 0)) ? +1 : 0;
2535	const int channels_total = channels_for_bg + (channels_for_row * freeze_row_multiplier) + channels_for_dummy;
2536	table->DrawSplitter->Split(draw_list: table->InnerWindow->DrawList, count: channels_total);
2537	table->DummyDrawChannel = (ImGuiTableDrawChannelIdx)((channels_for_dummy > 0) ? channels_total - 1 : -1);
2538	table->Bg2DrawChannelCurrent = TABLE_DRAW_CHANNEL_BG2_FROZEN;
2539	table->Bg2DrawChannelUnfrozen = (ImGuiTableDrawChannelIdx)((table->FreezeRowsCount > 0) ? 2 + channels_for_row : TABLE_DRAW_CHANNEL_BG2_FROZEN);
2540
2541	int draw_channel_current = 2;
2542	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2543	{
2544	ImGuiTableColumn* column = &table->Columns[column_n];
2545	if (column->IsVisibleX && column->IsVisibleY)
2546	{
2547	column->DrawChannelFrozen = (ImGuiTableDrawChannelIdx)(draw_channel_current);
2548	column->DrawChannelUnfrozen = (ImGuiTableDrawChannelIdx)(draw_channel_current + (table->FreezeRowsCount > 0 ? channels_for_row + 1 : 0));
2549	if (!(table->Flags & ImGuiTableFlags_NoClip))
2550	draw_channel_current++;
2551	}
2552	else
2553	{
2554	column->DrawChannelFrozen = column->DrawChannelUnfrozen = table->DummyDrawChannel;
2555	}
2556	column->DrawChannelCurrent = column->DrawChannelFrozen;
2557	}
2558
2559	// Initial draw cmd starts with a BgClipRect that matches the one of its host, to facilitate merge draw commands by default.
2560	// All our cell highlight are manually clipped with BgClipRect. When unfreezing it will be made smaller to fit scrolling rect.
2561	// (This technically isn't part of setting up draw channels, but is reasonably related to be done here)
2562	table->BgClipRect = table->InnerClipRect;
2563	table->Bg0ClipRectForDrawCmd = table->OuterWindow->ClipRect;
2564	table->Bg2ClipRectForDrawCmd = table->HostClipRect;
2565	IM_ASSERT(table->BgClipRect.Min.y <= table->BgClipRect.Max.y);
2566	}
2567
2568	// This function reorder draw channels based on matching clip rectangle, to facilitate merging them. Called by EndTable().
2569	// For simplicity we call it TableMergeDrawChannels() but in fact it only reorder channels + overwrite ClipRect,
2570	// actual merging is done by table->DrawSplitter.Merge() which is called right after TableMergeDrawChannels().
2571	//
2572	// Columns where the contents didn't stray off their local clip rectangle can be merged. To achieve
2573	// this we merge their clip rect and make them contiguous in the channel list, so they can be merged
2574	// by the call to DrawSplitter.Merge() following to the call to this function.
2575	// We reorder draw commands by arranging them into a maximum of 4 distinct groups:
2576	//
2577	// 1 group: 2 groups: 2 groups: 4 groups:
2578	// [ 0. ] no freeze [ 0. ] row freeze [ 01 ] col freeze [ 01 ] row+col freeze
2579	// [ .. ] or no scroll [ 2. ] and v-scroll [ .. ] and h-scroll [ 23 ] and v+h-scroll
2580	//
2581	// Each column itself can use 1 channel (row freeze disabled) or 2 channels (row freeze enabled).
2582	// When the contents of a column didn't stray off its limit, we move its channels into the corresponding group
2583	// based on its position (within frozen rows/columns groups or not).
2584	// At the end of the operation our 1-4 groups will each have a ImDrawCmd using the same ClipRect.
2585	// This function assume that each column are pointing to a distinct draw channel,
2586	// otherwise merge_group->ChannelsCount will not match set bit count of merge_group->ChannelsMask.
2587	//
2588	// Column channels will not be merged into one of the 1-4 groups in the following cases:
2589	// - The contents stray off its clipping rectangle (we only compare the MaxX value, not the MinX value).
2590	// Direct ImDrawList calls won't be taken into account by default, if you use them make sure the ImGui:: bounds
2591	// matches, by e.g. calling SetCursorScreenPos().
2592	// - The channel uses more than one draw command itself. We drop all our attempt at merging stuff here..
2593	// we could do better but it's going to be rare and probably not worth the hassle.
2594	// Columns for which the draw channel(s) haven't been merged with other will use their own ImDrawCmd.
2595	//
2596	// This function is particularly tricky to understand.. take a breath.
2597	void ImGui::TableMergeDrawChannels(ImGuiTable* table)
2598	{
2599	ImGuiContext& g = *GImGui;
2600	ImDrawListSplitter* splitter = table->DrawSplitter;
2601	const bool has_freeze_v = (table->FreezeRowsCount > 0);
2602	const bool has_freeze_h = (table->FreezeColumnsCount > 0);
2603	IM_ASSERT(splitter->_Current == 0);
2604
2605	// Track which groups we are going to attempt to merge, and which channels goes into each group.
2606	struct MergeGroup
2607	{
2608	ImRect ClipRect;
2609	int ChannelsCount = 0;
2610	ImBitArrayPtr ChannelsMask = NULL;
2611	};
2612	int merge_group_mask = 0x00;
2613	MergeGroup merge_groups[4];
2614
2615	// Use a reusable temp buffer for the merge masks as they are dynamically sized.
2616	const int max_draw_channels = (4 + table->ColumnsCount * 2);
2617	const int size_for_masks_bitarrays_one = (int)ImBitArrayGetStorageSizeInBytes(bitcount: max_draw_channels);
2618	g.TempBuffer.reserve(new_capacity: size_for_masks_bitarrays_one * 5);
2619	memset(s: g.TempBuffer.Data, c: 0, n: size_for_masks_bitarrays_one * 5);
2620	for (int n = 0; n < IM_ARRAYSIZE(merge_groups); n++)
2621	merge_groups[n].ChannelsMask = (ImBitArrayPtr)(void*)(g.TempBuffer.Data + (size_for_masks_bitarrays_one * n));
2622	ImBitArrayPtr remaining_mask = (ImBitArrayPtr)(void*)(g.TempBuffer.Data + (size_for_masks_bitarrays_one * 4));
2623
2624	// 1. Scan channels and take note of those which can be merged
2625	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2626	{
2627	if (!IM_BITARRAY_TESTBIT(table->VisibleMaskByIndex, column_n))
2628	continue;
2629	ImGuiTableColumn* column = &table->Columns[column_n];
2630
2631	const int merge_group_sub_count = has_freeze_v ? 2 : 1;
2632	for (int merge_group_sub_n = 0; merge_group_sub_n < merge_group_sub_count; merge_group_sub_n++)
2633	{
2634	const int channel_no = (merge_group_sub_n == 0) ? column->DrawChannelFrozen : column->DrawChannelUnfrozen;
2635
2636	// Don't attempt to merge if there are multiple draw calls within the column
2637	ImDrawChannel* src_channel = &splitter->_Channels[channel_no];
2638	if (src_channel->_CmdBuffer.Size > 0 && src_channel->_CmdBuffer.back().ElemCount == 0 && src_channel->_CmdBuffer.back().UserCallback == NULL) // Equivalent of PopUnusedDrawCmd()
2639	src_channel->_CmdBuffer.pop_back();
2640	if (src_channel->_CmdBuffer.Size != 1)
2641	continue;
2642
2643	// Find out the width of this merge group and check if it will fit in our column
2644	// (note that we assume that rendering didn't stray on the left direction. we should need a CursorMinPos to detect it)
2645	if (!(column->Flags & ImGuiTableColumnFlags_NoClip))
2646	{
2647	float content_max_x;
2648	if (!has_freeze_v)
2649	content_max_x = ImMax(lhs: column->ContentMaxXUnfrozen, rhs: column->ContentMaxXHeadersUsed); // No row freeze
2650	else if (merge_group_sub_n == 0)
2651	content_max_x = ImMax(lhs: column->ContentMaxXFrozen, rhs: column->ContentMaxXHeadersUsed); // Row freeze: use width before freeze
2652	else
2653	content_max_x = column->ContentMaxXUnfrozen; // Row freeze: use width after freeze
2654	if (content_max_x > column->ClipRect.Max.x)
2655	continue;
2656	}
2657
2658	const int merge_group_n = (has_freeze_h && column_n < table->FreezeColumnsCount ? 0 : 1) + (has_freeze_v && merge_group_sub_n == 0 ? 0 : 2);
2659	IM_ASSERT(channel_no < max_draw_channels);
2660	MergeGroup* merge_group = &merge_groups[merge_group_n];
2661	if (merge_group->ChannelsCount == 0)
2662	merge_group->ClipRect = ImRect(+FLT_MAX, +FLT_MAX, -FLT_MAX, -FLT_MAX);
2663	ImBitArraySetBit(arr: merge_group->ChannelsMask, n: channel_no);
2664	merge_group->ChannelsCount++;
2665	merge_group->ClipRect.Add(r: src_channel->_CmdBuffer[0].ClipRect);
2666	merge_group_mask |= (1 << merge_group_n);
2667	}
2668
2669	// Invalidate current draw channel
2670	// (we don't clear DrawChannelFrozen/DrawChannelUnfrozen solely to facilitate debugging/later inspection of data)
2671	column->DrawChannelCurrent = (ImGuiTableDrawChannelIdx)-1;
2672	}
2673
2674	// [DEBUG] Display merge groups
2675	#if 0
2676	if (g.IO.KeyShift)
2677	for (int merge_group_n = 0; merge_group_n < IM_ARRAYSIZE(merge_groups); merge_group_n++)
2678	{
2679	MergeGroup* merge_group = &merge_groups[merge_group_n];
2680	if (merge_group->ChannelsCount == 0)
2681	continue;
2682	char buf[32];
2683	ImFormatString(buf, 32, "MG%d:%d", merge_group_n, merge_group->ChannelsCount);
2684	ImVec2 text_pos = merge_group->ClipRect.Min + ImVec2(4, 4);
2685	ImVec2 text_size = CalcTextSize(buf, NULL);
2686	GetForegroundDrawList()->AddRectFilled(text_pos, text_pos + text_size, IM_COL32(0, 0, 0, 255));
2687	GetForegroundDrawList()->AddText(text_pos, IM_COL32(255, 255, 0, 255), buf, NULL);
2688	GetForegroundDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 255, 0, 255));
2689	}
2690	#endif
2691
2692	// 2. Rewrite channel list in our preferred order
2693	if (merge_group_mask != 0)
2694	{
2695	// We skip channel 0 (Bg0/Bg1) and 1 (Bg2 frozen) from the shuffling since they won't move - see channels allocation in TableSetupDrawChannels().
2696	const int LEADING_DRAW_CHANNELS = 2;
2697	g.DrawChannelsTempMergeBuffer.resize(new_size: splitter->_Count - LEADING_DRAW_CHANNELS); // Use shared temporary storage so the allocation gets amortized
2698	ImDrawChannel* dst_tmp = g.DrawChannelsTempMergeBuffer.Data;
2699	ImBitArraySetBitRange(arr: remaining_mask, n: LEADING_DRAW_CHANNELS, n2: splitter->_Count);
2700	ImBitArrayClearBit(arr: remaining_mask, n: table->Bg2DrawChannelUnfrozen);
2701	IM_ASSERT(has_freeze_v == false || table->Bg2DrawChannelUnfrozen != TABLE_DRAW_CHANNEL_BG2_FROZEN);
2702	int remaining_count = splitter->_Count - (has_freeze_v ? LEADING_DRAW_CHANNELS + 1 : LEADING_DRAW_CHANNELS);
2703	//ImRect host_rect = (table->InnerWindow == table->OuterWindow) ? table->InnerClipRect : table->HostClipRect;
2704	ImRect host_rect = table->HostClipRect;
2705	for (int merge_group_n = 0; merge_group_n < IM_ARRAYSIZE(merge_groups); merge_group_n++)
2706	{
2707	if (int merge_channels_count = merge_groups[merge_group_n].ChannelsCount)
2708	{
2709	MergeGroup* merge_group = &merge_groups[merge_group_n];
2710	ImRect merge_clip_rect = merge_group->ClipRect;
2711
2712	// Extend outer-most clip limits to match those of host, so draw calls can be merged even if
2713	// outer-most columns have some outer padding offsetting them from their parent ClipRect.
2714	// The principal cases this is dealing with are:
2715	// - On a same-window table (not scrolling = single group), all fitting columns ClipRect -> will extend and match host ClipRect -> will merge
2716	// - Columns can use padding and have left-most ClipRect.Min.x and right-most ClipRect.Max.x != from host ClipRect -> will extend and match host ClipRect -> will merge
2717	// FIXME-TABLE FIXME-WORKRECT: We are wasting a merge opportunity on tables without scrolling if column doesn't fit
2718	// within host clip rect, solely because of the half-padding difference between window->WorkRect and window->InnerClipRect.
2719	if ((merge_group_n & 1) == 0 || !has_freeze_h)
2720	merge_clip_rect.Min.x = ImMin(lhs: merge_clip_rect.Min.x, rhs: host_rect.Min.x);
2721	if ((merge_group_n & 2) == 0 || !has_freeze_v)
2722	merge_clip_rect.Min.y = ImMin(lhs: merge_clip_rect.Min.y, rhs: host_rect.Min.y);
2723	if ((merge_group_n & 1) != 0)
2724	merge_clip_rect.Max.x = ImMax(lhs: merge_clip_rect.Max.x, rhs: host_rect.Max.x);
2725	if ((merge_group_n & 2) != 0 && (table->Flags & ImGuiTableFlags_NoHostExtendY) == 0)
2726	merge_clip_rect.Max.y = ImMax(lhs: merge_clip_rect.Max.y, rhs: host_rect.Max.y);
2727	//GetForegroundDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 0, 0, 200), 0.0f, 0, 1.0f); // [DEBUG]
2728	//GetForegroundDrawList()->AddLine(merge_group->ClipRect.Min, merge_clip_rect.Min, IM_COL32(255, 100, 0, 200));
2729	//GetForegroundDrawList()->AddLine(merge_group->ClipRect.Max, merge_clip_rect.Max, IM_COL32(255, 100, 0, 200));
2730	remaining_count -= merge_group->ChannelsCount;
2731	for (int n = 0; n < (size_for_masks_bitarrays_one >> 2); n++)
2732	remaining_mask[n] &= ~merge_group->ChannelsMask[n];
2733	for (int n = 0; n < splitter->_Count && merge_channels_count != 0; n++)
2734	{
2735	// Copy + overwrite new clip rect
2736	if (!IM_BITARRAY_TESTBIT(merge_group->ChannelsMask, n))
2737	continue;
2738	IM_BITARRAY_CLEARBIT(merge_group->ChannelsMask, n);
2739	merge_channels_count--;
2740
2741	ImDrawChannel* channel = &splitter->_Channels[n];
2742	IM_ASSERT(channel->_CmdBuffer.Size == 1 && merge_clip_rect.Contains(ImRect(channel->_CmdBuffer[0].ClipRect)));
2743	channel->_CmdBuffer[0].ClipRect = merge_clip_rect.ToVec4();
2744	memcpy(dest: dst_tmp++, src: channel, n: sizeof(ImDrawChannel));
2745	}
2746	}
2747
2748	// Make sure Bg2DrawChannelUnfrozen appears in the middle of our groups (whereas Bg0/Bg1 and Bg2 frozen are fixed to 0 and 1)
2749	if (merge_group_n == 1 && has_freeze_v)
2750	memcpy(dest: dst_tmp++, src: &splitter->_Channels[table->Bg2DrawChannelUnfrozen], n: sizeof(ImDrawChannel));
2751	}
2752
2753	// Append unmergeable channels that we didn't reorder at the end of the list
2754	for (int n = 0; n < splitter->_Count && remaining_count != 0; n++)
2755	{
2756	if (!IM_BITARRAY_TESTBIT(remaining_mask, n))
2757	continue;
2758	ImDrawChannel* channel = &splitter->_Channels[n];
2759	memcpy(dest: dst_tmp++, src: channel, n: sizeof(ImDrawChannel));
2760	remaining_count--;
2761	}
2762	IM_ASSERT(dst_tmp == g.DrawChannelsTempMergeBuffer.Data + g.DrawChannelsTempMergeBuffer.Size);
2763	memcpy(dest: splitter->_Channels.Data + LEADING_DRAW_CHANNELS, src: g.DrawChannelsTempMergeBuffer.Data, n: (splitter->_Count - LEADING_DRAW_CHANNELS) * sizeof(ImDrawChannel));
2764	}
2765	}
2766
2767	static ImU32 TableGetColumnBorderCol(ImGuiTable* table, int order_n, int column_n)
2768	{
2769	const bool is_hovered = (table->HoveredColumnBorder == column_n);
2770	const bool is_resized = (table->ResizedColumn == column_n) && (table->InstanceInteracted == table->InstanceCurrent);
2771	const bool is_frozen_separator = (table->FreezeColumnsCount == order_n + 1);
2772	if (is_resized || is_hovered)
2773	return ImGui::GetColorU32(idx: is_resized ? ImGuiCol_SeparatorActive : ImGuiCol_SeparatorHovered);
2774	if (is_frozen_separator || (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)))
2775	return table->BorderColorStrong;
2776	return table->BorderColorLight;
2777	}
2778
2779	// FIXME-TABLE: This is a mess, need to redesign how we render borders (as some are also done in TableEndRow)
2780	void ImGui::TableDrawBorders(ImGuiTable* table)
2781	{
2782	ImGuiWindow* inner_window = table->InnerWindow;
2783	if (!table->OuterWindow->ClipRect.Overlaps(r: table->OuterRect))
2784	return;
2785
2786	ImDrawList* inner_drawlist = inner_window->DrawList;
2787	table->DrawSplitter->SetCurrentChannel(draw_list: inner_drawlist, channel_idx: TABLE_DRAW_CHANNEL_BG0);
2788	inner_drawlist->PushClipRect(clip_rect_min: table->Bg0ClipRectForDrawCmd.Min, clip_rect_max: table->Bg0ClipRectForDrawCmd.Max, intersect_with_current_clip_rect: false);
2789
2790	// Draw inner border and resizing feedback
2791	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
2792	const float border_size = TABLE_BORDER_SIZE;
2793	const float draw_y1 = ImMax(lhs: table->InnerRect.Min.y, rhs: (table->FreezeRowsCount >= 1 ? table->InnerRect.Min.y : table->WorkRect.Min.y) + table->AngledHeadersHeight) + ((table->Flags & ImGuiTableFlags_BordersOuterH) ? 1.0f : 0.0f);
2794	const float draw_y2_body = table->InnerRect.Max.y;
2795	const float draw_y2_head = table->IsUsingHeaders ? ImMin(lhs: table->InnerRect.Max.y, rhs: (table->FreezeRowsCount >= 1 ? table->InnerRect.Min.y : table->WorkRect.Min.y) + table_instance->LastTopHeadersRowHeight) : draw_y1;
2796	if (table->Flags & ImGuiTableFlags_BordersInnerV)
2797	{
2798	for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
2799	{
2800	if (!IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))
2801	continue;
2802
2803	const int column_n = table->DisplayOrderToIndex[order_n];
2804	ImGuiTableColumn* column = &table->Columns[column_n];
2805	const bool is_hovered = (table->HoveredColumnBorder == column_n);
2806	const bool is_resized = (table->ResizedColumn == column_n) && (table->InstanceInteracted == table->InstanceCurrent);
2807	const bool is_resizable = (column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_NoDirectResize_)) == 0;
2808	const bool is_frozen_separator = (table->FreezeColumnsCount == order_n + 1);
2809	if (column->MaxX > table->InnerClipRect.Max.x && !is_resized)
2810	continue;
2811
2812	// Decide whether right-most column is visible
2813	if (column->NextEnabledColumn == -1 && !is_resizable)
2814	if ((table->Flags & ImGuiTableFlags_SizingMask_) != ImGuiTableFlags_SizingFixedSame || (table->Flags & ImGuiTableFlags_NoHostExtendX))
2815	continue;
2816	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..
2817	continue;
2818
2819	// Draw in outer window so right-most column won't be clipped
2820	// Always draw full height border when being resized/hovered, or on the delimitation of frozen column scrolling.
2821	float draw_y2 = (is_hovered || is_resized || is_frozen_separator || (table->Flags & (ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_NoBordersInBodyUntilResize)) == 0) ? draw_y2_body : draw_y2_head;
2822	if (draw_y2 > draw_y1)
2823	inner_drawlist->AddLine(p1: ImVec2(column->MaxX, draw_y1), p2: ImVec2(column->MaxX, draw_y2), col: TableGetColumnBorderCol(table, order_n, column_n), thickness: border_size);
2824	}
2825	}
2826
2827	// Draw outer border
2828	// FIXME: could use AddRect or explicit VLine/HLine helper?
2829	if (table->Flags & ImGuiTableFlags_BordersOuter)
2830	{
2831	// Display outer border offset by 1 which is a simple way to display it without adding an extra draw call
2832	// (Without the offset, in outer_window it would be rendered behind cells, because child windows are above their
2833	// parent. In inner_window, it won't reach out over scrollbars. Another weird solution would be to display part
2834	// of it in inner window, and the part that's over scrollbars in the outer window..)
2835	// Either solution currently won't allow us to use a larger border size: the border would clipped.
2836	const ImRect outer_border = table->OuterRect;
2837	const ImU32 outer_col = table->BorderColorStrong;
2838	if ((table->Flags & ImGuiTableFlags_BordersOuter) == ImGuiTableFlags_BordersOuter)
2839	{
2840	inner_drawlist->AddRect(p_min: outer_border.Min, p_max: outer_border.Max, col: outer_col, rounding: 0.0f, flags: 0, thickness: border_size);
2841	}
2842	else if (table->Flags & ImGuiTableFlags_BordersOuterV)
2843	{
2844	inner_drawlist->AddLine(p1: outer_border.Min, p2: ImVec2(outer_border.Min.x, outer_border.Max.y), col: outer_col, thickness: border_size);
2845	inner_drawlist->AddLine(p1: ImVec2(outer_border.Max.x, outer_border.Min.y), p2: outer_border.Max, col: outer_col, thickness: border_size);
2846	}
2847	else if (table->Flags & ImGuiTableFlags_BordersOuterH)
2848	{
2849	inner_drawlist->AddLine(p1: outer_border.Min, p2: ImVec2(outer_border.Max.x, outer_border.Min.y), col: outer_col, thickness: border_size);
2850	inner_drawlist->AddLine(p1: ImVec2(outer_border.Min.x, outer_border.Max.y), p2: outer_border.Max, col: outer_col, thickness: border_size);
2851	}
2852	}
2853	if ((table->Flags & ImGuiTableFlags_BordersInnerH) && table->RowPosY2 < table->OuterRect.Max.y)
2854	{
2855	// Draw bottom-most row border between it is above outer border.
2856	const float border_y = table->RowPosY2;
2857	if (border_y >= table->BgClipRect.Min.y && border_y < table->BgClipRect.Max.y)
2858	inner_drawlist->AddLine(p1: ImVec2(table->BorderX1, border_y), p2: ImVec2(table->BorderX2, border_y), col: table->BorderColorLight, thickness: border_size);
2859	}
2860
2861	inner_drawlist->PopClipRect();
2862	}
2863
2864	//-------------------------------------------------------------------------
2865	// [SECTION] Tables: Sorting
2866	//-------------------------------------------------------------------------
2867	// - TableGetSortSpecs()
2868	// - TableFixColumnSortDirection() [Internal]
2869	// - TableGetColumnNextSortDirection() [Internal]
2870	// - TableSetColumnSortDirection() [Internal]
2871	// - TableSortSpecsSanitize() [Internal]
2872	// - TableSortSpecsBuild() [Internal]
2873	//-------------------------------------------------------------------------
2874
2875	// Return NULL if no sort specs (most often when ImGuiTableFlags_Sortable is not set)
2876	// When 'sort_specs->SpecsDirty == true' you should sort your data. It will be true when sorting specs have
2877	// changed since last call, or the first time. Make sure to set 'SpecsDirty = false' after sorting,
2878	// else you may wastefully sort your data every frame!
2879	// Lifetime: don't hold on this pointer over multiple frames or past any subsequent call to BeginTable()!
2880	ImGuiTableSortSpecs* ImGui::TableGetSortSpecs()
2881	{
2882	ImGuiContext& g = *GImGui;
2883	ImGuiTable* table = g.CurrentTable;
2884	if (table == NULL || !(table->Flags & ImGuiTableFlags_Sortable))
2885	return NULL;
2886
2887	// Require layout (in case TableHeadersRow() hasn't been called) as it may alter IsSortSpecsDirty in some paths.
2888	if (!table->IsLayoutLocked)
2889	TableUpdateLayout(table);
2890
2891	TableSortSpecsBuild(table);
2892	return &table->SortSpecs;
2893	}
2894
2895	static inline ImGuiSortDirection TableGetColumnAvailSortDirection(ImGuiTableColumn* column, int n)
2896	{
2897	IM_ASSERT(n < column->SortDirectionsAvailCount);
2898	return (ImGuiSortDirection)((column->SortDirectionsAvailList >> (n << 1)) & 0x03);
2899	}
2900
2901	// Fix sort direction if currently set on a value which is unavailable (e.g. activating NoSortAscending/NoSortDescending)
2902	void ImGui::TableFixColumnSortDirection(ImGuiTable* table, ImGuiTableColumn* column)
2903	{
2904	if (column->SortOrder == -1 || (column->SortDirectionsAvailMask & (1 << column->SortDirection)) != 0)
2905	return;
2906	column->SortDirection = (ImU8)TableGetColumnAvailSortDirection(column, n: 0);
2907	table->IsSortSpecsDirty = true;
2908	}
2909
2910	// Calculate next sort direction that would be set after clicking the column
2911	// - If the PreferSortDescending flag is set, we will default to a Descending direction on the first click.
2912	// - Note that the PreferSortAscending flag is never checked, it is essentially the default and therefore a no-op.
2913	IM_STATIC_ASSERT(ImGuiSortDirection_None == 0 && ImGuiSortDirection_Ascending == 1 && ImGuiSortDirection_Descending == 2);
2914	ImGuiSortDirection ImGui::TableGetColumnNextSortDirection(ImGuiTableColumn* column)
2915	{
2916	IM_ASSERT(column->SortDirectionsAvailCount > 0);
2917	if (column->SortOrder == -1)
2918	return TableGetColumnAvailSortDirection(column, n: 0);
2919	for (int n = 0; n < 3; n++)
2920	if (column->SortDirection == TableGetColumnAvailSortDirection(column, n))
2921	return TableGetColumnAvailSortDirection(column, n: (n + 1) % column->SortDirectionsAvailCount);
2922	IM_ASSERT(0);
2923	return ImGuiSortDirection_None;
2924	}
2925
2926	// Note that the NoSortAscending/NoSortDescending flags are processed in TableSortSpecsSanitize(), and they may change/revert
2927	// the value of SortDirection. We could technically also do it here but it would be unnecessary and duplicate code.
2928	void ImGui::TableSetColumnSortDirection(int column_n, ImGuiSortDirection sort_direction, bool append_to_sort_specs)
2929	{
2930	ImGuiContext& g = *GImGui;
2931	ImGuiTable* table = g.CurrentTable;
2932
2933	if (!(table->Flags & ImGuiTableFlags_SortMulti))
2934	append_to_sort_specs = false;
2935	if (!(table->Flags & ImGuiTableFlags_SortTristate))
2936	IM_ASSERT(sort_direction != ImGuiSortDirection_None);
2937
2938	ImGuiTableColumnIdx sort_order_max = 0;
2939	if (append_to_sort_specs)
2940	for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
2941	sort_order_max = ImMax(lhs: sort_order_max, rhs: table->Columns[other_column_n].SortOrder);
2942
2943	ImGuiTableColumn* column = &table->Columns[column_n];
2944	column->SortDirection = (ImU8)sort_direction;
2945	if (column->SortDirection == ImGuiSortDirection_None)
2946	column->SortOrder = -1;
2947	else if (column->SortOrder == -1 || !append_to_sort_specs)
2948	column->SortOrder = append_to_sort_specs ? sort_order_max + 1 : 0;
2949
2950	for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
2951	{
2952	ImGuiTableColumn* other_column = &table->Columns[other_column_n];
2953	if (other_column != column && !append_to_sort_specs)
2954	other_column->SortOrder = -1;
2955	TableFixColumnSortDirection(table, column: other_column);
2956	}
2957	table->IsSettingsDirty = true;
2958	table->IsSortSpecsDirty = true;
2959	}
2960
2961	void ImGui::TableSortSpecsSanitize(ImGuiTable* table)
2962	{
2963	IM_ASSERT(table->Flags & ImGuiTableFlags_Sortable);
2964
2965	// Clear SortOrder from hidden column and verify that there's no gap or duplicate.
2966	int sort_order_count = 0;
2967	ImU64 sort_order_mask = 0x00;
2968	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2969	{
2970	ImGuiTableColumn* column = &table->Columns[column_n];
2971	if (column->SortOrder != -1 && !column->IsEnabled)
2972	column->SortOrder = -1;
2973	if (column->SortOrder == -1)
2974	continue;
2975	sort_order_count++;
2976	sort_order_mask |= ((ImU64)1 << column->SortOrder);
2977	IM_ASSERT(sort_order_count < (int)sizeof(sort_order_mask) * 8);
2978	}
2979
2980	const bool need_fix_linearize = ((ImU64)1 << sort_order_count) != (sort_order_mask + 1);
2981	const bool need_fix_single_sort_order = (sort_order_count > 1) && !(table->Flags & ImGuiTableFlags_SortMulti);
2982	if (need_fix_linearize || need_fix_single_sort_order)
2983	{
2984	ImU64 fixed_mask = 0x00;
2985	for (int sort_n = 0; sort_n < sort_order_count; sort_n++)
2986	{
2987	// Fix: Rewrite sort order fields if needed so they have no gap or duplicate.
2988	// (e.g. SortOrder 0 disappeared, SortOrder 1..2 exists --> rewrite then as SortOrder 0..1)
2989	int column_with_smallest_sort_order = -1;
2990	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
2991	if ((fixed_mask & ((ImU64)1 << (ImU64)column_n)) == 0 && table->Columns[column_n].SortOrder != -1)
2992	if (column_with_smallest_sort_order == -1 || table->Columns[column_n].SortOrder < table->Columns[column_with_smallest_sort_order].SortOrder)
2993	column_with_smallest_sort_order = column_n;
2994	IM_ASSERT(column_with_smallest_sort_order != -1);
2995	fixed_mask |= ((ImU64)1 << column_with_smallest_sort_order);
2996	table->Columns[column_with_smallest_sort_order].SortOrder = (ImGuiTableColumnIdx)sort_n;
2997
2998	// Fix: Make sure only one column has a SortOrder if ImGuiTableFlags_MultiSortable is not set.
2999	if (need_fix_single_sort_order)
3000	{
3001	sort_order_count = 1;
3002	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3003	if (column_n != column_with_smallest_sort_order)
3004	table->Columns[column_n].SortOrder = -1;
3005	break;
3006	}
3007	}
3008	}
3009
3010	// Fallback default sort order (if no column with the ImGuiTableColumnFlags_DefaultSort flag)
3011	if (sort_order_count == 0 && !(table->Flags & ImGuiTableFlags_SortTristate))
3012	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3013	{
3014	ImGuiTableColumn* column = &table->Columns[column_n];
3015	if (column->IsEnabled && !(column->Flags & ImGuiTableColumnFlags_NoSort))
3016	{
3017	sort_order_count = 1;
3018	column->SortOrder = 0;
3019	column->SortDirection = (ImU8)TableGetColumnAvailSortDirection(column, n: 0);
3020	break;
3021	}
3022	}
3023
3024	table->SortSpecsCount = (ImGuiTableColumnIdx)sort_order_count;
3025	}
3026
3027	void ImGui::TableSortSpecsBuild(ImGuiTable* table)
3028	{
3029	bool dirty = table->IsSortSpecsDirty;
3030	if (dirty)
3031	{
3032	TableSortSpecsSanitize(table);
3033	table->SortSpecsMulti.resize(new_size: table->SortSpecsCount <= 1 ? 0 : table->SortSpecsCount);
3034	table->SortSpecs.SpecsDirty = true; // Mark as dirty for user
3035	table->IsSortSpecsDirty = false; // Mark as not dirty for us
3036	}
3037
3038	// Write output
3039	// May be able to move all SortSpecs data from table (48 bytes) to ImGuiTableTempData if we decide to write it back on every BeginTable()
3040	ImGuiTableColumnSortSpecs* sort_specs = (table->SortSpecsCount == 0) ? NULL : (table->SortSpecsCount == 1) ? &table->SortSpecsSingle : table->SortSpecsMulti.Data;
3041	if (dirty && sort_specs != NULL)
3042	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3043	{
3044	ImGuiTableColumn* column = &table->Columns[column_n];
3045	if (column->SortOrder == -1)
3046	continue;
3047	IM_ASSERT(column->SortOrder < table->SortSpecsCount);
3048	ImGuiTableColumnSortSpecs* sort_spec = &sort_specs[column->SortOrder];
3049	sort_spec->ColumnUserID = column->UserID;
3050	sort_spec->ColumnIndex = (ImGuiTableColumnIdx)column_n;
3051	sort_spec->SortOrder = (ImGuiTableColumnIdx)column->SortOrder;
3052	sort_spec->SortDirection = (ImGuiSortDirection)column->SortDirection;
3053	}
3054
3055	table->SortSpecs.Specs = sort_specs;
3056	table->SortSpecs.SpecsCount = table->SortSpecsCount;
3057	}
3058
3059	//-------------------------------------------------------------------------
3060	// [SECTION] Tables: Headers
3061	//-------------------------------------------------------------------------
3062	// - TableGetHeaderRowHeight() [Internal]
3063	// - TableGetHeaderAngledMaxLabelWidth() [Internal]
3064	// - TableHeadersRow()
3065	// - TableHeader()
3066	// - TableAngledHeadersRow()
3067	// - TableAngledHeadersRowEx() [Internal]
3068	//-------------------------------------------------------------------------
3069
3070	float ImGui::TableGetHeaderRowHeight()
3071	{
3072	// Caring for a minor edge case:
3073	// Calculate row height, for the unlikely case that some labels may be taller than others.
3074	// If we didn't do that, uneven header height would highlight but smaller one before the tallest wouldn't catch input for all height.
3075	// In your custom header row you may omit this all together and just call TableNextRow() without a height...
3076	ImGuiContext& g = *GImGui;
3077	ImGuiTable* table = g.CurrentTable;
3078	float row_height = g.FontSize;
3079	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3080	if (IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
3081	if ((table->Columns[column_n].Flags & ImGuiTableColumnFlags_NoHeaderLabel) == 0)
3082	row_height = ImMax(lhs: row_height, rhs: CalcTextSize(text: TableGetColumnName(table, column_n)).y);
3083	return row_height + g.Style.CellPadding.y * 2.0f;
3084	}
3085
3086	float ImGui::TableGetHeaderAngledMaxLabelWidth()
3087	{
3088	ImGuiContext& g = *GImGui;
3089	ImGuiTable* table = g.CurrentTable;
3090	float width = 0.0f;
3091	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3092	if (IM_BITARRAY_TESTBIT(table->EnabledMaskByIndex, column_n))
3093	if (table->Columns[column_n].Flags & ImGuiTableColumnFlags_AngledHeader)
3094	width = ImMax(lhs: width, rhs: CalcTextSize(text: TableGetColumnName(table, column_n), NULL, hide_text_after_double_hash: true).x);
3095	return width + g.Style.CellPadding.y * 2.0f; // Swap padding
3096	}
3097
3098	// [Public] This is a helper to output TableHeader() calls based on the column names declared in TableSetupColumn().
3099	// The intent is that advanced users willing to create customized headers would not need to use this helper
3100	// and can create their own! For example: TableHeader() may be preceded by Checkbox() or other custom widgets.
3101	// See 'Demo->Tables->Custom headers' for a demonstration of implementing a custom version of this.
3102	// This code is intentionally written to not make much use of internal functions, to give you better direction
3103	// if you need to write your own.
3104	// FIXME-TABLE: TableOpenContextMenu() and TableGetHeaderRowHeight() are not public.
3105	void ImGui::TableHeadersRow()
3106	{
3107	ImGuiContext& g = *GImGui;
3108	ImGuiTable* table = g.CurrentTable;
3109	if (table == NULL)
3110	{
3111	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
3112	return;
3113	}
3114
3115	// Call layout if not already done. This is automatically done by TableNextRow: we do it here _only_ to make
3116	// it easier to debug-step in TableUpdateLayout(). Your own version of this function doesn't need this.
3117	if (!table->IsLayoutLocked)
3118	TableUpdateLayout(table);
3119
3120	// Open row
3121	const float row_height = TableGetHeaderRowHeight();
3122	TableNextRow(row_flags: ImGuiTableRowFlags_Headers, row_min_height: row_height);
3123	const float row_y1 = GetCursorScreenPos().y;
3124	if (table->HostSkipItems) // Merely an optimization, you may skip in your own code.
3125	return;
3126
3127	const int columns_count = TableGetColumnCount();
3128	for (int column_n = 0; column_n < columns_count; column_n++)
3129	{
3130	if (!TableSetColumnIndex(column_n))
3131	continue;
3132
3133	// 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)
3134	const char* name = (TableGetColumnFlags(column_n) & ImGuiTableColumnFlags_NoHeaderLabel) ? "" : TableGetColumnName(column_n);
3135	PushID(int_id: column_n);
3136	TableHeader(label: name);
3137	PopID();
3138	}
3139
3140	// Allow opening popup from the right-most section after the last column.
3141	ImVec2 mouse_pos = ImGui::GetMousePos();
3142	if (IsMouseReleased(button: 1) && TableGetHoveredColumn() == columns_count)
3143	if (mouse_pos.y >= row_y1 && mouse_pos.y < row_y1 + row_height)
3144	TableOpenContextMenu(column_n: columns_count); // Will open a non-column-specific popup.
3145	}
3146
3147	// Emit a column header (text + optional sort order)
3148	// We cpu-clip text here so that all columns headers can be merged into a same draw call.
3149	// Note that because of how we cpu-clip and display sorting indicators, you _cannot_ use SameLine() after a TableHeader()
3150	void ImGui::TableHeader(const char* label)
3151	{
3152	ImGuiContext& g = *GImGui;
3153	ImGuiWindow* window = g.CurrentWindow;
3154	if (window->SkipItems)
3155	return;
3156
3157	ImGuiTable* table = g.CurrentTable;
3158	if (table == NULL)
3159	{
3160	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
3161	return;
3162	}
3163
3164	IM_ASSERT(table->CurrentColumn != -1);
3165	const int column_n = table->CurrentColumn;
3166	ImGuiTableColumn* column = &table->Columns[column_n];
3167
3168	// Label
3169	if (label == NULL)
3170	label = "";
3171	const char* label_end = FindRenderedTextEnd(text: label);
3172	ImVec2 label_size = CalcTextSize(text: label, text_end: label_end, hide_text_after_double_hash: true);
3173	ImVec2 label_pos = window->DC.CursorPos;
3174
3175	// If we already got a row height, there's use that.
3176	// FIXME-TABLE: Padding problem if the correct outer-padding CellBgRect strays off our ClipRect?
3177	ImRect cell_r = TableGetCellBgRect(table, column_n);
3178	float label_height = ImMax(lhs: label_size.y, rhs: table->RowMinHeight - table->RowCellPaddingY * 2.0f);
3179
3180	// Calculate ideal size for sort order arrow
3181	float w_arrow = 0.0f;
3182	float w_sort_text = 0.0f;
3183	bool sort_arrow = false;
3184	char sort_order_suf[4] = "";
3185	const float ARROW_SCALE = 0.65f;
3186	if ((table->Flags & ImGuiTableFlags_Sortable) && !(column->Flags & ImGuiTableColumnFlags_NoSort))
3187	{
3188	w_arrow = ImTrunc(f: g.FontSize * ARROW_SCALE + g.Style.FramePadding.x);
3189	if (column->SortOrder != -1)
3190	sort_arrow = true;
3191	if (column->SortOrder > 0)
3192	{
3193	ImFormatString(buf: sort_order_suf, IM_ARRAYSIZE(sort_order_suf), fmt: "%d", column->SortOrder + 1);
3194	w_sort_text = g.Style.ItemInnerSpacing.x + CalcTextSize(text: sort_order_suf).x;
3195	}
3196	}
3197
3198	// We feed our unclipped width to the column without writing on CursorMaxPos, so that column is still considered for merging.
3199	float max_pos_x = label_pos.x + label_size.x + w_sort_text + w_arrow;
3200	column->ContentMaxXHeadersUsed = ImMax(lhs: column->ContentMaxXHeadersUsed, rhs: sort_arrow ? cell_r.Max.x : ImMin(lhs: max_pos_x, rhs: cell_r.Max.x));
3201	column->ContentMaxXHeadersIdeal = ImMax(lhs: column->ContentMaxXHeadersIdeal, rhs: max_pos_x);
3202
3203	// Keep header highlighted when context menu is open.
3204	ImGuiID id = window->GetID(str: label);
3205	ImRect bb(cell_r.Min.x, cell_r.Min.y, cell_r.Max.x, ImMax(lhs: cell_r.Max.y, rhs: cell_r.Min.y + label_height + g.Style.CellPadding.y * 2.0f));
3206	ItemSize(size: ImVec2(0.0f, label_height)); // Don't declare unclipped width, it'll be fed ContentMaxPosHeadersIdeal
3207	if (!ItemAdd(bb, id))
3208	return;
3209
3210	//GetForegroundDrawList()->AddRect(cell_r.Min, cell_r.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]
3211	//GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(255, 0, 0, 255)); // [DEBUG]
3212
3213	// Using AllowOverlap mode because we cover the whole cell, and we want user to be able to submit subsequent items.
3214	const bool highlight = (table->HighlightColumnHeader == column_n);
3215	bool hovered, held;
3216	bool pressed = ButtonBehavior(bb, id, out_hovered: &hovered, out_held: &held, flags: ImGuiButtonFlags_AllowOverlap);
3217	if (held || hovered || highlight)
3218	{
3219	const ImU32 col = GetColorU32(idx: held ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
3220	//RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
3221	TableSetBgColor(target: ImGuiTableBgTarget_CellBg, color: col, column_n: table->CurrentColumn);
3222	}
3223	else
3224	{
3225	// Submit single cell bg color in the case we didn't submit a full header row
3226	if ((table->RowFlags & ImGuiTableRowFlags_Headers) == 0)
3227	TableSetBgColor(target: ImGuiTableBgTarget_CellBg, color: GetColorU32(idx: ImGuiCol_TableHeaderBg), column_n: table->CurrentColumn);
3228	}
3229	RenderNavCursor(bb, id, flags: ImGuiNavRenderCursorFlags_Compact | ImGuiNavRenderCursorFlags_NoRounding);
3230	if (held)
3231	table->HeldHeaderColumn = (ImGuiTableColumnIdx)column_n;
3232	window->DC.CursorPos.y -= g.Style.ItemSpacing.y * 0.5f;
3233
3234	// Drag and drop to re-order columns.
3235	// FIXME-TABLE: Scroll request while reordering a column and it lands out of the scrolling zone.
3236	if (held && (table->Flags & ImGuiTableFlags_Reorderable) && IsMouseDragging(button: 0) && !g.DragDropActive)
3237	{
3238	// While moving a column it will jump on the other side of the mouse, so we also test for MouseDelta.x
3239	table->ReorderColumn = (ImGuiTableColumnIdx)column_n;
3240	table->InstanceInteracted = table->InstanceCurrent;
3241
3242	// We don't reorder: through the frozen<>unfrozen line, or through a column that is marked with ImGuiTableColumnFlags_NoReorder.
3243	if (g.IO.MouseDelta.x < 0.0f && g.IO.MousePos.x < cell_r.Min.x)
3244	if (ImGuiTableColumn* prev_column = (column->PrevEnabledColumn != -1) ? &table->Columns[column->PrevEnabledColumn] : NULL)
3245	if (!((column->Flags | prev_column->Flags) & ImGuiTableColumnFlags_NoReorder))
3246	if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (prev_column->IndexWithinEnabledSet < table->FreezeColumnsRequest))
3247	table->ReorderColumnDir = -1;
3248	if (g.IO.MouseDelta.x > 0.0f && g.IO.MousePos.x > cell_r.Max.x)
3249	if (ImGuiTableColumn* next_column = (column->NextEnabledColumn != -1) ? &table->Columns[column->NextEnabledColumn] : NULL)
3250	if (!((column->Flags | next_column->Flags) & ImGuiTableColumnFlags_NoReorder))
3251	if ((column->IndexWithinEnabledSet < table->FreezeColumnsRequest) == (next_column->IndexWithinEnabledSet < table->FreezeColumnsRequest))
3252	table->ReorderColumnDir = +1;
3253	}
3254
3255	// Sort order arrow
3256	const float ellipsis_max = ImMax(lhs: cell_r.Max.x - w_arrow - w_sort_text, rhs: label_pos.x);
3257	if ((table->Flags & ImGuiTableFlags_Sortable) && !(column->Flags & ImGuiTableColumnFlags_NoSort))
3258	{
3259	if (column->SortOrder != -1)
3260	{
3261	float x = ImMax(lhs: cell_r.Min.x, rhs: cell_r.Max.x - w_arrow - w_sort_text);
3262	float y = label_pos.y;
3263	if (column->SortOrder > 0)
3264	{
3265	PushStyleColor(idx: ImGuiCol_Text, col: GetColorU32(idx: ImGuiCol_Text, alpha_mul: 0.70f));
3266	RenderText(pos: ImVec2(x + g.Style.ItemInnerSpacing.x, y), text: sort_order_suf);
3267	PopStyleColor();
3268	x += w_sort_text;
3269	}
3270	RenderArrow(draw_list: window->DrawList, pos: ImVec2(x, y), col: GetColorU32(idx: ImGuiCol_Text), dir: column->SortDirection == ImGuiSortDirection_Ascending ? ImGuiDir_Up : ImGuiDir_Down, scale: ARROW_SCALE);
3271	}
3272
3273	// Handle clicking on column header to adjust Sort Order
3274	if (pressed && table->ReorderColumn != column_n)
3275	{
3276	ImGuiSortDirection sort_direction = TableGetColumnNextSortDirection(column);
3277	TableSetColumnSortDirection(column_n, sort_direction, append_to_sort_specs: g.IO.KeyShift);
3278	}
3279	}
3280
3281	// Render clipped label. Clipping here ensure that in the majority of situations, all our header cells will
3282	// be merged into a single draw call.
3283	//window->DrawList->AddCircleFilled(ImVec2(ellipsis_max, label_pos.y), 40, IM_COL32_WHITE);
3284	RenderTextEllipsis(draw_list: window->DrawList, pos_min: label_pos, pos_max: ImVec2(ellipsis_max, bb.Max.y), ellipsis_max_x: ellipsis_max, text: label, text_end: label_end, text_size_if_known: &label_size);
3285
3286	const bool text_clipped = label_size.x > (ellipsis_max - label_pos.x);
3287	if (text_clipped && hovered && g.ActiveId == 0)
3288	SetItemTooltip("%.*s", (int)(label_end - label), label);
3289
3290	// We don't use BeginPopupContextItem() because we want the popup to stay up even after the column is hidden
3291	if (IsMouseReleased(button: 1) && IsItemHovered())
3292	TableOpenContextMenu(column_n);
3293	}
3294
3295	// Unlike TableHeadersRow() it is not expected that you can reimplement or customize this with custom widgets.
3296	// FIXME: No hit-testing/button on the angled header.
3297	void ImGui::TableAngledHeadersRow()
3298	{
3299	ImGuiContext& g = *GImGui;
3300	ImGuiTable* table = g.CurrentTable;
3301	ImGuiTableTempData* temp_data = table->TempData;
3302	temp_data->AngledHeadersRequests.resize(new_size: 0);
3303	temp_data->AngledHeadersRequests.reserve(new_capacity: table->ColumnsEnabledCount);
3304
3305	// Which column needs highlight?
3306	const ImGuiID row_id = GetID(str_id: "##AngledHeaders");
3307	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: table->InstanceCurrent);
3308	int highlight_column_n = table->HighlightColumnHeader;
3309	if (highlight_column_n == -1 && table->HoveredColumnBody != -1)
3310	if (table_instance->HoveredRowLast == 0 && table->HoveredColumnBorder == -1 && (g.ActiveId == 0 || g.ActiveId == row_id || (table->IsActiveIdInTable || g.DragDropActive)))
3311	highlight_column_n = table->HoveredColumnBody;
3312
3313	// Build up request
3314	ImU32 col_header_bg = GetColorU32(idx: ImGuiCol_TableHeaderBg);
3315	ImU32 col_text = GetColorU32(idx: ImGuiCol_Text);
3316	for (int order_n = 0; order_n < table->ColumnsCount; order_n++)
3317	if (IM_BITARRAY_TESTBIT(table->EnabledMaskByDisplayOrder, order_n))
3318	{
3319	const int column_n = table->DisplayOrderToIndex[order_n];
3320	ImGuiTableColumn* column = &table->Columns[column_n];
3321	if ((column->Flags & ImGuiTableColumnFlags_AngledHeader) == 0) // Note: can't rely on ImGuiTableColumnFlags_IsVisible test here.
3322	continue;
3323	ImGuiTableHeaderData request = { .Index: (ImGuiTableColumnIdx)column_n, .TextColor: col_text, .BgColor0: col_header_bg, .BgColor1: (column_n == highlight_column_n) ? GetColorU32(idx: ImGuiCol_Header) : 0 };
3324	temp_data->AngledHeadersRequests.push_back(v: request);
3325	}
3326
3327	// Render row
3328	TableAngledHeadersRowEx(row_id, angle: g.Style.TableAngledHeadersAngle, max_label_width: 0.0f, data: temp_data->AngledHeadersRequests.Data, data_count: temp_data->AngledHeadersRequests.Size);
3329	}
3330
3331	// Important: data must be fed left to right
3332	void ImGui::TableAngledHeadersRowEx(ImGuiID row_id, float angle, float max_label_width, const ImGuiTableHeaderData* data, int data_count)
3333	{
3334	ImGuiContext& g = *GImGui;
3335	ImGuiTable* table = g.CurrentTable;
3336	ImGuiWindow* window = g.CurrentWindow;
3337	ImDrawList* draw_list = window->DrawList;
3338	if (table == NULL)
3339	{
3340	IM_ASSERT_USER_ERROR(table != NULL, "Call should only be done while in BeginTable() scope!");
3341	return;
3342	}
3343	IM_ASSERT(table->CurrentRow == -1 && "Must be first row");
3344
3345	if (max_label_width == 0.0f)
3346	max_label_width = TableGetHeaderAngledMaxLabelWidth();
3347
3348	// Angle argument expressed in (-IM_PI/2 .. +IM_PI/2) as it is easier to think about for user.
3349	const bool flip_label = (angle < 0.0f);
3350	angle -= IM_PI * 0.5f;
3351	const float cos_a = ImCos(angle);
3352	const float sin_a = ImSin(angle);
3353	const float label_cos_a = flip_label ? ImCos(angle + IM_PI) : cos_a;
3354	const float label_sin_a = flip_label ? ImSin(angle + IM_PI) : sin_a;
3355	const ImVec2 unit_right = ImVec2(cos_a, sin_a);
3356
3357	// Calculate our base metrics and set angled headers data _before_ the first call to TableNextRow()
3358	// FIXME-STYLE: Would it be better for user to submit 'max_label_width' or 'row_height' ? One can be derived from the other.
3359	const float header_height = g.FontSize + g.Style.CellPadding.x * 2.0f;
3360	const float row_height = ImTrunc(ImFabs(ImRotate(ImVec2(max_label_width, flip_label ? +header_height : -header_height), cos_a, sin_a).y));
3361	table->AngledHeadersHeight = row_height;
3362	table->AngledHeadersSlope = (sin_a != 0.0f) ? (cos_a / sin_a) : 0.0f;
3363	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
3364
3365	// Declare row, override and draw our own background
3366	TableNextRow(row_flags: ImGuiTableRowFlags_Headers, row_min_height: row_height);
3367	TableNextColumn();
3368	const ImRect row_r(table->WorkRect.Min.x, table->BgClipRect.Min.y, table->WorkRect.Max.x, table->RowPosY2);
3369	table->DrawSplitter->SetCurrentChannel(draw_list, channel_idx: TABLE_DRAW_CHANNEL_BG0);
3370	float clip_rect_min_x = table->BgClipRect.Min.x;
3371	if (table->FreezeColumnsCount > 0)
3372	clip_rect_min_x = ImMax(lhs: clip_rect_min_x, rhs: table->Columns[table->FreezeColumnsCount - 1].MaxX);
3373	TableSetBgColor(target: ImGuiTableBgTarget_RowBg0, color: 0); // Cancel
3374	PushClipRect(clip_rect_min: table->BgClipRect.Min, clip_rect_max: table->BgClipRect.Max, intersect_with_current_clip_rect: false); // Span all columns
3375	draw_list->AddRectFilled(p_min: ImVec2(table->BgClipRect.Min.x, row_r.Min.y), p_max: ImVec2(table->BgClipRect.Max.x, row_r.Max.y), col: GetColorU32(idx: ImGuiCol_TableHeaderBg, alpha_mul: 0.25f)); // FIXME-STYLE: Change row background with an arbitrary color.
3376	PushClipRect(clip_rect_min: ImVec2(clip_rect_min_x, table->BgClipRect.Min.y), clip_rect_max: table->BgClipRect.Max, intersect_with_current_clip_rect: true); // Span all columns
3377
3378	ButtonBehavior(bb: row_r, id: row_id, NULL, NULL);
3379	KeepAliveID(id: row_id);
3380
3381	const float ascent_scaled = g.FontBaked->Ascent * g.FontBakedScale; // FIXME: Standardize those scaling factors better
3382	const float line_off_for_ascent_x = (ImMax(lhs: (g.FontSize - ascent_scaled) * 0.5f, rhs: 0.0f) / -sin_a) * (flip_label ? -1.0f : 1.0f);
3383	const ImVec2 padding = g.Style.CellPadding; // We will always use swapped component
3384	const ImVec2 align = g.Style.TableAngledHeadersTextAlign;
3385
3386	// Draw background and labels in first pass, then all borders.
3387	float max_x = -FLT_MAX;
3388	for (int pass = 0; pass < 2; pass++)
3389	for (int order_n = 0; order_n < data_count; order_n++)
3390	{
3391	const ImGuiTableHeaderData* request = &data[order_n];
3392	const int column_n = request->Index;
3393	ImGuiTableColumn* column = &table->Columns[column_n];
3394
3395	ImVec2 bg_shape[4];
3396	bg_shape[0] = ImVec2(column->MaxX, row_r.Max.y);
3397	bg_shape[1] = ImVec2(column->MinX, row_r.Max.y);
3398	bg_shape[2] = bg_shape[1] + header_angled_vector;
3399	bg_shape[3] = bg_shape[0] + header_angled_vector;
3400	if (pass == 0)
3401	{
3402	// Draw shape
3403	draw_list->AddQuadFilled(p1: bg_shape[0], p2: bg_shape[1], p3: bg_shape[2], p4: bg_shape[3], col: request->BgColor0);
3404	draw_list->AddQuadFilled(p1: bg_shape[0], p2: bg_shape[1], p3: bg_shape[2], p4: bg_shape[3], col: request->BgColor1); // Optional highlight
3405	max_x = ImMax(lhs: max_x, rhs: bg_shape[3].x);
3406
3407	// Draw label
3408	// - First draw at an offset where RenderTextXXX() function won't meddle with applying current ClipRect, then transform to final offset.
3409	// - Handle multiple lines manually, as we want each lines to follow on the horizontal border, rather than see a whole block rotated.
3410	const char* label_name = TableGetColumnName(table, column_n);
3411	const char* label_name_end = FindRenderedTextEnd(text: label_name);
3412	const float line_off_step_x = (g.FontSize / -sin_a);
3413	const int label_lines = ImTextCountLines(in_text: label_name, in_text_end: label_name_end);
3414
3415	// Left<>Right alignment
3416	float line_off_curr_x = flip_label ? (label_lines - 1) * line_off_step_x : 0.0f;
3417	float line_off_for_align_x = ImMax(lhs: (((column->MaxX - column->MinX) - padding.x * 2.0f) - (label_lines * line_off_step_x)), rhs: 0.0f) * align.x;
3418	line_off_curr_x += line_off_for_align_x - line_off_for_ascent_x;
3419
3420	// Register header width
3421	column->ContentMaxXHeadersUsed = column->ContentMaxXHeadersIdeal = column->WorkMinX + ImCeil(label_lines * line_off_step_x - line_off_for_align_x);
3422
3423	while (label_name < label_name_end)
3424	{
3425	const char* label_name_eol = strchr(s: label_name, c: '\n');
3426	if (label_name_eol == NULL)
3427	label_name_eol = label_name_end;
3428
3429	// FIXME: Individual line clipping for right-most column is broken for negative angles.
3430	ImVec2 label_size = CalcTextSize(text: label_name, text_end: label_name_eol);
3431	float clip_width = max_label_width - padding.y; // Using padding.y*2.0f would be symmetrical but hide more text.
3432	float clip_height = ImMin(lhs: label_size.y, rhs: column->ClipRect.Max.x - column->WorkMinX - line_off_curr_x);
3433	ImRect clip_r(window->ClipRect.Min, window->ClipRect.Min + ImVec2(clip_width, clip_height));
3434	int vtx_idx_begin = draw_list->_VtxCurrentIdx;
3435	PushStyleColor(idx: ImGuiCol_Text, col: request->TextColor);
3436	RenderTextEllipsis(draw_list, pos_min: clip_r.Min, pos_max: clip_r.Max, ellipsis_max_x: clip_r.Max.x, text: label_name, text_end: label_name_eol, text_size_if_known: &label_size);
3437	PopStyleColor();
3438	int vtx_idx_end = draw_list->_VtxCurrentIdx;
3439
3440	// Up<>Down alignment
3441	const float available_space = ImMax(lhs: clip_width - label_size.x + ImAbs(x: padding.x * cos_a) * 2.0f - ImAbs(x: padding.y * sin_a) * 2.0f, rhs: 0.0f);
3442	const float vertical_offset = available_space * align.y * (flip_label ? -1.0f : 1.0f);
3443
3444	// Rotate and offset label
3445	ImVec2 pivot_in = ImVec2(window->ClipRect.Min.x - vertical_offset, window->ClipRect.Min.y + label_size.y);
3446	ImVec2 pivot_out = ImVec2(column->WorkMinX, row_r.Max.y);
3447	line_off_curr_x += flip_label ? -line_off_step_x : line_off_step_x;
3448	pivot_out += unit_right * padding.y;
3449	if (flip_label)
3450	pivot_out += unit_right * (clip_width - ImMax(lhs: 0.0f, rhs: clip_width - label_size.x));
3451	pivot_out.x += flip_label ? line_off_curr_x + line_off_step_x : line_off_curr_x;
3452	ShadeVertsTransformPos(draw_list, vert_start_idx: vtx_idx_begin, vert_end_idx: vtx_idx_end, pivot_in, cos_a: label_cos_a, sin_a: label_sin_a, pivot_out); // Rotate and offset
3453	//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); }
3454
3455	label_name = label_name_eol + 1;
3456	}
3457	}
3458	if (pass == 1)
3459	{
3460	// Draw border
3461	draw_list->AddLine(p1: bg_shape[0], p2: bg_shape[3], col: TableGetColumnBorderCol(table, order_n, column_n));
3462	}
3463	}
3464	PopClipRect();
3465	PopClipRect();
3466	table->TempData->AngledHeadersExtraWidth = ImMax(lhs: 0.0f, rhs: max_x - table->Columns[table->RightMostEnabledColumn].MaxX);
3467	}
3468
3469	//-------------------------------------------------------------------------
3470	// [SECTION] Tables: Context Menu
3471	//-------------------------------------------------------------------------
3472	// - TableOpenContextMenu() [Internal]
3473	// - TableBeginContextMenuPopup() [Internal]
3474	// - TableDrawDefaultContextMenu() [Internal]
3475	//-------------------------------------------------------------------------
3476
3477	// Use -1 to open menu not specific to a given column.
3478	void ImGui::TableOpenContextMenu(int column_n)
3479	{
3480	ImGuiContext& g = *GImGui;
3481	ImGuiTable* table = g.CurrentTable;
3482	if (column_n == -1 && table->CurrentColumn != -1) // When called within a column automatically use this one (for consistency)
3483	column_n = table->CurrentColumn;
3484	if (column_n == table->ColumnsCount) // To facilitate using with TableGetHoveredColumn()
3485	column_n = -1;
3486	IM_ASSERT(column_n >= -1 && column_n < table->ColumnsCount);
3487	if (table->Flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable))
3488	{
3489	table->IsContextPopupOpen = true;
3490	table->ContextPopupColumn = (ImGuiTableColumnIdx)column_n;
3491	table->InstanceInteracted = table->InstanceCurrent;
3492	const ImGuiID context_menu_id = ImHashStr(data: "##ContextMenu", data_size: 0, seed: table->ID);
3493	OpenPopupEx(id: context_menu_id, popup_flags: ImGuiPopupFlags_None);
3494	}
3495	}
3496
3497	bool ImGui::TableBeginContextMenuPopup(ImGuiTable* table)
3498	{
3499	if (!table->IsContextPopupOpen || table->InstanceCurrent != table->InstanceInteracted)
3500	return false;
3501	const ImGuiID context_menu_id = ImHashStr(data: "##ContextMenu", data_size: 0, seed: table->ID);
3502	if (BeginPopupEx(id: context_menu_id, extra_window_flags: ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings))
3503	return true;
3504	table->IsContextPopupOpen = false;
3505	return false;
3506	}
3507
3508	// Output context menu into current window (generally a popup)
3509	// FIXME-TABLE: Ideally this should be writable by the user. Full programmatic access to that data?
3510	// Sections to display are pulled from 'flags_for_section_to_display', which is typically == table->Flags.
3511	// - ImGuiTableFlags_Resizable -> display Sizing menu items
3512	// - ImGuiTableFlags_Reorderable -> display "Reset Order"
3513	////- ImGuiTableFlags_Sortable -> display sorting options (disabled)
3514	// - ImGuiTableFlags_Hideable -> display columns visibility menu items
3515	// It means if you have a custom context menus you can call this section and omit some sections, and add your own.
3516	void ImGui::TableDrawDefaultContextMenu(ImGuiTable* table, ImGuiTableFlags flags_for_section_to_display)
3517	{
3518	ImGuiContext& g = *GImGui;
3519	ImGuiWindow* window = g.CurrentWindow;
3520	if (window->SkipItems)
3521	return;
3522
3523	bool want_separator = false;
3524	const int column_n = (table->ContextPopupColumn >= 0 && table->ContextPopupColumn < table->ColumnsCount) ? table->ContextPopupColumn : -1;
3525	ImGuiTableColumn* column = (column_n != -1) ? &table->Columns[column_n] : NULL;
3526
3527	// Sizing
3528	if (flags_for_section_to_display & ImGuiTableFlags_Resizable)
3529	{
3530	if (column != NULL)
3531	{
3532	const bool can_resize = !(column->Flags & ImGuiTableColumnFlags_NoResize) && column->IsEnabled;
3533	if (MenuItem(label: LocalizeGetMsg(key: ImGuiLocKey_TableSizeOne), NULL, selected: false, enabled: can_resize)) // "###SizeOne"
3534	TableSetColumnWidthAutoSingle(table, column_n);
3535	}
3536
3537	const char* size_all_desc;
3538	if (table->ColumnsEnabledFixedCount == table->ColumnsEnabledCount && (table->Flags & ImGuiTableFlags_SizingMask_) != ImGuiTableFlags_SizingFixedSame)
3539	size_all_desc = LocalizeGetMsg(key: ImGuiLocKey_TableSizeAllFit); // "###SizeAll" All fixed
3540	else
3541	size_all_desc = LocalizeGetMsg(key: ImGuiLocKey_TableSizeAllDefault); // "###SizeAll" All stretch or mixed
3542	if (MenuItem(label: size_all_desc, NULL))
3543	TableSetColumnWidthAutoAll(table);
3544	want_separator = true;
3545	}
3546
3547	// Ordering
3548	if (flags_for_section_to_display & ImGuiTableFlags_Reorderable)
3549	{
3550	if (MenuItem(label: LocalizeGetMsg(key: ImGuiLocKey_TableResetOrder), NULL, selected: false, enabled: !table->IsDefaultDisplayOrder))
3551	table->IsResetDisplayOrderRequest = true;
3552	want_separator = true;
3553	}
3554
3555	// Reset all (should work but seems unnecessary/noisy to expose?)
3556	//if (MenuItem("Reset all"))
3557	// table->IsResetAllRequest = true;
3558
3559	// Sorting
3560	// (modify TableOpenContextMenu() to add _Sortable flag if enabling this)
3561	#if 0
3562	if ((flags_for_section_to_display & ImGuiTableFlags_Sortable) && column != NULL && (column->Flags & ImGuiTableColumnFlags_NoSort) == 0)
3563	{
3564	if (want_separator)
3565	Separator();
3566	want_separator = true;
3567
3568	bool append_to_sort_specs = g.IO.KeyShift;
3569	if (MenuItem("Sort in Ascending Order", NULL, column->SortOrder != -1 && column->SortDirection == ImGuiSortDirection_Ascending, (column->Flags & ImGuiTableColumnFlags_NoSortAscending) == 0))
3570	TableSetColumnSortDirection(table, column_n, ImGuiSortDirection_Ascending, append_to_sort_specs);
3571	if (MenuItem("Sort in Descending Order", NULL, column->SortOrder != -1 && column->SortDirection == ImGuiSortDirection_Descending, (column->Flags & ImGuiTableColumnFlags_NoSortDescending) == 0))
3572	TableSetColumnSortDirection(table, column_n, ImGuiSortDirection_Descending, append_to_sort_specs);
3573	}
3574	#endif
3575
3576	// Hiding / Visibility
3577	if (flags_for_section_to_display & ImGuiTableFlags_Hideable)
3578	{
3579	if (want_separator)
3580	Separator();
3581	want_separator = true;
3582
3583	PushItemFlag(option: ImGuiItemFlags_AutoClosePopups, enabled: false);
3584	for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
3585	{
3586	ImGuiTableColumn* other_column = &table->Columns[other_column_n];
3587	if (other_column->Flags & ImGuiTableColumnFlags_Disabled)
3588	continue;
3589
3590	const char* name = TableGetColumnName(table, column_n: other_column_n);
3591	if (name == NULL || name[0] == 0)
3592	name = "<Unknown>";
3593
3594	// Make sure we can't hide the last active column
3595	bool menu_item_active = (other_column->Flags & ImGuiTableColumnFlags_NoHide) ? false : true;
3596	if (other_column->IsUserEnabled && table->ColumnsEnabledCount <= 1)
3597	menu_item_active = false;
3598	if (MenuItem(label: name, NULL, selected: other_column->IsUserEnabled, enabled: menu_item_active))
3599	other_column->IsUserEnabledNextFrame = !other_column->IsUserEnabled;
3600	}
3601	PopItemFlag();
3602	}
3603	}
3604
3605	//-------------------------------------------------------------------------
3606	// [SECTION] Tables: Settings (.ini data)
3607	//-------------------------------------------------------------------------
3608	// FIXME: The binding/finding/creating flow are too confusing.
3609	//-------------------------------------------------------------------------
3610	// - TableSettingsInit() [Internal]
3611	// - TableSettingsCalcChunkSize() [Internal]
3612	// - TableSettingsCreate() [Internal]
3613	// - TableSettingsFindByID() [Internal]
3614	// - TableGetBoundSettings() [Internal]
3615	// - TableResetSettings()
3616	// - TableSaveSettings() [Internal]
3617	// - TableLoadSettings() [Internal]
3618	// - TableSettingsHandler_ClearAll() [Internal]
3619	// - TableSettingsHandler_ApplyAll() [Internal]
3620	// - TableSettingsHandler_ReadOpen() [Internal]
3621	// - TableSettingsHandler_ReadLine() [Internal]
3622	// - TableSettingsHandler_WriteAll() [Internal]
3623	// - TableSettingsInstallHandler() [Internal]
3624	//-------------------------------------------------------------------------
3625	// [Init] 1: TableSettingsHandler_ReadXXXX() Load and parse .ini file into TableSettings.
3626	// [Main] 2: TableLoadSettings() When table is created, bind Table to TableSettings, serialize TableSettings data into Table.
3627	// [Main] 3: TableSaveSettings() When table properties are modified, serialize Table data into bound or new TableSettings, mark .ini as dirty.
3628	// [Main] 4: TableSettingsHandler_WriteAll() When .ini file is dirty (which can come from other source), save TableSettings into .ini file.
3629	//-------------------------------------------------------------------------
3630
3631	// Clear and initialize empty settings instance
3632	static void TableSettingsInit(ImGuiTableSettings* settings, ImGuiID id, int columns_count, int columns_count_max)
3633	{
3634	IM_PLACEMENT_NEW(settings) ImGuiTableSettings();
3635	ImGuiTableColumnSettings* settings_column = settings->GetColumnSettings();
3636	for (int n = 0; n < columns_count_max; n++, settings_column++)
3637	IM_PLACEMENT_NEW(settings_column) ImGuiTableColumnSettings();
3638	settings->ID = id;
3639	settings->ColumnsCount = (ImGuiTableColumnIdx)columns_count;
3640	settings->ColumnsCountMax = (ImGuiTableColumnIdx)columns_count_max;
3641	settings->WantApply = true;
3642	}
3643
3644	static size_t TableSettingsCalcChunkSize(int columns_count)
3645	{
3646	return sizeof(ImGuiTableSettings) + (size_t)columns_count * sizeof(ImGuiTableColumnSettings);
3647	}
3648
3649	ImGuiTableSettings* ImGui::TableSettingsCreate(ImGuiID id, int columns_count)
3650	{
3651	ImGuiContext& g = *GImGui;
3652	ImGuiTableSettings* settings = g.SettingsTables.alloc_chunk(sz: TableSettingsCalcChunkSize(columns_count));
3653	TableSettingsInit(settings, id, columns_count, columns_count_max: columns_count);
3654	return settings;
3655	}
3656
3657	// Find existing settings
3658	ImGuiTableSettings* ImGui::TableSettingsFindByID(ImGuiID id)
3659	{
3660	// FIXME-OPT: Might want to store a lookup map for this?
3661	ImGuiContext& g = *GImGui;
3662	for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(p: settings))
3663	if (settings->ID == id)
3664	return settings;
3665	return NULL;
3666	}
3667
3668	// Get settings for a given table, NULL if none
3669	ImGuiTableSettings* ImGui::TableGetBoundSettings(ImGuiTable* table)
3670	{
3671	if (table->SettingsOffset != -1)
3672	{
3673	ImGuiContext& g = *GImGui;
3674	ImGuiTableSettings* settings = g.SettingsTables.ptr_from_offset(off: table->SettingsOffset);
3675	IM_ASSERT(settings->ID == table->ID);
3676	if (settings->ColumnsCountMax >= table->ColumnsCount)
3677	return settings; // OK
3678	settings->ID = 0; // Invalidate storage, we won't fit because of a count change
3679	}
3680	return NULL;
3681	}
3682
3683	// Restore initial state of table (with or without saved settings)
3684	void ImGui::TableResetSettings(ImGuiTable* table)
3685	{
3686	table->IsInitializing = table->IsSettingsDirty = true;
3687	table->IsResetAllRequest = false;
3688	table->IsSettingsRequestLoad = false; // Don't reload from ini
3689	table->SettingsLoadedFlags = ImGuiTableFlags_None; // Mark as nothing loaded so our initialized data becomes authoritative
3690	}
3691
3692	void ImGui::TableSaveSettings(ImGuiTable* table)
3693	{
3694	table->IsSettingsDirty = false;
3695	if (table->Flags & ImGuiTableFlags_NoSavedSettings)
3696	return;
3697
3698	// Bind or create settings data
3699	ImGuiContext& g = *GImGui;
3700	ImGuiTableSettings* settings = TableGetBoundSettings(table);
3701	if (settings == NULL)
3702	{
3703	settings = TableSettingsCreate(id: table->ID, columns_count: table->ColumnsCount);
3704	table->SettingsOffset = g.SettingsTables.offset_from_ptr(p: settings);
3705	}
3706	settings->ColumnsCount = (ImGuiTableColumnIdx)table->ColumnsCount;
3707
3708	// Serialize ImGuiTable/ImGuiTableColumn into ImGuiTableSettings/ImGuiTableColumnSettings
3709	IM_ASSERT(settings->ID == table->ID);
3710	IM_ASSERT(settings->ColumnsCount == table->ColumnsCount && settings->ColumnsCountMax >= settings->ColumnsCount);
3711	ImGuiTableColumn* column = table->Columns.Data;
3712	ImGuiTableColumnSettings* column_settings = settings->GetColumnSettings();
3713
3714	bool save_ref_scale = false;
3715	settings->SaveFlags = ImGuiTableFlags_None;
3716	for (int n = 0; n < table->ColumnsCount; n++, column++, column_settings++)
3717	{
3718	const float width_or_weight = (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? column->StretchWeight : column->WidthRequest;
3719	column_settings->WidthOrWeight = width_or_weight;
3720	column_settings->Index = (ImGuiTableColumnIdx)n;
3721	column_settings->DisplayOrder = column->DisplayOrder;
3722	column_settings->SortOrder = column->SortOrder;
3723	column_settings->SortDirection = column->SortDirection;
3724	column_settings->IsEnabled = column->IsUserEnabled;
3725	column_settings->IsStretch = (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? 1 : 0;
3726	if ((column->Flags & ImGuiTableColumnFlags_WidthStretch) == 0)
3727	save_ref_scale = true;
3728
3729	// We skip saving some data in the .ini file when they are unnecessary to restore our state.
3730	// Note that fixed width where initial width was derived from auto-fit will always be saved as InitStretchWeightOrWidth will be 0.0f.
3731	// FIXME-TABLE: We don't have logic to easily compare SortOrder to DefaultSortOrder yet so it's always saved when present.
3732	if (width_or_weight != column->InitStretchWeightOrWidth)
3733	settings->SaveFlags |= ImGuiTableFlags_Resizable;
3734	if (column->DisplayOrder != n)
3735	settings->SaveFlags |= ImGuiTableFlags_Reorderable;
3736	if (column->SortOrder != -1)
3737	settings->SaveFlags |= ImGuiTableFlags_Sortable;
3738	if (column->IsUserEnabled != ((column->Flags & ImGuiTableColumnFlags_DefaultHide) == 0))
3739	settings->SaveFlags |= ImGuiTableFlags_Hideable;
3740	}
3741	settings->SaveFlags &= table->Flags;
3742	settings->RefScale = save_ref_scale ? table->RefScale : 0.0f;
3743
3744	MarkIniSettingsDirty();
3745	}
3746
3747	void ImGui::TableLoadSettings(ImGuiTable* table)
3748	{
3749	ImGuiContext& g = *GImGui;
3750	table->IsSettingsRequestLoad = false;
3751	if (table->Flags & ImGuiTableFlags_NoSavedSettings)
3752	return;
3753
3754	// Bind settings
3755	ImGuiTableSettings* settings;
3756	if (table->SettingsOffset == -1)
3757	{
3758	settings = TableSettingsFindByID(id: table->ID);
3759	if (settings == NULL)
3760	return;
3761	if (settings->ColumnsCount != table->ColumnsCount) // Allow settings if columns count changed. We could otherwise decide to return...
3762	table->IsSettingsDirty = true;
3763	table->SettingsOffset = g.SettingsTables.offset_from_ptr(p: settings);
3764	}
3765	else
3766	{
3767	settings = TableGetBoundSettings(table);
3768	}
3769
3770	table->SettingsLoadedFlags = settings->SaveFlags;
3771	table->RefScale = settings->RefScale;
3772
3773	// Initialize default columns settings
3774	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3775	{
3776	ImGuiTableColumn* column = &table->Columns[column_n];
3777	TableInitColumnDefaults(table, column, init_mask: ~0);
3778	column->AutoFitQueue = 0x00;
3779	}
3780
3781	// Serialize ImGuiTableSettings/ImGuiTableColumnSettings into ImGuiTable/ImGuiTableColumn
3782	ImGuiTableColumnSettings* column_settings = settings->GetColumnSettings();
3783	ImU64 display_order_mask = 0;
3784	for (int data_n = 0; data_n < settings->ColumnsCount; data_n++, column_settings++)
3785	{
3786	int column_n = column_settings->Index;
3787	if (column_n < 0 || column_n >= table->ColumnsCount)
3788	continue;
3789
3790	ImGuiTableColumn* column = &table->Columns[column_n];
3791	if (settings->SaveFlags & ImGuiTableFlags_Resizable)
3792	{
3793	if (column_settings->IsStretch)
3794	column->StretchWeight = column_settings->WidthOrWeight;
3795	else
3796	column->WidthRequest = column_settings->WidthOrWeight;
3797	}
3798	if (settings->SaveFlags & ImGuiTableFlags_Reorderable)
3799	column->DisplayOrder = column_settings->DisplayOrder;
3800	display_order_mask |= (ImU64)1 << column->DisplayOrder;
3801	if ((settings->SaveFlags & ImGuiTableFlags_Hideable) && column_settings->IsEnabled != -1)
3802	column->IsUserEnabled = column->IsUserEnabledNextFrame = column_settings->IsEnabled == 1;
3803	column->SortOrder = column_settings->SortOrder;
3804	column->SortDirection = column_settings->SortDirection;
3805	}
3806
3807	// Validate and fix invalid display order data
3808	const ImU64 expected_display_order_mask = (settings->ColumnsCount == 64) ? ~0 : ((ImU64)1 << settings->ColumnsCount) - 1;
3809	if (display_order_mask != expected_display_order_mask)
3810	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3811	table->Columns[column_n].DisplayOrder = (ImGuiTableColumnIdx)column_n;
3812
3813	// Rebuild index
3814	for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
3815	table->DisplayOrderToIndex[table->Columns[column_n].DisplayOrder] = (ImGuiTableColumnIdx)column_n;
3816	}
3817
3818	static void TableSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
3819	{
3820	ImGuiContext& g = *ctx;
3821	for (int i = 0; i != g.Tables.GetMapSize(); i++)
3822	if (ImGuiTable* table = g.Tables.TryGetMapData(n: i))
3823	table->SettingsOffset = -1;
3824	g.SettingsTables.clear();
3825	}
3826
3827	// Apply to existing windows (if any)
3828	static void TableSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
3829	{
3830	ImGuiContext& g = *ctx;
3831	for (int i = 0; i != g.Tables.GetMapSize(); i++)
3832	if (ImGuiTable* table = g.Tables.TryGetMapData(n: i))
3833	{
3834	table->IsSettingsRequestLoad = true;
3835	table->SettingsOffset = -1;
3836	}
3837	}
3838
3839	static void* TableSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name)
3840	{
3841	ImGuiID id = 0;
3842	int columns_count = 0;
3843	if (sscanf(s: name, format: "0x%08X,%d", &id, &columns_count) < 2)
3844	return NULL;
3845
3846	if (ImGuiTableSettings* settings = ImGui::TableSettingsFindByID(id))
3847	{
3848	if (settings->ColumnsCountMax >= columns_count)
3849	{
3850	TableSettingsInit(settings, id, columns_count, columns_count_max: settings->ColumnsCountMax); // Recycle
3851	return settings;
3852	}
3853	settings->ID = 0; // Invalidate storage, we won't fit because of a count change
3854	}
3855	return ImGui::TableSettingsCreate(id, columns_count);
3856	}
3857
3858	static void TableSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line)
3859	{
3860	// "Column 0 UserID=0x42AD2D21 Width=100 Visible=1 Order=0 Sort=0v"
3861	ImGuiTableSettings* settings = (ImGuiTableSettings*)entry;
3862	float f = 0.0f;
3863	int column_n = 0, r = 0, n = 0;
3864
3865	if (sscanf(s: line, format: "RefScale=%f", &f) == 1) { settings->RefScale = f; return; }
3866
3867	if (sscanf(s: line, format: "Column %d%n", &column_n, &r) == 1)
3868	{
3869	if (column_n < 0 || column_n >= settings->ColumnsCount)
3870	return;
3871	line = ImStrSkipBlank(str: line + r);
3872	char c = 0;
3873	ImGuiTableColumnSettings* column = settings->GetColumnSettings() + column_n;
3874	column->Index = (ImGuiTableColumnIdx)column_n;
3875	if (sscanf(s: line, format: "UserID=0x%08X%n", (ImU32*)&n, &r)==1) { line = ImStrSkipBlank(str: line + r); column->UserID = (ImGuiID)n; }
3876	if (sscanf(s: line, format: "Width=%d%n", &n, &r) == 1) { line = ImStrSkipBlank(str: line + r); column->WidthOrWeight = (float)n; column->IsStretch = 0; settings->SaveFlags |= ImGuiTableFlags_Resizable; }
3877	if (sscanf(s: line, format: "Weight=%f%n", &f, &r) == 1) { line = ImStrSkipBlank(str: line + r); column->WidthOrWeight = f; column->IsStretch = 1; settings->SaveFlags |= ImGuiTableFlags_Resizable; }
3878	if (sscanf(s: line, format: "Visible=%d%n", &n, &r) == 1) { line = ImStrSkipBlank(str: line + r); column->IsEnabled = (ImU8)n; settings->SaveFlags |= ImGuiTableFlags_Hideable; }
3879	if (sscanf(s: line, format: "Order=%d%n", &n, &r) == 1) { line = ImStrSkipBlank(str: line + r); column->DisplayOrder = (ImGuiTableColumnIdx)n; settings->SaveFlags |= ImGuiTableFlags_Reorderable; }
3880	if (sscanf(s: line, format: "Sort=%d%c%n", &n, &c, &r) == 2) { line = ImStrSkipBlank(str: line + r); column->SortOrder = (ImGuiTableColumnIdx)n; column->SortDirection = (c == '^') ? ImGuiSortDirection_Descending : ImGuiSortDirection_Ascending; settings->SaveFlags |= ImGuiTableFlags_Sortable; }
3881	}
3882	}
3883
3884	static void TableSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf)
3885	{
3886	ImGuiContext& g = *ctx;
3887	for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(p: settings))
3888	{
3889	if (settings->ID == 0) // Skip ditched settings
3890	continue;
3891
3892	// TableSaveSettings() may clear some of those flags when we establish that the data can be stripped
3893	// (e.g. Order was unchanged)
3894	const bool save_size = (settings->SaveFlags & ImGuiTableFlags_Resizable) != 0;
3895	const bool save_visible = (settings->SaveFlags & ImGuiTableFlags_Hideable) != 0;
3896	const bool save_order = (settings->SaveFlags & ImGuiTableFlags_Reorderable) != 0;
3897	const bool save_sort = (settings->SaveFlags & ImGuiTableFlags_Sortable) != 0;
3898	// We need to save the [Table] entry even if all the bools are false, since this records a table with "default settings".
3899
3900	buf->reserve(capacity: buf->size() + 30 + settings->ColumnsCount * 50); // ballpark reserve
3901	buf->appendf(fmt: "[%s][0x%08X,%d]\n", handler->TypeName, settings->ID, settings->ColumnsCount);
3902	if (settings->RefScale != 0.0f)
3903	buf->appendf(fmt: "RefScale=%g\n", settings->RefScale);
3904	ImGuiTableColumnSettings* column = settings->GetColumnSettings();
3905	for (int column_n = 0; column_n < settings->ColumnsCount; column_n++, column++)
3906	{
3907	// "Column 0 UserID=0x42AD2D21 Width=100 Visible=1 Order=0 Sort=0v"
3908	bool save_column = column->UserID != 0 || save_size || save_visible || save_order || (save_sort && column->SortOrder != -1);
3909	if (!save_column)
3910	continue;
3911	buf->appendf(fmt: "Column %-2d", column_n);
3912	if (column->UserID != 0) { buf->appendf(fmt: " UserID=%08X", column->UserID); }
3913	if (save_size && column->IsStretch) { buf->appendf(fmt: " Weight=%.4f", column->WidthOrWeight); }
3914	if (save_size && !column->IsStretch) { buf->appendf(fmt: " Width=%d", (int)column->WidthOrWeight); }
3915	if (save_visible) { buf->appendf(fmt: " Visible=%d", column->IsEnabled); }
3916	if (save_order) { buf->appendf(fmt: " Order=%d", column->DisplayOrder); }
3917	if (save_sort && column->SortOrder != -1) { buf->appendf(fmt: " Sort=%d%c", column->SortOrder, (column->SortDirection == ImGuiSortDirection_Ascending) ? 'v' : '^'); }
3918	buf->append(str: "\n");
3919	}
3920	buf->append(str: "\n");
3921	}
3922	}
3923
3924	void ImGui::TableSettingsAddSettingsHandler()
3925	{
3926	ImGuiSettingsHandler ini_handler;
3927	ini_handler.TypeName = "Table";
3928	ini_handler.TypeHash = ImHashStr(data: "Table");
3929	ini_handler.ClearAllFn = TableSettingsHandler_ClearAll;
3930	ini_handler.ReadOpenFn = TableSettingsHandler_ReadOpen;
3931	ini_handler.ReadLineFn = TableSettingsHandler_ReadLine;
3932	ini_handler.ApplyAllFn = TableSettingsHandler_ApplyAll;
3933	ini_handler.WriteAllFn = TableSettingsHandler_WriteAll;
3934	AddSettingsHandler(handler: &ini_handler);
3935	}
3936
3937	//-------------------------------------------------------------------------
3938	// [SECTION] Tables: Garbage Collection
3939	//-------------------------------------------------------------------------
3940	// - TableRemove() [Internal]
3941	// - TableGcCompactTransientBuffers() [Internal]
3942	// - TableGcCompactSettings() [Internal]
3943	//-------------------------------------------------------------------------
3944
3945	// Remove Table (currently only used by TestEngine)
3946	void ImGui::TableRemove(ImGuiTable* table)
3947	{
3948	//IMGUI_DEBUG_PRINT("TableRemove() id=0x%08X\n", table->ID);
3949	ImGuiContext& g = *GImGui;
3950	int table_idx = g.Tables.GetIndex(p: table);
3951	//memset(table->RawData.Data, 0, table->RawData.size_in_bytes());
3952	//memset(table, 0, sizeof(ImGuiTable));
3953	g.Tables.Remove(key: table->ID, p: table);
3954	g.TablesLastTimeActive[table_idx] = -1.0f;
3955	}
3956
3957	// Free up/compact internal Table buffers for when it gets unused
3958	void ImGui::TableGcCompactTransientBuffers(ImGuiTable* table)
3959	{
3960	//IMGUI_DEBUG_PRINT("TableGcCompactTransientBuffers() id=0x%08X\n", table->ID);
3961	ImGuiContext& g = *GImGui;
3962	IM_ASSERT(table->MemoryCompacted == false);
3963	table->SortSpecs.Specs = NULL;
3964	table->SortSpecsMulti.clear();
3965	table->IsSortSpecsDirty = true; // FIXME: In theory shouldn't have to leak into user performing a sort on resume.
3966	table->ColumnsNames.clear();
3967	table->MemoryCompacted = true;
3968	for (int n = 0; n < table->ColumnsCount; n++)
3969	table->Columns[n].NameOffset = -1;
3970	g.TablesLastTimeActive[g.Tables.GetIndex(p: table)] = -1.0f;
3971	}
3972
3973	void ImGui::TableGcCompactTransientBuffers(ImGuiTableTempData* temp_data)
3974	{
3975	temp_data->DrawSplitter.ClearFreeMemory();
3976	temp_data->LastTimeActive = -1.0f;
3977	}
3978
3979	// Compact and remove unused settings data (currently only used by TestEngine)
3980	void ImGui::TableGcCompactSettings()
3981	{
3982	ImGuiContext& g = *GImGui;
3983	int required_memory = 0;
3984	for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(p: settings))
3985	if (settings->ID != 0)
3986	required_memory += (int)TableSettingsCalcChunkSize(columns_count: settings->ColumnsCount);
3987	if (required_memory == g.SettingsTables.Buf.Size)
3988	return;
3989	ImChunkStream<ImGuiTableSettings> new_chunk_stream;
3990	new_chunk_stream.Buf.reserve(new_capacity: required_memory);
3991	for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(p: settings))
3992	if (settings->ID != 0)
3993	memcpy(dest: new_chunk_stream.alloc_chunk(sz: TableSettingsCalcChunkSize(columns_count: settings->ColumnsCount)), src: settings, n: TableSettingsCalcChunkSize(columns_count: settings->ColumnsCount));
3994	g.SettingsTables.swap(rhs&: new_chunk_stream);
3995	}
3996
3997
3998	//-------------------------------------------------------------------------
3999	// [SECTION] Tables: Debugging
4000	//-------------------------------------------------------------------------
4001	// - DebugNodeTable() [Internal]
4002	//-------------------------------------------------------------------------
4003
4004	#ifndef IMGUI_DISABLE_DEBUG_TOOLS
4005
4006	static const char* DebugNodeTableGetSizingPolicyDesc(ImGuiTableFlags sizing_policy)
4007	{
4008	sizing_policy &= ImGuiTableFlags_SizingMask_;
4009	if (sizing_policy == ImGuiTableFlags_SizingFixedFit) { return "FixedFit"; }
4010	if (sizing_policy == ImGuiTableFlags_SizingFixedSame) { return "FixedSame"; }
4011	if (sizing_policy == ImGuiTableFlags_SizingStretchProp) { return "StretchProp"; }
4012	if (sizing_policy == ImGuiTableFlags_SizingStretchSame) { return "StretchSame"; }
4013	return "N/A";
4014	}
4015
4016	void ImGui::DebugNodeTable(ImGuiTable* table)
4017	{
4018	ImGuiContext& g = *GImGui;
4019	const bool is_active = (table->LastFrameActive >= g.FrameCount - 2); // Note that fully clipped early out scrolling tables will appear as inactive here.
4020	if (!is_active) { PushStyleColor(idx: ImGuiCol_Text, col: GetStyleColorVec4(idx: ImGuiCol_TextDisabled)); }
4021	bool open = TreeNode(ptr_id: table, fmt: "Table 0x%08X (%d columns, in '%s')%s", table->ID, table->ColumnsCount, table->OuterWindow->Name, is_active ? "" : " *Inactive*");
4022	if (!is_active) { PopStyleColor(); }
4023	if (IsItemHovered())
4024	GetForegroundDrawList()->AddRect(p_min: table->OuterRect.Min, p_max: table->OuterRect.Max, IM_COL32(255, 255, 0, 255));
4025	if (IsItemVisible() && table->HoveredColumnBody != -1)
4026	GetForegroundDrawList()->AddRect(p_min: GetItemRectMin(), p_max: GetItemRectMax(), IM_COL32(255, 255, 0, 255));
4027	if (!open)
4028	return;
4029	if (table->InstanceCurrent > 0)
4030	Text(fmt: "** %d instances of same table! Some data below will refer to last instance.", table->InstanceCurrent + 1);
4031	if (g.IO.ConfigDebugIsDebuggerPresent)
4032	{
4033	if (DebugBreakButton(label: "**DebugBreak**", description_of_location: "in BeginTable()"))
4034	g.DebugBreakInTable = table->ID;
4035	SameLine();
4036	}
4037
4038	bool clear_settings = SmallButton(label: "Clear settings");
4039	BulletText(fmt: "OuterRect: Pos: (%.1f,%.1f) Size: (%.1f,%.1f) Sizing: '%s'", table->OuterRect.Min.x, table->OuterRect.Min.y, table->OuterRect.GetWidth(), table->OuterRect.GetHeight(), DebugNodeTableGetSizingPolicyDesc(sizing_policy: table->Flags));
4040	BulletText(fmt: "ColumnsGivenWidth: %.1f, ColumnsAutoFitWidth: %.1f, InnerWidth: %.1f%s", table->ColumnsGivenWidth, table->ColumnsAutoFitWidth, table->InnerWidth, table->InnerWidth == 0.0f ? " (auto)" : "");
4041	BulletText(fmt: "CellPaddingX: %.1f, CellSpacingX: %.1f/%.1f, OuterPaddingX: %.1f", table->CellPaddingX, table->CellSpacingX1, table->CellSpacingX2, table->OuterPaddingX);
4042	BulletText(fmt: "HoveredColumnBody: %d, HoveredColumnBorder: %d", table->HoveredColumnBody, table->HoveredColumnBorder);
4043	BulletText(fmt: "ResizedColumn: %d, ReorderColumn: %d, HeldHeaderColumn: %d", table->ResizedColumn, table->ReorderColumn, table->HeldHeaderColumn);
4044	for (int n = 0; n < table->InstanceCurrent + 1; n++)
4045	{
4046	ImGuiTableInstanceData* table_instance = TableGetInstanceData(table, instance_no: n);
4047	BulletText(fmt: "Instance %d: HoveredRow: %d, LastOuterHeight: %.2f", n, table_instance->HoveredRowLast, table_instance->LastOuterHeight);
4048	}
4049	//BulletText("BgDrawChannels: %d/%d", 0, table->BgDrawChannelUnfrozen);
4050	float sum_weights = 0.0f;
4051	for (int n = 0; n < table->ColumnsCount; n++)
4052	if (table->Columns[n].Flags & ImGuiTableColumnFlags_WidthStretch)
4053	sum_weights += table->Columns[n].StretchWeight;
4054	for (int n = 0; n < table->ColumnsCount; n++)
4055	{
4056	ImGuiTableColumn* column = &table->Columns[n];
4057	const char* name = TableGetColumnName(table, column_n: n);
4058	char buf[512];
4059	ImFormatString(buf, IM_ARRAYSIZE(buf),
4060	fmt: "Column %d order %d '%s': offset %+.2f to %+.2f%s\n"
4061	"Enabled: %d, VisibleX/Y: %d/%d, RequestOutput: %d, SkipItems: %d, DrawChannels: %d,%d\n"
4062	"WidthGiven: %.1f, Request/Auto: %.1f/%.1f, StretchWeight: %.3f (%.1f%%)\n"
4063	"MinX: %.1f, MaxX: %.1f (%+.1f), ClipRect: %.1f to %.1f (+%.1f)\n"
4064	"ContentWidth: %.1f,%.1f, HeadersUsed/Ideal %.1f/%.1f\n"
4065	"Sort: %d%s, UserID: 0x%08X, Flags: 0x%04X: %s%s%s..",
4066	n, column->DisplayOrder, name, column->MinX - table->WorkRect.Min.x, column->MaxX - table->WorkRect.Min.x, (n < table->FreezeColumnsRequest) ? " (Frozen)" : "",
4067	column->IsEnabled, column->IsVisibleX, column->IsVisibleY, column->IsRequestOutput, column->IsSkipItems, column->DrawChannelFrozen, column->DrawChannelUnfrozen,
4068	column->WidthGiven, column->WidthRequest, column->WidthAuto, column->StretchWeight, column->StretchWeight > 0.0f ? (column->StretchWeight / sum_weights) * 100.0f : 0.0f,
4069	column->MinX, column->MaxX, column->MaxX - column->MinX, column->ClipRect.Min.x, column->ClipRect.Max.x, column->ClipRect.Max.x - column->ClipRect.Min.x,
4070	column->ContentMaxXFrozen - column->WorkMinX, column->ContentMaxXUnfrozen - column->WorkMinX, column->ContentMaxXHeadersUsed - column->WorkMinX, column->ContentMaxXHeadersIdeal - column->WorkMinX,
4071	column->SortOrder, (column->SortDirection == ImGuiSortDirection_Ascending) ? " (Asc)" : (column->SortDirection == ImGuiSortDirection_Descending) ? " (Des)" : "", column->UserID, column->Flags,
4072	(column->Flags & ImGuiTableColumnFlags_WidthStretch) ? "WidthStretch " : "",
4073	(column->Flags & ImGuiTableColumnFlags_WidthFixed) ? "WidthFixed " : "",
4074	(column->Flags & ImGuiTableColumnFlags_NoResize) ? "NoResize " : "");
4075	Bullet();
4076	Selectable(label: buf);
4077	if (IsItemHovered())
4078	{
4079	ImRect r(column->MinX, table->OuterRect.Min.y, column->MaxX, table->OuterRect.Max.y);
4080	GetForegroundDrawList()->AddRect(p_min: r.Min, p_max: r.Max, IM_COL32(255, 255, 0, 255));
4081	}
4082	}
4083	if (ImGuiTableSettings* settings = TableGetBoundSettings(table))
4084	DebugNodeTableSettings(settings);
4085	if (clear_settings)
4086	table->IsResetAllRequest = true;
4087	TreePop();
4088	}
4089
4090	void ImGui::DebugNodeTableSettings(ImGuiTableSettings* settings)
4091	{
4092	if (!TreeNode(ptr_id: (void*)(intptr_t)settings->ID, fmt: "Settings 0x%08X (%d columns)", settings->ID, settings->ColumnsCount))
4093	return;
4094	BulletText(fmt: "SaveFlags: 0x%08X", settings->SaveFlags);
4095	BulletText(fmt: "ColumnsCount: %d (max %d)", settings->ColumnsCount, settings->ColumnsCountMax);
4096	for (int n = 0; n < settings->ColumnsCount; n++)
4097	{
4098	ImGuiTableColumnSettings* column_settings = &settings->GetColumnSettings()[n];
4099	ImGuiSortDirection sort_dir = (column_settings->SortOrder != -1) ? (ImGuiSortDirection)column_settings->SortDirection : ImGuiSortDirection_None;
4100	BulletText(fmt: "Column %d Order %d SortOrder %d %s Vis %d %s %7.3f UserID 0x%08X",
4101	n, column_settings->DisplayOrder, column_settings->SortOrder,
4102	(sort_dir == ImGuiSortDirection_Ascending) ? "Asc" : (sort_dir == ImGuiSortDirection_Descending) ? "Des" : "---",
4103	column_settings->IsEnabled, column_settings->IsStretch ? "Weight" : "Width ", column_settings->WidthOrWeight, column_settings->UserID);
4104	}
4105	TreePop();
4106	}
4107
4108	#else // #ifndef IMGUI_DISABLE_DEBUG_TOOLS
4109
4110	void ImGui::DebugNodeTable(ImGuiTable*) {}
4111	void ImGui::DebugNodeTableSettings(ImGuiTableSettings*) {}
4112
4113	#endif
4114
4115
4116	//-------------------------------------------------------------------------
4117	// [SECTION] Columns, BeginColumns, EndColumns, etc.
4118	// (This is a legacy API, prefer using BeginTable/EndTable!)
4119	//-------------------------------------------------------------------------
4120	// FIXME: sizing is lossy when columns width is very small (default width may turn negative etc.)
4121	//-------------------------------------------------------------------------
4122	// - SetWindowClipRectBeforeSetChannel() [Internal]
4123	// - GetColumnIndex()
4124	// - GetColumnsCount()
4125	// - GetColumnOffset()
4126	// - GetColumnWidth()
4127	// - SetColumnOffset()
4128	// - SetColumnWidth()
4129	// - PushColumnClipRect() [Internal]
4130	// - PushColumnsBackground() [Internal]
4131	// - PopColumnsBackground() [Internal]
4132	// - FindOrCreateColumns() [Internal]
4133	// - GetColumnsID() [Internal]
4134	// - BeginColumns()
4135	// - NextColumn()
4136	// - EndColumns()
4137	// - Columns()
4138	//-------------------------------------------------------------------------
4139
4140	// [Internal] Small optimization to avoid calls to PopClipRect/SetCurrentChannel/PushClipRect in sequences,
4141	// they would meddle many times with the underlying ImDrawCmd.
4142	// Instead, we do a preemptive overwrite of clipping rectangle _without_ altering the command-buffer and let
4143	// the subsequent single call to SetCurrentChannel() does it things once.
4144	void ImGui::SetWindowClipRectBeforeSetChannel(ImGuiWindow* window, const ImRect& clip_rect)
4145	{
4146	ImVec4 clip_rect_vec4 = clip_rect.ToVec4();
4147	window->ClipRect = clip_rect;
4148	window->DrawList->_CmdHeader.ClipRect = clip_rect_vec4;
4149	window->DrawList->_ClipRectStack.Data[window->DrawList->_ClipRectStack.Size - 1] = clip_rect_vec4;
4150	}
4151
4152	int ImGui::GetColumnIndex()
4153	{
4154	ImGuiWindow* window = GetCurrentWindowRead();
4155	return window->DC.CurrentColumns ? window->DC.CurrentColumns->Current : 0;
4156	}
4157
4158	int ImGui::GetColumnsCount()
4159	{
4160	ImGuiWindow* window = GetCurrentWindowRead();
4161	return window->DC.CurrentColumns ? window->DC.CurrentColumns->Count : 1;
4162	}
4163
4164	float ImGui::GetColumnOffsetFromNorm(const ImGuiOldColumns* columns, float offset_norm)
4165	{
4166	return offset_norm * (columns->OffMaxX - columns->OffMinX);
4167	}
4168
4169	float ImGui::GetColumnNormFromOffset(const ImGuiOldColumns* columns, float offset)
4170	{
4171	return offset / (columns->OffMaxX - columns->OffMinX);
4172	}
4173
4174	static const float COLUMNS_HIT_RECT_HALF_THICKNESS = 4.0f;
4175
4176	static float GetDraggedColumnOffset(ImGuiOldColumns* columns, int column_index)
4177	{
4178	// Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
4179	// window creates a feedback loop because we store normalized positions. So while dragging we enforce absolute positioning.
4180	ImGuiContext& g = *GImGui;
4181	ImGuiWindow* window = g.CurrentWindow;
4182	IM_ASSERT(column_index > 0); // We are not supposed to drag column 0.
4183	IM_ASSERT(g.ActiveId == columns->ID + ImGuiID(column_index));
4184
4185	float x = g.IO.MousePos.x - g.ActiveIdClickOffset.x + ImTrunc(f: COLUMNS_HIT_RECT_HALF_THICKNESS * g.CurrentDpiScale) - window->Pos.x;
4186	x = ImMax(lhs: x, rhs: ImGui::GetColumnOffset(column_index: column_index - 1) + g.Style.ColumnsMinSpacing);
4187	if ((columns->Flags & ImGuiOldColumnFlags_NoPreserveWidths))
4188	x = ImMin(lhs: x, rhs: ImGui::GetColumnOffset(column_index: column_index + 1) - g.Style.ColumnsMinSpacing);
4189
4190	return x;
4191	}
4192
4193	float ImGui::GetColumnOffset(int column_index)
4194	{
4195	ImGuiWindow* window = GetCurrentWindowRead();
4196	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4197	if (columns == NULL)
4198	return 0.0f;
4199
4200	if (column_index < 0)
4201	column_index = columns->Current;
4202	IM_ASSERT(column_index < columns->Columns.Size);
4203
4204	const float t = columns->Columns[column_index].OffsetNorm;
4205	const float x_offset = ImLerp(a: columns->OffMinX, b: columns->OffMaxX, t);
4206	return x_offset;
4207	}
4208
4209	static float GetColumnWidthEx(ImGuiOldColumns* columns, int column_index, bool before_resize = false)
4210	{
4211	if (column_index < 0)
4212	column_index = columns->Current;
4213
4214	float offset_norm;
4215	if (before_resize)
4216	offset_norm = columns->Columns[column_index + 1].OffsetNormBeforeResize - columns->Columns[column_index].OffsetNormBeforeResize;
4217	else
4218	offset_norm = columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm;
4219	return ImGui::GetColumnOffsetFromNorm(columns, offset_norm);
4220	}
4221
4222	float ImGui::GetColumnWidth(int column_index)
4223	{
4224	ImGuiContext& g = *GImGui;
4225	ImGuiWindow* window = g.CurrentWindow;
4226	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4227	if (columns == NULL)
4228	return GetContentRegionAvail().x;
4229
4230	if (column_index < 0)
4231	column_index = columns->Current;
4232	return GetColumnOffsetFromNorm(columns, offset_norm: columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm);
4233	}
4234
4235	void ImGui::SetColumnOffset(int column_index, float offset)
4236	{
4237	ImGuiContext& g = *GImGui;
4238	ImGuiWindow* window = g.CurrentWindow;
4239	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4240	IM_ASSERT(columns != NULL);
4241
4242	if (column_index < 0)
4243	column_index = columns->Current;
4244	IM_ASSERT(column_index < columns->Columns.Size);
4245
4246	const bool preserve_width = !(columns->Flags & ImGuiOldColumnFlags_NoPreserveWidths) && (column_index < columns->Count - 1);
4247	const float width = preserve_width ? GetColumnWidthEx(columns, column_index, before_resize: columns->IsBeingResized) : 0.0f;
4248
4249	if (!(columns->Flags & ImGuiOldColumnFlags_NoForceWithinWindow))
4250	offset = ImMin(lhs: offset, rhs: columns->OffMaxX - g.Style.ColumnsMinSpacing * (columns->Count - column_index));
4251	columns->Columns[column_index].OffsetNorm = GetColumnNormFromOffset(columns, offset: offset - columns->OffMinX);
4252
4253	if (preserve_width)
4254	SetColumnOffset(column_index: column_index + 1, offset: offset + ImMax(lhs: g.Style.ColumnsMinSpacing, rhs: width));
4255	}
4256
4257	void ImGui::SetColumnWidth(int column_index, float width)
4258	{
4259	ImGuiWindow* window = GetCurrentWindowRead();
4260	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4261	IM_ASSERT(columns != NULL);
4262
4263	if (column_index < 0)
4264	column_index = columns->Current;
4265	SetColumnOffset(column_index: column_index + 1, offset: GetColumnOffset(column_index) + width);
4266	}
4267
4268	void ImGui::PushColumnClipRect(int column_index)
4269	{
4270	ImGuiWindow* window = GetCurrentWindowRead();
4271	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4272	if (column_index < 0)
4273	column_index = columns->Current;
4274
4275	ImGuiOldColumnData* column = &columns->Columns[column_index];
4276	PushClipRect(clip_rect_min: column->ClipRect.Min, clip_rect_max: column->ClipRect.Max, intersect_with_current_clip_rect: false);
4277	}
4278
4279	// Get into the columns background draw command (which is generally the same draw command as before we called BeginColumns)
4280	void ImGui::PushColumnsBackground()
4281	{
4282	ImGuiWindow* window = GetCurrentWindowRead();
4283	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4284	if (columns->Count == 1)
4285	return;
4286
4287	// Optimization: avoid SetCurrentChannel() + PushClipRect()
4288	columns->HostBackupClipRect = window->ClipRect;
4289	SetWindowClipRectBeforeSetChannel(window, clip_rect: columns->HostInitialClipRect);
4290	columns->Splitter.SetCurrentChannel(draw_list: window->DrawList, channel_idx: 0);
4291	}
4292
4293	void ImGui::PopColumnsBackground()
4294	{
4295	ImGuiWindow* window = GetCurrentWindowRead();
4296	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4297	if (columns->Count == 1)
4298	return;
4299
4300	// Optimization: avoid PopClipRect() + SetCurrentChannel()
4301	SetWindowClipRectBeforeSetChannel(window, clip_rect: columns->HostBackupClipRect);
4302	columns->Splitter.SetCurrentChannel(draw_list: window->DrawList, channel_idx: columns->Current + 1);
4303	}
4304
4305	ImGuiOldColumns* ImGui::FindOrCreateColumns(ImGuiWindow* window, ImGuiID id)
4306	{
4307	// We have few columns per window so for now we don't need bother much with turning this into a faster lookup.
4308	for (int n = 0; n < window->ColumnsStorage.Size; n++)
4309	if (window->ColumnsStorage[n].ID == id)
4310	return &window->ColumnsStorage[n];
4311
4312	window->ColumnsStorage.push_back(v: ImGuiOldColumns());
4313	ImGuiOldColumns* columns = &window->ColumnsStorage.back();
4314	columns->ID = id;
4315	return columns;
4316	}
4317
4318	ImGuiID ImGui::GetColumnsID(const char* str_id, int columns_count)
4319	{
4320	ImGuiWindow* window = GetCurrentWindow();
4321
4322	// Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
4323	// In addition, when an identifier isn't explicitly provided we include the number of columns in the hash to make it uniquer.
4324	PushID(int_id: 0x11223347 + (str_id ? 0 : columns_count));
4325	ImGuiID id = window->GetID(str: str_id ? str_id : "columns");
4326	PopID();
4327
4328	return id;
4329	}
4330
4331	void ImGui::BeginColumns(const char* str_id, int columns_count, ImGuiOldColumnFlags flags)
4332	{
4333	ImGuiContext& g = *GImGui;
4334	ImGuiWindow* window = GetCurrentWindow();
4335
4336	IM_ASSERT(columns_count >= 1);
4337	IM_ASSERT(window->DC.CurrentColumns == NULL); // Nested columns are currently not supported
4338
4339	// Acquire storage for the columns set
4340	ImGuiID id = GetColumnsID(str_id, columns_count);
4341	ImGuiOldColumns* columns = FindOrCreateColumns(window, id);
4342	IM_ASSERT(columns->ID == id);
4343	columns->Current = 0;
4344	columns->Count = columns_count;
4345	columns->Flags = flags;
4346	window->DC.CurrentColumns = columns;
4347	window->DC.NavIsScrollPushableX = false; // Shortcut for NavUpdateCurrentWindowIsScrollPushableX();
4348
4349	columns->HostCursorPosY = window->DC.CursorPos.y;
4350	columns->HostCursorMaxPosX = window->DC.CursorMaxPos.x;
4351	columns->HostInitialClipRect = window->ClipRect;
4352	columns->HostBackupParentWorkRect = window->ParentWorkRect;
4353	window->ParentWorkRect = window->WorkRect;
4354
4355	// Set state for first column
4356	// We aim so that the right-most column will have the same clipping width as other after being clipped by parent ClipRect
4357	const float column_padding = g.Style.ItemSpacing.x;
4358	const float half_clip_extend_x = ImTrunc(f: ImMax(lhs: window->WindowPadding.x * 0.5f, rhs: window->WindowBorderSize));
4359	const float max_1 = window->WorkRect.Max.x + column_padding - ImMax(lhs: column_padding - window->WindowPadding.x, rhs: 0.0f);
4360	const float max_2 = window->WorkRect.Max.x + half_clip_extend_x;
4361	columns->OffMinX = window->DC.Indent.x - column_padding + ImMax(lhs: column_padding - window->WindowPadding.x, rhs: 0.0f);
4362	columns->OffMaxX = ImMax(lhs: ImMin(lhs: max_1, rhs: max_2) - window->Pos.x, rhs: columns->OffMinX + 1.0f);
4363	columns->LineMinY = columns->LineMaxY = window->DC.CursorPos.y;
4364
4365	// Clear data if columns count changed
4366	if (columns->Columns.Size != 0 && columns->Columns.Size != columns_count + 1)
4367	columns->Columns.resize(new_size: 0);
4368
4369	// Initialize default widths
4370	columns->IsFirstFrame = (columns->Columns.Size == 0);
4371	if (columns->Columns.Size == 0)
4372	{
4373	columns->Columns.reserve(new_capacity: columns_count + 1);
4374	for (int n = 0; n < columns_count + 1; n++)
4375	{
4376	ImGuiOldColumnData column;
4377	column.OffsetNorm = n / (float)columns_count;
4378	columns->Columns.push_back(v: column);
4379	}
4380	}
4381
4382	for (int n = 0; n < columns_count; n++)
4383	{
4384	// Compute clipping rectangle
4385	ImGuiOldColumnData* column = &columns->Columns[n];
4386	float clip_x1 = IM_ROUND(window->Pos.x + GetColumnOffset(n));
4387	float clip_x2 = IM_ROUND(window->Pos.x + GetColumnOffset(n + 1) - 1.0f);
4388	column->ClipRect = ImRect(clip_x1, -FLT_MAX, clip_x2, +FLT_MAX);
4389	column->ClipRect.ClipWithFull(r: window->ClipRect);
4390	}
4391
4392	if (columns->Count > 1)
4393	{
4394	columns->Splitter.Split(draw_list: window->DrawList, count: 1 + columns->Count);
4395	columns->Splitter.SetCurrentChannel(draw_list: window->DrawList, channel_idx: 1);
4396	PushColumnClipRect(column_index: 0);
4397	}
4398
4399	// We don't generally store Indent.x inside ColumnsOffset because it may be manipulated by the user.
4400	float offset_0 = GetColumnOffset(column_index: columns->Current);
4401	float offset_1 = GetColumnOffset(column_index: columns->Current + 1);
4402	float width = offset_1 - offset_0;
4403	PushItemWidth(item_width: width * 0.65f);
4404	window->DC.ColumnsOffset.x = ImMax(lhs: column_padding - window->WindowPadding.x, rhs: 0.0f);
4405	window->DC.CursorPos.x = IM_TRUNC(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
4406	window->WorkRect.Max.x = window->Pos.x + offset_1 - column_padding;
4407	window->WorkRect.Max.y = window->ContentRegionRect.Max.y;
4408	}
4409
4410	void ImGui::NextColumn()
4411	{
4412	ImGuiWindow* window = GetCurrentWindow();
4413	if (window->SkipItems || window->DC.CurrentColumns == NULL)
4414	return;
4415
4416	ImGuiContext& g = *GImGui;
4417	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4418
4419	if (columns->Count == 1)
4420	{
4421	window->DC.CursorPos.x = IM_TRUNC(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
4422	IM_ASSERT(columns->Current == 0);
4423	return;
4424	}
4425
4426	// Next column
4427	if (++columns->Current == columns->Count)
4428	columns->Current = 0;
4429
4430	PopItemWidth();
4431
4432	// Optimization: avoid PopClipRect() + SetCurrentChannel() + PushClipRect()
4433	// (which would needlessly attempt to update commands in the wrong channel, then pop or overwrite them),
4434	ImGuiOldColumnData* column = &columns->Columns[columns->Current];
4435	SetWindowClipRectBeforeSetChannel(window, clip_rect: column->ClipRect);
4436	columns->Splitter.SetCurrentChannel(draw_list: window->DrawList, channel_idx: columns->Current + 1);
4437
4438	const float column_padding = g.Style.ItemSpacing.x;
4439	columns->LineMaxY = ImMax(lhs: columns->LineMaxY, rhs: window->DC.CursorPos.y);
4440	if (columns->Current > 0)
4441	{
4442	// Columns 1+ ignore IndentX (by canceling it out)
4443	// FIXME-COLUMNS: Unnecessary, could be locked?
4444	window->DC.ColumnsOffset.x = GetColumnOffset(column_index: columns->Current) - window->DC.Indent.x + column_padding;
4445	}
4446	else
4447	{
4448	// New row/line: column 0 honor IndentX.
4449	window->DC.ColumnsOffset.x = ImMax(lhs: column_padding - window->WindowPadding.x, rhs: 0.0f);
4450	window->DC.IsSameLine = false;
4451	columns->LineMinY = columns->LineMaxY;
4452	}
4453	window->DC.CursorPos.x = IM_TRUNC(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
4454	window->DC.CursorPos.y = columns->LineMinY;
4455	window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
4456	window->DC.CurrLineTextBaseOffset = 0.0f;
4457
4458	// FIXME-COLUMNS: Share code with BeginColumns() - move code on columns setup.
4459	float offset_0 = GetColumnOffset(column_index: columns->Current);
4460	float offset_1 = GetColumnOffset(column_index: columns->Current + 1);
4461	float width = offset_1 - offset_0;
4462	PushItemWidth(item_width: width * 0.65f);
4463	window->WorkRect.Max.x = window->Pos.x + offset_1 - column_padding;
4464	}
4465
4466	void ImGui::EndColumns()
4467	{
4468	ImGuiContext& g = *GImGui;
4469	ImGuiWindow* window = GetCurrentWindow();
4470	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4471	IM_ASSERT(columns != NULL);
4472
4473	PopItemWidth();
4474	if (columns->Count > 1)
4475	{
4476	PopClipRect();
4477	columns->Splitter.Merge(draw_list: window->DrawList);
4478	}
4479
4480	const ImGuiOldColumnFlags flags = columns->Flags;
4481	columns->LineMaxY = ImMax(lhs: columns->LineMaxY, rhs: window->DC.CursorPos.y);
4482	window->DC.CursorPos.y = columns->LineMaxY;
4483	if (!(flags & ImGuiOldColumnFlags_GrowParentContentsSize))
4484	window->DC.CursorMaxPos.x = columns->HostCursorMaxPosX; // Restore cursor max pos, as columns don't grow parent
4485
4486	// Draw columns borders and handle resize
4487	// The IsBeingResized flag ensure we preserve pre-resize columns width so back-and-forth are not lossy
4488	bool is_being_resized = false;
4489	if (!(flags & ImGuiOldColumnFlags_NoBorder) && !window->SkipItems)
4490	{
4491	// We clip Y boundaries CPU side because very long triangles are mishandled by some GPU drivers.
4492	const float y1 = ImMax(lhs: columns->HostCursorPosY, rhs: window->ClipRect.Min.y);
4493	const float y2 = ImMin(lhs: window->DC.CursorPos.y, rhs: window->ClipRect.Max.y);
4494	int dragging_column = -1;
4495	for (int n = 1; n < columns->Count; n++)
4496	{
4497	ImGuiOldColumnData* column = &columns->Columns[n];
4498	float x = window->Pos.x + GetColumnOffset(column_index: n);
4499	const ImGuiID column_id = columns->ID + ImGuiID(n);
4500	const float column_hit_hw = ImTrunc(f: COLUMNS_HIT_RECT_HALF_THICKNESS * g.CurrentDpiScale);
4501	const ImRect column_hit_rect(ImVec2(x - column_hit_hw, y1), ImVec2(x + column_hit_hw, y2));
4502	if (!ItemAdd(bb: column_hit_rect, id: column_id, NULL, extra_flags: ImGuiItemFlags_NoNav))
4503	continue;
4504
4505	bool hovered = false, held = false;
4506	if (!(flags & ImGuiOldColumnFlags_NoResize))
4507	{
4508	ButtonBehavior(bb: column_hit_rect, id: column_id, out_hovered: &hovered, out_held: &held);
4509	if (hovered || held)
4510	SetMouseCursor(ImGuiMouseCursor_ResizeEW);
4511	if (held && !(column->Flags & ImGuiOldColumnFlags_NoResize))
4512	dragging_column = n;
4513	}
4514
4515	// Draw column
4516	const ImU32 col = GetColorU32(idx: held ? ImGuiCol_SeparatorActive : hovered ? ImGuiCol_SeparatorHovered : ImGuiCol_Separator);
4517	const float xi = IM_TRUNC(x);
4518	window->DrawList->AddLine(p1: ImVec2(xi, y1 + 1.0f), p2: ImVec2(xi, y2), col);
4519	}
4520
4521	// Apply dragging after drawing the column lines, so our rendered lines are in sync with how items were displayed during the frame.
4522	if (dragging_column != -1)
4523	{
4524	if (!columns->IsBeingResized)
4525	for (int n = 0; n < columns->Count + 1; n++)
4526	columns->Columns[n].OffsetNormBeforeResize = columns->Columns[n].OffsetNorm;
4527	columns->IsBeingResized = is_being_resized = true;
4528	float x = GetDraggedColumnOffset(columns, column_index: dragging_column);
4529	SetColumnOffset(column_index: dragging_column, offset: x);
4530	}
4531	}
4532	columns->IsBeingResized = is_being_resized;
4533
4534	window->WorkRect = window->ParentWorkRect;
4535	window->ParentWorkRect = columns->HostBackupParentWorkRect;
4536	window->DC.CurrentColumns = NULL;
4537	window->DC.ColumnsOffset.x = 0.0f;
4538	window->DC.CursorPos.x = IM_TRUNC(window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x);
4539	NavUpdateCurrentWindowIsScrollPushableX();
4540	}
4541
4542	void ImGui::Columns(int columns_count, const char* id, bool borders)
4543	{
4544	ImGuiWindow* window = GetCurrentWindow();
4545	IM_ASSERT(columns_count >= 1);
4546
4547	ImGuiOldColumnFlags flags = (borders ? 0 : ImGuiOldColumnFlags_NoBorder);
4548	//flags |= ImGuiOldColumnFlags_NoPreserveWidths; // NB: Legacy behavior
4549	ImGuiOldColumns* columns = window->DC.CurrentColumns;
4550	if (columns != NULL && columns->Count == columns_count && columns->Flags == flags)
4551	return;
4552
4553	if (columns != NULL)
4554	EndColumns();
4555
4556	if (columns_count != 1)
4557	BeginColumns(str_id: id, columns_count, flags);
4558	}
4559
4560	//-------------------------------------------------------------------------
4561
4562	#endif // #ifndef IMGUI_DISABLE
4563