{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return;

ImGuiContext& g = *GImGui;

// Accept null ranges

if (text == text_end)

text = text_end = "";

// Calculate length

const char* text_begin = text;

if (text_end == NULL)

text_end = text + strlen(text); // FIXME-OPT

const ImVec2 text_pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);

const float wrap_pos_x = window->DC.TextWrapPos;

const bool wrap_enabled = (wrap_pos_x >= 0.0f);

if (text_end - text <= 2000 || wrap_enabled)

{

// Common case

const float wrap_width = wrap_enabled ? CalcWrapWidthForPos(window->DC.CursorPos, wrap_pos_x) : 0.0f;

const ImVec2 text_size = CalcTextSize(text_begin, text_end, false, wrap_width);

ImRect bb(text_pos, text_pos + text_size);

ItemSize(text_size, 0.0f);

if (!ItemAdd(bb, 0))

return;

// Render (we don't hide text after ## in this end-user function)

RenderTextWrapped(bb.Min, text_begin, text_end, wrap_width);

}

else

{

// Long text!

// Perform manual coarse clipping to optimize for long multi-line text

// - From this point we will only compute the width of lines that are visible. Optimization only available when word-wrapping is disabled.

// - We also don't vertically center the text within the line full height, which is unlikely to matter because we are likely the biggest and only item on the line.

// - We use memchr(), pay attention that well optimized versions of those str/mem functions are much faster than a casually written loop.

const char* line = text;

const float line_height = GetTextLineHeight();

ImVec2 text_size(0, 0);

// Lines to skip (can't skip when logging text)

ImVec2 pos = text_pos;

if (!g.LogEnabled)

{

int lines_skippable = (int)((window->ClipRect.Min.y - text_pos.y) / line_height);

if (lines_skippable > 0)

{

int lines_skipped = 0;

while (line < text_end && lines_skipped < lines_skippable)

{

const char* line_end = (const char*)memchr(line, '\n', text_end - line);

if (!line_end)

line_end = text_end;

if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)

text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);

line = line_end + 1;

lines_skipped++;

}

pos.y += lines_skipped * line_height;

}

}

// Lines to render

if (line < text_end)

{

ImRect line_rect(pos, pos + ImVec2(FLT_MAX, line_height));

while (line < text_end)

{

if (IsClippedEx(line_rect, 0))

break;

const char* line_end = (const char*)memchr(line, '\n', text_end - line);

if (!line_end)

line_end = text_end;

text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);

RenderText(pos, line, line_end, false);

line = line_end + 1;

line_rect.Min.y += line_height;

line_rect.Max.y += line_height;

pos.y += line_height;

}

// Count remaining lines

int lines_skipped = 0;

while (line < text_end)

{

const char* line_end = (const char*)memchr(line, '\n', text_end - line);

if (!line_end)

line_end = text_end;

if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)

text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);

line = line_end + 1;

lines_skipped++;

}

pos.y += lines_skipped * line_height;

}

text_size.y = (pos - text_pos).y;

ImRect bb(text_pos, text_pos + text_size);

ItemSize(text_size, 0.0f);

ItemAdd(bb, 0);

}

