Internals: rename ImGuiNextWindowData::Flags to HasFlags for consistency and to reduce mistakes.

ocornut · ocornut · commit e5668b8c738b · 2025-02-07T22:48:31.000+01:00
diff --git a/imgui.cpp b/imgui.cpp
@@ -6068,7 +6068,7 @@ bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, I
     // A SetNextWindowSize() call always has priority (#8020)
     // (since the code in Begin() never supported SizeVal==0.0f aka auto-resize via SetNextWindowSize() call, we don't support it here for now)
     // FIXME: We only support ImGuiCond_Always in this path. Supporting other paths would requires to obtain window pointer.
-    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) != 0 && (g.NextWindowData.SizeCond & ImGuiCond_Always) != 0)
+    if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) != 0 && (g.NextWindowData.SizeCond & ImGuiCond_Always) != 0)
     {
         if (g.NextWindowData.SizeVal.x > 0.0f)
         {
@@ -6084,11 +6084,11 @@ bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, I
     SetNextWindowSize(size);
 
     // Forward child flags (we allow prior settings to merge but it'll only work for adding flags)
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasChildFlags)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasChildFlags)
         g.NextWindowData.ChildFlags |= child_flags;
     else
         g.NextWindowData.ChildFlags = child_flags;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasChildFlags;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasChildFlags;
 
     // Build up name. If you need to append to a same child from multiple location in the ID stack, use BeginChild(ImGuiID id) with a stable value.
     // FIXME: 2023/11/14: commented out shorted version. We had an issue with multiple ### in child window path names, which the trailing hash helped workaround.
@@ -6302,7 +6302,7 @@ static ImVec2 CalcWindowSizeAfterConstraint(ImGuiWindow* window, const ImVec2& s
 {
     ImGuiContext& g = *GImGui;
     ImVec2 new_size = size_desired;
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSizeConstraint)
     {
         // See comments in SetNextWindowSizeConstraints() for details about setting size_min an size_max.
         ImRect cr = g.NextWindowData.SizeConstraintRect;
@@ -6780,7 +6780,7 @@ void ImGui::RenderWindowDecorations(ImGuiWindow* window, const ImRect& title_bar
             ImU32 bg_col = GetColorU32(GetWindowBgColorIdx(window));
             bool override_alpha = false;
             float alpha = 1.0f;
-            if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasBgAlpha)
+            if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasBgAlpha)
             {
                 alpha = g.NextWindowData.BgAlphaVal;
                 override_alpha = true;
@@ -6950,7 +6950,7 @@ void ImGui::UpdateWindowSkipRefresh(ImGuiWindow* window)
 {
     ImGuiContext& g = *GImGui;
     window->SkipRefresh = false;
-    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasRefreshPolicy) == 0)
+    if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasRefreshPolicy) == 0)
         return;
     if (g.NextWindowData.RefreshFlagsVal & ImGuiWindowRefreshFlags_TryToAvoidRefresh)
     {
@@ -7031,7 +7031,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)
     {
         UpdateWindowInFocusOrderList(window, window_just_created, flags);
         window->Flags = (ImGuiWindowFlags)flags;
-        window->ChildFlags = (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasChildFlags) ? g.NextWindowData.ChildFlags : 0;
+        window->ChildFlags = (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasChildFlags) ? g.NextWindowData.ChildFlags : 0;
         window->LastFrameActive = current_frame;
         window->LastTimeActive = (float)g.Time;
         window->BeginOrderWithinParent = 0;
@@ -7095,7 +7095,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)
     // (FIXME: Consider splitting the HasXXX flags into X/Y components
     bool window_pos_set_by_api = false;
     bool window_size_x_set_by_api = false, window_size_y_set_by_api = false;
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasPos)
     {
         window_pos_set_by_api = (window->SetWindowPosAllowFlags & g.NextWindowData.PosCond) != 0;
         if (window_pos_set_by_api && ImLengthSqr(g.NextWindowData.PosPivotVal) > 0.00001f)
@@ -7111,7 +7111,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)
             SetWindowPos(window, g.NextWindowData.PosVal, g.NextWindowData.PosCond);
         }
     }
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize)
     {
         window_size_x_set_by_api = (window->SetWindowSizeAllowFlags & g.NextWindowData.SizeCond) != 0 && (g.NextWindowData.SizeVal.x > 0.0f);
         window_size_y_set_by_api = (window->SetWindowSizeAllowFlags & g.NextWindowData.SizeCond) != 0 && (g.NextWindowData.SizeVal.y > 0.0f);
@@ -7121,7 +7121,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)
             g.NextWindowData.SizeVal.y = window->SizeFull.y;
         SetWindowSize(window, g.NextWindowData.SizeVal, g.NextWindowData.SizeCond);
     }
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasScroll)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasScroll)
     {
         if (g.NextWindowData.ScrollVal.x >= 0.0f)
         {
@@ -7134,13 +7134,13 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)
             window->ScrollTargetCenterRatio.y = 0.0f;
         }
     }
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasContentSize)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasContentSize)
         window->ContentSizeExplicit = g.NextWindowData.ContentSizeVal;
     else if (first_begin_of_the_frame)
         window->ContentSizeExplicit = ImVec2(0.0f, 0.0f);
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasCollapsed)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasCollapsed)
         SetWindowCollapsed(window, g.NextWindowData.CollapsedVal, g.NextWindowData.CollapsedCond);
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasFocus)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasFocus)
         FocusWindow(window);
     if (window->Appearing)
         SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, false);
