Home Explore Help
Sign In
cpp
/
crown-engine
mirror of https://github.com/crownengine/crown.git
2
0
Fork 0
Files Issues 0 Wiki
Browse Source

3rdparty: update ocornut-imgui

Daniele Bartolini 6 years ago
parent
294675ac64
commit
dee2dbf6a0
6 changed files with 1004 additions and 566 deletions
Split View Show Diff Stats
  1. 299 135
      3rdparty/ocornut-imgui/imgui.cpp
  2. 85 63
      3rdparty/ocornut-imgui/imgui.h
  3. 219 146
      3rdparty/ocornut-imgui/imgui_demo.cpp
  4. 36 18
      3rdparty/ocornut-imgui/imgui_draw.cpp
  5. 90 62
      3rdparty/ocornut-imgui/imgui_internal.h
  6. 275 142
      3rdparty/ocornut-imgui/imgui_widgets.cpp

File diff suppressed because it is too large
+ 299 - 135
3rdparty/ocornut-imgui/imgui.cpp


+ 85 - 63
3rdparty/ocornut-imgui/imgui.h
View File 

@@ -1,4 +1,4 @@
 
-// dear imgui, v1.69 WIP
 
+// dear imgui, v1.70 WIP
 
 // (headers)
 
 
 // See imgui.cpp file for documentation.
 
@@ -13,13 +13,14 @@ Index of this file:
 
 // Forward declarations and basic types
 
 // ImGui API (Dear ImGui end-user API)
 
 // Flags & Enumerations
 
+// Memory allocations macros
 
 // ImVector<>
 
 // ImGuiStyle
 
 // ImGuiIO
 
 // Misc data structures (ImGuiInputTextCallbackData, ImGuiSizeCallbackData, ImGuiPayload, ImGuiWindowClass)
 
 // Obsolete functions
 
 // Helpers (ImGuiOnceUponAFrame, ImGuiTextFilter, ImGuiTextBuffer, ImGuiStorage, ImGuiListClipper, ImColor)
 
-// Draw List API (ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListFlags, ImDrawList, ImDrawData)
 
+// Draw List API (ImDrawCallback, ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListFlags, ImDrawList, ImDrawData)
 
 // Font API (ImFontConfig, ImFontGlyph, ImFontGlyphRangesBuilder, ImFontAtlasFlags, ImFontAtlas, ImFont)
 
 // Platform interface for multi-viewport support (ImGuiPlatformMonitor, ImGuiPlatformIO, ImGuiViewport)
 
 
@@ -46,8 +47,8 @@ Index of this file:
 
 
 // Version
 
 // (Integer encoded as XYYZZ for use in #if preprocessor conditionals. Work in progress versions typically starts at XYY99 then bounce up to XYY00, XYY01 etc. when release tagging happens)
 
-#define IMGUI_VERSION               "1.69 WIP"
 
-#define IMGUI_VERSION_NUM           16899
 
+#define IMGUI_VERSION               "1.70 WIP"
 
+#define IMGUI_VERSION_NUM           16990
 
 #define IMGUI_CHECKVERSION()        ImGui::DebugCheckVersionAndDataLayout(IMGUI_VERSION, sizeof(ImGuiIO), sizeof(ImGuiStyle), sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert))
 
 #define IMGUI_HAS_VIEWPORT          1 // Viewport WIP branch
 
 #define IMGUI_HAS_DOCK              1 // Docking WIP branch
 
@@ -275,13 +276,8 @@ namespace ImGui
 
     IMGUI_API ImVec2        GetWindowSize();                            // get current window size
 
     IMGUI_API float         GetWindowWidth();                           // get current window width (shortcut for GetWindowSize().x)
 
     IMGUI_API float         GetWindowHeight();                          // get current window height (shortcut for GetWindowSize().y)
 
-    IMGUI_API ImVec2        GetContentRegionMax();                      // current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
 
-    IMGUI_API ImVec2        GetContentRegionAvail();                    // == GetContentRegionMax() - GetCursorPos()
 
-    IMGUI_API float         GetContentRegionAvailWidth();               // == GetContentRegionAvail().x
 
-    IMGUI_API ImVec2        GetWindowContentRegionMin();                // content boundaries min (roughly (0,0)-Scroll), in window coordinates
 
-    IMGUI_API ImVec2        GetWindowContentRegionMax();                // content boundaries max (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
 
-    IMGUI_API float         GetWindowContentRegionWidth();              //
 
 
+    // Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin).
 
     IMGUI_API void          SetNextWindowPos(const ImVec2& pos, ImGuiCond cond = 0, const ImVec2& pivot = ImVec2(0,0)); // set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
 
     IMGUI_API void          SetNextWindowSize(const ImVec2& size, ImGuiCond cond = 0);                  // set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
 
     IMGUI_API void          SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback = NULL, void* custom_callback_data = NULL); // set next window size limits. use -1,-1 on either X/Y axis to preserve the current size. Use callback to apply non-trivial programmatic constraints.
 
@@ -300,6 +296,15 @@ namespace ImGui
 
     IMGUI_API void          SetWindowCollapsed(const char* name, bool collapsed, ImGuiCond cond = 0);   // set named window collapsed state
 
     IMGUI_API void          SetWindowFocus(const char* name);                                           // set named window to be focused / front-most. use NULL to remove focus.
 
 
+    // Content region
 
+    // - Those functions are bound to be redesigned soon (they are confusing, incomplete and return values in local window coordinates which increases confusion)
 
+    IMGUI_API ImVec2        GetContentRegionMax();                                          // current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
 
+    IMGUI_API ImVec2        GetContentRegionAvail();                                        // == GetContentRegionMax() - GetCursorPos()
 
+    IMGUI_API float         GetContentRegionAvailWidth();                                   // == GetContentRegionAvail().x
 
+    IMGUI_API ImVec2        GetWindowContentRegionMin();                                    // content boundaries min (roughly (0,0)-Scroll), in window coordinates
 
+    IMGUI_API ImVec2        GetWindowContentRegionMax();                                    // content boundaries max (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
 
+    IMGUI_API float         GetWindowContentRegionWidth();                                  //
 
+
 
     // Windows Scrolling
 
     IMGUI_API float         GetScrollX();                                                   // get scrolling amount [0..GetScrollMaxX()]
 
     IMGUI_API float         GetScrollY();                                                   // get scrolling amount [0..GetScrollMaxY()]
 
@@ -328,8 +333,9 @@ namespace ImGui
 
     IMGUI_API ImU32         GetColorU32(ImU32 col);                                         // retrieve given color with style alpha applied
 
 
     // Parameters stacks (current window)
 
-    IMGUI_API void          PushItemWidth(float item_width);                                // width of items for the common item+label case, pixels. 0.0f = default to ~2/3 of windows width, >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side)
 
+    IMGUI_API void          PushItemWidth(float item_width);                                // set width of items for common large "item+label" widgets. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side). 0.0f = default to ~2/3 of windows width, 
     IMGUI_API void          PopItemWidth();
 
+    IMGUI_API void          SetNextItemWidth(float item_width);                             // set width of the _next_ common large "item+label" widget. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side)
 
     IMGUI_API float         CalcItemWidth();                                                // width of item given pushed settings and current cursor position
 
     IMGUI_API void          PushTextWrapPos(float wrap_local_pos_x = 0.0f);                 // word-wrapping for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space
 
     IMGUI_API void          PopTextWrapPos();
 
@@ -342,7 +348,7 @@ namespace ImGui
 
     // - By "cursor" we mean the current output position.
 
     // - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down.
 
     IMGUI_API void          Separator();                                                    // separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.
 
-    IMGUI_API void          SameLine(float local_pos_x = 0.0f, float spacing_w = -1.0f);    // call between widgets or groups to layout them horizontally. X position given in window coordinates.
 
+    IMGUI_API void          SameLine(float offset_from_start_x=0.0f, float spacing=-1.0f);  // call between widgets or groups to layout them horizontally. X position given in window coordinates.
 
     IMGUI_API void          NewLine();                                                      // undo a SameLine() or force a new line when in an horizontal-layout context.
 
     IMGUI_API void          Spacing();                                                      // add vertical spacing.
 
     IMGUI_API void          Dummy(const ImVec2& size);                                      // add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into.
 
@@ -374,7 +380,7 @@ namespace ImGui
 
     //   whereas "str_id" denote a string that is only used as an ID and not normally displayed.
 
     IMGUI_API void          PushID(const char* str_id);                                     // push string into the ID stack (will hash string).
 
     IMGUI_API void          PushID(const char* str_id_begin, const char* str_id_end);       // push string into the ID stack (will hash string).
 
-    IMGUI_API void          PushID(const void* ptr_id);                                     // push pointer into the ID stack (will hash pointer). 
+    IMGUI_API void          PushID(const void* ptr_id);                                     // push pointer into the ID stack (will hash pointer).
 
     IMGUI_API void          PushID(int int_id);                                             // push integer into the ID stack (will hash integer).
 
     IMGUI_API void          PopID();                                                        // pop from the ID stack.
 
     IMGUI_API ImGuiID       GetID(const char* str_id);                                      // calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
 
@@ -475,7 +481,8 @@ namespace ImGui
 
     IMGUI_API bool          InputScalarN(const char* label, ImGuiDataType data_type, void* v, int components, const void* step = NULL, const void* step_fast = NULL, const char* format = NULL, ImGuiInputTextFlags flags = 0);
 
 
     // Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little colored preview square that can be left-clicked to open a picker, and right-clicked to open an option menu.)
 
-    // - Note that in C++ a 'float v[X]' function argument is the _same_ as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can the pass the address of a first float element out of a contiguous structure, e.g. &myvector.x
 
+    // - Note that in C++ a 'float v[X]' function argument is the _same_ as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible.
 
+    // - You can pass the address of a first float element out of a contiguous structure, e.g. &myvector.x
 
     IMGUI_API bool          ColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
 
     IMGUI_API bool          ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags = 0);
 
     IMGUI_API bool          ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
 
@@ -486,7 +493,7 @@ namespace ImGui
 
     // Widgets: Trees
 
     // - TreeNode functions return true when the node is open, in which case you need to also call TreePop() when you are finished displaying the tree node contents.
 
     IMGUI_API bool          TreeNode(const char* label);
 
-    IMGUI_API bool          TreeNode(const char* str_id, const char* fmt, ...) IM_FMTARGS(2);   // helper variation to completely decorelate the id from the displayed string. Read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
 
+    IMGUI_API bool          TreeNode(const char* str_id, const char* fmt, ...) IM_FMTARGS(2);   // helper variation to easily decorelate the id from the displayed string. Read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
 
     IMGUI_API bool          TreeNode(const void* ptr_id, const char* fmt, ...) IM_FMTARGS(2);   // "
 
     IMGUI_API bool          TreeNodeV(const char* str_id, const char* fmt, va_list args) IM_FMTLIST(2);
 
     IMGUI_API bool          TreeNodeV(const void* ptr_id, const char* fmt, va_list args) IM_FMTLIST(2);
 
@@ -544,7 +551,7 @@ namespace ImGui
 
     // Tooltips
 
     IMGUI_API void          BeginTooltip();                                                     // begin/append a tooltip window. to create full-featured tooltip (with any kind of items).
 
     IMGUI_API void          EndTooltip();
 
-    IMGUI_API void          SetTooltip(const char* fmt, ...) IM_FMTARGS(1);                     // set a text-only tooltip, typically use with ImGui::IsItemHovered(). overidde any previous call to SetTooltip().
 
+    IMGUI_API void          SetTooltip(const char* fmt, ...) IM_FMTARGS(1);                     // set a text-only tooltip, typically use with ImGui::IsItemHovered(). override any previous call to SetTooltip().
 
     IMGUI_API void          SetTooltipV(const char* fmt, va_list args) IM_FMTLIST(1);
 
 
     // Popups, Modals
 
@@ -590,10 +597,11 @@ namespace ImGui
 
     // Docking 
     // [BETA API] Enable with io.ConfigFlags |= ImGuiConfigFlags_DockingEnable.
 
     // Note: you DO NOT need to call DockSpace() to use most Docking facilities! 
-    // To dock windows: hold SHIFT anywhere while moving windows (if io.ConfigDockingWithShift == true) or drag windows from their title bar (if io.ConfigDockingWithShift = false)
 
+    // To dock windows: if io.ConfigDockingWithShift == false: drag window from their title bar.
 
+    // To dock windows: if io.ConfigDockingWithShift == true: hold SHIFT anywhere while moving windows.
 
     // Use DockSpace() to create an explicit dock node _within_ an existing window. See Docking demo for details.
 
     IMGUI_API void          DockSpace(ImGuiID id, const ImVec2& size = ImVec2(0, 0), ImGuiDockNodeFlags flags = 0, const ImGuiWindowClass* window_class = NULL);
 
-    IMGUI_API ImGuiID       DockSpaceOverViewport(ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags dockspace_flags = 0, const ImGuiWindowClass* window_class = NULL);
 
+    IMGUI_API ImGuiID       DockSpaceOverViewport(ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, const ImGuiWindowClass* window_class = NULL);
 
     IMGUI_API void          SetNextWindowDockID(ImGuiID dock_id, ImGuiCond cond = 0);           // set next window dock id (FIXME-DOCK)
 
     IMGUI_API void          SetNextWindowClass(const ImGuiWindowClass* window_class);           // set next window class (rare/advanced uses: provide hints to the platform back-end via altered viewport flags and parent/child info)
 
     IMGUI_API ImGuiID       GetWindowDockID();
 
@@ -687,7 +695,7 @@ namespace ImGui
 
     IMGUI_API bool          IsMousePosValid(const ImVec2* mouse_pos = NULL);                    // by convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse
 
     IMGUI_API ImVec2        GetMousePos();                                                      // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
 
     IMGUI_API ImVec2        GetMousePosOnOpeningCurrentPopup();                                 // retrieve backup of mouse position at the time of opening popup we have BeginPopup() into
 
-    IMGUI_API ImVec2        GetMouseDragDelta(int button = 0, float lock_threshold = -1.0f);    // return the delta from the initial clicking position. This is locked and return 0.0f until the mouse moves past a distance threshold at least once. If lock_threshold < -1.0f uses io.MouseDraggingThreshold
 
+    IMGUI_API ImVec2        GetMouseDragDelta(int button = 0, float lock_threshold = -1.0f);    // return the delta from the initial clicking position while the mouse button is pressed or was just released. This is locked and return 0.0f until the mouse moves past a distance threshold at least once. If lock_threshold < -1.0f uses io.MouseDraggingThreshold.
 
     IMGUI_API void          ResetMouseDragDelta(int button = 0);                                //
 
     IMGUI_API ImGuiMouseCursor GetMouseCursor();                                                // get desired cursor type, reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you
 
     IMGUI_API void          SetMouseCursor(ImGuiMouseCursor type);                              // set desired cursor type
 
@@ -703,7 +711,7 @@ namespace ImGui
 
     // - Set io.IniFilename to NULL to load/save manually. Read io.WantSaveIniSettings description about handling .ini saving manually.
 
     IMGUI_API void          LoadIniSettingsFromDisk(const char* ini_filename);                  // call after CreateContext() and before the first call to NewFrame(). NewFrame() automatically calls LoadIniSettingsFromDisk(io.IniFilename).
 
     IMGUI_API void          LoadIniSettingsFromMemory(const char* ini_data, size_t ini_size=0); // call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source.
 
-    IMGUI_API void          SaveIniSettingsToDisk(const char* ini_filename);                    // this is automatically called (if io.IniFilename is not empty) a few seconds after any modification that should be reflected in the .ini file (and also by DestroyContext). 
+    IMGUI_API void          SaveIniSettingsToDisk(const char* ini_filename);                    // this is automatically called (if io.IniFilename is not empty) a few seconds after any modification that should be reflected in the .ini file (and also by DestroyContext).
 
     IMGUI_API const char*   SaveIniSettingsToMemory(size_t* out_ini_size = NULL);               // return a zero-terminated string with the .ini data which you can save by your own mean. call when io.WantSaveIniSettings is set, then save data by your own mean and clear io.WantSaveIniSettings.
 
 
     // Memory Allocators
 
@@ -718,7 +726,7 @@ namespace ImGui
 
     IMGUI_API ImGuiPlatformIO&  GetPlatformIO();                                                // platform/renderer functions, for back-end to setup + viewports list.
 
     IMGUI_API ImGuiViewport*    GetMainViewport();                                              // main viewport. same as GetPlatformIO().MainViewport == GetPlatformIO().Viewports[0].
 
     IMGUI_API void              UpdatePlatformWindows();                                        // call in main loop. will call CreateWindow/ResizeWindow/etc. platform functions for each secondary viewport, and DestroyWindow for each inactive viewport.
 
-    IMGUI_API void              RenderPlatformWindowsDefault(void* platform_arg = NULL, void* renderer_arg = NULL); // call in main loop. will call RenderWindow/SwapBuffers platform functions for each secondary viewport. may be reimplemented by user for custom rendering needs.
 
+    IMGUI_API void              RenderPlatformWindowsDefault(void* platform_arg = NULL, void* renderer_arg = NULL); // call in main loop. will call RenderWindow/SwapBuffers platform functions for each secondary viewport which doesn't have the ImGuiViewportFlags_Minimized flag set. May be reimplemented by user for custom rendering needs.
 
     IMGUI_API void              DestroyPlatformWindows();                                       // call DestroyWindow platform functions for all viewports. call from back-end Shutdown() if you need to close platform windows before imgui shutdown. otherwise will be called by DestroyContext().
 
     IMGUI_API ImGuiViewport*    FindViewportByID(ImGuiID id);                                   // this is a helper for back-ends.
 
     IMGUI_API ImGuiViewport*    FindViewportByPlatformHandle(void* platform_handle);            // this is a helper for back-ends. the type platform_handle is decided by the back-end (e.g. HWND, MyWindow*, GLFWwindow* etc.)
 
@@ -736,7 +744,7 @@ enum ImGuiWindowFlags_
 
     ImGuiWindowFlags_NoTitleBar             = 1 << 0,   // Disable title-bar
 
     ImGuiWindowFlags_NoResize               = 1 << 1,   // Disable user resizing with the lower-right grip
 
     ImGuiWindowFlags_NoMove                 = 1 << 2,   // Disable user moving the window
 
-    ImGuiWindowFlags_NoScrollbar            = 1 << 3,   // Disable scrollbars (window can still scroll with mouse or programatically)
 
+    ImGuiWindowFlags_NoScrollbar            = 1 << 3,   // Disable scrollbars (window can still scroll with mouse or programmatically)
 
     ImGuiWindowFlags_NoScrollWithMouse      = 1 << 4,   // Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set.
 
     ImGuiWindowFlags_NoCollapse             = 1 << 5,   // Disable user collapsing window by double-clicking on it
 
     ImGuiWindowFlags_AlwaysAutoResize       = 1 << 6,   // Resize every window to its content every frame
 
@@ -746,7 +754,7 @@ enum ImGuiWindowFlags_
 
     ImGuiWindowFlags_MenuBar                = 1 << 10,  // Has a menu-bar
 
     ImGuiWindowFlags_HorizontalScrollbar    = 1 << 11,  // Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the "Horizontal Scrolling" section.
 
     ImGuiWindowFlags_NoFocusOnAppearing     = 1 << 12,  // Disable taking focus when transitioning from hidden to visible state
 
-    ImGuiWindowFlags_NoBringToFrontOnFocus  = 1 << 13,  // Disable bringing window to front when taking focus (e.g. clicking on it or programatically giving it focus)
 