{

va_list args;

va_start(args, fmt);

TextV(fmt, args);

va_end(args);

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return;

const char* text, *text_end;

ImFormatStringToTempBufferV(&text, &text_end, fmt, args);

TextEx(text, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);

{

va_list args;

va_start(args, fmt);

TextColoredV(col, fmt, args);

va_end(args);

{

PushStyleColor(ImGuiCol_Text, col);

TextV(fmt, args);

PopStyleColor();

{

va_list args;

va_start(args, fmt);

TextDisabledV(fmt, args);

va_end(args);

{

ImGuiContext& g = *GImGui;

PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);

TextV(fmt, args);

PopStyleColor();

{

va_list args;

va_start(args, fmt);

TextWrappedV(fmt, args);

va_end(args);

{

ImGuiContext& g = *GImGui;

const bool need_backup = (g.CurrentWindow->DC.TextWrapPos < 0.0f); // Keep existing wrap position if one is already set

if (need_backup)

PushTextWrapPos(0.0f);

TextV(fmt, args);

if (need_backup)

PopTextWrapPos();

{

va_list args;

va_start(args, fmt);

LabelTextV(label, fmt, args);

va_end(args);

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return;

ImGuiContext& g = *GImGui;

const ImGuiStyle& style = g.Style;

const float w = CalcItemWidth();

const char* value_text_begin, *value_text_end;

ImFormatStringToTempBufferV(&value_text_begin, &value_text_end, fmt, args);

const ImVec2 value_size = CalcTextSize(value_text_begin, value_text_end, false);

const ImVec2 label_size = CalcTextSize(label, NULL, true);

const ImVec2 pos = window->DC.CursorPos;

const ImRect value_bb(pos, pos + ImVec2(w, value_size.y + style.FramePadding.y * 2));

const ImRect total_bb(pos, pos + ImVec2(w + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), ImMax(value_size.y, label_size.y) + style.FramePadding.y * 2));

ItemSize(total_bb, style.FramePadding.y);

if (!ItemAdd(total_bb, 0))

return;

// Render

RenderTextClipped(value_bb.Min + style.FramePadding, value_bb.Max, value_text_begin, value_text_end, &value_size, ImVec2(0.0f, 0.0f));

if (label_size.x > 0.0f)

RenderText(ImVec2(value_bb.Max.x + style.ItemInnerSpacing.x, value_bb.Min.y + style.FramePadding.y), label);

{

va_list args;

va_start(args, fmt);

BulletTextV(fmt, args);

va_end(args);

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return;

ImGuiContext& g = *GImGui;

const ImGuiStyle& style = g.Style;

const char* text_begin, *text_end;

ImFormatStringToTempBufferV(&text_begin, &text_end, fmt, args);

const ImVec2 label_size = CalcTextSize(text_begin, text_end, false);

const ImVec2 total_size = ImVec2(g.FontSize + (label_size.x > 0.0f ? (label_size.x + style.FramePadding.x * 2) : 0.0f), label_size.y); // Empty text doesn't add padding

ImVec2 pos = window->DC.CursorPos;

pos.y += window->DC.CurrLineTextBaseOffset;

ItemSize(total_size, 0.0f);

const ImRect bb(pos, pos + total_size);

if (!ItemAdd(bb, 0))

return;

// Render

ImU32 text_col = GetColorU32(ImGuiCol_Text);

RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, g.FontSize * 0.5f), text_col);

RenderText(bb.Min + ImVec2(g.FontSize + style.FramePadding.x * 2, 0.0f), text_begin, text_end, false);

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = GetCurrentWindow();

// Default only reacts to left mouse button

if ((flags & ImGuiButtonFlags_MouseButtonMask_) == 0)

flags |= ImGuiButtonFlags_MouseButtonLeft;

// Default behavior requires click + release inside bounding box

if ((flags & ImGuiButtonFlags_PressedOnMask_) == 0)

flags |= ImGuiButtonFlags_PressedOnDefault_;

// Default behavior inherited from item flags

// Note that _both_ ButtonFlags and ItemFlags are valid sources, so copy one into the item_flags and only check that.

ImGuiItemFlags item_flags = (g.LastItemData.ID == id ? g.LastItemData.InFlags : g.CurrentItemFlags);

if (flags & ImGuiButtonFlags_AllowOverlap)

item_flags |= ImGuiItemFlags_AllowOverlap;

if (flags & ImGuiButtonFlags_Repeat)

item_flags |= ImGuiItemFlags_ButtonRepeat;

ImGuiWindow* backup_hovered_window = g.HoveredWindow;

const bool flatten_hovered_children = (flags & ImGuiButtonFlags_FlattenChildren) && g.HoveredWindow && g.HoveredWindow->RootWindow == window;

if (flatten_hovered_children)

g.HoveredWindow = window;

#ifdef IMGUI_ENABLE_TEST_ENGINE

// Alternate registration spot, for when caller didn't use ItemAdd()

if (g.LastItemData.ID != id)

IMGUI_TEST_ENGINE_ITEM_ADD(id, bb, NULL);

#endif

bool pressed = false;

bool hovered = ItemHoverable(bb, id, item_flags);

// Special mode for Drag and Drop where holding button pressed for a long time while dragging another item triggers the button

if (g.DragDropActive && (flags & ImGuiButtonFlags_PressedOnDragDropHold) && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoHoldToOpenOthers))

if (IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))

{

hovered = true;

SetHoveredID(id);

if (g.HoveredIdTimer - g.IO.DeltaTime <= DRAGDROP_HOLD_TO_OPEN_TIMER && g.HoveredIdTimer >= DRAGDROP_HOLD_TO_OPEN_TIMER)

{

pressed = true;

g.DragDropHoldJustPressedId = id;

FocusWindow(window);

}

}

if (flatten_hovered_children)

g.HoveredWindow = backup_hovered_window;

// Mouse handling

const ImGuiID test_owner_id = (flags & ImGuiButtonFlags_NoTestKeyOwner) ? ImGuiKeyOwner_Any : id;

if (hovered)

{

IM_ASSERT(id != 0); // Lazily check inside rare path.

// Poll mouse buttons

// - 'mouse_button_clicked' is generally carried into ActiveIdMouseButton when setting ActiveId.

// - Technically we only need some values in one code path, but since this is gated by hovered test this is fine.

int mouse_button_clicked = -1;

int mouse_button_released = -1;

for (int button = 0; button < 3; button++)

if (flags & (ImGuiButtonFlags_MouseButtonLeft << button)) // Handle ImGuiButtonFlags_MouseButtonRight and ImGuiButtonFlags_MouseButtonMiddle here.

{

if (IsMouseClicked(button, ImGuiInputFlags_None, test_owner_id) && mouse_button_clicked == -1) { mouse_button_clicked = button; }

if (IsMouseReleased(button, test_owner_id) && mouse_button_released == -1) { mouse_button_released = button; }

}

// Process initial action

if (!(flags & ImGuiButtonFlags_NoKeyModifiers) || (!g.IO.KeyCtrl && !g.IO.KeyShift && !g.IO.KeyAlt))

{

if (mouse_button_clicked != -1 && g.ActiveId != id)

{

if (!(flags & ImGuiButtonFlags_NoSetKeyOwner))

SetKeyOwner(MouseButtonToKey(mouse_button_clicked), id);

if (flags & (ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere))

{

SetActiveID(id, window);

g.ActiveIdMouseButton = mouse_button_clicked;

if (!(flags & ImGuiButtonFlags_NoNavFocus))

{

SetFocusID(id, window);

FocusWindow(window);

}

else

{

FocusWindow(window, ImGuiFocusRequestFlags_RestoreFocusedChild); // Still need to focus and bring to front, but try to avoid losing NavId when navigating a child

}

}

if ((flags & ImGuiButtonFlags_PressedOnClick) || ((flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseClickedCount[mouse_button_clicked] == 2))

{

pressed = true;

if (flags & ImGuiButtonFlags_NoHoldingActiveId)

ClearActiveID();

else

SetActiveID(id, window); // Hold on ID

g.ActiveIdMouseButton = mouse_button_clicked;

if (!(flags & ImGuiButtonFlags_NoNavFocus))

{

SetFocusID(id, window);

FocusWindow(window);

}

else

{

FocusWindow(window, ImGuiFocusRequestFlags_RestoreFocusedChild); // Still need to focus and bring to front, but try to avoid losing NavId when navigating a child

}

}

}

if (flags & ImGuiButtonFlags_PressedOnRelease)

{

if (mouse_button_released != -1)

{

const bool has_repeated_at_least_once = (item_flags & ImGuiItemFlags_ButtonRepeat) && g.IO.MouseDownDurationPrev[mouse_button_released] >= g.IO.KeyRepeatDelay; // Repeat mode trumps on release behavior

if (!has_repeated_at_least_once)

pressed = true;

if (!(flags & ImGuiButtonFlags_NoNavFocus))

SetFocusID(id, window);

ClearActiveID();

}

}

// 'Repeat' mode acts when held regardless of _PressedOn flags (see table above).

// Relies on repeat logic of IsMouseClicked() but we may as well do it ourselves if we end up exposing finer RepeatDelay/RepeatRate settings.

if (g.ActiveId == id && (item_flags & ImGuiItemFlags_ButtonRepeat))

if (g.IO.MouseDownDuration[g.ActiveIdMouseButton] > 0.0f && IsMouseClicked(g.ActiveIdMouseButton, ImGuiInputFlags_Repeat, test_owner_id))

pressed = true;

}

if (pressed)

g.NavDisableHighlight = true;

}

// Gamepad/Keyboard handling

// We report navigated and navigation-activated items as hovered but we don't set g.HoveredId to not interfere with mouse.

if (g.NavId == id && !g.NavDisableHighlight && g.NavDisableMouseHover)

if (!(flags & ImGuiButtonFlags_NoHoveredOnFocus))

hovered = true;

if (g.NavActivateDownId == id)

{

bool nav_activated_by_code = (g.NavActivateId == id);

bool nav_activated_by_inputs = (g.NavActivatePressedId == id);

if (!nav_activated_by_inputs && (item_flags & ImGuiItemFlags_ButtonRepeat))

{

// Avoid pressing multiple keys from triggering excessive amount of repeat events

const ImGuiKeyData* key1 = GetKeyData(ImGuiKey_Space);

const ImGuiKeyData* key2 = GetKeyData(ImGuiKey_Enter);

const ImGuiKeyData* key3 = GetKeyData(ImGuiKey_NavGamepadActivate);

const float t1 = ImMax(ImMax(key1->DownDuration, key2->DownDuration), key3->DownDuration);

nav_activated_by_inputs = CalcTypematicRepeatAmount(t1 - g.IO.DeltaTime, t1, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate) > 0;

}

if (nav_activated_by_code || nav_activated_by_inputs)

{

// Set active id so it can be queried by user via IsItemActive(), equivalent of holding the mouse button.

pressed = true;

SetActiveID(id, window);

g.ActiveIdSource = g.NavInputSource;

if (!(flags & ImGuiButtonFlags_NoNavFocus) && !(g.NavActivateFlags & ImGuiActivateFlags_FromShortcut))

SetFocusID(id, window);

if (g.NavActivateFlags & ImGuiActivateFlags_FromShortcut)

g.ActiveIdFromShortcut = true;

}

}

// Process while held

bool held = false;

if (g.ActiveId == id)

{

if (g.ActiveIdSource == ImGuiInputSource_Mouse)

{

if (g.ActiveIdIsJustActivated)

g.ActiveIdClickOffset = g.IO.MousePos - bb.Min;

const int mouse_button = g.ActiveIdMouseButton;

if (mouse_button == -1)

{

// Fallback for the rare situation were g.ActiveId was set programmatically or from another widget (e.g. #6304).

ClearActiveID();

}

else if (IsMouseDown(mouse_button, test_owner_id))

{

held = true;

}

else

{

bool release_in = hovered && (flags & ImGuiButtonFlags_PressedOnClickRelease) != 0;

bool release_anywhere = (flags & ImGuiButtonFlags_PressedOnClickReleaseAnywhere) != 0;

if ((release_in || release_anywhere) && !g.DragDropActive)

{

// Report as pressed when releasing the mouse (this is the most common path)

bool is_double_click_release = (flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseReleased[mouse_button] && g.IO.MouseClickedLastCount[mouse_button] == 2;

bool is_repeating_already = (item_flags & ImGuiItemFlags_ButtonRepeat) && g.IO.MouseDownDurationPrev[mouse_button] >= g.IO.KeyRepeatDelay; // Repeat mode trumps <on release>

bool is_button_avail_or_owned = TestKeyOwner(MouseButtonToKey(mouse_button), test_owner_id);

if (!is_double_click_release && !is_repeating_already && is_button_avail_or_owned)

pressed = true;

}

ClearActiveID();

}

if (!(flags & ImGuiButtonFlags_NoNavFocus))

g.NavDisableHighlight = true;

}

else if (g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad)

{

// When activated using Nav, we hold on the ActiveID until activation button is released

if (g.NavActivateDownId == id)

held = true; // hovered == true not true as we are already likely hovered on direct activation.

else

ClearActiveID();

}

if (pressed)

g.ActiveIdHasBeenPressedBefore = true;

}

// Activation highlight (this may be a remote activation)

if (g.NavHighlightActivatedId == id)

hovered = true;

if (out_hovered) *out_hovered = hovered;

if (out_held) *out_held = held;

return pressed;

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return false;

ImGuiContext& g = *GImGui;

const ImGuiStyle& style = g.Style;

const ImGuiID id = window->GetID(label);

const ImVec2 label_size = CalcTextSize(label, NULL, true);

ImVec2 pos = window->DC.CursorPos;

if ((flags & ImGuiButtonFlags_AlignTextBaseLine) && style.FramePadding.y < window->DC.CurrLineTextBaseOffset) // Try to vertically align buttons that are smaller/have no padding so that text baseline matches (bit hacky, since it shouldn't be a flag)

pos.y += window->DC.CurrLineTextBaseOffset - style.FramePadding.y;

ImVec2 size = CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);

const ImRect bb(pos, pos + size);

ItemSize(size, style.FramePadding.y);

if (!ItemAdd(bb, id))

return false;

bool hovered, held;

bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

// Render

const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);

RenderNavHighlight(bb, id);

RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);

if (g.LogEnabled)

LogSetNextTextDecoration("[", "]");

RenderTextClipped(bb.Min + style.FramePadding, bb.Max - style.FramePadding, label, NULL, &label_size, style.ButtonTextAlign, &bb);

// Automatically close popups

//if (pressed && !(flags & ImGuiButtonFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))

// CloseCurrentPopup();

IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);

return pressed;

{

ImGuiContext& g = *GImGui;

float backup_padding_y = g.Style.FramePadding.y;

g.Style.FramePadding.y = 0.0f;

bool pressed = ButtonEx(label, ImVec2(0, 0), ImGuiButtonFlags_AlignTextBaseLine);

g.Style.FramePadding.y = backup_padding_y;

return pressed;

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return false;

// Cannot use zero-size for InvisibleButton(). Unlike Button() there is not way to fallback using the label size.

IM_ASSERT(size_arg.x != 0.0f && size_arg.y != 0.0f);

const ImGuiID id = window->GetID(str_id);

ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);

const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);