@@ -8223,7 +8223,7 @@ void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiCond cond, const ImVec2& pi
 {
     ImGuiContext& g = *GImGui;
     IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasPos;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasPos;
     g.NextWindowData.PosVal = pos;
     g.NextWindowData.PosPivotVal = pivot;
     g.NextWindowData.PosCond = cond ? cond : ImGuiCond_Always;
@@ -8233,7 +8233,7 @@ void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)
 {
     ImGuiContext& g = *GImGui;
     IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSize;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasSize;
     g.NextWindowData.SizeVal = size;
     g.NextWindowData.SizeCond = cond ? cond : ImGuiCond_Always;
 }
@@ -8245,7 +8245,7 @@ void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)
 void ImGui::SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback, void* custom_callback_user_data)
 {
     ImGuiContext& g = *GImGui;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSizeConstraint;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasSizeConstraint;
     g.NextWindowData.SizeConstraintRect = ImRect(size_min, size_max);
     g.NextWindowData.SizeCallback = custom_callback;
     g.NextWindowData.SizeCallbackUserData = custom_callback_user_data;
@@ -8256,38 +8256,38 @@ void ImGui::SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& s
 void ImGui::SetNextWindowContentSize(const ImVec2& size)
 {
     ImGuiContext& g = *GImGui;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasContentSize;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasContentSize;
     g.NextWindowData.ContentSizeVal = ImTrunc(size);
 }
 
 void ImGui::SetNextWindowScroll(const ImVec2& scroll)
 {
     ImGuiContext& g = *GImGui;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasScroll;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasScroll;
     g.NextWindowData.ScrollVal = scroll;
 }
 
 void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
 {
     ImGuiContext& g = *GImGui;
     IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasCollapsed;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasCollapsed;
     g.NextWindowData.CollapsedVal = collapsed;
     g.NextWindowData.CollapsedCond = cond ? cond : ImGuiCond_Always;
 }
 
 void ImGui::SetNextWindowBgAlpha(float alpha)
 {
     ImGuiContext& g = *GImGui;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasBgAlpha;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasBgAlpha;
     g.NextWindowData.BgAlphaVal = alpha;
 }
 
 // This is experimental and meant to be a toy for exploring a future/wider range of features.
 void ImGui::SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags)
 {
     ImGuiContext& g = *GImGui;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasRefreshPolicy;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasRefreshPolicy;
     g.NextWindowData.RefreshFlagsVal = flags;
 }
 
@@ -11301,7 +11301,7 @@ bool ImGui::BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags ext
         // See FindBestWindowPosForPopup() for positionning logic of other tooltips (not drag and drop ones).
         //ImVec2 tooltip_pos = g.IO.MousePos - g.ActiveIdClickOffset - g.Style.WindowPadding;
         const bool is_touchscreen = (g.IO.MouseSource == ImGuiMouseSource_TouchScreen);