+    ImGuiWindowFlags_NoBringToFrontOnFocus  = 1 << 13,  // Disable bringing window to front when taking focus (e.g. clicking on it or programmatically giving it focus)
 
     ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14,  // Always show vertical scrollbar (even if ContentSize.y < Size.y)
 
     ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15,  // Always show horizontal scrollbar (even if ContentSize.x < Size.x)
 
     ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16,  // Ensure child windows without border uses style.WindowPadding (ignored by default for non-bordered child windows, because more convenient)
 
@@ -871,23 +879,23 @@ enum ImGuiTabItemFlags_
 
 {
 
     ImGuiTabItemFlags_None                          = 0,
 
     ImGuiTabItemFlags_UnsavedDocument               = 1 << 0,   // Append '*' to title without affecting the ID, as a convenience to avoid using the ### operator. Also: tab is selected on closure and closure is deferred by one frame to allow code to undo it without flicker.
 
-    ImGuiTabItemFlags_SetSelected                   = 1 << 1,   // Trigger flag to programatically make the tab selected when calling BeginTabItem()
 
+    ImGuiTabItemFlags_SetSelected                   = 1 << 1,   // Trigger flag to programmatically make the tab selected when calling BeginTabItem()
 
     ImGuiTabItemFlags_NoCloseWithMiddleMouseButton  = 1 << 2,   // Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You can still repro this behavior on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
 
     ImGuiTabItemFlags_NoPushId                      = 1 << 3    // Don't call PushID(tab->ID)/PopID() on BeginTabItem()/EndTabItem()
 
 };
 
 
-// Flags for ImGui::DockSpace(), inherited by child nodes.
 
+// Flags for ImGui::DockSpace(), shared/inherited by child nodes.
 
+// (Some flags can be applied to individual nodes directly)
 
 enum ImGuiDockNodeFlags_
 
 {
 
     ImGuiDockNodeFlags_None                         = 0,
 
-    ImGuiDockNodeFlags_KeepAliveOnly                = 1 << 0,   // Don't display the dockspace node but keep it alive. Windows docked into this dockspace node won't be undocked.
 
-    ImGuiDockNodeFlags_NoSplit                      = 1 << 1,   // Disable splitting the node into smaller nodes. Useful e.g. when embedding dockspaces into a main root one (the root one may have splitting disabled to reduce confusion)
 
-    //ImGuiDockNodeFlags_NoCentralNode              = 1 << 2,   // Disable Central Node (the node which can stay empty)
 
-    ImGuiDockNodeFlags_NoDockingInCentralNode       = 1 << 3,   // Disable docking inside the Central Node, which will be always kept empty.
 
-    //ImGuiDockNodeFlags_NoLayoutChanges            = 1 << 4,   // Disable adding/removing nodes interactively. Useful with programatically setup dockspaces.
 
-    ImGuiDockNodeFlags_NoResize                     = 1 << 5,   // Disable resizing child nodes using the splitter/separators. Useful with programatically setup dockspaces. 
-    ImGuiDockNodeFlags_PassthruDockspace            = 1 << 6,   // Enable passthru dockspace: 1) DockSpace() will render a ImGuiCol_WindowBg background covering everything excepted the Central Node when empty. Meaning the host window should probably use SetNextWindowBgAlpha(0.0f) prior to Begin() when using this. 2) When Central Node is empty: let inputs pass-through + won't display a DockingEmptyBg background.
 
-    ImGuiDockNodeFlags_AutoHideTabBar               = 1 << 7    // Tab bar will automatically hide when there is a single window in the dock node.
 
+    ImGuiDockNodeFlags_KeepAliveOnly                = 1 << 0,   // Shared       // Don't display the dockspace node but keep it alive. Windows docked into this dockspace node won't be undocked.
 
+    //ImGuiDockNodeFlags_NoCentralNode              = 1 << 1,   // Shared       // Disable Central Node (the node which can stay empty)
 
+    ImGuiDockNodeFlags_NoDockingInCentralNode       = 1 << 2,   // Shared       // Disable docking inside the Central Node, which will be always kept empty.
 
+    ImGuiDockNodeFlags_PassthruCentralNode          = 1 << 3,   // Shared       // Enable passthru dockspace: 1) DockSpace() will render a ImGuiCol_WindowBg background covering everything excepted the Central Node when empty. Meaning the host window should probably use SetNextWindowBgAlpha(0.0f) prior to Begin() when using this. 2) When Central Node is empty: let inputs pass-through + won't display a DockingEmptyBg background. See demo for details.
 
+    ImGuiDockNodeFlags_NoSplit                      = 1 << 4,   // Shared/Local // Disable splitting the node into smaller nodes. Useful e.g. when embedding dockspaces into a main root one (the root one may have splitting disabled to reduce confusion). Note: when turned off, existing splits will be preserved.
 
+    ImGuiDockNodeFlags_NoResize                     = 1 << 5,   // Shared/Local // Disable resizing child nodes using the splitter/separators. Useful with programatically setup dockspaces. 
+    ImGuiDockNodeFlags_AutoHideTabBar               = 1 << 6    // Shared/Local // Tab bar will automatically hide when there is a single window in the dock node.
 
 };
 
 
 // Flags for ImGui::IsWindowFocused()
 
@@ -1185,8 +1193,7 @@ enum ImGuiColorEditFlags_
 
     ImGuiColorEditFlags_NoSidePreview   = 1 << 8,   //              // ColorPicker: disable bigger color preview on right side of the picker, use small colored square preview instead.
 
     ImGuiColorEditFlags_NoDragDrop      = 1 << 9,   //              // ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source.
 
 
-    // User Options (right-click on widget to change some of them). You can set application defaults using SetColorEditOptions(). 
-    // The intent is that you probably don't want to override them in most of your calls, let the user choose via the option menu and/or call SetColorEditOptions() during startup.
 
+    // User Options (right-click on widget to change some of them).
 
     ImGuiColorEditFlags_AlphaBar        = 1 << 16,  //              // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.
 
     ImGuiColorEditFlags_AlphaPreview    = 1 << 17,  //              // ColorEdit, ColorPicker, ColorButton: display preview as a transparent color over a checkerboard, instead of opaque.
 
     ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 18,  //              // ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard, instead of opaque.
 
@@ -1196,14 +1203,20 @@ enum ImGuiColorEditFlags_
 
     ImGuiColorEditFlags_DisplayHex      = 1 << 22,  // [Display]    // "
 
     ImGuiColorEditFlags_Uint8           = 1 << 23,  // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.
 
     ImGuiColorEditFlags_Float           = 1 << 24,  // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers.
 
-    ImGuiColorEditFlags_PickerHueBar    = 1 << 25,  // [PickerMode] // ColorPicker: bar for Hue, rectangle for Sat/Value.
 
-    ImGuiColorEditFlags_PickerHueWheel  = 1 << 26,  // [PickerMode] // ColorPicker: wheel for Hue, triangle for Sat/Value.
 
+    ImGuiColorEditFlags_PickerHueBar    = 1 << 25,  // [Picker]     // ColorPicker: bar for Hue, rectangle for Sat/Value.
 
+    ImGuiColorEditFlags_PickerHueWheel  = 1 << 26,  // [Picker]     // ColorPicker: wheel for Hue, triangle for Sat/Value.
 
+    ImGuiColorEditFlags_InputRGB        = 1 << 27,  // [Input]      // ColorEdit, ColorPicker: input and output data in RGB format.
 
+    ImGuiColorEditFlags_InputHSV        = 1 << 28,  // [Input]      // ColorEdit, ColorPicker: input and output data in HSV format.
 
+
 
+    // Defaults Options. You can set application defaults using SetColorEditOptions(). The intent is that you probably don't want to
 
+    // override them in most of your calls. Let the user choose via the option menu and/or call SetColorEditOptions() once during startup.
 
+    ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_PickerHueBar,
 
 
     // [Internal] Masks
 
     ImGuiColorEditFlags__DisplayMask    = ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_DisplayHSV|ImGuiColorEditFlags_DisplayHex,
 
     ImGuiColorEditFlags__DataTypeMask   = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float,
 
     ImGuiColorEditFlags__PickerMask     = ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar,
 
-    ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_PickerHueBar    // Change application default using SetColorEditOptions()
 
+    ImGuiColorEditFlags__InputMask      = ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_InputHSV
 
 
     // Obsolete names (will be removed)
 
 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
 
@@ -1248,6 +1261,22 @@ enum ImGuiCond_
 
 #endif
 
 };
 
 
+//-----------------------------------------------------------------------------
 
+// Helpers: Memory allocations macros
 
+// IM_MALLOC(), IM_FREE(), IM_NEW(), IM_PLACEMENT_NEW(), IM_DELETE()
 
+// We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.
 
+// Defining a custom placement new() with a dummy parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions.
 
+//-----------------------------------------------------------------------------
 
+
 
+struct ImNewDummy {};
 
+inline void* operator new(size_t, ImNewDummy, void* ptr) { return ptr; }
 
+inline void  operator delete(void*, ImNewDummy, void*)   {} // This is only required so we can use the symmetrical new()
 
+#define IM_ALLOC(_SIZE)                     ImGui::MemAlloc(_SIZE)
 
+#define IM_FREE(_PTR)                       ImGui::MemFree(_PTR)
 
+#define IM_PLACEMENT_NEW(_PTR)              new(ImNewDummy(), _PTR)
 
+#define IM_NEW(_TYPE)                       new(ImNewDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
 
+template<typename T> void IM_DELETE(T* p)   { if (p) { p->~T(); ImGui::MemFree(p); } }
 
+
 
 //-----------------------------------------------------------------------------
 
 // Helper: ImVector<>
 
 // Lightweight std::vector<>-like class to avoid dragging dependencies (also, some implementations of STL with debug enabled are absurdly slow, we bypass it so our code runs fast in debug).
 
@@ -1273,7 +1302,7 @@ struct ImVector
 
     inline ImVector()                                       { Size = Capacity = 0; Data = NULL; }
 
     inline ImVector(const ImVector<T>& src)                 { Size = Capacity = 0; Data = NULL; operator=(src); }
 
     inline ImVector<T>& operator=(const ImVector<T>& src)   { clear(); resize(src.Size); memcpy(Data, src.Data, (size_t)Size * sizeof(T)); return *this; }
 
-    inline ~ImVector()                                      { if (Data) ImGui::MemFree(Data); }
 
+    inline ~ImVector()                                      { if (Data) IM_FREE(Data); }
 
 
     inline bool         empty() const                       { return Size == 0; }
 
     inline int          size() const                        { return Size; }
 
@@ -1282,7 +1311,7 @@ struct ImVector
 
     inline T&           operator[](int i)                   { IM_ASSERT(i < Size); return Data[i]; }
 
     inline const T&     operator[](int i) const             { IM_ASSERT(i < Size); return Data[i]; }
 
 
-    inline void         clear()                             { if (Data) { Size = Capacity = 0; ImGui::MemFree(Data); Data = NULL; } }
 
+    inline void         clear()                             { if (Data) { Size = Capacity = 0; IM_FREE(Data); Data = NULL; } }
 
     inline T*           begin()                             { return Data; }
 
     inline const T*     begin() const                       { return Data; }
 
     inline T*           end()                               { return Data + Size; }
 
@@ -1296,7 +1325,7 @@ struct ImVector
 
     inline int          _grow_capacity(int sz) const        { int new_capacity = Capacity ? (Capacity + Capacity/2) : 8; return new_capacity > sz ? new_capacity : sz; }
 
     inline void         resize(int new_size)                { if (new_size > Capacity) reserve(_grow_capacity(new_size)); Size = new_size; }
 
     inline void         resize(int new_size, const T& v)    { if (new_size > Capacity) reserve(_grow_capacity(new_size)); if (new_size > Size) for (int n = Size; n < new_size; n++) memcpy(&Data[n], &v, sizeof(v)); Size = new_size; }
 
-    inline void         reserve(int new_capacity)           { if (new_capacity <= Capacity) return; T* new_data = (T*)ImGui::MemAlloc((size_t)new_capacity * sizeof(T)); if (Data) { memcpy(new_data, Data, (size_t)Size * sizeof(T)); ImGui::MemFree(Data); } Data = new_data; Capacity = new_capacity; }
 
+    inline void         reserve(int new_capacity)           { if (new_capacity <= Capacity) return; T* new_data = (T*)IM_ALLOC((size_t)new_capacity * sizeof(T)); if (Data) { memcpy(new_data, Data, (size_t)Size * sizeof(T)); IM_FREE(Data); } Data = new_data; Capacity = new_capacity; }
 
 
     // NB: It is illegal to call push_back/push_front/insert with a reference pointing inside the ImVector data itself! e.g. v.push_back(v[10]) is forbidden.
 
     inline void         push_back(const T& v)               { if (Size == Capacity) reserve(_grow_capacity(Size + 1)); memcpy(&Data[Size], &v, sizeof(v)); Size++; }
 
@@ -1400,13 +1429,13 @@ struct ImGuiIO
 
     bool        ConfigViewportsNoAutoMerge;     // = false;         // Set to make all floating imgui windows always create their own viewport. Otherwise, they are merged into the main host viewports when overlapping it.
 
     bool        ConfigViewportsNoTaskBarIcon;   // = false          // Disable default OS task bar icon flag for secondary viewports. When a viewport doesn't want a task bar icon, ImGuiViewportFlags_NoTaskBarIcon will be set on it.
 
     bool        ConfigViewportsNoDecoration;    // = true           // [BETA] Disable default OS window decoration flag for secondary viewports. When a viewport doesn't want window decorations, ImGuiViewportFlags_NoDecoration will be set on it. Enabling decoration can create subsequent issues at OS levels (e.g. minimum window size).
 
-    bool        ConfigViewportsNoParent;        // = false          // Disable default OS parenting to main viewport for secondary viewports. By default, viewports are marked with ParentViewportId = <main_viewport>, expecting the platform back-end to setup a parent/child relationship between the OS windows (some back-end may ignore this). Set to true if you want the default to be 0, then all viewports will be top-level OS windows.
 
+    bool        ConfigViewportsNoDefaultParent; // = false          // Disable default OS parenting to main viewport for secondary viewports. By default, viewports are marked with ParentViewportId = <main_viewport>, expecting the platform back-end to setup a parent/child relationship between the OS windows (some back-end may ignore this). Set to true if you want the default to be 0, then all viewports will be top-level OS windows.
 
 
     // Miscellaneous options
 
     bool        MouseDrawCursor;                // = false          // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor). Cannot be easily renamed to 'io.ConfigXXX' because this is frequently used by back-end implementations.
 
     bool        ConfigMacOSXBehaviors;          // = defined(__APPLE__) // OS X style: Text editing cursor movement using Alt instead of Ctrl, Shortcuts using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows instead of Home/End, Double click selects by word instead of selecting whole text, Multi-selection in lists uses Cmd/Super instead of Ctrl (was called io.OptMacOSXBehaviors prior to 1.63)
 
     bool        ConfigInputTextCursorBlink;     // = true           // Set to false to disable blinking cursor, for users who consider it distracting. (was called: io.OptCursorBlink prior to 1.63)
 
-    bool        ConfigWindowsResizeFromEdges;   // = true           // Enable resizing of windows from their edges and from the lower-left corner. This requires (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors) because it needs mouse cursor feedback. (This used to be the a per-window ImGuiWindowFlags_ResizeFromAnySide flag)
 
+    bool        ConfigWindowsResizeFromEdges;   // = true           // Enable resizing of windows from their edges and from the lower-left corner. This requires (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors) because it needs mouse cursor feedback. (This used to be a per-window ImGuiWindowFlags_ResizeFromAnySide flag)
 
     bool        ConfigWindowsMoveFromTitleBarOnly; // = false       // [BETA] Set to true to only allow moving windows when clicked+dragged from the title bar. Windows without a title bar are not affected.
 
 
     //------------------------------------------------------------------
 
@@ -1632,16 +1661,6 @@ typedef ImGuiInputTextCallbackData  ImGuiTextEditCallbackData;
 
 // Helpers
 
 //-----------------------------------------------------------------------------
 
 
-// Helper: IM_NEW(), IM_PLACEMENT_NEW(), IM_DELETE() macros to call MemAlloc + Placement New, Placement Delete + MemFree
 
-// We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.
 
-// Defining a custom placement new() with a dummy parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions.
 
-struct ImNewDummy {};
 
-inline void* operator new(size_t, ImNewDummy, void* ptr) { return ptr; }
 
-inline void  operator delete(void*, ImNewDummy, void*)   {} // This is only required so we can use the symetrical new()
 
-#define IM_PLACEMENT_NEW(_PTR)              new(ImNewDummy(), _PTR)
 
-#define IM_NEW(_TYPE)                       new(ImNewDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
 
-template<typename T> void IM_DELETE(T* p)   { if (p) { p->~T(); ImGui::MemFree(p); } }
 
-
 
 // Helper: Execute a block of code at maximum once a frame. Convenient if you want to quickly create an UI within deep-nested code that runs multiple times every frame.
 
 // Usage: static ImGuiOnceUponAFrame oaf; if (oaf) ImGui::Text("This will be called only once per frame");
 
 struct ImGuiOnceUponAFrame
 
@@ -1803,7 +1822,7 @@ struct ImGuiListClipper
 
 #define IM_COL32_BLACK       IM_COL32(0,0,0,255)        // Opaque black
 
 #define IM_COL32_BLACK_TRANS IM_COL32(0,0,0,0)          // Transparent black = 0x00000000
 
 
-// Helper: ImColor() implicity converts colors to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)
 
+// Helper: ImColor() implicitly converts colors to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)
 
 // Prefer using IM_COL32() macros if you want a guaranteed compile-time ImU32 for usage with ImDrawList API.
 
 // **Avoid storing ImColor! Store either u32 of ImVec4. This is not a full-featured color class. MAY OBSOLETE.
 
 // **None of the ImGui API are using ImColor directly but you can use it as a convenience to pass colors in either ImU32 or ImVec4 formats. Explicitly cast to ImU32 or ImVec4 if needed.
 
@@ -1937,8 +1956,8 @@ struct ImDrawList
 
 
     // Primitives
 
     IMGUI_API void  AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness = 1.0f);
 
-    IMGUI_API void  AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All, float thickness = 1.0f);   // a: upper-left, b: lower-right, rounding_corners_flags: 4-bits corresponding to which corner to round
 
-    IMGUI_API void  AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All);                     // a: upper-left, b: lower-right
 
+    IMGUI_API void  AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All, float thickness = 1.0f);   // a: upper-left, b: lower-right (== upper-left + size), rounding_corners_flags: 4-bits corresponding to which corner to round
 
+    IMGUI_API void  AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All);                     // a: upper-left, b: lower-right (== upper-left + size)
 
     IMGUI_API void  AddRectFilledMultiColor(const ImVec2& a, const ImVec2& b, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left);
 
     IMGUI_API void  AddQuad(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col, float thickness = 1.0f);
 
     IMGUI_API void  AddQuadFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col);
 
@@ -1948,11 +1967,11 @@ struct ImDrawList
 
     IMGUI_API void  AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
 
     IMGUI_API void  AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL);
 
     IMGUI_API void  AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec4* cpu_fine_clip_rect = NULL);
 
-    IMGUI_API void  AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,1), ImU32 col = 0xFFFFFFFF);
 
-    IMGUI_API void  AddImageQuad(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,0), const ImVec2& uv_c = ImVec2(1,1), const ImVec2& uv_d = ImVec2(0,1), ImU32 col = 0xFFFFFFFF);
 
+    IMGUI_API void  AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,1), ImU32 col = IM_COL32_WHITE);
 