ItemSize(size);

if (!ItemAdd(bb, id))

return false;

bool hovered, held;

bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

IMGUI_TEST_ENGINE_ITEM_INFO(id, str_id, g.LastItemData.StatusFlags);

return pressed;

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return false;

const ImGuiID id = window->GetID(str_id);

const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);

const float default_size = GetFrameHeight();

ItemSize(size, (size.y >= default_size) ? g.Style.FramePadding.y : -1.0f);

if (!ItemAdd(bb, id))

return false;

bool hovered, held;

bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

// Render

const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);

const ImU32 text_col = GetColorU32(ImGuiCol_Text);

RenderNavHighlight(bb, id);

RenderFrame(bb.Min, bb.Max, bg_col, true, g.Style.FrameRounding);

RenderArrow(window->DrawList, bb.Min + ImVec2(ImMax(0.0f, (size.x - g.FontSize) * 0.5f), ImMax(0.0f, (size.y - g.FontSize) * 0.5f)), text_col, dir);

IMGUI_TEST_ENGINE_ITEM_INFO(id, str_id, g.LastItemData.StatusFlags);

return pressed;

{

float sz = GetFrameHeight();

return ArrowButtonEx(str_id, dir, ImVec2(sz, sz), ImGuiButtonFlags_None);

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

// Tweak 1: Shrink hit-testing area if button covers an abnormally large proportion of the visible region. That's in order to facilitate moving the window away. (#3825)

// This may better be applied as a general hit-rect reduction mechanism for all widgets to ensure the area to move window is always accessible?

const ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize));