-        if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)
+        if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasPos) == 0)
         {
             ImVec2 tooltip_pos = is_touchscreen ? (g.IO.MousePos + TOOLTIP_DEFAULT_OFFSET_TOUCH * g.Style.MouseCursorScale) : (g.IO.MousePos + TOOLTIP_DEFAULT_OFFSET_MOUSE * g.Style.MouseCursorScale);
             ImVec2 tooltip_pivot = is_touchscreen ? TOOLTIP_DEFAULT_PIVOT_TOUCH : ImVec2(0.0f, 0.0f);
@@ -11724,7 +11724,7 @@ bool ImGui::BeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags fla
     // Center modal windows by default for increased visibility
     // (this won't really last as settings will kick in, and is mostly for backward compatibility. user may do the same themselves)
     // FIXME: Should test for (PosCond & window->SetWindowPosAllowFlags) with the upcoming window.
-    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)
+    if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasPos) == 0)
     {
         const ImGuiViewport* viewport = GetMainViewport();
         SetNextWindowPos(viewport->GetCenter(), ImGuiCond_FirstUseEver, ImVec2(0.5f, 0.5f));
@@ -12017,7 +12017,7 @@ void ImGui::SetWindowFocus(const char* name)
 void ImGui::SetNextWindowFocus()
 {
     ImGuiContext& g = *GImGui;
-    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasFocus;
+    g.NextWindowData.HasFlags |= ImGuiNextWindowDataFlags_HasFocus;
 }
 
 // Similar to IsWindowHovered()
@@ -16548,7 +16548,7 @@ static void ShowDebugLogFlag(const char* name, ImGuiDebugLogFlags flags)
 void ImGui::ShowDebugLogWindow(bool* p_open)
 {
     ImGuiContext& g = *GImGui;
-    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0)
+    if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0)
         SetNextWindowSize(ImVec2(0.0f, GetFontSize() * 12.0f), ImGuiCond_FirstUseEver);
     if (!Begin("Dear ImGui Debug Log", p_open) || GetCurrentWindow()->BeginCount > 1)
     {
@@ -16868,7 +16868,7 @@ static int StackToolFormatLevelInfo(ImGuiIDStackTool* tool, int n, bool format_f
 void ImGui::ShowIDStackToolWindow(bool* p_open)
 {
     ImGuiContext& g = *GImGui;
-    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0)
+    if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0)
         SetNextWindowSize(ImVec2(0.0f, GetFontSize() * 8.0f), ImGuiCond_FirstUseEver);
     if (!Begin("Dear ImGui ID Stack Tool", p_open) || GetCurrentWindow()->BeginCount > 1)
     {
diff --git a/imgui_internal.h b/imgui_internal.h
@@ -1201,7 +1201,9 @@ enum ImGuiNextWindowDataFlags_
 // Storage for SetNexWindow** functions
 struct ImGuiNextWindowData
 {
-    ImGuiNextWindowDataFlags    Flags;
+    ImGuiNextWindowDataFlags    HasFlags;
+
+    // Members below are NOT cleared. Always rely on HasFlags.
     ImGuiCond                   PosCond;
     ImGuiCond                   SizeCond;
     ImGuiCond                   CollapsedCond;
@@ -1220,7 +1222,7 @@ struct ImGuiNextWindowData
     ImGuiWindowRefreshFlags     RefreshFlagsVal;
 
     ImGuiNextWindowData()       { memset(this, 0, sizeof(*this)); }
-    inline void ClearFlags()    { Flags = ImGuiNextWindowDataFlags_None; }
+    inline void ClearFlags()    { HasFlags = ImGuiNextWindowDataFlags_None; }
 };
 
 enum ImGuiNextItemDataFlags_
@@ -1237,7 +1239,8 @@ struct ImGuiNextItemData
 {
     ImGuiNextItemDataFlags      HasFlags;           // Called HasFlags instead of Flags to avoid mistaking this
     ImGuiItemFlags              ItemFlags;          // Currently only tested/used for ImGuiItemFlags_AllowOverlap and ImGuiItemFlags_HasSelectionUserData.
-    // Non-flags members are NOT cleared by ItemAdd() meaning they are still valid during NavProcessItem()
+
+    // Members below are NOT cleared by ItemAdd() meaning they are still valid during e.g. NavProcessItem(). Always rely on HasFlags.
     ImGuiID                     FocusScopeId;       // Set by SetNextItemSelectionUserData()
     ImGuiSelectionUserData      SelectionUserData;  // Set by SetNextItemSelectionUserData() (note that NULL/0 is a valid value, we use -1 == ImGuiSelectionUserData_Invalid to mark invalid values)
     float                       Width;              // Set by SetNextItemWidth()
diff --git a/imgui_tables.cpp b/imgui_tables.cpp
@@ -415,7 +415,7 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
 
         // Reset scroll if we are reactivating it
         if ((previous_flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) == 0)
-            if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasScroll) == 0)
+            if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasScroll) == 0)
                 SetNextWindowScroll(ImVec2(0.0f, 0.0f));
 
         // Create scrolling region (without border and zero window padding)