+    IMGUI_API void  AddImageQuad(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,0), const ImVec2& uv_c = ImVec2(1,1), const ImVec2& uv_d = ImVec2(0,1), ImU32 col = IM_COL32_WHITE);
 
     IMGUI_API void  AddImageRounded(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col, float rounding, int rounding_corners = ImDrawCornerFlags_All);
 
-    IMGUI_API void  AddPolyline(const ImVec2* points, const int num_points, ImU32 col, bool closed, float thickness);
 
-    IMGUI_API void  AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col); // Note: Anti-aliased filling requires points to be in clockwise order.
 
+    IMGUI_API void  AddPolyline(const ImVec2* points, int num_points, ImU32 col, bool closed, float thickness);
 
+    IMGUI_API void  AddConvexPolyFilled(const ImVec2* points, int num_points, ImU32 col); // Note: Anti-aliased filling requires points to be in clockwise order.
 
     IMGUI_API void  AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments = 0);
 
 
     // Stateful path API, add points then finish with PathFillConvex() or PathStroke()
 
@@ -2005,11 +2024,12 @@ struct ImDrawData
 
     ImVec2          DisplayPos;             // Upper-left position of the viewport to render (== upper-left of the orthogonal projection matrix to use)
 
     ImVec2          DisplaySize;            // Size of the viewport to render (== io.DisplaySize for the main viewport) (DisplayPos + DisplaySize == lower-right of the orthogonal projection matrix to use)
 
     ImVec2          FramebufferScale;       // Amount of pixels for each unit of DisplaySize. Based on io.DisplayFramebufferScale. Generally (1,1) on normal display, (2,2) on OSX with Retina display.
 
+    ImGuiViewport*  OwnerViewport;          // Viewport carrying the ImDrawData instance, might be of use to the renderer (generally not).
 
 
     // Functions
 
     ImDrawData()    { Valid = false; Clear(); }
 
     ~ImDrawData()   { Clear(); }
 
-    void Clear()    { Valid = false; CmdLists = NULL; CmdListsCount = TotalVtxCount = TotalIdxCount = 0; DisplayPos = DisplaySize = FramebufferScale = ImVec2(0.f, 0.f); } // The ImDrawList are owned by ImGuiContext!
 
+    void Clear()    { Valid = false; CmdLists = NULL; CmdListsCount = TotalVtxCount = TotalIdxCount = 0; DisplayPos = DisplaySize = FramebufferScale = ImVec2(0.f, 0.f); OwnerViewport = NULL; } // The ImDrawList are owned by ImGuiContext!
 
     IMGUI_API void  DeIndexAllBuffers();                    // Helper to convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
 
     IMGUI_API void  ScaleClipRects(const ImVec2& fb_scale); // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
 
 };
 
@@ -2026,7 +2046,7 @@ struct ImFontConfig
 
     int             FontNo;                 // 0        // Index of font within TTF/OTF file
 
     float           SizePixels;             //          // Size in pixels for rasterizer (more or less maps to the resulting font height).
 
     int             OversampleH;            // 3        // Rasterize at higher quality for sub-pixel positioning. Read https://github.com/nothings/stb/blob/master/tests/oversample/README.md for details.
 
-    int             OversampleV;            // 1        // Rasterize at higher quality for sub-pixel positioning. We don't use sub-pixel positions on the Y axis. 
+    int             OversampleV;            // 1        // Rasterize at higher quality for sub-pixel positioning. We don't use sub-pixel positions on the Y axis.
 
     bool            PixelSnapH;             // false    // Align every glyph to pixel boundary. Useful e.g. if you are merging a non-pixel aligned font with the default font. If enabled, you can set OversampleH/V to 1.
 
     ImVec2          GlyphExtraSpacing;      // 0, 0     // Extra spacing (in pixels) between glyphs. Only X axis is supported for now.
 
     ImVec2          GlyphOffset;            // 0, 0     // Offset all glyphs from this font input.
 
@@ -2131,6 +2151,7 @@ struct ImFontAtlas
 
     IMGUI_API const ImWchar*    GetGlyphRangesChineseSimplifiedCommon();// Default + Half-Width + Japanese Hiragana/Katakana + set of 2500 CJK Unified Ideographs for common simplified Chinese
 
     IMGUI_API const ImWchar*    GetGlyphRangesCyrillic();               // Default + about 400 Cyrillic characters
 
     IMGUI_API const ImWchar*    GetGlyphRangesThai();                   // Default + Thai characters
 
+    IMGUI_API const ImWchar*    GetGlyphRangesVietnamese();             // Default + Vietname characters
 
 
     //-------------------------------------------
 
     // Custom Rectangles/Glyphs API
 
@@ -2326,7 +2347,8 @@ enum ImGuiViewportFlags_
 
     ImGuiViewportFlags_NoFocusOnClick           = 1 << 3,   // Platform Window: Don't take focus when clicked on.
 
     ImGuiViewportFlags_NoInputs                 = 1 << 4,   // Platform Window: Make mouse pass through so we can drag this window while peaking behind it.
 
     ImGuiViewportFlags_NoRendererClear          = 1 << 5,   // Platform Window: Renderer doesn't need to clear the framebuffer ahead (because we will fill it entirely).
 
-    ImGuiViewportFlags_TopMost                  = 1 << 6    // Platform Window: Display on top (for tooltips only)
 
+    ImGuiViewportFlags_TopMost                  = 1 << 6,   // Platform Window: Display on top (for tooltips only)
 
+    ImGuiViewportFlags_Minimized                = 1 << 7    // Platform Window: Window is minimized, can skip render. When minimized we tend to avoid using the viewport pos/size for clipping window or testing if they are contained in the viewport.
 
 };
 
 
 // The viewports created and managed by imgui. The role of the platform back-end is to create the platform/OS windows corresponding to each viewport.

+ 219 - 146
3rdparty/ocornut-imgui/imgui_demo.cpp
View File 

@@ -1,4 +1,4 @@
 
-// dear imgui, v1.69 WIP
 
+// dear imgui, v1.70 WIP
 
 // (demo code)
 
 
 // Message to the person tempted to delete this file when integrating Dear ImGui into their code base:
 
@@ -50,7 +50,7 @@ Index of this file:
 
 #endif
 
 
 #include "imgui.h"
 
-#include <ctype.h>          // toupper, isprint
 
+#include <ctype.h>          // toupper
 
 #include <limits.h>         // INT_MIN, INT_MAX
 
 #include <math.h>           // sqrtf, powf, cosf, sinf, floorf, ceilf
 
 #include <stdio.h>          // vsnprintf, sscanf, printf
 
@@ -128,6 +128,7 @@ static void ShowExampleAppCustomRendering(bool* p_open);
 
 static void ShowExampleMenuFile();
 
 
 // Helper to display a little (?) mark which shows a tooltip when hovered.
 