ImRect bb_interact = bb;

const float area_to_visible_ratio = window->OuterRectClipped.GetArea() / bb.GetArea();

if (area_to_visible_ratio < 1.5f)

bb_interact.Expand(ImTrunc(bb_interact.GetSize() * -0.25f));

// Tweak 2: We intentionally allow interaction when clipped so that a mechanical Alt,Right,Activate sequence can always close a window.

// (this isn't the common behavior of buttons, but it doesn't affect the user because navigation tends to keep items visible in scrolling layer).

bool is_clipped = !ItemAdd(bb_interact, id);

bool hovered, held;

bool pressed = ButtonBehavior(bb_interact, id, &hovered, &held);

if (is_clipped)

return pressed;

// Render

ImU32 bg_col = GetColorU32(held ? ImGuiCol_ButtonActive : ImGuiCol_ButtonHovered);

if (hovered)

window->DrawList->AddRectFilled(bb.Min, bb.Max, bg_col);

RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_Compact);

ImU32 cross_col = GetColorU32(ImGuiCol_Text);

ImVec2 cross_center = bb.GetCenter() - ImVec2(0.5f, 0.5f);

float cross_extent = g.FontSize * 0.5f * 0.7071f - 1.0f;

window->DrawList->AddLine(cross_center + ImVec2(+cross_extent, +cross_extent), cross_center + ImVec2(-cross_extent, -cross_extent), cross_col, 1.0f);