diff --git a/imgui_widgets.cpp b/imgui_widgets.cpp
@@ -1829,7 +1829,7 @@ bool ImGui::BeginCombo(const char* label, const char* preview_value, ImGuiComboF
     ImGuiContext& g = *GImGui;
     ImGuiWindow* window = GetCurrentWindow();
 
-    ImGuiNextWindowDataFlags backup_next_window_data_flags = g.NextWindowData.Flags;
+    ImGuiNextWindowDataFlags backup_next_window_data_flags = g.NextWindowData.HasFlags;
     g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
     if (window->SkipItems)
         return false;
@@ -1898,7 +1898,7 @@ bool ImGui::BeginCombo(const char* label, const char* preview_value, ImGuiComboF
     if (!popup_open)
         return false;
 
-    g.NextWindowData.Flags = backup_next_window_data_flags;
+    g.NextWindowData.HasFlags = backup_next_window_data_flags;
     return BeginComboPopup(popup_id, bb, flags);
 }
 
@@ -1913,7 +1913,7 @@ bool ImGui::BeginComboPopup(ImGuiID popup_id, const ImRect& bb, ImGuiComboFlags
 
     // Set popup size
     float w = bb.GetWidth();
-    if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint)
+    if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSizeConstraint)
     {
         g.NextWindowData.SizeConstraintRect.Min.x = ImMax(g.NextWindowData.SizeConstraintRect.Min.x, w);
     }
@@ -1927,9 +1927,9 @@ bool ImGui::BeginComboPopup(ImGuiID popup_id, const ImRect& bb, ImGuiComboFlags
         else if (flags & ImGuiComboFlags_HeightSmall)  popup_max_height_in_items = 4;
         else if (flags & ImGuiComboFlags_HeightLarge)  popup_max_height_in_items = 20;
         ImVec2 constraint_min(0.0f, 0.0f), constraint_max(FLT_MAX, FLT_MAX);
-        if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.x <= 0.0f) // Don't apply constraints if user specified a size
+        if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.x <= 0.0f) // Don't apply constraints if user specified a size
             constraint_min.x = w;
-        if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.y <= 0.0f)
+        if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.y <= 0.0f)
             constraint_max.y = CalcMaxPopupHeightFromItemCount(popup_max_height_in_items);
         SetNextWindowSizeConstraints(constraint_min, constraint_max);
     }