+// In your own code you may want to display an actual icon if you are using a merged icon fonts (see misc/fonts/README.txt)
 
 static void HelpMarker(const char* desc)
 
 {
 
     ImGui::TextDisabled("(?)");
 
@@ -154,12 +155,13 @@ static void ShowDockingDisabledMessage()
 
 // Helper to display basic user controls.
 
 void ImGui::ShowUserGuide()
 
 {
 
+    ImGuiIO& io = ImGui::GetIO();
 
     ImGui::BulletText("Double-click on title bar to collapse window.");
 
     ImGui::BulletText("Click and drag on lower right corner to resize window\n(double-click to auto fit window to its contents).");
 
     ImGui::BulletText("Click and drag on any empty space to move window.");
 
     ImGui::BulletText("TAB/SHIFT+TAB to cycle through keyboard editable fields.");
 
     ImGui::BulletText("CTRL+Click on a slider or drag box to input value as text.");
 
-    if (ImGui::GetIO().FontAllowUserScaling)
 
+    if (io.FontAllowUserScaling)
 
         ImGui::BulletText("CTRL+Mouse Wheel to zoom window contents.");
 
     ImGui::BulletText("Mouse Wheel to scroll.");
 
     ImGui::BulletText("While editing text:\n");
 
@@ -189,6 +191,8 @@ static void ShowDemoWindowMisc();
 
 // You may execute this function to experiment with the UI and understand what it does. You may then search for keywords in the code when you are interested by a specific feature.
 
 void ImGui::ShowDemoWindow(bool* p_open)
 
 {
 
+    IM_ASSERT(ImGui::GetCurrentContext() != NULL && "Missing dear imgui context. Refer to examples app!"); // Exceptionally add an extra assert here for people confused with initial dear imgui setup
 
+
 
     // Examples Apps (accessible from the "Examples" menu)
 
     static bool show_app_dockspace = false;
 
     static bool show_app_documents = false;
 
@@ -265,13 +269,12 @@ void ImGui::ShowDemoWindow(bool* p_open)
 
         ImGui::End();
 
         return;
 
     }
 
-    ImGui::Text("dear imgui says hello. (%s)", IMGUI_VERSION);
 
 
     // Most "big" widgets share a common width settings by default.
 
     //ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.65f);    // Use 2/3 of the space for widgets and 1/3 for labels (default)
 
     ImGui::PushItemWidth(ImGui::GetFontSize() * -12);           // Use fixed width for labels (by passing a negative value), the rest goes to widgets. We choose a width proportional to our font size.
 
 
-    // Menu
 
+    // Menu Bar
 
     if (ImGui::BeginMenuBar())
 
     {
 
         if (ImGui::BeginMenu("Menu"))
 
@@ -306,7 +309,9 @@ void ImGui::ShowDemoWindow(bool* p_open)
 
         ImGui::EndMenuBar();
 
     }
 
 
+    ImGui::Text("dear imgui says hello. (%s)", IMGUI_VERSION);
 
     ImGui::Spacing();
 
+
 
     if (ImGui::CollapsingHeader("Help"))
 
     {
 
         ImGui::Text("PROGRAMMER GUIDE:");
 
@@ -373,7 +378,7 @@ void ImGui::ShowDemoWindow(bool* p_open)
 
                 ImGui::SameLine(); HelpMarker("Toggling this at runtime is normally unsupported (most platform back-ends won't refresh the task bar icon state right away).");
 
                 ImGui::Checkbox("io.ConfigViewportsNoDecoration", &io.ConfigViewportsNoDecoration);
 
                 ImGui::SameLine(); HelpMarker("Toggling this at runtime is normally unsupported (most platform back-ends won't refresh the decoration right away).");
 
-                ImGui::Checkbox("io.ConfigViewportsNoParent", &io.ConfigViewportsNoParent);
 
+                ImGui::Checkbox("io.ConfigViewportsNoDefaultParent", &io.ConfigViewportsNoDefaultParent);
 
                 ImGui::SameLine(); HelpMarker("Toggling this at runtime is normally unsupported (most platform back-ends won't refresh the parenting right away).");
 
                 ImGui::Unindent();
 
             }
 
@@ -392,7 +397,7 @@ void ImGui::ShowDemoWindow(bool* p_open)
 
         if (ImGui::TreeNode("Backend Flags"))
 
         {
 
             HelpMarker("Those flags are set by the back-ends (imgui_impl_xxx files) to specify their capabilities.");
 
-            ImGuiBackendFlags backend_flags = io.BackendFlags; // Make a local copy to avoid modifying the back-end flags.
 
+            ImGuiBackendFlags backend_flags = io.BackendFlags; // Make a local copy to avoid modifying actual back-end flags.
 
             ImGui::CheckboxFlags("io.BackendFlags: HasGamepad", (unsigned int *)&backend_flags, ImGuiBackendFlags_HasGamepad);
 
             ImGui::CheckboxFlags("io.BackendFlags: HasMouseCursors", (unsigned int *)&backend_flags, ImGuiBackendFlags_HasMouseCursors);
 
             ImGui::CheckboxFlags("io.BackendFlags: HasSetMousePos", (unsigned int *)&backend_flags, ImGuiBackendFlags_HasSetMousePos);
 
@@ -600,9 +605,8 @@ static void ShowDemoWindowWidgets()
 
             ImGui::ListBox("listbox\n(single select)", &listbox_item_current, listbox_items, IM_ARRAYSIZE(listbox_items), 4);
 
 
             //static int listbox_item_current2 = 2;
 
-            //ImGui::PushItemWidth(-1);
 
+            //ImGui::SetNextItemWidth(-1);
 
             //ImGui::ListBox("##listbox2", &listbox_item_current2, listbox_items, IM_ARRAYSIZE(listbox_items), 4);
 
-            //ImGui::PopItemWidth();
 
         }
 
 
         ImGui::TreePop();
 
@@ -631,7 +635,7 @@ static void ShowDemoWindowWidgets()
 
 
         if (ImGui::TreeNode("Advanced, with Selectable nodes"))
 
         {
 
-            HelpMarker("This is a more standard looking tree with selectable nodes.\nClick to select, CTRL+Click to toggle, click on arrows or double-click to open.");
 
+            HelpMarker("This is a more typical looking tree with selectable nodes.\nClick to select, CTRL+Click to toggle, click on arrows or double-click to open.");
 
             static bool align_label_with_current_x_position = false;
 
             ImGui::Checkbox("Align label with current X position)", &align_label_with_current_x_position);
 
             ImGui::Text("Hello!");
 
@@ -644,10 +648,12 @@ static void ShowDemoWindowWidgets()
 
             for (int i = 0; i < 6; i++)
 
             {
 
                 // Disable the default open on single-click behavior and pass in Selected flag according to our selection state.
 
-                ImGuiTreeNodeFlags node_flags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick | ((selection_mask & (1 << i)) ? ImGuiTreeNodeFlags_Selected : 0);
 
+                ImGuiTreeNodeFlags node_flags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick;
 
+                if (selection_mask & (1 << i))
 
+                    node_flags |= ImGuiTreeNodeFlags_Selected;
 
                 if (i < 3)
 
                 {
 
-                    // Node
 
+                    // Items 0..2 are Tree Node
 
                     bool node_open = ImGui::TreeNodeEx((void*)(intptr_t)i, node_flags, "Selectable Node %d", i);
 
                     if (ImGui::IsItemClicked())
 
                         node_clicked = i;
 
@@ -659,7 +665,9 @@ static void ShowDemoWindowWidgets()
 
                 }
 
                 else
 
                 {
 
-                    // Leaf: The only reason we have a TreeNode at all is to allow selection of the leaf. Otherwise we can use BulletText() or TreeAdvanceToLabelPos()+Text().
 
+                    // Items 3..5 are Tree Leaves
 
+                    // The only reason we use TreeNode at all is to allow selection of the leaf.
 
+                    // Otherwise we can use BulletText() or TreeAdvanceToLabelPos()+Text().
 
                     node_flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen; // ImGuiTreeNodeFlags_Bullet
 
                     ImGui::TreeNodeEx((void*)(intptr_t)i, node_flags, "Selectable Leaf %d", i);
 
                     if (ImGui::IsItemClicked())
 
@@ -685,7 +693,7 @@ static void ShowDemoWindowWidgets()
 
     if (ImGui::TreeNode("Collapsing Headers"))
 
     {
 
         static bool closable_group = true;
 
-        ImGui::Checkbox("Enable extra group", &closable_group);
 
+        ImGui::Checkbox("Show 2nd header", &closable_group);
 
         if (ImGui::CollapsingHeader("Header"))
 
         {
 
             ImGui::Text("IsItemHovered: %d", ImGui::IsItemHovered());
 
@@ -789,7 +797,7 @@ static void ShowDemoWindowWidgets()
 
 
         ImGui::Text("%.0fx%.0f", my_tex_w, my_tex_h);
 
         ImVec2 pos = ImGui::GetCursorScreenPos();
 
-        ImGui::Image(my_tex_id, ImVec2(my_tex_w, my_tex_h), ImVec2(0,0), ImVec2(1,1), ImColor(255,255,255,255), ImColor(255,255,255,128));
 
+        ImGui::Image(my_tex_id, ImVec2(my_tex_w, my_tex_h), ImVec2(0,0), ImVec2(1,1), ImVec4(1.0f,1.0f,1.0f,1.0f), ImVec4(1.0f,1.0f,1.0f,0.5f));
 
         if (ImGui::IsItemHovered())
 
         {
 
             ImGui::BeginTooltip();
 
@@ -801,7 +809,7 @@ static void ShowDemoWindowWidgets()
 
             ImGui::Text("Max: (%.2f, %.2f)", region_x + region_sz, region_y + region_sz);
 
             ImVec2 uv0 = ImVec2((region_x) / my_tex_w, (region_y) / my_tex_h);
 
             ImVec2 uv1 = ImVec2((region_x + region_sz) / my_tex_w, (region_y + region_sz) / my_tex_h);
 
-            ImGui::Image(my_tex_id, ImVec2(region_sz * zoom, region_sz * zoom), uv0, uv1, ImColor(255,255,255,255), ImColor(255,255,255,128));
 
+            ImGui::Image(my_tex_id, ImVec2(region_sz * zoom, region_sz * zoom), uv0, uv1, ImVec4(1.0f, 1.0f, 1.0f, 1.0f), ImVec4(1.0f, 1.0f, 1.0f, 0.5f));
 
             ImGui::EndTooltip();
 
         }
 
         ImGui::TextWrapped("And now some textured buttons..");
 
@@ -810,7 +818,7 @@ static void ShowDemoWindowWidgets()
 
         {
 
             ImGui::PushID(i);
 
             int frame_padding = -1 + i;     // -1 = uses default padding
 
-            if (ImGui::ImageButton(my_tex_id, ImVec2(32,32), ImVec2(0,0), ImVec2(32.0f/my_tex_w,32/my_tex_h), frame_padding, ImColor(0,0,0,255)))
 
+            if (ImGui::ImageButton(my_tex_id, ImVec2(32,32), ImVec2(0,0), ImVec2(32.0f/my_tex_w,32/my_tex_h), frame_padding, ImVec4(0.0f,0.0f,0.0f,1.0f)))
 
                 pressed_count += 1;
 
             ImGui::PopID();
 
             ImGui::SameLine();
 
@@ -976,48 +984,90 @@ static void ShowDemoWindowWidgets()
 
         ImGui::TreePop();
 
     }
 
 
-    if (ImGui::TreeNode("Filtered Text Input"))
 
+    if (ImGui::TreeNode("Text Input"))
 
     {
 
-        static char buf1[64] = ""; ImGui::InputText("default", buf1, 64);
 
-        static char buf2[64] = ""; ImGui::InputText("decimal", buf2, 64, ImGuiInputTextFlags_CharsDecimal);
 
-        static char buf3[64] = ""; ImGui::InputText("hexadecimal", buf3, 64, ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase);
 
-        static char buf4[64] = ""; ImGui::InputText("uppercase", buf4, 64, ImGuiInputTextFlags_CharsUppercase);
 
-        static char buf5[64] = ""; ImGui::InputText("no blank", buf5, 64, ImGuiInputTextFlags_CharsNoBlank);
 
-        struct TextFilters { static int FilterImGuiLetters(ImGuiInputTextCallbackData* data) { if (data->EventChar < 256 && strchr("imgui", (char)data->EventChar)) return 0; return 1; } };
 
-        static char buf6[64] = ""; ImGui::InputText("\"imgui\" letters", buf6, 64, ImGuiInputTextFlags_CallbackCharFilter, TextFilters::FilterImGuiLetters);
 
-
 
-        ImGui::Text("Password input");
 
-        static char bufpass[64] = "password123";
 
-        ImGui::InputText("password", bufpass, 64, ImGuiInputTextFlags_Password | ImGuiInputTextFlags_CharsNoBlank);
 
-        ImGui::SameLine(); HelpMarker("Display all characters as '*'.\nDisable clipboard cut and copy.\nDisable logging.\n");
 
-        ImGui::InputTextWithHint("password (w/ hint)", "<password>", bufpass, 64, ImGuiInputTextFlags_Password | ImGuiInputTextFlags_CharsNoBlank);
 
-        ImGui::InputText("password (clear)", bufpass, 64, ImGuiInputTextFlags_CharsNoBlank);
 
+        if (ImGui::TreeNode("Multi-line Text Input"))
 
+        {
 
+            // Note: we are using a fixed-sized buffer for simplicity here. See ImGuiInputTextFlags_CallbackResize
 
+            // and the code in misc/cpp/imgui_stdlib.h for how to setup InputText() for dynamically resizing strings.
 
+            static char text[1024 * 16] =
 
+                "/*\n"
 
+                " The Pentium F00F bug, shorthand for F0 0F C7 C8,\n"
 
+                " the hexadecimal encoding of one offending instruction,\n"
 
+                " more formally, the invalid operand with locked CMPXCHG8B\n"
 
+                " instruction bug, is a design flaw in the majority of\n"
 
+                " Intel Pentium, Pentium MMX, and Pentium OverDrive\n"
 
+                " processors (all in the P5 microarchitecture).\n"
 
+                "*/\n\n"
 
+                "label:\n"
 
+                "\tlock cmpxchg8b eax\n";
 
+
 
+            static ImGuiInputTextFlags flags = ImGuiInputTextFlags_AllowTabInput;
 
+            HelpMarker("You can use the ImGuiInputTextFlags_CallbackResize facility if you need to wire InputTextMultiline() to a dynamic string type. See misc/cpp/imgui_stdlib.h for an example. (This is not demonstrated in imgui_demo.cpp)");
 
+            ImGui::CheckboxFlags("ImGuiInputTextFlags_ReadOnly", (unsigned int*)&flags, ImGuiInputTextFlags_ReadOnly);
 
+            ImGui::CheckboxFlags("ImGuiInputTextFlags_AllowTabInput", (unsigned int*)&flags, ImGuiInputTextFlags_AllowTabInput);
 
+            ImGui::CheckboxFlags("ImGuiInputTextFlags_CtrlEnterForNewLine", (unsigned int*)&flags, ImGuiInputTextFlags_CtrlEnterForNewLine);
 
+            ImGui::InputTextMultiline("##source", text, IM_ARRAYSIZE(text), ImVec2(-1.0f, ImGui::GetTextLineHeight() * 16), flags);
 
+            ImGui::TreePop();
 
+        }
 
 
-        ImGui::TreePop();
 
-    }
 
+        if (ImGui::TreeNode("Filtered Text Input"))
 
+        {
 
+            static char buf1[64] = ""; ImGui::InputText("default", buf1, 64);
 
+            static char buf2[64] = ""; ImGui::InputText("decimal", buf2, 64, ImGuiInputTextFlags_CharsDecimal);
 
+            static char buf3[64] = ""; ImGui::InputText("hexadecimal", buf3, 64, ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase);
 
+            static char buf4[64] = ""; ImGui::InputText("uppercase", buf4, 64, ImGuiInputTextFlags_CharsUppercase);
 
+            static char buf5[64] = ""; ImGui::InputText("no blank", buf5, 64, ImGuiInputTextFlags_CharsNoBlank);
 
+            struct TextFilters { static int FilterImGuiLetters(ImGuiInputTextCallbackData* data) { if (data->EventChar < 256 && strchr("imgui", (char)data->EventChar)) return 0; return 1; } };
 
+            static char buf6[64] = ""; ImGui::InputText("\"imgui\" letters", buf6, 64, ImGuiInputTextFlags_CallbackCharFilter, TextFilters::FilterImGuiLetters);
 
+
 
+            ImGui::Text("Password input");
 
+            static char bufpass[64] = "password123";
 
+            ImGui::InputText("password", bufpass, 64, ImGuiInputTextFlags_Password | ImGuiInputTextFlags_CharsNoBlank);
 
+            ImGui::SameLine(); HelpMarker("Display all characters as '*'.\nDisable clipboard cut and copy.\nDisable logging.\n");
 
+            ImGui::InputTextWithHint("password (w/ hint)", "<password>", bufpass, 64, ImGuiInputTextFlags_Password | ImGuiInputTextFlags_CharsNoBlank);
 
+            ImGui::InputText("password (clear)", bufpass, 64, ImGuiInputTextFlags_CharsNoBlank);
 
+            ImGui::TreePop();
 
+        }
 
+
 
+        if (ImGui::TreeNode("Resize Callback"))
 
+        {
 
+            // If you have a custom string type you would typically create a ImGui::InputText() wrapper than takes your type as input.
 
+            // See misc/cpp/imgui_stdlib.h and .cpp for an implementation of this using std::string.
 
+            HelpMarker("Demonstrate using ImGuiInputTextFlags_CallbackResize to wire your resizable string type to InputText().\n\nSee misc/cpp/imgui_stdlib.h for an implementation of this for std::string.");
 
+            struct Funcs
 
+            {
 
+                static int MyResizeCallback(ImGuiInputTextCallbackData* data)
 
+                {
 
+                    if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
 
+                    {
 
+                        ImVector<char>* my_str = (ImVector<char>*)data->UserData;
 
+                        IM_ASSERT(my_str->begin() == data->Buf);
 
+                        my_str->resize(data->BufSize);  // NB: On resizing calls, generally data->BufSize == data->BufTextLen + 1
 
+                        data->Buf = my_str->begin();
 
+                    }
 
+                    return 0;
 
+                }
 
+
 
+                // Tip: Because ImGui:: is a namespace you would typicall add your own function into the namespace in your own source files.
 
+                // For example, you may add a function called ImGui::InputText(const char* label, MyString* my_str).
 
+                static bool MyInputTextMultiline(const char* label, ImVector<char>* my_str, const ImVec2& size = ImVec2(0, 0), ImGuiInputTextFlags flags = 0)
 
+                {
 
+                    IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
 
+                    return ImGui::InputTextMultiline(label, my_str->begin(), (size_t)my_str->size(), size, flags | ImGuiInputTextFlags_CallbackResize, Funcs::MyResizeCallback, (void*)my_str);
 
+                }
 
+            };
 
+
 
+            // For this demo we are using ImVector as a string container.
 
+            // Note that because we need to store a terminating zero character, our size/capacity are 1 more than usually reported by a typical string class.
 
+            static ImVector<char> my_str;
 
+            if (my_str.empty())
 
+                my_str.push_back(0);
 
+            Funcs::MyInputTextMultiline("##MyStr", &my_str, ImVec2(-1.0f, ImGui::GetTextLineHeight() * 16));
 
+            ImGui::Text("Data: %p\nSize: %d\nCapacity: %d", (void*)my_str.begin(), my_str.size(), my_str.capacity());
 
+            ImGui::TreePop();
 
+        }
 
 
-    if (ImGui::TreeNode("Multi-line Text Input"))
 
-    {
 
-        // Note: we are using a fixed-sized buffer for simplicity here. See ImGuiInputTextFlags_CallbackResize
 
-        // and the code in misc/cpp/imgui_stdlib.h for how to setup InputText() for dynamically resizing strings.
 
-        static char text[1024*16] =
 
-            "/*\n"
 
-            " The Pentium F00F bug, shorthand for F0 0F C7 C8,\n"
 
-            " the hexadecimal encoding of one offending instruction,\n"
 
-            " more formally, the invalid operand with locked CMPXCHG8B\n"
 
-            " instruction bug, is a design flaw in the majority of\n"
 
-            " Intel Pentium, Pentium MMX, and Pentium OverDrive\n"
 
-            " processors (all in the P5 microarchitecture).\n"
 
-            "*/\n\n"
 
-            "label:\n"
 
-            "\tlock cmpxchg8b eax\n";
 
-
 
-        static ImGuiInputTextFlags flags = ImGuiInputTextFlags_AllowTabInput;
 
-        HelpMarker("You can use the ImGuiInputTextFlags_CallbackResize facility if you need to wire InputTextMultiline() to a dynamic string type. See misc/cpp/imgui_stdlib.h for an example. (This is not demonstrated in imgui_demo.cpp)");
 
-        ImGui::CheckboxFlags("ImGuiInputTextFlags_ReadOnly", (unsigned int*)&flags, ImGuiInputTextFlags_ReadOnly);
 
-        ImGui::CheckboxFlags("ImGuiInputTextFlags_AllowTabInput", (unsigned int*)&flags, ImGuiInputTextFlags_AllowTabInput);
 
-        ImGui::CheckboxFlags("ImGuiInputTextFlags_CtrlEnterForNewLine", (unsigned int*)&flags, ImGuiInputTextFlags_CtrlEnterForNewLine);
 
-        ImGui::InputTextMultiline("##source", text, IM_ARRAYSIZE(text), ImVec2(-1.0f, ImGui::GetTextLineHeight() * 16), flags);
 
         ImGui::TreePop();
 
     }
 
 
@@ -1056,7 +1106,8 @@ static void ShowDemoWindowWidgets()
 
         };
 
         static int func_type = 0, display_count = 70;
 
         ImGui::Separator();
 
-        ImGui::PushItemWidth(100); ImGui::Combo("func", &func_type, "Sin\0Saw\0"); ImGui::PopItemWidth();
 
+        ImGui::SetNextItemWidth(100);
 
+        ImGui::Combo("func", &func_type, "Sin\0Saw\0");
 
         ImGui::SameLine();
 
         ImGui::SliderInt("Sample count", &display_count, 1, 400);
 
         float (*func)(void*, int) = (func_type == 0) ? Funcs::Sin : Funcs::Saw;
 
@@ -1226,6 +1277,16 @@ static void ShowDemoWindowWidgets()
 
         if (ImGui::Button("Default: Float + HDR + Hue Wheel"))
 
             ImGui::SetColorEditOptions(ImGuiColorEditFlags_Float | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_PickerHueWheel);
 
 
+        // HSV encoded support (to avoid RGB<>HSV round trips and singularities when S==0 or V==0)
 
+        static ImVec4 color_stored_as_hsv(0.23f, 1.0f, 1.0f, 1.0f);
 
+        ImGui::Spacing();
 
+        ImGui::Text("HSV encoded colors");
 
+        ImGui::SameLine(); HelpMarker("By default, colors are given to ColorEdit and ColorPicker in RGB, but ImGuiColorEditFlags_InputHSV allows you to store colors as HSV and pass them to ColorEdit and ColorPicker as HSV. This comes with the added benefit that you can manipulate hue values with the picker even when saturation or value are zero.");
 
+        ImGui::Text("Color widget with InputHSV:");
 
+        ImGui::ColorEdit4("HSV shown as HSV##1", (float*)&color_stored_as_hsv, ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_InputHSV | ImGuiColorEditFlags_Float);
 
+        ImGui::ColorEdit4("HSV shown as RGB##1", (float*)&color_stored_as_hsv, ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_InputHSV | ImGuiColorEditFlags_Float);
 
+        ImGui::DragFloat4("Raw HSV values", (float*)&color_stored_as_hsv, 0.01f, 0.0f, 1.0f);
 
+
 
         ImGui::TreePop();
 
     }
 
 
@@ -1528,7 +1589,9 @@ static void ShowDemoWindowWidgets()
 
         ImGui::RadioButton("SliderFloat", &item_type, 3);
 
         ImGui::RadioButton("InputText", &item_type, 4);
 
         ImGui::RadioButton("ColorEdit4", &item_type, 5);
 
-        ImGui::RadioButton("ListBox", &item_type, 6);
 
+        ImGui::RadioButton("MenuItem", &item_type, 6);
 
+        ImGui::RadioButton("TreeNode (w/ double-click)", &item_type, 7);
 
+        ImGui::RadioButton("ListBox", &item_type, 8);
 
         ImGui::Separator();
 
         bool ret = false;
 
         if (item_type == 0) { ImGui::Text("ITEM: Text"); }                                              // Testing text items with no identifier/interaction
 
@@ -1537,7 +1600,9 @@ static void ShowDemoWindowWidgets()
 
         if (item_type == 3) { ret = ImGui::SliderFloat("ITEM: SliderFloat", &col4f[0], 0.0f, 1.0f); }   // Testing basic item
 
         if (item_type == 4) { ret = ImGui::InputText("ITEM: InputText", &str[0], IM_ARRAYSIZE(str)); }  // Testing input text (which handles tabbing)
 
         if (item_type == 5) { ret = ImGui::ColorEdit4("ITEM: ColorEdit4", col4f); }                     // Testing multi-component items (IsItemXXX flags are reported merged)
 
-        if (item_type == 6) { const char* items[] = { "Apple", "Banana", "Cherry", "Kiwi" }; static int current = 1; ret = ImGui::ListBox("ITEM: ListBox", &current, items, IM_ARRAYSIZE(items), IM_ARRAYSIZE(items)); }
 
+        if (item_type == 6) { ret = ImGui::MenuItem("ITEM: MenuItem"); }                                // Testing menu item (they use ImGuiButtonFlags_PressedOnRelease button policy)
 
+        if (item_type == 7) { ret = ImGui::TreeNodeEx("ITEM: TreeNode w/ ImGuiTreeNodeFlags_OpenOnDoubleClick", ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_NoTreePushOnOpen); } // Testing tree node with ImGuiButtonFlags_PressedOnDoubleClick button policy.
 
+        if (item_type == 8) { const char* items[] = { "Apple", "Banana", "Cherry", "Kiwi" }; static int current = 1; ret = ImGui::ListBox("ITEM: ListBox", &current, items, IM_ARRAYSIZE(items), IM_ARRAYSIZE(items)); }
 
         ImGui::BulletText(
 
             "Return value = %d\n"
 
             "IsItemFocused() = %d\n"
 
@@ -1550,8 +1615,9 @@ static void ShowDemoWindowWidgets()
 
             "IsItemEdited() = %d\n"
 
             "IsItemActivated() = %d\n"
 
             "IsItemDeactivated() = %d\n"
 
-            "IsItemDeactivatedEdit() = %d\n"
 
+            "IsItemDeactivatedAfterEdit() = %d\n"
 
             "IsItemVisible() = %d\n"
 
+            "IsItemClicked() = %d\n"
 
             "GetItemRectMin() = (%.1f, %.1f)\n"
 
             "GetItemRectMax() = (%.1f, %.1f)\n"
 
             "GetItemRectSize() = (%.1f, %.1f)",
 
@@ -1568,6 +1634,7 @@ static void ShowDemoWindowWidgets()
 
             ImGui::IsItemDeactivated(),
 
             ImGui::IsItemDeactivatedAfterEdit(),
 
             ImGui::IsItemVisible(),
 
+            ImGui::IsItemClicked(),
 
             ImGui::GetItemRectMin().x, ImGui::GetItemRectMin().y,
 
             ImGui::GetItemRectMax().x, ImGui::GetItemRectMax().y,
 
             ImGui::GetItemRectSize().x, ImGui::GetItemRectSize().y
 
@@ -1598,6 +1665,7 @@ static void ShowDemoWindowWidgets()
 
             "IsWindowHovered(_AllowWhenBlockedByActiveItem) = %d\n"
 
             "IsWindowHovered(_ChildWindows) = %d\n"
 
             "IsWindowHovered(_ChildWindows|_RootWindow) = %d\n"
 
+            "IsWindowHovered(_ChildWindows|_AllowWhenBlockedByPopup) = %d\n"
 
             "IsWindowHovered(_RootWindow) = %d\n"
 
             "IsWindowHovered(_AnyWindow) = %d\n",
 
             ImGui::IsWindowHovered(),
 
@@ -1605,6 +1673,7 @@ static void ShowDemoWindowWidgets()
 
             ImGui::IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem),
 
             ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows),
 
             ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow),
 
+            ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_AllowWhenBlockedByPopup),
 
             ImGui::IsWindowHovered(ImGuiHoveredFlags_RootWindow),
 
             ImGui::IsWindowHovered(ImGuiHoveredFlags_AnyWindow));
 
 
@@ -1629,7 +1698,6 @@ static void ShowDemoWindowWidgets()
 
                 if (ImGui::MenuItem("Close")) { test_window = false; }
 
                 ImGui::EndPopup();
 
             }
 
-            //if (IsItemHovered() || IsItemActive()) { printf("[%05d] Hovered %d Active %d\n", GetFrameCount(), IsItemHovered(), IsItemActive()); } // [DEBUG]
 
             ImGui::Text(
 
                 "IsItemHovered() after begin = %d (== is title bar hovered)\n"
 
                 "IsItemActive() after begin = %d (== is window being clicked/moved)\n",
 
@@ -1657,9 +1725,8 @@ static void ShowDemoWindowLayout()
 
         static int line = 50;
 
         bool goto_line = ImGui::Button("Goto");
 
         ImGui::SameLine();
 
-        ImGui::PushItemWidth(100);
 
+        ImGui::SetNextItemWidth(100);
 
         goto_line |= ImGui::InputInt("##Line", &line, 0, 0, ImGuiInputTextFlags_EnterReturnsTrue);
 
-        ImGui::PopItemWidth();
 
 
         // Child 1: no border, enable horizontal scrollbar
 
         {
 
@@ -1730,35 +1797,36 @@ static void ShowDemoWindowLayout()
 
 
     if (ImGui::TreeNode("Widgets Width"))
 
     {
 
+        // Use SetNextItemWidth() to set the width of a single upcoming item.
 
+        // Use PushItemWidth()/PopItemWidth() to set the width of a group of items.
 
         static float f = 0.0f;
 
-        ImGui::Text("PushItemWidth(100)");
 
+        ImGui::Text("SetNextItemWidth/PushItemWidth(100)");
 
         ImGui::SameLine(); HelpMarker("Fixed width.");
 
-        ImGui::PushItemWidth(100);
 
+        ImGui::SetNextItemWidth(100);
 
         ImGui::DragFloat("float##1", &f);
 
-        ImGui::PopItemWidth();
 
 
-        ImGui::Text("PushItemWidth(GetWindowWidth() * 0.5f)");
 
+        ImGui::Text("SetNextItemWidth/PushItemWidth(GetWindowWidth() * 0.5f)");
 
         ImGui::SameLine(); HelpMarker("Half of window width.");
 
-        ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
 
+        ImGui::SetNextItemWidth(ImGui::GetWindowWidth() * 0.5f);
 
         ImGui::DragFloat("float##2", &f);
 
-        ImGui::PopItemWidth();
 
 
-        ImGui::Text("PushItemWidth(GetContentRegionAvailWidth() * 0.5f)");
 
+        ImGui::Text("SetNextItemWidth/PushItemWidth(GetContentRegionAvailWidth() * 0.5f)");
 
         ImGui::SameLine(); HelpMarker("Half of available width.\n(~ right-cursor_pos)\n(works within a column set)");
 
-        ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth() * 0.5f);
 
+        ImGui::SetNextItemWidth(ImGui::GetContentRegionAvailWidth() * 0.5f);
 
         ImGui::DragFloat("float##3", &f);
 
-        ImGui::PopItemWidth();
 
 
-        ImGui::Text("PushItemWidth(-100)");
 
+        ImGui::Text("SetNextItemWidth/PushItemWidth(-100)");
 
         ImGui::SameLine(); HelpMarker("Align to right edge minus 100");
 
-        ImGui::PushItemWidth(-100);
 
+        ImGui::SetNextItemWidth(-100);
 
         ImGui::DragFloat("float##4", &f);
 
-        ImGui::PopItemWidth();
 
 
-        ImGui::Text("PushItemWidth(-1)");
 
+        // Demonstrate using PushItemWidth to surround three items. Calling SetNextItemWidth() before each of them would have the same effect.
 
+        ImGui::Text("SetNextItemWidth/PushItemWidth(-1)");
 
         ImGui::SameLine(); HelpMarker("Align to right edge");
 
         ImGui::PushItemWidth(-1);
 
-        ImGui::DragFloat("float##5", &f);
 
+        ImGui::DragFloat("float##5a", &f);
 
+        ImGui::DragFloat("float##5b", &f);
 
+        ImGui::DragFloat("float##5c", &f);
 
         ImGui::PopItemWidth();
 
 
         ImGui::TreePop();
 
@@ -2093,7 +2161,8 @@ static void ShowDemoWindowLayout()
 
                 ImGui::PopID();
 
             }
 
         }
 