window->DrawList->AddLine(cross_center + ImVec2(+cross_extent, -cross_extent), cross_center + ImVec2(-cross_extent, +cross_extent), cross_col, 1.0f);

return pressed;

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize));

bool is_clipped = !ItemAdd(bb, id);

bool hovered, held;

bool pressed = ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_None);

if (is_clipped)

return pressed;

// Render

ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);

ImU32 text_col = GetColorU32(ImGuiCol_Text);

if (hovered || held)

window->DrawList->AddRectFilled(bb.Min, bb.Max, bg_col);

RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_Compact);

RenderArrow(window->DrawList, bb.Min, text_col, window->Collapsed ? ImGuiDir_Right : ImGuiDir_Down, 1.0f);

// Switch to moving the window after mouse is moved beyond the initial drag threshold

if (IsItemActive() && IsMouseDragging(0))

StartMouseMovingWindow(window);

return pressed;

{

const ImRect outer_rect = window->Rect();

const ImRect inner_rect = window->InnerRect;

const float border_size = window->WindowBorderSize;

const float scrollbar_size = window->ScrollbarSizes[axis ^ 1]; // (ScrollbarSizes.x = width of Y scrollbar; ScrollbarSizes.y = height of X scrollbar)

IM_ASSERT(scrollbar_size > 0.0f);

if (axis == ImGuiAxis_X)

return ImRect(inner_rect.Min.x, ImMax(outer_rect.Min.y, outer_rect.Max.y - border_size - scrollbar_size), inner_rect.Max.x - border_size, outer_rect.Max.y - border_size);

else

return ImRect(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y, outer_rect.Max.x - border_size, inner_rect.Max.y - border_size);

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

const ImGuiID id = GetWindowScrollbarID(window, axis);

// Calculate scrollbar bounding box

ImRect bb = GetWindowScrollbarRect(window, axis);

ImDrawFlags rounding_corners = ImDrawFlags_RoundCornersNone;

if (axis == ImGuiAxis_X)

{

rounding_corners |= ImDrawFlags_RoundCornersBottomLeft;

if (!window->ScrollbarY)

rounding_corners |= ImDrawFlags_RoundCornersBottomRight;

}

else

{

if ((window->Flags & ImGuiWindowFlags_NoTitleBar) && !(window->Flags & ImGuiWindowFlags_MenuBar))

rounding_corners |= ImDrawFlags_RoundCornersTopRight;

if (!window->ScrollbarX)

rounding_corners |= ImDrawFlags_RoundCornersBottomRight;

}

float size_visible = window->InnerRect.Max[axis] - window->InnerRect.Min[axis];

float size_contents = window->ContentSize[axis] + window->WindowPadding[axis] * 2.0f;

ImS64 scroll = (ImS64)window->Scroll[axis];

ScrollbarEx(bb, id, axis, &scroll, (ImS64)size_visible, (ImS64)size_contents, rounding_corners);

window->Scroll[axis] = (float)scroll;

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

if (window->SkipItems)

return false;

const float bb_frame_width = bb_frame.GetWidth();

const float bb_frame_height = bb_frame.GetHeight();

if (bb_frame_width <= 0.0f || bb_frame_height <= 0.0f)

return false;

// When we are too small, start hiding and disabling the grab (this reduce visual noise on very small window and facilitate using the window resize grab)

float alpha = 1.0f;

if ((axis == ImGuiAxis_Y) && bb_frame_height < g.FontSize + g.Style.FramePadding.y * 2.0f)

alpha = ImSaturate((bb_frame_height - g.FontSize) / (g.Style.FramePadding.y * 2.0f));

if (alpha <= 0.0f)

return false;

const ImGuiStyle& style = g.Style;

const bool allow_interaction = (alpha >= 1.0f);

ImRect bb = bb_frame;

bb.Expand(ImVec2(-ImClamp(IM_TRUNC((bb_frame_width - 2.0f) * 0.5f), 0.0f, 3.0f), -ImClamp(IM_TRUNC((bb_frame_height - 2.0f) * 0.5f), 0.0f, 3.0f)));

// V denote the main, longer axis of the scrollbar (= height for a vertical scrollbar)

const float scrollbar_size_v = (axis == ImGuiAxis_X) ? bb.GetWidth() : bb.GetHeight();

// Calculate the height of our grabbable box. It generally represent the amount visible (vs the total scrollable amount)

// But we maintain a minimum size in pixel to allow for the user to still aim inside.

IM_ASSERT(ImMax(size_contents_v, size_visible_v) > 0.0f); // Adding this assert to check if the ImMax(XXX,1.0f) is still needed. PLEASE CONTACT ME if this triggers.

const ImS64 win_size_v = ImMax(ImMax(size_contents_v, size_visible_v), (ImS64)1);

const float grab_h_pixels = ImClamp(scrollbar_size_v * ((float)size_visible_v / (float)win_size_v), style.GrabMinSize, scrollbar_size_v);

const float grab_h_norm = grab_h_pixels / scrollbar_size_v;

// Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().

bool held = false;

bool hovered = false;

ItemAdd(bb_frame, id, NULL, ImGuiItemFlags_NoNav);

ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_NoNavFocus);

const ImS64 scroll_max = ImMax((ImS64)1, size_contents_v - size_visible_v);

float scroll_ratio = ImSaturate((float)*p_scroll_v / (float)scroll_max);

float grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v; // Grab position in normalized space

if (held && allow_interaction && grab_h_norm < 1.0f)

{

const float scrollbar_pos_v = bb.Min[axis];

const float mouse_pos_v = g.IO.MousePos[axis];

// Click position in scrollbar normalized space (0.0f->1.0f)

const float clicked_v_norm = ImSaturate((mouse_pos_v - scrollbar_pos_v) / scrollbar_size_v);

const int held_dir = (clicked_v_norm < grab_v_norm) ? -1 : (clicked_v_norm > grab_v_norm + grab_h_norm) ? +1 : 0;

if (g.ActiveIdIsJustActivated)