@@ -2061,7 +2061,7 @@ bool ImGui::Combo(const char* label, int* current_item, const char* (*getter)(vo
         preview_value = getter(user_data, *current_item);
 
     // The old Combo() API exposed "popup_max_height_in_items". The new more general BeginCombo() API doesn't have/need it, but we emulate it here.
-    if (popup_max_height_in_items != -1 && !(g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint))
+    if (popup_max_height_in_items != -1 && !(g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSizeConstraint))
         SetNextWindowSizeConstraints(ImVec2(0, 0), ImVec2(FLT_MAX, CalcMaxPopupHeightFromItemCount(popup_max_height_in_items)));
 
     if (!BeginCombo(label, preview_value, ImGuiComboFlags_None))

Original file line number	Diff line number	Diff line change
`@@ -6068,7 +6068,7 @@ bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, I`
`6068`	`6068`	`// A SetNextWindowSize() call always has priority (#8020)`
`6069`	`6069`	`// (since the code in Begin() never supported SizeVal==0.0f aka auto-resize via SetNextWindowSize() call, we don't support it here for now)`
`6070`	`6070`	`// FIXME: We only support ImGuiCond_Always in this path. Supporting other paths would requires to obtain window pointer.`
`6071`		`- if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) != 0 && (g.NextWindowData.SizeCond & ImGuiCond_Always) != 0)`
	`6071`	`+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) != 0 && (g.NextWindowData.SizeCond & ImGuiCond_Always) != 0)`
`6072`	`6072`	`{`
`6073`	`6073`	`if (g.NextWindowData.SizeVal.x > 0.0f)`
`6074`	`6074`	`{`
`@@ -6084,11 +6084,11 @@ bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, I`
`6084`	`6084`	`SetNextWindowSize(size);`
`6085`	`6085`
`6086`	`6086`	`// Forward child flags (we allow prior settings to merge but it'll only work for adding flags)`
`6087`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasChildFlags)`
	`6087`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasChildFlags)`
`6088`	`6088`	`g.NextWindowData.ChildFlags \|= child_flags;`
`6089`	`6089`	`else`
`6090`	`6090`	`g.NextWindowData.ChildFlags = child_flags;`
`6091`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasChildFlags;`
	`6091`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasChildFlags;`
`6092`	`6092`
`6093`	`6093`	`// Build up name. If you need to append to a same child from multiple location in the ID stack, use BeginChild(ImGuiID id) with a stable value.`
`6094`	`6094`	`// FIXME: 2023/11/14: commented out shorted version. We had an issue with multiple ### in child window path names, which the trailing hash helped workaround.`
`@@ -6302,7 +6302,7 @@ static ImVec2 CalcWindowSizeAfterConstraint(ImGuiWindow* window, const ImVec2& s`
`6302`	`6302`	`{`
`6303`	`6303`	`ImGuiContext& g = *GImGui;`
`6304`	`6304`	`ImVec2 new_size = size_desired;`
`6305`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint)`
	`6305`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSizeConstraint)`
`6306`	`6306`	`{`
`6307`	`6307`	`// See comments in SetNextWindowSizeConstraints() for details about setting size_min an size_max.`
`6308`	`6308`	`ImRect cr = g.NextWindowData.SizeConstraintRect;`
`@@ -6780,7 +6780,7 @@ void ImGui::RenderWindowDecorations(ImGuiWindow* window, const ImRect& title_bar`
`6780`	`6780`	`ImU32 bg_col = GetColorU32(GetWindowBgColorIdx(window));`
`6781`	`6781`	`bool override_alpha = false;`
`6782`	`6782`	`float alpha = 1.0f;`
`6783`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasBgAlpha)`
	`6783`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasBgAlpha)`
`6784`	`6784`	`{`
`6785`	`6785`	`alpha = g.NextWindowData.BgAlphaVal;`
`6786`	`6786`	`override_alpha = true;`
`@@ -6950,7 +6950,7 @@ void ImGui::UpdateWindowSkipRefresh(ImGuiWindow* window)`
`6950`	`6950`	`{`
`6951`	`6951`	`ImGuiContext& g = *GImGui;`
`6952`	`6952`	`window->SkipRefresh = false;`
`6953`		`- if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasRefreshPolicy) == 0)`
	`6953`	`+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasRefreshPolicy) == 0)`