-        float scroll_x = ImGui::GetScrollX(), scroll_max_x = ImGui::GetScrollMaxX();
 
+        float scroll_x = ImGui::GetScrollX();
 
+        float scroll_max_x = ImGui::GetScrollMaxX();
 
         ImGui::EndChild();
 
         ImGui::PopStyleVar(2);
 
         float scroll_x_delta = 0.0f;
 
@@ -2230,9 +2299,8 @@ static void ShowDemoWindowPopups()
 
         {
 
             if (ImGui::Selectable("Set to zero")) value = 0.0f;
 
             if (ImGui::Selectable("Set to PI")) value = 3.1415f;
 
-            ImGui::PushItemWidth(-1);
 
+            ImGui::SetNextItemWidth(-1);
 
             ImGui::DragFloat("##Value", &value, 0.1f, 0.0f, 0.0f);
 
-            ImGui::PopItemWidth();
 
             ImGui::EndPopup();
 
         }
 
 
@@ -2573,10 +2641,11 @@ static void ShowDemoWindowMisc()
 
             ImGui::Text("Mouse released:"); for (int i = 0; i < IM_ARRAYSIZE(io.MouseDown); i++) if (ImGui::IsMouseReleased(i))         { ImGui::SameLine(); ImGui::Text("b%d", i); }
 
             ImGui::Text("Mouse wheel: %.1f", io.MouseWheel);
 
 
-            ImGui::Text("Keys down:");      for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); i++) if (io.KeysDownDuration[i] >= 0.0f)     { ImGui::SameLine(); ImGui::Text("%d (%.02f secs)", i, io.KeysDownDuration[i]); }
 
-            ImGui::Text("Keys pressed:");   for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); i++) if (ImGui::IsKeyPressed(i))             { ImGui::SameLine(); ImGui::Text("%d", i); }
 
-            ImGui::Text("Keys release:");   for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); i++) if (ImGui::IsKeyReleased(i))            { ImGui::SameLine(); ImGui::Text("%d", i); }
 
+            ImGui::Text("Keys down:");      for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); i++) if (io.KeysDownDuration[i] >= 0.0f)     { ImGui::SameLine(); ImGui::Text("%d (0x%X) (%.02f secs)", i, i, io.KeysDownDuration[i]); }
 
+            ImGui::Text("Keys pressed:");   for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); i++) if (ImGui::IsKeyPressed(i))             { ImGui::SameLine(); ImGui::Text("%d (0x%X)", i, i); }
 
+            ImGui::Text("Keys release:");   for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); i++) if (ImGui::IsKeyReleased(i))            { ImGui::SameLine(); ImGui::Text("%d (0x%X)", i, i); }
 
             ImGui::Text("Keys mods: %s%s%s%s", io.KeyCtrl ? "CTRL " : "", io.KeyShift ? "SHIFT " : "", io.KeyAlt ? "ALT " : "", io.KeySuper ? "SUPER " : "");
 
+            ImGui::Text("Chars queue:");    for (int i = 0; i < io.InputQueueCharacters.Size; i++) { ImWchar c = io.InputQueueCharacters[i]; ImGui::SameLine();  ImGui::Text("\'%c\' (0x%04X)", (c > ' ' && c <= 255) ? (char)c : '?', c); } // FIXME: We should convert 'c' to UTF-8 here but the functions are not public.
 
 
             ImGui::Text("NavInputs down:"); for (int i = 0; i < IM_ARRAYSIZE(io.NavInputs); i++) if (io.NavInputs[i] > 0.0f)                    { ImGui::SameLine(); ImGui::Text("[%d] %.2f", i, io.NavInputs[i]); }
 
             ImGui::Text("NavInputs pressed:"); for (int i = 0; i < IM_ARRAYSIZE(io.NavInputs); i++) if (io.NavInputsDownDuration[i] == 0.0f)    { ImGui::SameLine(); ImGui::Text("[%d]", i); }
 
@@ -2654,22 +2723,17 @@ static void ShowDemoWindowMisc()
 
             for (int button = 0; button < 3; button++)
 
                 ImGui::Text("IsMouseDragging(%d):\n  w/ default threshold: %d,\n  w/ zero threshold: %d\n  w/ large threshold: %d",
 
                     button, ImGui::IsMouseDragging(button), ImGui::IsMouseDragging(button, 0.0f), ImGui::IsMouseDragging(button, 20.0f));
 
+
 
             ImGui::Button("Drag Me");
 
             if (ImGui::IsItemActive())
 
-            {
 
-                // Draw a line between the button and the mouse cursor
 
-                ImDrawList* draw_list = ImGui::GetWindowDrawList();
 
-                draw_list->PushClipRectFullScreen();
 
-                draw_list->AddLine(io.MouseClickedPos[0], io.MousePos, ImGui::GetColorU32(ImGuiCol_Button), 4.0f);
 
-                draw_list->PopClipRect();
 
-
 
-                // Drag operations gets "unlocked" when the mouse has moved past a certain threshold (the default threshold is stored in io.MouseDragThreshold)
 
-                // You can request a lower or higher threshold using the second parameter of IsMouseDragging() and GetMouseDragDelta()
 
-                ImVec2 value_raw = ImGui::GetMouseDragDelta(0, 0.0f);
 
-                ImVec2 value_with_lock_threshold = ImGui::GetMouseDragDelta(0);
 
-                ImVec2 mouse_delta = io.MouseDelta;
 
-                ImGui::SameLine(); ImGui::Text("Raw (%.1f, %.1f), WithLockThresold (%.1f, %.1f), MouseDelta (%.1f, %.1f)", value_raw.x, value_raw.y, value_with_lock_threshold.x, value_with_lock_threshold.y, mouse_delta.x, mouse_delta.y);
 
-            }
 
+                ImGui::GetForegroundDrawList()->AddLine(io.MouseClickedPos[0], io.MousePos, ImGui::GetColorU32(ImGuiCol_Button), 4.0f); // Draw a line between the button and the mouse cursor
 
+
 
+            // Drag operations gets "unlocked" when the mouse has moved past a certain threshold (the default threshold is stored in io.MouseDragThreshold)
 
+            // You can request a lower or higher threshold using the second parameter of IsMouseDragging() and GetMouseDragDelta()
 
+            ImVec2 value_raw = ImGui::GetMouseDragDelta(0, 0.0f);
 
+            ImVec2 value_with_lock_threshold = ImGui::GetMouseDragDelta(0);
 
+            ImVec2 mouse_delta = io.MouseDelta;
 
+            ImGui::Text("GetMouseDragDelta(0):\n  w/ default threshold: (%.1f, %.1f),\n  w/ zero threshold: (%.1f, %.1f)\nMouseDelta: (%.1f, %.1f)", value_with_lock_threshold.x, value_with_lock_threshold.y, value_raw.x, value_raw.y, mouse_delta.x, mouse_delta.y);
 
             ImGui::TreePop();
 
         }
 
 
@@ -2802,7 +2866,7 @@ void ImGui::ShowAboutWindow(bool* p_open)
 
         if (io.ConfigViewportsNoAutoMerge)                              ImGui::Text("io.ConfigViewportsNoAutoMerge");
 
         if (io.ConfigViewportsNoTaskBarIcon)                            ImGui::Text("io.ConfigViewportsNoTaskBarIcon");
 
         if (io.ConfigViewportsNoDecoration)                             ImGui::Text("io.ConfigViewportsNoDecoration");
 
-        if (io.ConfigViewportsNoParent)                                 ImGui::Text("io.ConfigViewportsNoParent");
 
+        if (io.ConfigViewportsNoDefaultParent)                          ImGui::Text("io.ConfigViewportsNoDefaultParent");
 
         if (io.ConfigDockingNoSplit)                                    ImGui::Text("io.ConfigDockingNoSplit");
 
         if (io.ConfigDockingWithShift)                                  ImGui::Text("io.ConfigDockingWithShift");
 
         if (io.ConfigDockingTabBarOnSingleWindows)                      ImGui::Text("io.ConfigDockingTabBarOnSingleWindows");
 
@@ -2982,7 +3046,7 @@ void ImGui::ShowStyleEditor(ImGuiStyle* ref)
 
                 }
 
                 ImGui::LogFinish();
 
             }
 
-            ImGui::SameLine(); ImGui::PushItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0"); ImGui::PopItemWidth();
 
+            ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
 
             ImGui::SameLine(); ImGui::Checkbox("Only Modified Colors", &output_only_modified);
 
 
             static ImGuiTextFilter filter;
 
@@ -3092,7 +3156,9 @@ void ImGui::ShowStyleEditor(ImGuiStyle* ref)
 
             }
 
             if (ImGui::TreeNode("Atlas texture", "Atlas texture (%dx%d pixels)", atlas->TexWidth, atlas->TexHeight))
 
             {
 
-                ImGui::Image(atlas->TexID, ImVec2((float)atlas->TexWidth, (float)atlas->TexHeight), ImVec2(0, 0), ImVec2(1, 1), ImColor(255, 255, 255, 255), ImColor(255, 255, 255, 128));
 
+                ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
 
+                ImVec4 border_col = ImVec4(1.0f, 1.0f, 1.0f, 0.5f);
 
+                ImGui::Image(atlas->TexID, ImVec2((float)atlas->TexWidth, (float)atlas->TexHeight), ImVec2(0, 0), ImVec2(1, 1), tint_col, border_col);
 
                 ImGui::TreePop();
 
             }
 
 
@@ -3128,7 +3194,10 @@ void ImGui::ShowStyleEditor(ImGuiStyle* ref)
 
 // [SECTION] Example App: Main Menu Bar / ShowExampleAppMainMenuBar()
 
 //-----------------------------------------------------------------------------
 
 
-// Demonstrate creating a fullscreen menu bar and populating it.
 
+// Demonstrate creating a "main" fullscreen menu bar and populating it.
 
+// Note the difference between BeginMainMenuBar() and BeginMenuBar():
 
+// - BeginMenuBar() = menu-bar inside current window we Begin()-ed into (the window needs the ImGuiWindowFlags_MenuBar flag)
 
+// - BeginMainMenuBar() = helper to create menu-bar-sized window at the top of the main viewport + call BeginMenuBar() into it.
 
 static void ShowExampleAppMainMenuBar()
 
 {
 
     if (ImGui::BeginMainMenuBar())
 
@@ -3152,6 +3221,7 @@ static void ShowExampleAppMainMenuBar()
 
     }
 
 }
 
 
+// Note that shortcuts are currently provided for display only (future version will add flags to BeginMenu to process shortcuts)
 
 static void ShowExampleMenuFile()
 
 {
 
     ImGui::MenuItem("(dummy menu)", NULL, false, false);
 
@@ -3685,7 +3755,7 @@ static void ShowExampleAppLog(bool* p_open)
 
     static ExampleAppLog log;
 
 
     // For the demo: add a debug button _BEFORE_ the normal log window contents
 
-    // We take advantage of the fact that multiple calls to Begin()/End() are appending to the same window.
 
+    // We take advantage of a rarely used feature: multiple calls to Begin()/End() are appending to the _same_ window.
 
     // Most of the contents of the window will be added by the log.Draw() call.
 
     ImGui::SetNextWindowSize(ImVec2(500, 400), ImGuiCond_FirstUseEver);
 
     ImGui::Begin("Example: Log", p_open);
 
@@ -3703,6 +3773,7 @@ static void ShowExampleAppLog(bool* p_open)
 
     }
 
     ImGui::End();
 
 
+    // Actually call in the regular Log helper (which will Begin() into the same window as we just did)
 
     log.Draw("Example: Log", p_open);
 
 }
 
 
@@ -3814,12 +3885,11 @@ static void ShowExampleAppPropertyEditor(bool* p_open)
 
                         ImGui::AlignTextToFramePadding();
 
                         ImGui::TreeNodeEx("Field", ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_Bullet, "Field_%d", i);
 
                         ImGui::NextColumn();
 
-                        ImGui::PushItemWidth(-1);
 
+                        ImGui::SetNextItemWidth(-1);
 
                         if (i >= 5)
 
                             ImGui::InputFloat("##value", &dummy_members[i], 1.0f);
 
                         else
 
                             ImGui::DragFloat("##value", &dummy_members[i], 0.01f);
 
-                        ImGui::PopItemWidth();
 
                         ImGui::NextColumn();
 
                     }
 
                     ImGui::PopID();
 
@@ -3961,10 +4031,10 @@ static void ShowExampleAppConstrainedResize(bool* p_open)
 
         if (ImGui::Button("200x200")) { ImGui::SetWindowSize(ImVec2(200, 200)); } ImGui::SameLine();
 
         if (ImGui::Button("500x500")) { ImGui::SetWindowSize(ImVec2(500, 500)); } ImGui::SameLine();
 
         if (ImGui::Button("800x200")) { ImGui::SetWindowSize(ImVec2(800, 200)); }
 
-        ImGui::PushItemWidth(200);
 
+        ImGui::SetNextItemWidth(200);
 
         ImGui::Combo("Constraint", &type, desc, IM_ARRAYSIZE(desc));
 
+        ImGui::SetNextItemWidth(200);
 
         ImGui::DragInt("Lines", &display_lines, 0.2f, 1, 100);
 
-        ImGui::PopItemWidth();
 
         ImGui::Checkbox("Auto-resize", &auto_resize);
 
         for (int i = 0; i < display_lines; i++)
 
             ImGui::Text("%*sHello, sailor! Making this line long enough for the example.", i * 4, "");
 
@@ -3979,7 +4049,7 @@ static void ShowExampleAppConstrainedResize(bool* p_open)
 
 // Demonstrate creating a simple static window with no decoration + a context-menu to choose which corner of the screen to use.
 
 static void ShowExampleAppSimpleOverlay(bool* p_open)
 
 {
 
-    // FIXME-VIEWPORT-ABS: Select a default viewport
 
+    // FIXME-VIEWPORT: Select a default viewport
 
     const float DISTANCE = 10.0f;
 
     static int corner = 0;
 
     ImGuiIO& io = ImGui::GetIO();
 
@@ -3991,7 +4061,7 @@ static void ShowExampleAppSimpleOverlay(bool* p_open)
 
         ImGui::SetNextWindowPos(window_pos, ImGuiCond_Always, window_pos_pivot);
 
         ImGui::SetNextWindowViewport(viewport->ID);
 
     }
 
-    ImGui::SetNextWindowBgAlpha(0.3f); // Transparent background
 
+    ImGui::SetNextWindowBgAlpha(0.35f); // Transparent background
 
     if (ImGui::Begin("Example: Simple overlay", p_open, (corner != -1 ? ImGuiWindowFlags_NoMove : 0) | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav))
 
     {
 
         ImGui::Text("Simple overlay\n" "in the corner of the screen.\n" "(right-click to change position)");
 
@@ -4083,30 +4153,30 @@ static void ShowExampleAppCustomRendering(bool* p_open)
 
             {
 
                 // First line uses a thickness of 1.0, second line uses the configurable thickness
 
                 float th = (n == 0) ? 1.0f : thickness;
 
-                draw_list->AddCircle(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 6, th); x += sz + spacing;     // Hexagon
 
-                draw_list->AddCircle(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 20, th); x += sz + spacing;    // Circle
 
-                draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, 0.0f, ImDrawCornerFlags_All, th); x += sz + spacing;
 
+                draw_list->AddCircle(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 6, th); x += sz + spacing;   // Hexagon
 
+                draw_list->AddCircle(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 20, th); x += sz + spacing;  // Circle
 
+                draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, 0.0f,  ImDrawCornerFlags_All, th); x += sz + spacing;
 
                 draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, 10.0f, ImDrawCornerFlags_All, th); x += sz + spacing;
 
                 draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, 10.0f, ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotRight, th); x += sz + spacing;
 
                 draw_list->AddTriangle(ImVec2(x + sz*0.5f, y), ImVec2(x + sz, y + sz - 0.5f), ImVec2(x, y + sz - 0.5f), col32, th); x += sz + spacing;
 
-                draw_list->AddLine(ImVec2(x, y), ImVec2(x + sz, y), col32, th); x += sz + spacing;               // Horizontal line (note: drawing a filled rectangle will be faster!)
 
-                draw_list->AddLine(ImVec2(x, y), ImVec2(x, y + sz), col32, th); x += spacing;                  // Vertical line (note: drawing a filled rectangle will be faster!)
 
-                draw_list->AddLine(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, th); x += sz + spacing;               // Diagonal line
 
+                draw_list->AddLine(ImVec2(x, y), ImVec2(x + sz, y), col32, th); x += sz + spacing;                  // Horizontal line (note: drawing a filled rectangle will be faster!)
 
+                draw_list->AddLine(ImVec2(x, y), ImVec2(x, y + sz), col32, th); x += spacing;                       // Vertical line (note: drawing a filled rectangle will be faster!)
 
+                draw_list->AddLine(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, th); x += sz + spacing;             // Diagonal line
 
                 draw_list->AddBezierCurve(ImVec2(x, y), ImVec2(x + sz*1.3f, y + sz*0.3f), ImVec2(x + sz - sz*1.3f, y + sz - sz*0.3f), ImVec2(x + sz, y + sz), col32, th);
 
                 x = p.x + 4;
 
                 y += sz + spacing;
 
             }
 
-            draw_list->AddCircleFilled(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 6); x += sz + spacing;       // Hexagon
 
-            draw_list->AddCircleFilled(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 32); x += sz + spacing;      // Circle
 
+            draw_list->AddCircleFilled(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 6); x += sz + spacing;     // Hexagon
 
+            draw_list->AddCircleFilled(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col32, 32); x += sz + spacing;    // Circle
 
             draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + sz), col32); x += sz + spacing;
 
             draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, 10.0f); x += sz + spacing;
 
             draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + sz), col32, 10.0f, ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotRight); x += sz + spacing;
 
             draw_list->AddTriangleFilled(ImVec2(x + sz*0.5f, y), ImVec2(x + sz, y + sz - 0.5f), ImVec2(x, y + sz - 0.5f), col32); x += sz + spacing;
 
-            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + thickness), col32); x += sz + spacing;          // Horizontal line (faster than AddLine, but only handle integer thickness)
 
-            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + thickness, y + sz), col32); x += spacing + spacing;     // Vertical line (faster than AddLine, but only handle integer thickness)
 
+            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + thickness), col32); x += sz + spacing;        // Horizontal line (faster than AddLine, but only handle integer thickness)
 
+            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + thickness, y + sz), col32); x += spacing + spacing;   // Vertical line (faster than AddLine, but only handle integer thickness)
 
             draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + 1, y + 1), col32);          x += sz;                  // Pixel (faster than AddLine)
 
             draw_list->AddRectFilledMultiColor(ImVec2(x, y), ImVec2(x + sz, y + sz), IM_COL32(0, 0, 0, 255), IM_COL32(255, 0, 0, 255), IM_COL32(255, 255, 0, 255), IM_COL32(0, 255, 0, 255));
 
-            ImGui::Dummy(ImVec2((sz + spacing) * 8, (sz + spacing) * 3));
 
+            ImGui::Dummy(ImVec2((sz + spacing) * 9.5f, (sz + spacing) * 3));
 
             ImGui::EndTabItem();
 
         }
 
 
@@ -4171,7 +4241,7 @@ static void ShowExampleAppCustomRendering(bool* p_open)
 
             ImVec2 window_size = ImGui::GetWindowSize();
 
             ImVec2 window_center = ImVec2(window_pos.x + window_size.x * 0.5f, window_pos.y + window_size.y * 0.5f);
 
             if (draw_bg)
 
-                ImGui::GetBackgroundDrawList()->AddCircle(window_center, window_size.x * 0.6f, IM_COL32(255, 0, 0, 200), 32, 10);
 
+                ImGui::GetBackgroundDrawList()->AddCircle(window_center, window_size.x * 0.6f, IM_COL32(255, 0, 0, 200), 32, 10+4);
 
             if (draw_fg)
 
                 ImGui::GetForegroundDrawList()->AddCircle(window_center, window_size.y * 0.6f, IM_COL32(0, 255, 0, 200), 32, 10);
 
             ImGui::EndTabItem();
 
@@ -4193,8 +4263,8 @@ static void ShowExampleAppCustomRendering(bool* p_open)
 
 void ShowExampleAppDockSpace(bool* p_open)
 
 {
 
     static bool opt_fullscreen_persistant = true;
 
-    static ImGuiDockNodeFlags opt_flags = ImGuiDockNodeFlags_None;
 
     bool opt_fullscreen = opt_fullscreen_persistant;
 
+    static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_None;
 
 
     // We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into,
 
     // because it would be confusing to have two docking targets within each others.
 
@@ -4211,8 +4281,8 @@ void ShowExampleAppDockSpace(bool* p_open)
 
         window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
 
     }
 
 
-    // When using ImGuiDockNodeFlags_PassthruDockspace, DockSpace() will render our background and handle the pass-thru hole, so we ask Begin() to not render a background.
 
-    if (opt_flags & ImGuiDockNodeFlags_PassthruDockspace)
 
+    // When using ImGuiDockNodeFlags_PassthruCentralNode, DockSpace() will render our background and handle the pass-thru hole, so we ask Begin() to not render a background.
 
+    if (dockspace_flags & ImGuiDockNodeFlags_PassthruCentralNode)
 
         window_flags |= ImGuiWindowFlags_NoBackground;
 
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
 
@@ -4222,12 +4292,12 @@ void ShowExampleAppDockSpace(bool* p_open)
 
     if (opt_fullscreen)
 
         ImGui::PopStyleVar(2);
 
 
-    // Dockspace
 
+    // DockSpace
 
     ImGuiIO& io = ImGui::GetIO();
 
     if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable)
 
     {
 
-        ImGuiID dockspace_id = ImGui::GetID("MyDockspace");
 
-        ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), opt_flags);
 
+        ImGuiID dockspace_id = ImGui::GetID("MyDockSpace");
 
+        ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags);
 
     }
 
     else
 
     {
 
@@ -4242,18 +4312,22 @@ void ShowExampleAppDockSpace(bool* p_open)
 
             // which we can't undo at the moment without finer window depth/z control.
 
             //ImGui::MenuItem("Fullscreen", NULL, &opt_fullscreen_persistant);
 
 
-            if (ImGui::MenuItem("Flag: NoSplit",                "", (opt_flags & ImGuiDockNodeFlags_NoSplit) != 0))                 opt_flags ^= ImGuiDockNodeFlags_NoSplit;
 
-            if (ImGui::MenuItem("Flag: NoDockingInCentralNode", "", (opt_flags & ImGuiDockNodeFlags_NoDockingInCentralNode) != 0))  opt_flags ^= ImGuiDockNodeFlags_NoDockingInCentralNode;
 
-            if (ImGui::MenuItem("Flag: NoResize",               "", (opt_flags & ImGuiDockNodeFlags_NoResize) != 0))                opt_flags ^= ImGuiDockNodeFlags_NoResize;
 
-            if (ImGui::MenuItem("Flag: PassthruDockspace",      "", (opt_flags & ImGuiDockNodeFlags_PassthruDockspace) != 0))       opt_flags ^= ImGuiDockNodeFlags_PassthruDockspace;
 
-            if (ImGui::MenuItem("Flag: AutoHideTabBar",         "", (opt_flags & ImGuiDockNodeFlags_AutoHideTabBar) != 0))          opt_flags ^= ImGuiDockNodeFlags_AutoHideTabBar;
 
+            if (ImGui::MenuItem("Flag: NoSplit",                "", (dockspace_flags & ImGuiDockNodeFlags_NoSplit) != 0))                 dockspace_flags ^= ImGuiDockNodeFlags_NoSplit;
 
+            if (ImGui::MenuItem("Flag: NoResize",               "", (dockspace_flags & ImGuiDockNodeFlags_NoResize) != 0))                dockspace_flags ^= ImGuiDockNodeFlags_NoResize;
 
+            if (ImGui::MenuItem("Flag: NoDockingInCentralNode", "", (dockspace_flags & ImGuiDockNodeFlags_NoDockingInCentralNode) != 0))  dockspace_flags ^= ImGuiDockNodeFlags_NoDockingInCentralNode;
 
+            if (ImGui::MenuItem("Flag: PassthruCentralNode",    "", (dockspace_flags & ImGuiDockNodeFlags_PassthruCentralNode) != 0))     dockspace_flags ^= ImGuiDockNodeFlags_PassthruCentralNode;
 
+            if (ImGui::MenuItem("Flag: AutoHideTabBar",         "", (dockspace_flags & ImGuiDockNodeFlags_AutoHideTabBar) != 0))          dockspace_flags ^= ImGuiDockNodeFlags_AutoHideTabBar;
 
             ImGui::Separator();
 
             if (ImGui::MenuItem("Close DockSpace", NULL, false, p_open != NULL))
 
                 *p_open = false;
 
             ImGui::EndMenu();
 
         }
 
         HelpMarker(
 
-            "You can _always_ dock _any_ window into another by holding the SHIFT key while moving a window. Try it now!" "\n"
 
+            "When docking is enabled, you can ALWAYS dock MOST window into another! Try it now!" "\n\n"
 
+            " > if io.ConfigDockingWithShift==false (default):" "\n"
 
+            "   drag windows from title bar to dock" "\n"
 
+            " > if io.ConfigDockingWithShift==true:" "\n"
 
+            "   drag windows from anywhere and hold Shift to dock" "\n\n"
 
             "This demo app has nothing to do with it!" "\n\n"
 
             "This demo app only demonstrate the use of ImGui::DockSpace() which allows you to manually create a docking node _within_ another window. This is useful so you can decorate your main application window (e.g. with a menu bar)." "\n\n"
 
             "ImGui::DockSpace() comes with one hard constraint: it needs to be submitted _before_ any window which may be docked into it. Therefore, if you use a dock spot as the central point of your application, you'll probably want it to be part of the very first window you are submitting to imgui every frame." "\n\n"
 
@@ -4368,13 +4442,13 @@ void ShowExampleAppDocuments(bool* p_open)
 
     {
 
         Target_None,
 
         Target_Tab,                 // Create documents as local tab into a local tab bar
 
-        Target_DockspaceAndWindow   // Create documents as regular windows, and create an embedded dockspace
 
+        Target_DockSpaceAndWindow   // Create documents as regular windows, and create an embedded dockspace
 
     };
 
     static Target opt_target = Target_Tab;
 
     static bool   opt_reorderable = true;
 
     static ImGuiTabBarFlags opt_fitting_flags = ImGuiTabBarFlags_FittingPolicyDefault_;
 
 
-    // When (opt_target == Target_DockspaceAndWindow) there is the possibily that one of our child Document window (e.g. "Eggplant")
 
+    // When (opt_target == Target_DockSpaceAndWindow) there is the possibily that one of our child Document window (e.g. "Eggplant")
 
     // that we emit gets docked into the same spot as the parent window ("Example: Documents").
 
     // This would create a problematic feedback loop because selecting the "Eggplant" tab would make the "Example: Documents" tab
 
     // not visible, which in turn would stop submitting the "Eggplant" window.
 
@@ -4382,7 +4456,7 @@ void ShowExampleAppDocuments(bool* p_open)
 
     // Another solution may be to make the "Example: Documents" window use the ImGuiWindowFlags_NoDocking.
 
 
     bool window_contents_visible = ImGui::Begin("Example: Documents", p_open, ImGuiWindowFlags_MenuBar);
 
-    if (!window_contents_visible && opt_target != Target_DockspaceAndWindow)
 
+    if (!window_contents_visible && opt_target != Target_DockSpaceAndWindow)
 
     {
 
         ImGui::End();
 
         return;
 
@@ -4434,7 +4508,7 @@ void ShowExampleAppDocuments(bool* p_open)
 
     ImGui::PopItemWidth();
 
     bool redock_all = false;
 
     if (opt_target == Target_Tab)                { ImGui::SameLine(); ImGui::Checkbox("Reorderable Tabs", &opt_reorderable); }
 
-    if (opt_target == Target_DockspaceAndWindow) { ImGui::SameLine(); redock_all = ImGui::Button("Redock all"); }
 
+    if (opt_target == Target_DockSpaceAndWindow) { ImGui::SameLine(); redock_all = ImGui::Button("Redock all"); }
 
 
     ImGui::Separator();
 
 
@@ -4479,7 +4553,7 @@ void ShowExampleAppDocuments(bool* p_open)
 
             ImGui::EndTabBar();
 
         }
 
     }
 
-    else if (opt_target == Target_DockspaceAndWindow)
 