`6954`	`6954`	`return;`
`6955`	`6955`	`if (g.NextWindowData.RefreshFlagsVal & ImGuiWindowRefreshFlags_TryToAvoidRefresh)`
`6956`	`6956`	`{`
`@@ -7031,7 +7031,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)`
`7031`	`7031`	`{`
`7032`	`7032`	`UpdateWindowInFocusOrderList(window, window_just_created, flags);`
`7033`	`7033`	`window->Flags = (ImGuiWindowFlags)flags;`
`7034`		`- window->ChildFlags = (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasChildFlags) ? g.NextWindowData.ChildFlags : 0;`
	`7034`	`+ window->ChildFlags = (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasChildFlags) ? g.NextWindowData.ChildFlags : 0;`
`7035`	`7035`	`window->LastFrameActive = current_frame;`
`7036`	`7036`	`window->LastTimeActive = (float)g.Time;`
`7037`	`7037`	`window->BeginOrderWithinParent = 0;`
`@@ -7095,7 +7095,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)`
`7095`	`7095`	`// (FIXME: Consider splitting the HasXXX flags into X/Y components`
`7096`	`7096`	`bool window_pos_set_by_api = false;`
`7097`	`7097`	`bool window_size_x_set_by_api = false, window_size_y_set_by_api = false;`
`7098`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos)`
	`7098`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasPos)`
`7099`	`7099`	`{`
`7100`	`7100`	`window_pos_set_by_api = (window->SetWindowPosAllowFlags & g.NextWindowData.PosCond) != 0;`
`7101`	`7101`	`if (window_pos_set_by_api && ImLengthSqr(g.NextWindowData.PosPivotVal) > 0.00001f)`
`@@ -7111,7 +7111,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)`
`7111`	`7111`	`SetWindowPos(window, g.NextWindowData.PosVal, g.NextWindowData.PosCond);`
`7112`	`7112`	`}`
`7113`	`7113`	`}`
`7114`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize)`
	`7114`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize)`
`7115`	`7115`	`{`
`7116`	`7116`	`window_size_x_set_by_api = (window->SetWindowSizeAllowFlags & g.NextWindowData.SizeCond) != 0 && (g.NextWindowData.SizeVal.x > 0.0f);`
`7117`	`7117`	`window_size_y_set_by_api = (window->SetWindowSizeAllowFlags & g.NextWindowData.SizeCond) != 0 && (g.NextWindowData.SizeVal.y > 0.0f);`
`@@ -7121,7 +7121,7 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)`
`7121`	`7121`	`g.NextWindowData.SizeVal.y = window->SizeFull.y;`
`7122`	`7122`	`SetWindowSize(window, g.NextWindowData.SizeVal, g.NextWindowData.SizeCond);`
`7123`	`7123`	`}`
`7124`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasScroll)`
	`7124`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasScroll)`
`7125`	`7125`	`{`
`7126`	`7126`	`if (g.NextWindowData.ScrollVal.x >= 0.0f)`
`7127`	`7127`	`{`
`@@ -7134,13 +7134,13 @@ bool ImGui::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)`
`7134`	`7134`	`window->ScrollTargetCenterRatio.y = 0.0f;`
`7135`	`7135`	`}`
`7136`	`7136`	`}`
`7137`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasContentSize)`
	`7137`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasContentSize)`
`7138`	`7138`	`window->ContentSizeExplicit = g.NextWindowData.ContentSizeVal;`
`7139`	`7139`	`else if (first_begin_of_the_frame)`
`7140`	`7140`	`window->ContentSizeExplicit = ImVec2(0.0f, 0.0f);`
`7141`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasCollapsed)`
	`7141`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasCollapsed)`
`7142`	`7142`	`SetWindowCollapsed(window, g.NextWindowData.CollapsedVal, g.NextWindowData.CollapsedCond);`
`7143`		`- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasFocus)`
	`7143`	`+ if (g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasFocus)`
`7144`	`7144`	`FocusWindow(window);`
`7145`	`7145`	`if (window->Appearing)`
`7146`	`7146`	`SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, false);`
`@@ -8223,7 +8223,7 @@ void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiCond cond, const ImVec2& pi`
`8223`	`8223`	`{`
`8224`	`8224`	`ImGuiContext& g = *GImGui;`
`8225`	`8225`	`IM_ASSERT(cond == 0 \|\| ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.`
`8226`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasPos;`
	`8226`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasPos;`
`8227`	`8227`	`g.NextWindowData.PosVal = pos;`
`8228`	`8228`	`g.NextWindowData.PosPivotVal = pivot;`
`8229`	`8229`	`g.NextWindowData.PosCond = cond ? cond : ImGuiCond_Always;`
`@@ -8233,7 +8233,7 @@ void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)`
`8233`	`8233`	`{`
`8234`	`8234`	`ImGuiContext& g = *GImGui;`
`8235`	`8235`	`IM_ASSERT(cond == 0 \|\| ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.`
`8236`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasSize;`
	`8236`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasSize;`
`8237`	`8237`	`g.NextWindowData.SizeVal = size;`
`8238`	`8238`	`g.NextWindowData.SizeCond = cond ? cond : ImGuiCond_Always;`
`8239`	`8239`	`}`
`@@ -8245,7 +8245,7 @@ void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)`
`8245`	`8245`	`void ImGui::SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback, void* custom_callback_user_data)`
`8246`	`8246`	`{`
`8247`	`8247`	`ImGuiContext& g = *GImGui;`
`8248`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasSizeConstraint;`
	`8248`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasSizeConstraint;`
`8249`	`8249`	`g.NextWindowData.SizeConstraintRect = ImRect(size_min, size_max);`
`8250`	`8250`	`g.NextWindowData.SizeCallback = custom_callback;`
`8251`	`8251`	`g.NextWindowData.SizeCallbackUserData = custom_callback_user_data;`
`@@ -8256,38 +8256,38 @@ void ImGui::SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& s`
`8256`	`8256`	`void ImGui::SetNextWindowContentSize(const ImVec2& size)`
`8257`	`8257`	`{`
`8258`	`8258`	`ImGuiContext& g = *GImGui;`
`8259`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasContentSize;`
	`8259`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasContentSize;`
`8260`	`8260`	`g.NextWindowData.ContentSizeVal = ImTrunc(size);`
`8261`	`8261`	`}`
`8262`	`8262`
`8263`	`8263`	`void ImGui::SetNextWindowScroll(const ImVec2& scroll)`
`8264`	`8264`	`{`
`8265`	`8265`	`ImGuiContext& g = *GImGui;`
`8266`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasScroll;`
	`8266`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasScroll;`
`8267`	`8267`	`g.NextWindowData.ScrollVal = scroll;`
`8268`	`8268`	`}`
`8269`	`8269`
`8270`	`8270`	`void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)`
`8271`	`8271`	`{`
`8272`	`8272`	`ImGuiContext& g = *GImGui;`
`8273`	`8273`	`IM_ASSERT(cond == 0 \|\| ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.`
`8274`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasCollapsed;`
	`8274`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasCollapsed;`
`8275`	`8275`	`g.NextWindowData.CollapsedVal = collapsed;`
`8276`	`8276`	`g.NextWindowData.CollapsedCond = cond ? cond : ImGuiCond_Always;`
`8277`	`8277`	`}`
`8278`	`8278`
`8279`	`8279`	`void ImGui::SetNextWindowBgAlpha(float alpha)`
`8280`	`8280`	`{`
`8281`	`8281`	`ImGuiContext& g = *GImGui;`
`8282`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasBgAlpha;`
	`8282`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasBgAlpha;`
`8283`	`8283`	`g.NextWindowData.BgAlphaVal = alpha;`
`8284`	`8284`	`}`
`8285`	`8285`
`8286`	`8286`	`// This is experimental and meant to be a toy for exploring a future/wider range of features.`
`8287`	`8287`	`void ImGui::SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags)`
`8288`	`8288`	`{`
`8289`	`8289`	`ImGuiContext& g = *GImGui;`
`8290`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasRefreshPolicy;`
	`8290`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasRefreshPolicy;`