+    else if (opt_target == Target_DockSpaceAndWindow)
 
     {
 
         if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_DockingEnable)
 
         {
 
@@ -4496,9 +4570,6 @@ void ShowExampleAppDocuments(bool* p_open)
 
                 if (!doc->Open)
 
                     continue;
 
 
-                // FIXME-DOCK: SetNextWindowDock()
 
-                //ImGuiID default_dock_id = GetDockspaceRootDocumentDockID();
 
-                //ImGuiID default_dock_id = GetDockspacePreferedDocumentDockID();
 
                 ImGui::SetNextWindowDockID(dockspace_id, redock_all ? ImGuiCond_Always : ImGuiCond_FirstUseEver);
 
                 ImGuiWindowFlags window_flags = (doc->Dirty ? ImGuiWindowFlags_UnsavedDocument : 0);
 
                 bool visible = ImGui::Begin(doc->Name, &doc->Open, window_flags);
 
@@ -4568,12 +4639,14 @@ void ShowExampleAppDocuments(bool* p_open)
 
             if (ImGui::BeginPopupModal("Save?"))
 
             {
 
                 ImGui::Text("Save change to the following items?");
 
-                ImGui::PushItemWidth(-1.0f);
 
-                ImGui::ListBoxHeader("##", close_queue_unsaved_documents, 6);
 
-                for (int n = 0; n < close_queue.Size; n++)
 
-                    if (close_queue[n]->Dirty)
 
-                        ImGui::Text("%s", close_queue[n]->Name);
 
-                ImGui::ListBoxFooter();
 
+                ImGui::SetNextItemWidth(-1.0f);
 
+                if (ImGui::ListBoxHeader("##", close_queue_unsaved_documents, 6))
 
+                {
 
+                    for (int n = 0; n < close_queue.Size; n++)
 
+                        if (close_queue[n]->Dirty)
 
+                            ImGui::Text("%s", close_queue[n]->Name);
 
+                    ImGui::ListBoxFooter();
 
+                }
 
 
                 if (ImGui::Button("Yes", ImVec2(80, 0)))
 
                 {

+ 36 - 18
3rdparty/ocornut-imgui/imgui_draw.cpp
View File 

@@ -1,4 +1,4 @@
 
-// dear imgui, v1.69 WIP
 
+// dear imgui, v1.70 WIP
 
 // (drawing and font code)
 
 
 /*
 
@@ -55,7 +55,7 @@ Index of this file:
 
 #ifdef __clang__
 
 #pragma clang diagnostic ignored "-Wold-style-cast"         // warning : use of old-style cast                              // yes, they are more terse.
 
 #pragma clang diagnostic ignored "-Wfloat-equal"            // warning : comparing floating point with == or != is unsafe   // storing and comparing against same constants ok.
 
-#pragma clang diagnostic ignored "-Wglobal-constructors"    // warning : declaration requires a global destructor           // similar to above, not sure what the exact difference it.
 
+#pragma clang diagnostic ignored "-Wglobal-constructors"    // warning : declaration requires a global destructor           // similar to above, not sure what the exact difference is.
 
 #pragma clang diagnostic ignored "-Wsign-conversion"        // warning : implicit conversion changes signedness             //
 
 #if __has_warning("-Wzero-as-null-pointer-constant")
 
 #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"  // warning : zero as null pointer constant              // some standard header variations use #define NULL 0
 
@@ -73,6 +73,7 @@ Index of this file:
 
 #pragma GCC diagnostic ignored "-Wunused-function"          // warning: 'xxxx' defined but not used
 
 #pragma GCC diagnostic ignored "-Wdouble-promotion"         // warning: implicit conversion from 'float' to 'double' when passing argument to function
 
 #pragma GCC diagnostic ignored "-Wconversion"               // warning: conversion to 'xxxx' from 'xxxx' may alter its value
 
+#pragma GCC diagnostic ignored "-Wstack-protector"          // warning: stack protector not protecting local variables: variable length buffer
 
 #if __GNUC__ >= 8
 
 #pragma GCC diagnostic ignored "-Wclass-memaccess"          // warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
 
 #endif
 
@@ -129,8 +130,8 @@ namespace IMGUI_STB_NAMESPACE
 
 
 #ifndef STB_TRUETYPE_IMPLEMENTATION                         // in case the user already have an implementation in the _same_ compilation unit (e.g. unity builds)
 
 #ifndef IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
 
-#define STBTT_malloc(x,u)   ((void)(u), ImGui::MemAlloc(x))
 
-#define STBTT_free(x,u)     ((void)(u), ImGui::MemFree(x))
 
+#define STBTT_malloc(x,u)   ((void)(u), IM_ALLOC(x))
 
+#define STBTT_free(x,u)     ((void)(u), IM_FREE(x))
 
 #define STBTT_assert(x)     IM_ASSERT(x)
 
 #define STBTT_fmod(x,y)     ImFmod(x,y)
 
 #define STBTT_sqrt(x)       ImSqrt(x)
 
@@ -1293,8 +1294,8 @@ void ImDrawData::DeIndexAllBuffers()
 
     }
 
 }
 
 
-// Helper to scale the ClipRect field of each ImDrawCmd. 
-// Use if your final output buffer is at a different scale than draw_data->DisplaySize, 
+// Helper to scale the ClipRect field of each ImDrawCmd.
 
+// Use if your final output buffer is at a different scale than draw_data->DisplaySize,
 
 // or if there is a difference between your window resolution and framebuffer resolution.
 
 void ImDrawData::ScaleClipRects(const ImVec2& fb_scale)
 
 {
 
@@ -1464,7 +1465,7 @@ void    ImFontAtlas::ClearInputData()
 
     for (int i = 0; i < ConfigData.Size; i++)
 
         if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas)
 
         {
 
-            ImGui::MemFree(ConfigData[i].FontData);
 
+            IM_FREE(ConfigData[i].FontData);
 
             ConfigData[i].FontData = NULL;
 
         }
 
 
@@ -1485,9 +1486,9 @@ void    ImFontAtlas::ClearTexData()
 
 {
 
     IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
 
     if (TexPixelsAlpha8)
 
-        ImGui::MemFree(TexPixelsAlpha8);
 
+        IM_FREE(TexPixelsAlpha8);
 
     if (TexPixelsRGBA32)
 
-        ImGui::MemFree(TexPixelsRGBA32);
 
+        IM_FREE(TexPixelsRGBA32);
 
     TexPixelsAlpha8 = NULL;
 
     TexPixelsRGBA32 = NULL;
 
 }
 
@@ -1533,7 +1534,7 @@ void    ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_wid
 
         GetTexDataAsAlpha8(&pixels, NULL, NULL);
 
         if (pixels)
 
         {
 
-            TexPixelsRGBA32 = (unsigned int*)ImGui::MemAlloc((size_t)TexWidth * (size_t)TexHeight * 4);
 
+            TexPixelsRGBA32 = (unsigned int*)IM_ALLOC((size_t)TexWidth * (size_t)TexHeight * 4);
 
             const unsigned char* src = pixels;
 
             unsigned int* dst = TexPixelsRGBA32;
 
             for (int n = TexWidth * TexHeight; n > 0; n--)
 
@@ -1565,7 +1566,7 @@ ImFont* ImFontAtlas::AddFont(const ImFontConfig* font_cfg)
 
         new_font_cfg.DstFont = Fonts.back();
 
     if (!new_font_cfg.FontDataOwnedByAtlas)
 
     {
 
-        new_font_cfg.FontData = ImGui::MemAlloc(new_font_cfg.FontDataSize);
 
+        new_font_cfg.FontData = IM_ALLOC(new_font_cfg.FontDataSize);
 
         new_font_cfg.FontDataOwnedByAtlas = true;
 
         memcpy(new_font_cfg.FontData, font_cfg->FontData, (size_t)new_font_cfg.FontDataSize);
 
     }
 
@@ -1600,9 +1601,9 @@ ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template)
 
         font_cfg.OversampleH = font_cfg.OversampleV = 1;
 
         font_cfg.PixelSnapH = true;
 
     }
 
-    if (font_cfg.SizePixels <= 0.0f) 
+    if (font_cfg.SizePixels <= 0.0f)
 
         font_cfg.SizePixels = 13.0f * 1.0f;
 
-    if (font_cfg.Name[0] == '\0') 
+    if (font_cfg.Name[0] == '\0')
 
         ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "ProggyClean.ttf, %dpx", (int)font_cfg.SizePixels);
 
 
     const char* ttf_compressed_base85 = GetDefaultCompressedFontDataTTFBase85();
 
@@ -1650,7 +1651,7 @@ ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float si
 
 ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
 
 {
 
     const unsigned int buf_decompressed_size = stb_decompress_length((const unsigned char*)compressed_ttf_data);
 
-    unsigned char* buf_decompressed_data = (unsigned char *)ImGui::MemAlloc(buf_decompressed_size);
 
+    unsigned char* buf_decompressed_data = (unsigned char *)IM_ALLOC(buf_decompressed_size);
 
     stb_decompress(buf_decompressed_data, (const unsigned char*)compressed_ttf_data, (unsigned int)compressed_ttf_size);
 
 
     ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
 
@@ -1662,10 +1663,10 @@ ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_d
 
 ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
 
 {
 
     int compressed_ttf_size = (((int)strlen(compressed_ttf_data_base85) + 4) / 5) * 4;
 
-    void* compressed_ttf = ImGui::MemAlloc((size_t)compressed_ttf_size);
 
+    void* compressed_ttf = IM_ALLOC((size_t)compressed_ttf_size);
 
     Decode85((const unsigned char*)compressed_ttf_data_base85, (unsigned char*)compressed_ttf);
 
     ImFont* font = AddFontFromMemoryCompressedTTF(compressed_ttf, compressed_ttf_size, size_pixels, font_cfg, glyph_ranges);
 
-    ImGui::MemFree(compressed_ttf);
 
+    IM_FREE(compressed_ttf);
 
     return font;
 
 }
 
 
@@ -1965,7 +1966,7 @@ bool    ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas)
 
     // 7. Allocate texture
 
     atlas->TexHeight = (atlas->Flags & ImFontAtlasFlags_NoPowerOfTwoHeight) ? (atlas->TexHeight + 1) : ImUpperPowerOfTwo(atlas->TexHeight);
 
     atlas->TexUvScale = ImVec2(1.0f / atlas->TexWidth, 1.0f / atlas->TexHeight);
 
-    atlas->TexPixelsAlpha8 = (unsigned char*)ImGui::MemAlloc(atlas->TexWidth * atlas->TexHeight);
 
+    atlas->TexPixelsAlpha8 = (unsigned char*)IM_ALLOC(atlas->TexWidth * atlas->TexHeight);
 
     memset(atlas->TexPixelsAlpha8, 0, atlas->TexWidth * atlas->TexHeight);
 
     spc.pixels = atlas->TexPixelsAlpha8;
 
     spc.height = atlas->TexHeight;
 
@@ -2352,6 +2353,23 @@ const ImWchar*  ImFontAtlas::GetGlyphRangesThai()
 
     return &ranges[0];
 
 }
 
 
+const ImWchar*  ImFontAtlas::GetGlyphRangesVietnamese()
 
+{
 
+    static const ImWchar ranges[] =
 
+    {
 
+        0x0020, 0x00FF, // Basic Latin
 
+        0x0102, 0x0103,
 
+        0x0110, 0x0111,
 
+        0x0128, 0x0129,
 
+        0x0168, 0x0169,
 
+        0x01A0, 0x01A1,
 
+        0x01AF, 0x01B0,
 
+        0x1EA0, 0x1EF9,
 
+        0,
 
+    };
 
+    return &ranges[0];
 
+}
 
+
 
 //-----------------------------------------------------------------------------
 
 // [SECTION] ImFontGlyphRangesBuilder
 
 //-----------------------------------------------------------------------------
 
@@ -2456,7 +2474,7 @@ void ImFont::BuildLookupTable()
 
         ImFontGlyph& tab_glyph = Glyphs.back();
 
         tab_glyph = *FindGlyph((ImWchar)' ');
 
         tab_glyph.Codepoint = '\t';
 
-        tab_glyph.AdvanceX *= 4;
 
+        tab_glyph.AdvanceX *= IM_TABSIZE;
 
         IndexAdvanceX[(int)tab_glyph.Codepoint] = (float)tab_glyph.AdvanceX;
 
         IndexLookup[(int)tab_glyph.Codepoint] = (ImWchar)(Glyphs.Size-1);
 
     }

+ 90 - 62
3rdparty/ocornut-imgui/imgui_internal.h
View File 

@@ -1,4 +1,4 @@
 
-// dear imgui, v1.69 WIP
 
+// dear imgui, v1.70 WIP
 
 // (internal structures/api)
 
 
 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
 
@@ -63,7 +63,7 @@ struct ImDrawDataBuilder;           // Helper to build a ImDrawData instance
 
 struct ImDrawListSharedData;        // Data shared between all ImDrawList instances
 
 struct ImGuiColorMod;               // Stacked color modifier, backup of modified data so we can restore it
 
 struct ImGuiColumnData;             // Storage data for a single column
 
-struct ImGuiColumnsSet;             // Storage data for a columns set
 
+struct ImGuiColumns;                // Storage data for a columns set
 
 struct ImGuiContext;                // Main imgui context
 
 struct ImGuiDockContext;            // Docking system context
 
 struct ImGuiDockNode;               // Docking system node (hold a list of Windows OR two child dock nodes)
 
@@ -84,8 +84,8 @@ struct ImGuiWindowTempData;         // Temporary storage for one window (that's
 
 struct ImGuiWindowSettings;         // Storage for window settings stored in .ini file (we keep one of those even if the actual window wasn't instanced during this session)
 
 
 // Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.
 
+typedef int ImGuiDataAuthority;     // -> enum ImGuiDataAuthority_     // Enum: for storing the source authority (dock node vs window) of a field
 
 typedef int ImGuiLayoutType;        // -> enum ImGuiLayoutType_        // Enum: Horizontal or vertical
 
-typedef int ImGuiDataAutority;      // -> enum ImGuiDataAutority_      // Enum: for storing the source autority (dock node vs window) of a field
 
 typedef int ImGuiButtonFlags;       // -> enum ImGuiButtonFlags_       // Flags: for ButtonEx(), ButtonBehavior()
 
 typedef int ImGuiDragFlags;         // -> enum ImGuiDragFlags_         // Flags: for DragBehavior()
 
 typedef int ImGuiItemFlags;         // -> enum ImGuiItemFlags_         // Flags: for PushItemFlag()
 
@@ -136,6 +136,7 @@ extern IMGUI_API ImGuiContext* GImGui;  // Current implicit ImGui context pointe
 
 #else
 
 #define IM_NEWLINE      "\n"
 
 #endif
 
+#define IM_TABSIZE      (4)
 
 
 #define IMGUI_DEBUG_LOG(_FMT,...)       printf("[%05d] " _FMT, GImGui->FrameCount, __VA_ARGS__)
 
 #define IM_STATIC_ASSERT(_COND)         typedef char static_assertion_##__line__[(_COND)?1:-1]
 
@@ -159,7 +160,7 @@ IMGUI_API int           ImTextCountUtf8BytesFromStr(const ImWchar* in_text, cons
 
 
 // Helpers: Misc
 
 IMGUI_API ImU32         ImHashData(const void* data, size_t data_size, ImU32 seed = 0);
 
-IMGUI_API ImU32         ImHashStr(const char* data, size_t data_size, ImU32 seed = 0);
 
+IMGUI_API ImU32         ImHashStr(const char* data, size_t data_size = 0, ImU32 seed = 0);
 
 IMGUI_API void*         ImFileLoadToMemory(const char* filename, const char* file_open_mode, size_t* out_file_size = NULL, int padding_bytes = 0);
 
 IMGUI_API FILE*         ImFileOpen(const char* filename, const char* file_open_mode);
 
 static inline bool      ImCharIsBlankA(char c)          { return c == ' ' || c == '\t'; }
 
@@ -307,7 +308,7 @@ enum ImGuiButtonFlags_
 
 {
 
     ImGuiButtonFlags_None                   = 0,
 
     ImGuiButtonFlags_Repeat                 = 1 << 0,   // hold to repeat
 
-    ImGuiButtonFlags_PressedOnClickRelease  = 1 << 1,   // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
 
+    ImGuiButtonFlags_PressedOnClickRelease  = 1 << 1,   // [Default] return true on click + release on same item
 
     ImGuiButtonFlags_PressedOnClick         = 1 << 2,   // return true on click (default requires click+release)
 
     ImGuiButtonFlags_PressedOnRelease       = 1 << 3,   // return true on release (default requires click+release)
 
     ImGuiButtonFlags_PressedOnDoubleClick   = 1 << 4,   // return true on double-click (default requires click+release)
 
@@ -319,7 +320,8 @@ enum ImGuiButtonFlags_
 
     ImGuiButtonFlags_NoKeyModifiers         = 1 << 10,  // disable interaction if a key modifier is held
 
     ImGuiButtonFlags_NoHoldingActiveID      = 1 << 11,  // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
 
     ImGuiButtonFlags_PressedOnDragDropHold  = 1 << 12,  // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
 
-    ImGuiButtonFlags_NoNavFocus             = 1 << 13   // don't override navigation focus when activated
 
+    ImGuiButtonFlags_NoNavFocus             = 1 << 13,  // don't override navigation focus when activated
 
+    ImGuiButtonFlags_NoHoveredOnNav         = 1 << 14   // don't report as hovered when navigated on
 
 };
 
 
 enum ImGuiSliderFlags_
 
@@ -351,7 +353,8 @@ enum ImGuiSelectableFlagsPrivate_
 
     ImGuiSelectableFlags_NoHoldingActiveID  = 1 << 10,
 
     ImGuiSelectableFlags_PressedOnClick     = 1 << 11,
 
     ImGuiSelectableFlags_PressedOnRelease   = 1 << 12,
 
-    ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 13
 
+    ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 13,
 
+    ImGuiSelectableFlags_AllowItemOverlap   = 1 << 14
 
 };
 
 
 enum ImGuiSeparatorFlags_
 
@@ -380,7 +383,8 @@ enum ImGuiItemStatusFlags_
 
     ImGuiItemStatusFlags_None               = 0,
 
     ImGuiItemStatusFlags_HoveredRect        = 1 << 0,
 
     ImGuiItemStatusFlags_HasDisplayRect     = 1 << 1,
 
-    ImGuiItemStatusFlags_Edited             = 1 << 2    // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
 
+    ImGuiItemStatusFlags_Edited             = 1 << 2,   // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
 
+    ImGuiItemStatusFlags_ToggledSelection   = 1 << 3    // Set when Selectable(), TreeNode() reports toggling a selection. We can't report "Selected" because reporting the change allows us to handle clipping with less issues.
 
 
 #ifdef IMGUI_ENABLE_TEST_ENGINE
 
     , // [imgui-test only]
 
@@ -583,10 +587,9 @@ struct ImGuiGroupData
 
 // Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
 
 struct IMGUI_API ImGuiMenuColumns
 
 {
 
-    int         Count;
 
     float       Spacing;
 
     float       Width, NextWidth;
 
-    float       Pos[4], NextWidths[4];
 
+    float       Pos[3], NextWidths[3];
 
 
     ImGuiMenuColumns();
 
     void        Update(int count, float spacing, bool clear);
 
@@ -647,7 +650,7 @@ struct ImGuiWindowSettings
 
 struct ImGuiSettingsHandler
 
 {
 
     const char* TypeName;       // Short description stored in .ini file. Disallowed characters: '[' ']'
 
-    ImGuiID     TypeHash;       // == ImHashStr(TypeName, 0, 0)
 
+    ImGuiID     TypeHash;       // == ImHashStr(TypeName)
 
     void*       (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name);              // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
 
     void        (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry
 
     void        (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf);      // Write: Output every entries into 'out_buf'
 
@@ -663,7 +666,7 @@ struct ImGuiPopupRef
 
     ImGuiWindow*        Window;         // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
 
     ImGuiWindow*        ParentWindow;   // Set on OpenPopup()
 
     int                 OpenFrameCount; // Set on OpenPopup()
 
-    ImGuiID             OpenParentId;   // Set on OpenPopup(), we need this to differenciate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
 
+    ImGuiID             OpenParentId;   // Set on OpenPopup(), we need this to differentiate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
 
     ImVec2              OpenPopupPos;   // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
 
     ImVec2              OpenMousePos;   // Set on OpenPopup(), copy of mouse position at the time of opening popup
 
 };
 
@@ -675,10 +678,10 @@ struct ImGuiColumnData
 
     ImGuiColumnsFlags   Flags;              // Not exposed
 
     ImRect              ClipRect;
 
 
-    ImGuiColumnData()   { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = 0; }
 
+    ImGuiColumnData()   { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = ImGuiColumnsFlags_None; }
 
 };
 
 
-struct ImGuiColumnsSet
 
+struct ImGuiColumns
 
 {
 
     ImGuiID             ID;
 
     ImGuiColumnsFlags   Flags;
 
@@ -688,23 +691,23 @@ struct ImGuiColumnsSet
 
     int                 Count;
 
     float               MinX, MaxX;
 
     float               LineMinY, LineMaxY;
 
-    float               StartPosY;          // Copy of CursorPos
 
-    float               StartMaxPosX;       // Copy of CursorMaxPos
 
+    float               BackupCursorPosY;       // Backup of CursorPos at the time of BeginColumns()
 
+    float               BackupCursorMaxPosX;    // Backup of CursorMaxPos at the time of BeginColumns()
 
     ImVector<ImGuiColumnData> Columns;
 
 
-    ImGuiColumnsSet()   { Clear(); }
 
+    ImGuiColumns()      { Clear(); }
 
     void Clear()
 
     {
 
         ID = 0;
 
-        Flags = 0;
 
+        Flags = ImGuiColumnsFlags_None;
 
         IsFirstFrame = false;
 
         IsBeingResized = false;
 
         Current = 0;
 
         Count = 1;
 
         MinX = MaxX = 0.0f;
 
         LineMinY = LineMaxY = 0.0f;
 
-        StartPosY = 0.0f;
 
-        StartMaxPosX = 0.0f;
 
+        BackupCursorPosY = 0.0f;
 
+        BackupCursorMaxPosX = 0.0f;
 
         Columns.clear();
 
     }
 
 };
 
@@ -753,7 +756,6 @@ struct ImGuiViewportP : public ImGuiViewport
 
     float               LastAlpha;
 
     short               PlatformMonitor;
 
     bool                PlatformWindowCreated;
 
-    bool                PlatformWindowMinimized;  // When minimized we tend to avoid using the viewport pos/size for clipping window or testing if they are contained in the viewport
 
     ImGuiWindow*        Window;                   // Set when the viewport is owned by a window (and ImGuiViewportFlags_CanHostOtherWindows is NOT set)
 
     ImDrawList*         DrawLists[2];             // Convenience background (0) and foreground (1) draw lists. We use them to draw software mouser cursor when io.MouseDrawCursor is set and to draw most debug overlays.
 
     ImDrawData          DrawDataP;
 
@@ -762,7 +764,7 @@ struct ImGuiViewportP : public ImGuiViewport
 
     ImVec2              LastPlatformSize;
 
     ImVec2              LastRendererSize;
 
 
-    ImGuiViewportP()            { Idx = -1; LastFrameActive = LastFrameDrawLists[0] = LastFrameDrawLists[1] = LastFrontMostStampCount = -1; LastNameHash = 0; Alpha = LastAlpha = 1.0f; PlatformMonitor = -1; PlatformWindowCreated = PlatformWindowMinimized = false; Window = NULL; DrawLists[0] = DrawLists[1] = NULL; LastPlatformPos = LastPlatformSize = LastRendererSize = ImVec2(FLT_MAX, FLT_MAX); }
 
+    ImGuiViewportP()            { Idx = -1; LastFrameActive = LastFrameDrawLists[0] = LastFrameDrawLists[1] = LastFrontMostStampCount = -1; LastNameHash = 0; Alpha = LastAlpha = 1.0f; PlatformMonitor = -1; PlatformWindowCreated = false; Window = NULL; DrawLists[0] = DrawLists[1] = NULL; LastPlatformPos = LastPlatformSize = LastRendererSize = ImVec2(FLT_MAX, FLT_MAX); }
 
     ~ImGuiViewportP()           { if (DrawLists[0]) IM_DELETE(DrawLists[0]); if (DrawLists[1]) IM_DELETE(DrawLists[1]); }
 
     ImRect  GetRect() const     { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
 
     ImVec2  GetCenter() const   { return ImVec2(Pos.x + Size.x * 0.5f, Pos.y + Size.y * 0.5f); }
 
@@ -852,21 +854,30 @@ struct ImGuiTabBarRef
 
 
 enum ImGuiDockNodeFlagsPrivate_
 
 {
 
-    ImGuiDockNodeFlags_Dockspace  = 1 << 10
 
+    // [Internal]
 
+    ImGuiDockNodeFlags_DockSpace                = 1 << 10,  // Local  // A dockspace is a node that occupy space within an existing user window. Otherwise the node is floating and create its own window.
 
+    ImGuiDockNodeFlags_CentralNode              = 1 << 11,  // Local
 
+    ImGuiDockNodeFlags_NoTabBar                 = 1 << 12,  // Local  // Tab bar is completely unavailable. No triangle in the corner to enable it back.
 
+    ImGuiDockNodeFlags_HiddenTabBar             = 1 << 13,  // Local  // Tab bar is hidden, with a triangle in the corner to show it again (NB: actual tab-bar instance may be destroyed as this is only used for single-window tab bar)
 
+    ImGuiDockNodeFlags_SharedFlagsInheritMask_  = ~0,
 
+    ImGuiDockNodeFlags_LocalFlagsMask_          = ImGuiDockNodeFlags_NoSplit | ImGuiDockNodeFlags_NoResize | ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_DockSpace | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar,
 
+    ImGuiDockNodeFlags_LocalFlagsTransferMask_  = ImGuiDockNodeFlags_LocalFlagsMask_ & ~ImGuiDockNodeFlags_DockSpace  // When splitting those flags are moved to the inheriting child, never duplicated
 
 };
 
 
-enum ImGuiDataAutority_
 
+// Store the source authority (dock node vs window) of a field
 
+enum ImGuiDataAuthority_
 
 {
 
-    ImGuiDataAutority_Auto,
 
-    ImGuiDataAutority_DockNode,
 
-    ImGuiDataAutority_Window
 
+    ImGuiDataAuthority_Auto,
 
+    ImGuiDataAuthority_DockNode,
 
+    ImGuiDataAuthority_Window
 
 };
 
 
 // sizeof() 116~160
 
 struct ImGuiDockNode
 
 {
 
     ImGuiID                 ID;
 
-    ImGuiDockNodeFlags      Flags;
 
+    ImGuiDockNodeFlags      SharedFlags;                // Flags shared by all nodes of a same dockspace hierarchy (inherited from the root node)
 
+    ImGuiDockNodeFlags      LocalFlags;                 // Flags specific to this node
 
     ImGuiDockNode*          ParentNode;
 
     ImGuiDockNode*          ChildNodes[2];              // [Split node only] Child nodes (left/right or top/bottom). Consider switching to an array.
 
     ImVector<ImGuiWindow*>  Windows;                    // Note: unordered list! Iterate TabBar->Tabs for user-order.
 
@@ -887,13 +898,11 @@ struct ImGuiDockNode
 
     ImGuiID                 LastFocusedNodeID;          // [Root node only] Which of our child docking node (any ancestor in the hierarchy) was last focused.
 
     ImGuiID                 SelectedTabID;              // [Tab node only] Which of our tab is selected.
 
     ImGuiID                 WantCloseTabID;             // [Tab node only] Set when closing a specific tab.
 
-    ImGuiDataAutority       AutorityForPos          :3;
 
-    ImGuiDataAutority       AutorityForSize         :3;
 
-    ImGuiDataAutority       AutorityForViewport     :3;
 
+    ImGuiDataAuthority      AuthorityForPos         :3;
 
+    ImGuiDataAuthority      AuthorityForSize        :3;
 
+    ImGuiDataAuthority      AuthorityForViewport    :3;
 
     bool                    IsVisible               :1; // Set to false when the node is hidden (usually disabled as it has no active window)
 
     bool                    IsFocused               :1;
 
-    bool                    IsCentralNode           :1;
 
-    bool                    IsHiddenTabBar          :1;
 
     bool                    HasCloseButton          :1;
 
     bool                    HasCollapseButton       :1;
 
     bool                    WantCloseAll            :1; // Set when closing all tabs at once.
 
@@ -904,12 +913,16 @@ struct ImGuiDockNode
 
 
     ImGuiDockNode(ImGuiID id);
 
     ~ImGuiDockNode();
 
-    bool                    IsRootNode() const  { return ParentNode == NULL; }
 
-    bool                    IsDockSpace() const { return (Flags & ImGuiDockNodeFlags_Dockspace) != 0; }
 
-    bool                    IsSplitNode() const { return ChildNodes[0] != NULL; }
 
-    bool                    IsLeafNode() const  { return ChildNodes[0] == NULL; }
 
-    bool                    IsEmpty() const     { return ChildNodes[0] == NULL && Windows.Size == 0; }
 
-    ImRect                  Rect() const        { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
 
+    bool                    IsRootNode() const      { return ParentNode == NULL; }
 
+    bool                    IsDockSpace() const     { return (LocalFlags & ImGuiDockNodeFlags_DockSpace) != 0; }
 
+    bool                    IsCentralNode() const   { return (LocalFlags & ImGuiDockNodeFlags_CentralNode) != 0; }
 
+    bool                    IsHiddenTabBar() const  { return (LocalFlags & ImGuiDockNodeFlags_HiddenTabBar) != 0; } // Hidden tab bar can be shown back by clicking the small triangle
 
+    bool                    IsNoTabBar() const      { return (LocalFlags & ImGuiDockNodeFlags_NoTabBar) != 0; }     // Never show a tab bar
 
+    bool                    IsSplitNode() const     { return ChildNodes[0] != NULL; }
 
+    bool                    IsLeafNode() const      { return ChildNodes[0] == NULL; }
 
+    bool                    IsEmpty() const         { return ChildNodes[0] == NULL && Windows.Size == 0; }
 
+    ImGuiDockNodeFlags      GetMergedFlags() const  { return SharedFlags | LocalFlags; }
 
+    ImRect                  Rect() const            { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
 
 };
 
 
 //-----------------------------------------------------------------------------
 
@@ -942,7 +955,6 @@ struct ImGuiContext
 
     ImVector<ImGuiWindow*>  CurrentWindowStack;
 
     ImGuiStorage            WindowsById;
 
     int                     WindowsActiveCount;
 
-    int                     WindowsFrontMostStampCount;         // Every time the front-most window changes, we stamp its viewport with an incrementing counter
 
     ImGuiWindow*            CurrentWindow;                      // Being drawn into
 
     ImGuiWindow*            HoveredWindow;                      // Will catch mouse inputs
 
     ImGuiWindow*            HoveredRootWindow;                  // Will catch mouse inputs (for focus/move only)
 
@@ -987,6 +999,7 @@ struct ImGuiContext
 
     ImGuiViewportP*         MouseViewport;
 
     ImGuiViewportP*         MouseLastHoveredViewport;           // Last known viewport that was hovered by mouse (even if we are not hovering any viewport any more) + honoring the _NoInputs flag.
 
     ImGuiID                 PlatformLastFocusedViewport;        // Record of last focused platform window/viewport, when this changes we stamp the viewport as front-most
 
+    int                     ViewportFrontMostStampCount;        // Every time the front-most window changes, we stamp its viewport with an incrementing counter
 
 
     // Navigation data (for gamepad/keyboard)
 
     ImGuiWindow*            NavWindow;                          // Focused window for navigation. Could be called 'FocusWindow'
 
@@ -997,7 +1010,7 @@ struct ImGuiContext
 
     ImGuiID                 NavInputId;                         // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0
 
     ImGuiID                 NavJustTabbedId;                    // Just tabbed to this id.
 
     ImGuiID                 NavJustMovedToId;                   // Just navigated to this id (result of a successfully MoveRequest).
 
-    ImGuiID                 NavJustMovedToSelectScopeId;        // Just navigated to this select scope id (result of a successfully MoveRequest).
 
+    ImGuiID                 NavJustMovedToMultiSelectScopeId;   // Just navigated to this select scope id (result of a successfully MoveRequest).
 
     ImGuiID                 NavNextActivateId;                  // Set by ActivateItem(), queued until next frame.
 
     ImGuiInputSource        NavInputSource;                     // Keyboard or Gamepad mode? THIS WILL ONLY BE None or NavGamepad or NavKeyboard.
 
     ImRect                  NavScoringRectScreen;               // Rectangle used for scoring, in screen space. Based of window->DC.NavRefRectRel[], modified for directional navigation scoring.
 
@@ -1132,7 +1145,6 @@ struct ImGuiContext
 
         FrameCount = 0;
 
         FrameCountEnded = FrameCountPlatformEnded = FrameCountRendered = -1;
 
         WindowsActiveCount = 0;
 
-        WindowsFrontMostStampCount = 0;
 
         CurrentWindow = NULL;
 
         HoveredWindow = NULL;
 
         HoveredRootWindow = NULL;
 
@@ -1166,10 +1178,11 @@ struct ImGuiContext
 
         CurrentViewport = NULL;
 
         MouseViewport = MouseLastHoveredViewport = NULL;
 
         PlatformLastFocusedViewport = 0;
 
+        ViewportFrontMostStampCount = 0;
 
 
         NavWindow = NULL;
 
         NavId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavInputId = 0;
 
-        NavJustTabbedId = NavJustMovedToId = NavJustMovedToSelectScopeId = NavNextActivateId = 0;
 
+        NavJustTabbedId = NavJustMovedToId = NavJustMovedToMultiSelectScopeId = NavNextActivateId = 0;
 
         NavInputSource = ImGuiInputSource_None;
 
         NavScoringRectScreen = ImRect();
 
         NavScoringCount = 0;
 
@@ -1287,6 +1300,7 @@ struct IMGUI_API ImGuiWindowTempData
 
     // We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
 
     ImGuiItemFlags          ItemFlags;              // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
 
     float                   ItemWidth;              // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
 
+    float                   NextItemWidth;
 
     float                   TextWrapPos;            // == TextWrapPosStack.back() [empty == -1.0f]
 
     ImVector<ImGuiItemFlags>ItemFlagsStack;
 
     ImVector<float>         ItemWidthStack;
 
@@ -1297,7 +1311,7 @@ struct IMGUI_API ImGuiWindowTempData
 
     ImVec1                  Indent;                 // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
 
     ImVec1                  GroupOffset;
 
     ImVec1                  ColumnsOffset;          // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
 
-    ImGuiColumnsSet*        ColumnsSet;             // Current columns set
 
+    ImGuiColumns*           CurrentColumns;         // Current columns set
 
 
     ImGuiWindowTempData()
 
     {
 
@@ -1322,13 +1336,14 @@ struct IMGUI_API ImGuiWindowTempData
 
 
         ItemFlags = ImGuiItemFlags_Default_;
 
         ItemWidth = 0.0f;
 
+        NextItemWidth = +FLT_MAX;
 
         TextWrapPos = -1.0f;
 
         memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
 
 
         Indent = ImVec1(0.0f);
 
         GroupOffset = ImVec1(0.0f);
 
         ColumnsOffset = ImVec1(0.0f);
 
-        ColumnsSet = NULL;
 
+        CurrentColumns = NULL;
 
     }
 
 };
 
 
@@ -1368,7 +1383,7 @@ struct IMGUI_API ImGuiWindow
 
     bool                    WantCollapseToggle;
 
     bool                    SkipItems;                          // Set when items can safely be all clipped (e.g. window not visible or collapsed)
 
     bool                    Appearing;                          // Set during the frame where the window is appearing (or re-appearing)
 
-    bool                    Hidden;                             // Do not display (== (HiddenFramesForResize > 0) ||
 
+    bool                    Hidden;                             // Do not display (== (HiddenFrames*** > 0))
 
     bool                    HasCloseButton;                     // Set when the window has a close button (p_open != NULL)
 
     signed char             ResizeBorderHeld;                   // Current border being held for resize (-1: none, otherwise 0-3)
 
     short                   BeginCount;                         // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
 
@@ -1379,8 +1394,8 @@ struct IMGUI_API ImGuiWindow
 
     bool                    AutoFitOnlyGrows;
 
     int                     AutoFitChildAxises;
 
     ImGuiDir                AutoPosLastDirection;
 
-    int                     HiddenFramesRegular;                // Hide the window for N frames
 
-    int                     HiddenFramesForResize;              // Hide the window for N frames while allowing items to be submitted so we can measure their size
 
+    int                     HiddenFramesCanSkipItems;           // Hide the window for N frames
 
+    int                     HiddenFramesCannotSkipItems;        // Hide the window for N frames while allowing items to be submitted so we can measure their size
 
     ImGuiCond               SetWindowPosAllowFlags;             // store acceptable condition flags for SetNextWindowPos() use.
 
     ImGuiCond               SetWindowSizeAllowFlags;            // store acceptable condition flags for SetNextWindowSize() use.
 
     ImGuiCond               SetWindowCollapsedAllowFlags;       // store acceptable condition flags for SetNextWindowCollapsed() use.
 
@@ -1396,10 +1411,11 @@ struct IMGUI_API ImGuiWindow
 
     ImVec2ih                HitTestHoleSize, HitTestHoleOffset;
 
     ImRect                  ContentsRegionRect;                 // FIXME: This is currently confusing/misleading. Maximum visible content position ~~ Pos + (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
 
     int                     LastFrameActive;                    // Last frame number the window was Active.
 
+    int                     LastFrameJustFocused;               // Last frame number the window was made Focused.
 
     float                   ItemWidthDefault;
 
     ImGuiMenuColumns        MenuColumns;                        // Simplified columns storage for menu items
 
     ImGuiStorage            StateStorage;
 
-    ImVector<ImGuiColumnsSet> ColumnsStorage;
 
+    ImVector<ImGuiColumns>  ColumnsStorage;
 
     float                   FontWindowScale;                    // User scale multiplier per-window
 
     float                   FontDpiScale;
 
     int                     SettingsIdx;                        // Index into SettingsWindow[] (indices are always valid as we only grow the array from the back)
 
@@ -1509,6 +1525,8 @@ struct ImGuiTabBar
 
     float               OffsetNextTab;          // Distance from BarRect.Min.x, incremented with each BeginTabItem() call, not used if ImGuiTabBarFlags_Reorderable if set.
 
     float               ScrollingAnim;
 
     float               ScrollingTarget;
 
+    float               ScrollingTargetDistToVisibility;
 
+    float               ScrollingSpeed;
 
     ImGuiTabBarFlags    Flags;
 
     ImGuiID             ReorderRequestTabId;
 
     int                 ReorderRequestDir;
 
@@ -1516,15 +1534,15 @@ struct ImGuiTabBar
 
     bool                VisibleTabWasSubmitted;
 
     short               LastTabItemIdx;         // For BeginTabItem()/EndTabItem()
 
     ImVec2              FramePadding;           // style.FramePadding locked at the time of BeginTabBar()
 
-    ImGuiTextBuffer     TabsNames;              // For non-docking tab bar we re-append names in a contiguous buffer. 
+    ImGuiTextBuffer     TabsNames;              // For non-docking tab bar we re-append names in a contiguous buffer.
 
 
     ImGuiTabBar();
 
     int                 GetTabOrder(const ImGuiTabItem* tab) const  { return Tabs.index_from_ptr(tab); }
 
-    const char*         GetTabName(const ImGuiTabItem* tab) const 
+    const char*         GetTabName(const ImGuiTabItem* tab) const
 
     {
 
         if (tab->Window)
 
             return tab->Window->Name;
 
-        IM_ASSERT(tab->NameOffset != -1 && tab->NameOffset < TabsNames.Buf.Size); 
+        IM_ASSERT(tab->NameOffset != -1 && tab->NameOffset < TabsNames.Buf.Size);
 
         return TabsNames.Buf.Data + tab->NameOffset;
 
     }
 
 };
 
@@ -1609,11 +1627,14 @@ namespace ImGui
 
     IMGUI_API bool          IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
 
     IMGUI_API bool          FocusableItemRegister(ImGuiWindow* window, ImGuiID id);   // Return true if focus is requested
 
     IMGUI_API void          FocusableItemUnregister(ImGuiWindow* window);
 
-    IMGUI_API ImVec2        CalcItemSize(ImVec2 size, float default_x, float default_y);
 
+    IMGUI_API float         GetNextItemWidth();
 
+    IMGUI_API ImVec2        CalcItemSize(ImVec2 size, float default_w, float default_h);
 
     IMGUI_API float         CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
 
-    IMGUI_API void          PushMultiItemsWidths(int components, float width_full = 0.0f);
 
+    IMGUI_API void          PushMultiItemsWidths(int components, float width_full);
 
     IMGUI_API void          PushItemFlag(ImGuiItemFlags option, bool enabled);
 
     IMGUI_API void          PopItemFlag();
 
+    IMGUI_API bool          IsItemToggledSelection();                                           // was the last item selection toggled? (after Selectable(), TreeNode() etc. We only returns toggle _event_ in order to handle clipping correctly)
 
+    IMGUI_API ImVec2        GetContentRegionMaxScreen();
 
 
     // Logging/Capture
 
     IMGUI_API void          LogBegin(ImGuiLogType type, int auto_open_depth);   // -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name.
 
@@ -1655,10 +1676,12 @@ namespace ImGui
 
     IMGUI_API void          DockContextShutdown(ImGuiContext* ctx);
 
     IMGUI_API void          DockContextOnLoadSettings(ImGuiContext* ctx);
 
     IMGUI_API void          DockContextRebuild(ImGuiContext* ctx);
 
-    IMGUI_API void          DockContextNewFrameUpdateUndocking(ImGuiContext* ctx);
 
-    IMGUI_API void          DockContextNewFrameUpdateDocking(ImGuiContext* ctx);
 
+    IMGUI_API void          DockContextUpdateUndocking(ImGuiContext* ctx);
 
+    IMGUI_API void          DockContextUpdateDocking(ImGuiContext* ctx);
 
+    IMGUI_API void          DockContextQueueDock(ImGuiContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer);
 
     IMGUI_API void          DockContextQueueUndockWindow(ImGuiContext* ctx, ImGuiWindow* window);
 
     IMGUI_API void          DockContextQueueUndockNode(ImGuiContext* ctx, ImGuiDockNode* node);
 
+    IMGUI_API bool          DockContextCalcDropPosForDocking(ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, bool split_outer, ImVec2* out_pos);
 
     inline ImGuiDockNode*   DockNodeGetRootNode(ImGuiDockNode* node) { while (node->ParentNode) node = node->ParentNode; return node; }
 
     IMGUI_API void          BeginDocked(ImGuiWindow* window, bool* p_open);
 
     IMGUI_API void          BeginAsDockableDragDropSource(ImGuiWindow* window);
 
@@ -1670,14 +1693,14 @@ namespace ImGui
 
     IMGUI_API void          DockBuilderDockWindow(const char* window_name, ImGuiID node_id);
 
     IMGUI_API ImGuiDockNode*DockBuilderGetNode(ImGuiID node_id);                    // Warning: DO NOT HOLD ON ImGuiDockNode* pointer, will be invalided by any split/merge/remove operation.
 
     inline ImGuiDockNode*   DockBuilderGetCentralNode(ImGuiID node_id)              { ImGuiDockNode* node = DockBuilderGetNode(node_id); if (!node) return NULL; return DockNodeGetRootNode(node)->CentralNode; }
 
-    IMGUI_API ImGuiID       DockBuilderAddNode(ImGuiID node_id, ImGuiDockNodeFlags flags = 0);
 
+    IMGUI_API ImGuiID       DockBuilderAddNode(ImGuiID node_id, ImGuiDockNodeFlags flags = 0);  // Use (flags == ImGuiDockNodeFlags_DockSpace) to create a dockspace, otherwise it'll create a floating node.
 
     IMGUI_API void          DockBuilderRemoveNode(ImGuiID node_id);                 // Remove node and all its child, undock all windows
 
     IMGUI_API void          DockBuilderRemoveNodeDockedWindows(ImGuiID node_id, bool clear_persistent_docking_references = true);
 
     IMGUI_API void          DockBuilderRemoveNodeChildNodes(ImGuiID node_id);       // Remove all split/hierarchy. All remaining docked windows will be re-docked to the root.
 
     IMGUI_API void          DockBuilderSetNodePos(ImGuiID node_id, ImVec2 pos);
 
     IMGUI_API void          DockBuilderSetNodeSize(ImGuiID node_id, ImVec2 size);
 
     IMGUI_API ImGuiID       DockBuilderSplitNode(ImGuiID node_id, ImGuiDir split_dir, float size_ratio_for_node_at_dir, ImGuiID* out_id_dir, ImGuiID* out_id_other);
 
-    IMGUI_API void          DockBuilderCopyDockspace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id, ImVector<const char*>* in_window_remap_pairs);
 
+    IMGUI_API void          DockBuilderCopyDockSpace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id, ImVector<const char*>* in_window_remap_pairs);
 
     IMGUI_API void          DockBuilderCopyNode(ImGuiID src_node_id, ImGuiID dst_node_id, ImVector<ImGuiID>* out_node_remap_pairs);
 
     IMGUI_API void          DockBuilderCopyWindowSettings(const char* src_name, const char* dst_name);
 
     IMGUI_API void          DockBuilderFinish(ImGuiID node_id);
 
@@ -1691,10 +1714,13 @@ namespace ImGui
 
     IMGUI_API void          BeginColumns(const char* str_id, int count, ImGuiColumnsFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
 
     IMGUI_API void          EndColumns();                                                             // close columns
 
     IMGUI_API void          PushColumnClipRect(int column_index = -1);
 
+    IMGUI_API ImGuiID       GetColumnsID(const char* str_id, int count);
 
+    IMGUI_API ImGuiColumns* FindOrCreateColumns(ImGuiWindow* window, ImGuiID id);
 
 
     // Tab Bars
 
     IMGUI_API bool          BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& bb, ImGuiTabBarFlags flags, ImGuiDockNode* dock_node);
 
     IMGUI_API ImGuiTabItem* TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id);
 
+    IMGUI_API ImGuiTabItem* TabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar);
 
     IMGUI_API void          TabBarAddTab(ImGuiTabBar* tab_bar, ImGuiTabItemFlags tab_flags, ImGuiWindow* window);
 
     IMGUI_API void          TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id);
 
     IMGUI_API void          TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
 
@@ -1751,8 +1777,8 @@ namespace ImGui
 
     // Template functions are instantiated in imgui_widgets.cpp for a finite number of types.
 
     // To use them externally (for custom widget) you may need an "extern template" statement in your code in order to link to existing instances and silence Clang warnings (see #2036).
 
     // e.g. " extern template IMGUI_API float RoundScalarWithFormatT<float, float>(const char* format, ImGuiDataType data_type, float v); "
 
-    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API bool  DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, const T v_min, const T v_max, const char* format, float power, ImGuiDragFlags flags);
 
-    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API bool  SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, const T v_min, const T v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb);
 
+    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API bool  DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, T v_min, T v_max, const char* format, float power, ImGuiDragFlags flags);
 
+    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API bool  SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, T v_min, T v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb);
 
     template<typename T, typename FLOAT_T>                      IMGUI_API float SliderCalcRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, float power, float linear_zero_pos);
 
     template<typename T, typename SIGNED_T>                     IMGUI_API T     RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, T v);
 
 
@@ -1790,9 +1816,11 @@ extern void                 ImGuiTestEngineHook_PreNewFrame(ImGuiContext* ctx);
 
 extern void                 ImGuiTestEngineHook_PostNewFrame(ImGuiContext* ctx);
 
 extern void                 ImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, const ImRect& bb, ImGuiID id);
 
 extern void                 ImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags);
 
-#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS)  ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS)   // Register status flags
 
+#define IMGUI_TEST_ENGINE_ITEM_ADD(_BB, _ID)                ImGuiTestEngineHook_ItemAdd(&g, _BB, _ID)               // Register status flags
 
+#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS)    ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS)   // Register status flags
 
 #else
 
-#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS)  do { } while (0)
 
+#define IMGUI_TEST_ENGINE_ITEM_ADD(_BB, _ID)                do { } while (0)
 
+#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID, _LABEL, _FLAGS)    do { } while (0)
 
 #endif
 
 
 #ifdef __clang__

File diff suppressed because it is too large
+ 275 - 142
3rdparty/ocornut-imgui/imgui_widgets.cpp


Some files were not shown because too many files changed in this diff