`8291`	`8291`	`g.NextWindowData.RefreshFlagsVal = flags;`
`8292`	`8292`	`}`
`8293`	`8293`
`@@ -11301,7 +11301,7 @@ bool ImGui::BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags ext`
`11301`	`11301`	`// See FindBestWindowPosForPopup() for positionning logic of other tooltips (not drag and drop ones).`
`11302`	`11302`	`//ImVec2 tooltip_pos = g.IO.MousePos - g.ActiveIdClickOffset - g.Style.WindowPadding;`
`11303`	`11303`	`const bool is_touchscreen = (g.IO.MouseSource == ImGuiMouseSource_TouchScreen);`
`11304`		`- if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)`
	`11304`	`+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasPos) == 0)`
`11305`	`11305`	`{`
`11306`	`11306`	`ImVec2 tooltip_pos = is_touchscreen ? (g.IO.MousePos + TOOLTIP_DEFAULT_OFFSET_TOUCH * g.Style.MouseCursorScale) : (g.IO.MousePos + TOOLTIP_DEFAULT_OFFSET_MOUSE * g.Style.MouseCursorScale);`
`11307`	`11307`	`ImVec2 tooltip_pivot = is_touchscreen ? TOOLTIP_DEFAULT_PIVOT_TOUCH : ImVec2(0.0f, 0.0f);`
`@@ -11724,7 +11724,7 @@ bool ImGui::BeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags fla`
`11724`	`11724`	`// Center modal windows by default for increased visibility`
`11725`	`11725`	`// (this won't really last as settings will kick in, and is mostly for backward compatibility. user may do the same themselves)`
`11726`	`11726`	`// FIXME: Should test for (PosCond & window->SetWindowPosAllowFlags) with the upcoming window.`
`11727`		`- if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)`
	`11727`	`+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasPos) == 0)`
`11728`	`11728`	`{`
`11729`	`11729`	`const ImGuiViewport* viewport = GetMainViewport();`
`11730`	`11730`	`SetNextWindowPos(viewport->GetCenter(), ImGuiCond_FirstUseEver, ImVec2(0.5f, 0.5f));`
`@@ -12017,7 +12017,7 @@ void ImGui::SetWindowFocus(const char* name)`
`12017`	`12017`	`void ImGui::SetNextWindowFocus()`
`12018`	`12018`	`{`
`12019`	`12019`	`ImGuiContext& g = *GImGui;`
`12020`		`- g.NextWindowData.Flags \|= ImGuiNextWindowDataFlags_HasFocus;`
	`12020`	`+ g.NextWindowData.HasFlags \|= ImGuiNextWindowDataFlags_HasFocus;`
`12021`	`12021`	`}`
`12022`	`12022`
`12023`	`12023`	`// Similar to IsWindowHovered()`
`@@ -16548,7 +16548,7 @@ static void ShowDebugLogFlag(const char* name, ImGuiDebugLogFlags flags)`
`16548`	`16548`	`void ImGui::ShowDebugLogWindow(bool* p_open)`
`16549`	`16549`	`{`
`16550`	`16550`	`ImGuiContext& g = *GImGui;`
`16551`		`- if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0)`
	`16551`	`+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0)`
`16552`	`16552`	`SetNextWindowSize(ImVec2(0.0f, GetFontSize() * 12.0f), ImGuiCond_FirstUseEver);`
`16553`	`16553`	`if (!Begin("Dear ImGui Debug Log", p_open) \|\| GetCurrentWindow()->BeginCount > 1)`
`16554`	`16554`	`{`
`@@ -16868,7 +16868,7 @@ static int StackToolFormatLevelInfo(ImGuiIDStackTool* tool, int n, bool format_f`
`16868`	`16868`	`void ImGui::ShowIDStackToolWindow(bool* p_open)`
`16869`	`16869`	`{`
`16870`	`16870`	`ImGuiContext& g = *GImGui;`
`16871`		`- if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0)`
	`16871`	`+ if ((g.NextWindowData.HasFlags & ImGuiNextWindowDataFlags_HasSize) == 0)`
`16872`	`16872`	`SetNextWindowSize(ImVec2(0.0f, GetFontSize() * 8.0f), ImGuiCond_FirstUseEver);`
`16873`	`16873`	`if (!Begin("Dear ImGui ID Stack Tool", p_open) \|\| GetCurrentWindow()->BeginCount > 1)`
`16874`	`16874`	`{`