// ImGui library v1.45 WIP

// Main code & documentation

// See ImGui::ShowTestWindow() in imgui_demo.cpp for demo code.

// Read 'Programmer guide' below for notes on how to setup ImGui in your codebase.

// Get latest version at https://github.com/ocornut/imgui

// Releases change-log at https://github.com/ocornut/imgui/releases

// Developed by Omar Cornut and ImGui contributors.

/*

Index

- MISSION STATEMENT

- END-USER GUIDE

- PROGRAMMER GUIDE (read me!)

- API BREAKING CHANGES (read me when you update!)

- FREQUENTLY ASKED QUESTIONS (FAQ), TIPS

- How do I update to a newer version of ImGui?

- Can I have multiple widgets with the same label? Can I have widget without a label? (Yes)

- Why is my text output blurry?

- How can I load a different font than the default?

- How can I load multiple fonts?

- How can I display and input non-latin characters such as Chinese, Japanese, Korean, Cyrillic?

- ISSUES & TODO-LIST

- CODE

MISSION STATEMENT

=================

- easy to use to create code-driven and data-driven tools

- easy to use to create ad hoc short-lived tools and long-lived, more elaborate tools

- easy to hack and improve

- minimize screen real-estate usage

- minimize setup and maintenance

- minimize state storage on user side

- portable, minimize dependencies, run on target (consoles, phones, etc.)

- efficient runtime (NB- we do allocate when "growing" content - creating a window / opening a tree node for the first time, etc. - but a typical frame won't allocate anything)

- read about immediate-mode gui principles @ http://mollyrocket.com/861, http://mollyrocket.com/forums/index.html

Designed for developers and content-creators, not the typical end-user! Some of the weaknesses includes:

- doesn't look fancy, doesn't animate

- limited layout features, intricate layouts are typically crafted in code

- occasionally uses statically sized buffers for string manipulations - won't crash, but some very long pieces of text may be clipped. functions like ImGui::TextUnformatted() don't have such restriction.

END-USER GUIDE

==============

- double-click title bar to collapse window

- click upper right corner to close a window, available when 'bool* p_opened' is passed to ImGui::Begin()

- click and drag on lower right corner to resize window

- click and drag on any empty space to move window

- double-click/double-tap on lower right corner grip to auto-fit to content

- TAB/SHIFT+TAB to cycle through keyboard editable fields

- use mouse wheel to scroll

- use CTRL+mouse wheel to zoom window contents (if IO.FontAllowScaling is true)

- CTRL+Click on a slider or drag box to input value as text

- text editor:

- Hold SHIFT or use mouse to select text.

- CTRL+Left/Right to word jump

- CTRL+Shift+Left/Right to select words

- CTRL+A our Double-Click to select all

- CTRL+X,CTRL+C,CTRL+V to use OS clipboard

- CTRL+Z,CTRL+Y to undo/redo

- ESCAPE to revert text to its original value

- You can apply arithmetic operators +,*,/ on numerical values. Use +- to subtract (because - would set a negative value!)

PROGRAMMER GUIDE

================

- read the FAQ below this section!

- your code creates the UI, if your code doesn't run the UI is gone! == very dynamic UI, no construction/destructions steps, less data retention on your side, no state duplication, less sync, less bugs.

- call and read ImGui::ShowTestWindow() for demo code demonstrating most features.

- see examples/ folder for standalone sample applications. e.g. examples/opengl_example/

- customization: PushStyleColor()/PushStyleVar() or the style editor to tweak the look of the interface (e.g. if you want a more compact UI or a different color scheme).

- getting started:

- initialisation: call ImGui::GetIO() to retrieve the ImGuiIO structure and fill the 'Settings' data.

- every frame:

1/ in your mainloop or right after you got your keyboard/mouse info, call ImGui::GetIO() and fill the 'Input' data, then call ImGui::NewFrame().

2/ use any ImGui function you want between NewFrame() and Render()

3/ ImGui::Render() to render all the accumulated command-lists. it will call your RenderDrawListFn handler that you set in the IO structure.

- all rendering information are stored into command-lists until ImGui::Render() is called.

- ImGui never touches or know about your GPU state. the only function that knows about GPU is the RenderDrawListFn handler that you must provide.

- effectively it means you can create widgets at any time in your code, regardless of "update" vs "render" considerations.

- refer to the examples applications in the examples/ folder for instruction on how to setup your code.

- a typical application skeleton may be:

// Application init

ImGuiIO& io = ImGui::GetIO();

io.DisplaySize.x = 1920.0f;

io.DisplaySize.y = 1280.0f;

io.DeltaTime = 1.0f/60.0f;

io.IniFilename = "imgui.ini";

// TODO: Fill others settings of the io structure

// Load texture

unsigned char* pixels;

int width, height, bytes_per_pixels;

io.Fonts->GetTexDataAsRGBA32(pixels, &width, &height, &bytes_per_pixels);

// TODO: copy texture to graphics memory.

// TODO: store your texture pointer/identifier in 'io.Fonts->TexID'

// Application main loop

while (true)

{

// 1) get low-level input

// e.g. on Win32, GetKeyboardState(), or poll your events, etc.

// 2) TODO: fill all fields of IO structure and call NewFrame

ImGuiIO& io = ImGui::GetIO();

io.MousePos = mouse_pos;

io.MouseDown[0] = mouse_button_0;

io.KeysDown[i] = ...

ImGui::NewFrame();

// 3) most of your application code here - you can use any of ImGui::* functions at any point in the frame

ImGui::Begin("My window");

ImGui::Text("Hello, world.");

ImGui::End();

GameUpdate();

GameRender();

// 4) render & swap video buffers

ImGui::Render();

// swap video buffer, etc.

}

- after calling ImGui::NewFrame() you can read back flags from the IO structure to tell how ImGui intends to use your inputs.

When 'io.WantCaptureMouse' or 'io.WantCaptureKeyboard' flags are set you may want to discard/hide the inputs from the rest of your application.

When 'io.WantInputsCharacters' is set to may want to notify your OS to popup an onscreen keyboard, if available.

API BREAKING CHANGES

====================

Occasionally introducing changes that are breaking the API. The breakage are generally minor and easy to fix.

Here is a change-log of API breaking changes, if you are using one of the functions listed, expect to have to fix some code.

Also read releases logs https://github.com/ocornut/imgui/releases for more details.

- 2015/08/29 (1.45) - with the addition of horizontal scrollbar we made various fixes to inconsistencies with dealing with position:

GetCursorPos()/SetCursorPos() functions now include the scrolled amount. It shouldn't affect the majority of users, but take note that SetCursorPosX(100.0f) puts you at +100 from the starting x position which may include scrolling, not at +100 from the window left side.

GetContentRegionMax()/GetWindowContentRegionMin()/GetWindowContentRegionMax() functions allow include the scrolled amount. Typically those were used in cases where no scrolling would happen so it may not be a problem, but watch out!

- 2015/08/29 (1.45) - renamed style.ScrollbarWidth to style.ScrollbarSize

- 2015/08/05 (1.44) - split imgui.cpp into extra files: imgui_demo.cpp imgui_draw.cpp imgui_internal.h that you need to add to your project.

- 2015/07/18 (1.44) - fixed angles in ImDrawList::PathArcTo(), PathArcToFast() (introduced in 1.43) being off by an extra PI for no justifiable reason

- 2015/07/14 (1.43) - add new ImFontAtlas::AddFont() API. For the old AddFont***, moved the 'font_no' parameter of ImFontAtlas::AddFont** functions to the ImFontConfig structure.

you need to render your textured triangles with bilinear filtering to benefit from sub-pixel positioning of text.

- 2015/07/08 (1.43) - switched rendering data to use indexed rendering. this is saving a fair amount of CPU/GPU and enables us to get anti-aliasing for a marginal cost.

this necessary change will break your rendering function! the fix should be very easy. sorry for that :(

- if you are using a vanilla copy of one of the imgui_impl_XXXX.cpp provided in the example, you just need to update your copy and you can ignore the rest.

- the signature of the io.RenderDrawListsFn handler has changed!

ImGui_XXXX_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)

became:

ImGui_XXXX_RenderDrawLists(ImDrawData* draw_data).

argument 'cmd_lists' -> 'draw_data->CmdLists'

argument 'cmd_lists_count' -> 'draw_data->CmdListsCount'

ImDrawList 'commands' -> 'CmdBuffer'

ImDrawList 'vtx_buffer' -> 'VtxBuffer'

ImDrawList n/a -> 'IdxBuffer' (new)

ImDrawCmd 'vtx_count' -> 'ElemCount'

ImDrawCmd 'clip_rect' -> 'ClipRect'

ImDrawCmd 'user_callback' -> 'UserCallback'

ImDrawCmd 'texture_id' -> 'TextureId'

- each ImDrawList now contains both a vertex buffer and an index buffer. For each command, render ElemCount/3 triangles using indices from the index buffer.

- if you REALLY cannot render indexed primitives, you can call the draw_data->DeIndexAllBuffers() method to de-index the buffers. This is slow and a waste of CPU/GPU. Prefer using indexed rendering!

- refer to code in the examples/ folder or ask on the GitHub if you are unsure of how to upgrade. please upgrade!

- 2015/07/10 (1.43) - changed SameLine() parameters from int to float.

- 2015/07/02 (1.42) - renamed SetScrollPosHere() to SetScrollFromCursorPos(). Kept inline redirection function (will obsolete).

- 2015/07/02 (1.42) - renamed GetScrollPosY() to GetScrollY(). Necessary to reduce confusion along with other scrolling functions, because positions (e.g. cursor position) are not equivalent to scrolling amount.

- 2015/06/14 (1.41) - changed ImageButton() default bg_col parameter from (0,0,0,1) (black) to (0,0,0,0) (transparent) - makes a difference when texture have transparence

- 2015/06/14 (1.41) - changed Selectable() API from (label, selected, size) to (label, selected, flags, size). Size override should have been rarely be used. Sorry!

- 2015/05/31 (1.40) - renamed GetWindowCollapsed() to IsWindowCollapsed() for consistency. Kept inline redirection function (will obsolete).

- 2015/05/31 (1.40) - renamed IsRectClipped() to IsRectVisible() for consistency. Note that return value is opposite! Kept inline redirection function (will obsolete).

- 2015/05/27 (1.40) - removed the third 'repeat_if_held' parameter from Button() - sorry! it was rarely used and inconsistent. Use PushButtonRepeat(true) / PopButtonRepeat() to enable repeat on desired buttons.

- 2015/05/11 (1.40) - changed BeginPopup() API, takes a string identifier instead of a bool. ImGui needs to manage the open/closed state of popups. Call OpenPopup() to actually set the "opened" state of a popup. BeginPopup() returns true if the popup is opened.

- 2015/05/03 (1.40) - removed style.AutoFitPadding, using style.WindowPadding makes more sense (the default values were already the same).

- 2015/04/13 (1.38) - renamed IsClipped() to IsRectClipped(). Kept inline redirection function (will obsolete).

- 2015/04/09 (1.38) - renamed ImDrawList::AddArc() to ImDrawList::AddArcFast() for compatibility with future API

- 2015/04/03 (1.38) - removed ImGuiCol_CheckHovered, ImGuiCol_CheckActive, replaced with the more general ImGuiCol_FrameBgHovered, ImGuiCol_FrameBgActive.

- 2014/04/03 (1.38) - removed support for passing -FLT_MAX..+FLT_MAX as the range for a SliderFloat(). Use DragFloat() or Inputfloat() instead.

- 2015/03/17 (1.36) - renamed GetItemBoxMin()/GetItemBoxMax()/IsMouseHoveringBox() to GetItemRectMin()/GetItemRectMax()/IsMouseHoveringRect(). Kept inline redirection function (will obsolete).

- 2015/03/15 (1.36) - renamed style.TreeNodeSpacing to style.IndentSpacing, ImGuiStyleVar_TreeNodeSpacing to ImGuiStyleVar_IndentSpacing

- 2015/03/13 (1.36) - renamed GetWindowIsFocused() to IsWindowFocused(). Kept inline redirection function (will obsolete).

- 2015/03/08 (1.35) - renamed style.ScrollBarWidth to style.ScrollbarWidth

- 2015/02/27 (1.34) - renamed OpenNextNode(bool) to SetNextTreeNodeOpened(bool, ImGuiSetCond). Kept inline redirection function (will obsolete).

- 2015/02/27 (1.34) - renamed ImGuiSetCondition_*** to ImGuiSetCond_***, and _FirstUseThisSession becomes _Once.

- 2015/02/11 (1.32) - changed text input callback ImGuiTextEditCallback return type from void-->int. reserved for future use, return 0 for now.

- 2015/02/10 (1.32) - renamed GetItemWidth() to CalcItemWidth() to clarify its evolving behavior

- 2015/02/08 (1.31) - renamed GetTextLineSpacing() to GetTextLineHeightWithSpacing()

- 2015/02/01 (1.31) - removed IO.MemReallocFn (unused)

- 2015/01/19 (1.30) - renamed ImGuiStorage::GetIntPtr()/GetFloatPtr() to GetIntRef()/GetIntRef() because Ptr was conflicting with actual pointer storage functions.

- 2015/01/11 (1.30) - big font/image API change! now loads TTF file. allow for multiple fonts. no need for a PNG loader.

(1.30) - removed GetDefaultFontData(). uses io.Fonts->GetTextureData*() API to retrieve uncompressed pixels.

this sequence:

const void* png_data;

unsigned int png_size;

ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);

// <Copy to GPU>

became:

unsigned char* pixels;

int width, height;

io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);

// <Copy to GPU>

io.Fonts->TexID = (your_texture_identifier);

you now have much more flexibility to load multiple TTF fonts and manage the texture buffer for internal needs.

it is now recommended that you sample the font texture with bilinear interpolation.

(1.30) - added texture identifier in ImDrawCmd passed to your render function (we can now render images). make sure to set io.Fonts->TexID.

(1.30) - removed IO.PixelCenterOffset (unnecessary, can be handled in user projection matrix)

(1.30) - removed ImGui::IsItemFocused() in favor of ImGui::IsItemActive() which handles all widgets

- 2014/12/10 (1.18) - removed SetNewWindowDefaultPos() in favor of new generic API SetNextWindowPos(pos, ImGuiSetCondition_FirstUseEver)

- 2014/11/28 (1.17) - moved IO.Font*** options to inside the IO.Font-> structure (FontYOffset, FontTexUvForWhite, FontBaseScale, FontFallbackGlyph)

- 2014/11/26 (1.17) - reworked syntax of IMGUI_ONCE_UPON_A_FRAME helper macro to increase compiler compatibility

- 2014/11/07 (1.15) - renamed IsHovered() to IsItemHovered()

- 2014/10/02 (1.14) - renamed IMGUI_INCLUDE_IMGUI_USER_CPP to IMGUI_INCLUDE_IMGUI_USER_INL and imgui_user.cpp to imgui_user.inl (more IDE friendly)

- 2014/09/25 (1.13) - removed 'text_end' parameter from IO.SetClipboardTextFn (the string is now always zero-terminated for simplicity)

- 2014/09/24 (1.12) - renamed SetFontScale() to SetWindowFontScale()

- 2014/09/24 (1.12) - moved IM_MALLOC/IM_REALLOC/IM_FREE preprocessor defines to IO.MemAllocFn/IO.MemReallocFn/IO.MemFreeFn

- 2014/08/30 (1.09) - removed IO.FontHeight (now computed automatically)

- 2014/08/30 (1.09) - moved IMGUI_FONT_TEX_UV_FOR_WHITE preprocessor define to IO.FontTexUvForWhite

- 2014/08/28 (1.09) - changed the behavior of IO.PixelCenterOffset following various rendering fixes

FREQUENTLY ASKED QUESTIONS (FAQ), TIPS

======================================

Q: How do I update to a newer version of ImGui?

A: Overwrite the following files:

imgui.cpp

imgui.h

imgui_demo.cpp

imgui_draw.cpp

imgui_internal.h

stb_rect_pack.h

stb_textedit.h

stb_truetype.h

Don't overwrite imconfig.h if you have modification to your copy.

Check the "API BREAKING CHANGES" sections for a list of occasional API breaking changes. If you have a problem with a function, search for its name

in the code, there will likely be a comment about it. Please report any issue to the GitHub page!

Q: Can I have multiple widgets with the same label? Can I have widget without a label? (Yes)

A: Yes. A primer on the use of labels/IDs in ImGui..

- Elements that are not clickable, such as Text() items don't need an ID.

- Interactive widgets require state to be carried over multiple frames (most typically ImGui often needs to remember what is the "active" widget).

to do so they need an unique ID. unique ID are typically derived from a string label, an integer index or a pointer.

Button("OK"); // Label = "OK", ID = hash of "OK"

Button("Cancel"); // Label = "Cancel", ID = hash of "Cancel"

- ID are uniquely scoped within windows, tree nodes, etc. so no conflict can happen if you have two buttons called "OK" in two different windows

or in two different locations of a tree.

- if you have a same ID twice in the same location, you'll have a conflict:

Button("OK");

Button("OK"); // ID collision! Both buttons will be treated as the same.

Fear not! this is easy to solve and there are many ways to solve it!

- when passing a label you can optionally specify extra unique ID information within string itself. This helps solving the simpler collision cases.

use "##" to pass a complement to the ID that won't be visible to the end-user:

Button("Play##0"); // Label = "Play", ID = hash of "Play##0"

Button("Play##1"); // Label = "Play", ID = hash of "Play##1" (different from above)

- so if you want to hide the label but need an ID:

Checkbox("##On", &b); // Label = "", ID = hash of "##On"

- occasionally (rarely) you might want change a label while preserving a constant ID. This allows you to animate labels.

use "###" to pass a label that isn't part of ID:

Button("Hello###ID"; // Label = "Hello", ID = hash of "ID"

Button("World###ID"; // Label = "World", ID = hash of "ID" (same as above)

- use PushID() / PopID() to create scopes and avoid ID conflicts within the same Window.

this is the most convenient way of distinguish ID if you are iterating and creating many UI elements.

you can push a pointer, a string or an integer value. remember that ID are formed from the addition of everything in the ID stack!

for (int i = 0; i < 100; i++)

{

PushID(i);

Button("Click"); // Label = "Click", ID = hash of integer + "label" (unique)

PopID();

}

for (int i = 0; i < 100; i++)

{

MyObject* obj = Objects[i];

PushID(obj);

Button("Click"); // Label = "Click", ID = hash of pointer + "label" (unique)

PopID();

}

for (int i = 0; i < 100; i++)

{

MyObject* obj = Objects[i];

PushID(obj->Name);

Button("Click"); // Label = "Click", ID = hash of string + "label" (unique)

PopID();

}

- more example showing that you can stack multiple prefixes into the ID stack:

Button("Click"); // Label = "Click", ID = hash of "Click"

PushID("node");

Button("Click"); // Label = "Click", ID = hash of "node" + "Click"

PushID(my_ptr);

Button("Click"); // Label = "Click", ID = hash of "node" + ptr + "Click"

PopID();

PopID();

- tree nodes implicitly creates a scope for you by calling PushID().

Button("Click"); // Label = "Click", ID = hash of "Click"

if (TreeNode("node"))

{

Button("Click"); // Label = "Click", ID = hash of "node" + "Click"

TreePop();

}

- when working with trees, ID are used to preserve the opened/closed state of each tree node.

depending on your use cases you may want to use strings, indices or pointers as ID.

e.g. when displaying a single object that may change over time (1-1 relationship), using a static string as ID will preserve your node open/closed state when the targeted object change.

e.g. when displaying a list of objects, using indices or pointers as ID will preserve the node open/closed state differently. experiment and see what makes more sense!

Q: Why is my text output blurry?

A: In your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)

Q: How can I load a different font than the default? (default is an embedded version of ProggyClean.ttf, rendered at size 13)

A: Use the font atlas to load the TTF file you want:

io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels);

io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()

Q: How can I load multiple fonts?

A: Use the font atlas to pack them into a single texture:

ImFont* font0 = io.Fonts->AddFontDefault();

ImFont* font1 = io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels);

ImFont* font2 = io.Fonts->AddFontFromFileTTF("myfontfile2.ttf", size_in_pixels);

io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()

// the first loaded font gets used by default

// use ImGui::PushFont()/ImGui::PopFont() to change the font at runtime

// Options

ImFontConfig config;

config.OversampleH = 3;

config.OversampleV = 3;

config.GlyphExtraSpacing.x = 1.0f;

io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, &config);

// Combine multiple fonts into one

ImWchar ranges[] = { 0xf000, 0xf3ff, 0 };

ImFontConfig config;

config.MergeMode = true;

io.Fonts->AddFontDefault();

io.Fonts->LoadFromFileTTF("fontawesome-webfont.ttf", 16.0f, &config, ranges);

io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, NULL, &config, io.Fonts->GetGlyphRangesJapanese());

Read extra_fonts/README.txt or ImFontAtlas class for more details.

Q: How can I display and input non-latin characters such as Chinese, Japanese, Korean, Cyrillic?

A: When loading a font, pass custom Unicode ranges to specify the glyphs to load. ImGui will support UTF-8 encoding across the board.

Character input depends on you passing the right character code to io.AddInputCharacter(). The example applications do that.

io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels, NULL, io.Fonts->GetGlyphRangesJapanese()); // Load Japanese characters

io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()

io.ImeWindowHandle = MY_HWND; // To input using Microsoft IME, give ImGui the hwnd of your application

- tip: the construct 'IMGUI_ONCE_UPON_A_FRAME { ... }' will run the block of code only once a frame. You can use it to quickly add custom UI in the middle of a deep nested inner loop in your code.

- tip: you can create widgets without a Begin()/End() block, they will go in an implicit window called "Debug"

- tip: you can call Begin() multiple times with the same name during the same frame, it will keep appending to the same window. this is also useful to set yourself in the context of a window (to get/set other settings)

- tip: you can call Render() multiple times (e.g for VR renders).

- tip: call and read the ShowTestWindow() code for more example of how to use ImGui!

ISSUES & TODO-LIST

==================

Issue numbers (#) refer to github issues.

The list below consist mostly of notes of things to do before they are requested/discussed by users (at that point it usually happens on the github)

- window: autofit feedback loop when user relies on any dynamic layout (window width multiplier, column). maybe just clearly drop manual autofit?

- window: add a way for very transient windows (non-saved, temporary overlay over hundreds of objects) to "clean" up from the global window list.

- window: allow resizing of child windows (possibly given min/max for each axis?)

- window: background options for child windows, border option (disable rounding)

- window: resizing from any sides? + mouse cursor directives for app.

- window: get size/pos helpers given names (see discussion in #249)

- window: a collapsed window can be stuck behind the main menu bar?

!- scrolling: allow immediately effective change of scroll if we haven't appended items yet

- widgets: display mode: widget-label, label-widget (aligned on column or using fixed size), label-newline-tab-widget etc.

- widgets: clean up widgets internal toward exposing everything.

- widgets: add a disabled/read-only mode (#211)

- main: considering adding EndFrame()/Init(). some constructs are awkward in the implementation because of the lack of them.

- main: IsItemHovered() make it more consistent for various type of widgets, widgets with multiple components, etc. also effectively IsHovered() region sometimes differs from hot region, e.g tree nodes

- main: IsItemHovered() info stored in a stack? so that 'if TreeNode() { Text; TreePop; } if IsHovered' return the hover state of the TreeNode?

- input text: add ImGuiInputTextFlags_EnterToApply? (off #218)

- input text multi-line: way to dynamically grow the buffer without forcing the user to initially allocate for worse case (follow up on #200)

- input text multi-line: line numbers? status bar? (follow up on #200)

- input text: read-only mode (can still select/copy, always display input buffer)

- input number: optional range min/max for Input*() functions

- input number: holding [-]/[+] buttons could increase the step speed non-linearly (or user-controlled)

- input number: use mouse wheel to step up/down

- input number: applying arithmetics ops (+,-,*,/) messes up with text edit undo stack.

- text: proper alignment options

- layout: horizontal layout helper (#97)

- layout: more generic alignment state (left/right/centered) for single items?

- layout: clean up the InputFloatN/SliderFloatN/ColorEdit4 layout code. item width should include frame padding.

- columns: separator function or parameter that works within the column (currently Separator() bypass all columns) (#125)

- columns: declare column set (each column: fixed size, %, fill, distribute default size among fills) (#125)

- columns: columns header to act as button (~sort op) and allow resize/reorder (#125)

- columns: user specify columns size (#125)

- popup: border options. richer api like BeginChild() perhaps? (#197)

- combo: sparse combo boxes (via function call?)

- combo: contents should extends to fit label if combo widget is small

- combo/listbox: keyboard control. need InputText-like non-active focus + key handling. considering keybord for custom listbox (pr #203)

- listbox: multiple selection

- listbox: user may want to initial scroll to focus on the one selected value?

- listbox: keyboard navigation.

- listbox: scrolling should track modified selection.

- menus: local shortcuts, global shortcuts (#126)

- menus: icons

- menus: menubars: some sort of priority / effect of main menu-bar on desktop size?

- tabs

- separator: separator on the initial position of a window is not visible (cursorpos.y <= clippos.y)

- gauge: various forms of gauge/loading bars widgets

- color: add a better color picker (perhaps a popup).

- plot: plotlines should use the polygon-stroke facilities (currently issues with averaging normals)

- plot: make it easier for user to draw extra stuff into the graph (e.g: draw basis, highlight certain points, 2d plots, multiple plots)

- plot: "smooth" automatic scale over time, user give an input 0.0(full user scale) 1.0(full derived from value)

- plot: add a helper e.g. Plot(char* label, float value, float time_span=2.0f) that stores values and Plot them for you - probably another function name. and/or automatically allow to plot ANY displayed value (more reliance on stable ID)

- file selection widget -> build the tool in our codebase to improve model-dialog idioms

- slider: allow using the [-]/[+] buttons used by InputFloat()/InputInt()

- slider: initial absolute click is imprecise. change to relative movement slider (same as scrollbar).

- slider: add dragging-based widgets to edit values with mouse (on 2 axises), saving screen real-estate.

- slider: tint background based on value (e.g. v_min -> v_max, or use 0.0f either side of the sign)

- slider & drag: int data passing through a float

- drag float: up/down axis

- text edit: clean up the mess caused by converting UTF-8 <> wchar. the code is rather inefficient right now.

- text edit: centered text for slider as input text so it matches typical positioning.

- text edit: flag to disable live update of the user buffer.

- text edit: field resize behavior - field could stretch when being edited? hover tooltip shows more text?

- tree: add treenode/treepush int variants? because (void*) cast from int warns on some platforms/settings

- textwrapped: figure out better way to use TextWrapped() in an always auto-resize context (tooltip, etc.) (git issue #249)

- settings: write more decent code to allow saving/loading new fields

- settings: api for per-tool simple persistent data (bool,int,float,columns sizes,etc.) in .ini file

- style: store rounded corners in texture to use 1 quad per corner (filled and wireframe). so rounding have minor cost.

- style: colorbox not always square?

- text: simple markup language for color change?

- log: LogButtons() options for specifying depth and/or hiding depth slider

- log: have more control over the log scope (e.g. stop logging when leaving current tree node scope)

- log: be able to log anything (e.g. right-click on a window/tree-node, shows context menu? log into tty/file/clipboard)

- log: let user copy any window content to clipboard easily (CTRL+C on windows? while moving it? context menu?). code is commented because it fails with multiple Begin/End pairs.

- filters: set a current filter that tree node can automatically query to hide themselves

- filters: handle wildcards (with implicit leading/trailing *), regexps

- shortcuts: add a shortcut api, e.g. parse "&Save" and/or "Save (CTRL+S)", pass in to widgets or provide simple ways to use (button=activate, input=focus)

!- keyboard: tooltip & combo boxes are messing up / not honoring keyboard tabbing

- keyboard: full keyboard navigation and focus.

- focus: SetKeyboardFocusHere() on with >= 0 offset could be done on same frame (else latch and modulate on beginning of next frame)

- input: rework IO to be able to pass actual events to fix temporal aliasing issues.

- input: support track pad style scrolling & slider edit.

- memory: add a way to discard allocs of unused/transient windows. with the current architecture new windows (including popup, opened combos, listbox) perform at least 3 allocs.

- misc: provide a way to compile out the entire implementation while providing a dummy API (e.g. #define IMGUI_DUMMY_IMPL)

- misc: double-clicking on title bar to minimize isn't consistent, perhaps move to single-click on left-most collapse icon?

- style editor: have a more global HSV setter (e.g. alter hue on all elements). consider replacing active/hovered by offset in HSV space?

- style editor: color child window height expressed in multiple of line height.

- optimization/render: merge command-lists with same clip-rect into one even if they aren't sequential? (as long as in-between clip rectangle don't overlap)?

- optimization: turn some the various stack vectors into statically-sized arrays

- optimization: better clipping for multi-component widgets

*/

#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)

#define _CRT_SECURE_NO_WARNINGS

#endif

#include "imgui.h"

#define IMGUI_DEFINE_MATH_OPERATORS

#include "imgui_internal.h"

#include <ctype.h> // toupper, isprint

#include <math.h> // sqrtf, fabsf, fmodf, powf, cosf, sinf, floorf, ceilf

#include <stdio.h> // vsnprintf, sscanf, printf

#include <new> // new (ptr)

#if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier

#include <stddef.h> // intptr_t

#else

#include <stdint.h> // intptr_t

#endif

#ifdef _MSC_VER

#pragma warning (disable: 4127) // condition expression is constant

#pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff)

#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen

#define snprintf _snprintf

#endif

// Clang warnings with -Weverything

#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 "-Wformat-nonliteral" // warning : format string is not a string literal // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.

#pragma clang diagnostic ignored "-Wexit-time-destructors" // warning : declaration requires an exit-time destructor // exit-time destruction order is undefined. if MemFree() leads to users code that has been disabled before exit it might cause problems. ImGui coding style welcomes static/globals.

#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 "-Wsign-conversion" // warning : implicit conversion changes signedness //

#pragma clang diagnostic ignored "-Wmissing-noreturn" // warning : function xx could be declared with attribute 'noreturn' warning // GetDefaultFontData() asserts which some implementation makes it never return.

#pragma clang diagnostic ignored "-Wdeprecated-declarations"// warning : 'xx' is deprecated: The POSIX name for this item.. // for strdup used in demo code (so user can copy & paste the code)

#pragma clang diagnostic ignored "-Wint-to-void-pointer-cast" // warning : cast to 'void *' from smaller integer type 'int'

#endif

#ifdef __GNUC__

#pragma GCC diagnostic ignored "-Wunused-function" // warning: 'xxxx' defined but not used

#pragma GCC diagnostic ignored "-Wint-to-pointer-cast" // warning: cast to pointer from integer of different size

#endif

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

// Forward Declarations

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

static void LogRenderedText(const ImVec2& ref_pos, const char* text, const char* text_end = NULL);

static const char* FindTextDisplayEnd(const char* text, const char* text_end = NULL);

static void PushMultiItemsWidths(int components, float w_full = 0.0f);

static float GetDraggedColumnOffset(int column_index);

static bool IsKeyPressedMap(ImGuiKey key, bool repeat = true);

static void SetCurrentFont(ImFont* font);

static void SetCurrentWindow(ImGuiWindow* window);

static void SetWindowScrollY(ImGuiWindow* window, float new_scroll_y);

static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond);

static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond);

static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond);

static ImGuiWindow* FindWindowByName(const char* name);

static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs);

static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags);

static inline bool IsWindowContentHoverable(ImGuiWindow* window);

static void ClearSetNextWindowData();

static void CheckStacksSize(ImGuiWindow* window, bool write);

static void Scrollbar(ImGuiWindow* window, bool horizontal);

static bool CloseWindowButton(bool* p_opened);

static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list);

static void AddWindowToRenderList(ImVector<ImDrawList*>& out_render_list, ImGuiWindow* window);

static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window);

static ImGuiIniData* FindWindowSettings(const char* name);

static ImGuiIniData* AddWindowSettings(const char* name);

static void LoadSettings();

static void SaveSettings();

static void MarkSettingsDirty();

static void PushClipRect(const ImRect& clip_rect, bool clipped_by_current = true);

static void PushColumnClipRect(int column_index = -1);

static void PopClipRect();

static ImRect GetVisibleRect();

static bool BeginPopupEx(const char* str_id, ImGuiWindowFlags extra_flags);

static void CloseInactivePopups();

static void ClosePopupToLevel(int remaining);

static void ClosePopup(ImGuiID id);

static bool IsPopupOpen(ImGuiID id);

static ImGuiWindow* GetFrontMostModalRootWindow();

static ImVec2 FindBestPopupWindowPos(const ImVec2& base_pos, const ImVec2& size, ImGuiWindowFlags flags, int* last_dir, const ImRect& r_inner);

static bool InputTextFilterCharacter(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data);

static int InputTextCalcTextLenAndLineCount(const char* text_begin, const char** out_text_end);

static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = NULL, ImVec2* out_offset = NULL, bool stop_on_new_line = false);

static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, const char* display_format, char* buf, int buf_size);

static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, int decimal_precision, char* buf, int buf_size);

static void DataTypeApplyOp(ImGuiDataType data_type, int op, void* value1, const void* value2);

static void DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* data_ptr, const char* scalar_format);

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

// Platform dependent default implementations

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

static const char* GetClipboardTextFn_DefaultImpl();

static void SetClipboardTextFn_DefaultImpl(const char* text);

static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y);

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

// Context

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

// We access everything through this pointer (always assumed to be != NULL)

// You can swap the pointer to a different context by calling ImGui::SetInternalState()

static ImGuiState GImDefaultState;

ImGuiState* GImGui = &GImDefaultState;

// Statically allocated default font atlas. This is merely a maneuver to keep ImFontAtlas definition at the bottom of the .h file (otherwise it'd be inside ImGuiIO)

// Also we wouldn't be able to new() one at this point, before users may define IO.MemAllocFn.

static ImFontAtlas GImDefaultFontAtlas;

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

// User facing structures

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

ImGuiStyle::ImGuiStyle()

{

Alpha = 1.0f; // Global alpha applies to everything in ImGui

WindowPadding = ImVec2(8,8); // Padding within a window

WindowMinSize = ImVec2(32,32); // Minimum window size

WindowRounding = 9.0f; // Radius of window corners rounding. Set to 0.0f to have rectangular windows

WindowTitleAlign = ImGuiAlign_Left; // Alignment for title bar text

ChildWindowRounding = 0.0f; // Radius of child window corners rounding. Set to 0.0f to have rectangular windows

FramePadding = ImVec2(4,3); // Padding within a framed rectangle (used by most widgets)

FrameRounding = 0.0f; // Radius of frame corners rounding. Set to 0.0f to have rectangular frames (used by most widgets).

ItemSpacing = ImVec2(8,4); // Horizontal and vertical spacing between widgets/lines

ItemInnerSpacing = ImVec2(4,4); // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)

TouchExtraPadding = ImVec2(0,0); // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!

WindowFillAlphaDefault = 0.70f; // Default alpha of window background, if not specified in ImGui::Begin()

IndentSpacing = 22.0f; // Horizontal spacing when e.g. entering a tree node

ColumnsMinSpacing = 6.0f; // Minimum horizontal spacing between two columns

ScrollbarSize = 16.0f; // Width of the vertical scrollbar, Height of the horizontal scrollbar

ScrollbarRounding = 9.0f; // Radius of grab corners rounding for scrollbar

GrabMinSize = 10.0f; // Minimum width/height of a grab box for slider/scrollbar

GrabRounding = 0.0f; // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.

DisplayWindowPadding = ImVec2(22,22); // Window positions are clamped to be visible within the display area by at least this amount. Only covers regular windows.

DisplaySafeAreaPadding = ImVec2(4,4); // If you cannot see the edge of your screen (e.g. on a TV) increase the safe area padding. Covers popups/tooltips as well regular windows.

AntiAliasedLines = true; // Enable anti-aliasing on lines/borders. Disable if you are really short on CPU/GPU.

AntiAliasedShapes = true; // Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)

CurveTessellationTol = 1.25f; // Tessellation tolerance. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.

Colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);

Colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);

Colors[ImGuiCol_WindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);

Colors[ImGuiCol_ChildWindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

Colors[ImGuiCol_Border] = ImVec4(0.70f, 0.70f, 0.70f, 0.65f);

Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

Colors[ImGuiCol_FrameBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.30f); // Background of checkbox, radio button, plot, slider, text input

Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.90f, 0.80f, 0.80f, 0.40f);

Colors[ImGuiCol_FrameBgActive] = ImVec4(0.90f, 0.65f, 0.65f, 0.45f);

Colors[ImGuiCol_TitleBg] = ImVec4(0.50f, 0.50f, 1.00f, 0.45f);

Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.40f, 0.40f, 0.80f, 0.20f);

Colors[ImGuiCol_TitleBgActive] = ImVec4(0.50f, 0.50f, 1.00f, 0.55f);

Colors[ImGuiCol_MenuBarBg] = ImVec4(0.40f, 0.40f, 0.55f, 0.80f);

Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.40f, 0.40f, 0.80f, 0.15f);

Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.40f, 0.80f, 0.30f);

Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.40f, 0.80f, 0.40f);

Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.80f, 0.50f, 0.50f, 0.40f);

Colors[ImGuiCol_ComboBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.99f);

Colors[ImGuiCol_CheckMark] = ImVec4(0.90f, 0.90f, 0.90f, 0.50f);

Colors[ImGuiCol_SliderGrab] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);

Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.80f, 0.50f, 0.50f, 1.00f);

Colors[ImGuiCol_Button] = ImVec4(0.67f, 0.40f, 0.40f, 0.60f);

Colors[ImGuiCol_ButtonHovered] = ImVec4(0.67f, 0.40f, 0.40f, 1.00f);

Colors[ImGuiCol_ButtonActive] = ImVec4(0.80f, 0.50f, 0.50f, 1.00f);

Colors[ImGuiCol_Header] = ImVec4(0.40f, 0.40f, 0.90f, 0.45f);

Colors[ImGuiCol_HeaderHovered] = ImVec4(0.45f, 0.45f, 0.90f, 0.80f);

Colors[ImGuiCol_HeaderActive] = ImVec4(0.53f, 0.53f, 0.87f, 0.80f);

Colors[ImGuiCol_Column] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);

Colors[ImGuiCol_ColumnHovered] = ImVec4(0.70f, 0.60f, 0.60f, 1.00f);

Colors[ImGuiCol_ColumnActive] = ImVec4(0.90f, 0.70f, 0.70f, 1.00f);

Colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);

Colors[ImGuiCol_ResizeGripHovered] = ImVec4(1.00f, 1.00f, 1.00f, 0.60f);

Colors[ImGuiCol_ResizeGripActive] = ImVec4(1.00f, 1.00f, 1.00f, 0.90f);

Colors[ImGuiCol_CloseButton] = ImVec4(0.50f, 0.50f, 0.90f, 0.50f);

Colors[ImGuiCol_CloseButtonHovered] = ImVec4(0.70f, 0.70f, 0.90f, 0.60f);

Colors[ImGuiCol_CloseButtonActive] = ImVec4(0.70f, 0.70f, 0.70f, 1.00f);

Colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);

Colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);

Colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);

Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);

Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.00f, 0.00f, 1.00f, 0.35f);

Colors[ImGuiCol_TooltipBg] = ImVec4(0.05f, 0.05f, 0.10f, 0.90f);

Colors[ImGuiCol_ModalWindowDarkening] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);

}

ImGuiIO::ImGuiIO()

{

// Most fields are initialized with zero

memset(this, 0, sizeof(*this));

DisplaySize = ImVec2(-1.0f, -1.0f);

DeltaTime = 1.0f/60.0f;

IniSavingRate = 5.0f;

IniFilename = "imgui.ini";

LogFilename = "imgui_log.txt";

Fonts = &GImDefaultFontAtlas;

FontGlobalScale = 1.0f;

DisplayFramebufferScale = ImVec2(1.0f, 1.0f);

MousePos = ImVec2(-1,-1);

MousePosPrev = ImVec2(-1,-1);

MouseDoubleClickTime = 0.30f;

MouseDoubleClickMaxDist = 6.0f;

MouseDragThreshold = 6.0f;

for (int i = 0; i < ImGuiKey_COUNT; i++)

KeyMap[i] = -1;

KeyRepeatDelay = 0.250f;

KeyRepeatRate = 0.050f;

UserData = NULL;

// User functions

RenderDrawListsFn = NULL;

MemAllocFn = malloc;

MemFreeFn = free;

GetClipboardTextFn = GetClipboardTextFn_DefaultImpl; // Platform dependent default implementations

SetClipboardTextFn = SetClipboardTextFn_DefaultImpl;

ImeSetInputScreenPosFn = ImeSetInputScreenPosFn_DefaultImpl;

}

// Pass in translated ASCII characters for text input.

// - with glfw you can get those from the callback set in glfwSetCharCallback()

// - on Windows you can get those using ToAscii+keyboard state, or via the WM_CHAR message

void ImGuiIO::AddInputCharacter(ImWchar c)

{

const int n = ImStrlenW(InputCharacters);

if (n + 1 < IM_ARRAYSIZE(InputCharacters))

{

InputCharacters[n] = c;

InputCharacters[n+1] = '\0';

}

}

void ImGuiIO::AddInputCharactersUTF8(const char* utf8_chars)

{

// We can't pass more wchars than ImGuiIO::InputCharacters[] can hold so don't convert more

const int wchars_buf_len = sizeof(ImGuiIO::InputCharacters) / sizeof(ImWchar);

ImWchar wchars[wchars_buf_len];

ImTextStrFromUtf8(wchars, wchars_buf_len, utf8_chars, NULL);

for (int i = 0; wchars[i] != 0 && i < wchars_buf_len; i++)

AddInputCharacter(wchars[i]);

}

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

// HELPERS

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

#define IM_INT_MIN (-2147483647-1)

#define IM_INT_MAX (2147483647)

// Play it nice with Windows users. Notepad in 2015 still doesn't display text data with Unix-style \n.

#ifdef _WIN32

#define IM_NEWLINE "\r\n"

#else

#define IM_NEWLINE "\n"

#endif

bool ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c)

{

bool b1 = ((p.x - b.x) * (a.y - b.y) - (p.y - b.y) * (a.x - b.x)) < 0.0f;

bool b2 = ((p.x - c.x) * (b.y - c.y) - (p.y - c.y) * (b.x - c.x)) < 0.0f;

bool b3 = ((p.x - a.x) * (c.y - a.y) - (p.y - a.y) * (c.x - a.x)) < 0.0f;

return ((b1 == b2) && (b2 == b3));

}

int ImStricmp(const char* str1, const char* str2)

{

int d;

while ((d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; }

return d;

}

int ImStrnicmp(const char* str1, const char* str2, int count)

{

int d = 0;

while (count > 0 && (d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; count--; }

return d;

}

char* ImStrdup(const char *str)

{

char *buff = (char*)ImGui::MemAlloc(strlen(str) + 1);

IM_ASSERT(buff);

strcpy(buff, str);

return buff;

}

int ImStrlenW(const ImWchar* str)

{

int n = 0;

while (*str++) n++;

return n;

}

const ImWchar* ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin) // find beginning-of-line

{

while (buf_mid_line > buf_begin && buf_mid_line[-1] != '\n')

buf_mid_line--;

return buf_mid_line;

}

const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end)

{

if (!needle_end)

needle_end = needle + strlen(needle);

const char un0 = (char)toupper(*needle);

while ((!haystack_end && *haystack) || (haystack_end && haystack < haystack_end))

{

if (toupper(*haystack) == un0)

{

const char* b = needle + 1;

for (const char* a = haystack + 1; b < needle_end; a++, b++)

if (toupper(*a) != toupper(*b))

break;

if (b == needle_end)

return haystack;

}

haystack++;

}

return NULL;

}

int ImFormatString(char* buf, int buf_size, const char* fmt, ...)

{

va_list args;

va_start(args, fmt);

int w = vsnprintf(buf, buf_size, fmt, args);

va_end(args);

buf[buf_size-1] = 0;

return (w == -1) ? buf_size : w;

}

int ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args)

{

int w = vsnprintf(buf, buf_size, fmt, args);

buf[buf_size-1] = 0;

return (w == -1) ? buf_size : w;

}

// Pass data_size==0 for zero-terminated strings

// FIXME-OPT: Replace with e.g. FNV1a hash? CRC32 pretty much randomly access 1KB. Need to do proper measurements.

ImU32 ImHash(const void* data, int data_size, ImU32 seed)

{

static ImU32 crc32_lut[256] = { 0 };

if (!crc32_lut[1])

{

const ImU32 polynomial = 0xEDB88320;

for (ImU32 i = 0; i < 256; i++)

{

ImU32 crc = i;

for (ImU32 j = 0; j < 8; j++)

crc = (crc >> 1) ^ (ImU32(-int(crc & 1)) & polynomial);

crc32_lut[i] = crc;

}

}

seed = ~seed;

ImU32 crc = seed;

const unsigned char* current = (const unsigned char*)data;

if (data_size > 0)

{

// Known size

while (data_size--)

crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *current++];

}

else

{

// Zero-terminated string

while (unsigned char c = *current++)

{

// We support a syntax of "label###id" where only "###id" is included in the hash, and only "label" gets displayed.

// Because this syntax is rarely used we are optimizing for the common case.

// - If we reach ### in the string we discard the hash so far and reset to the seed.

// - We don't do 'current += 2; continue;' after handling ### to keep the code smaller.

if (c == '#' && current[0] == '#' && current[1] == '#')

crc = seed;

crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c];

}

}

return ~crc;

}

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

// ImText* helpers

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

// Convert UTF-8 to 32-bits character, process single character input.

// Based on stb_from_utf8() from github.com/nothings/stb/

// We handle UTF-8 decoding error by skipping forward.

int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end)

{

unsigned int c = (unsigned int)-1;

const unsigned char* str = (const unsigned char*)in_text;

if (!(*str & 0x80))

{

c = (unsigned int)(*str++);

*out_char = c;

return 1;

}

if ((*str & 0xe0) == 0xc0)

{

*out_char = 0xFFFD; // will be invalid but not end of string

if (in_text_end && in_text_end - (const char*)str < 2) return 0;

if (*str < 0xc2) return 2;

c = (unsigned int)((*str++ & 0x1f) << 6);

if ((*str & 0xc0) != 0x80) return 2;

c += (*str++ & 0x3f);

*out_char = c;

return 2;

}

if ((*str & 0xf0) == 0xe0)

{

*out_char = 0xFFFD; // will be invalid but not end of string

if (in_text_end && in_text_end - (const char*)str < 3) return 0;

if (*str == 0xe0 && (str[1] < 0xa0 || str[1] > 0xbf)) return 3;

if (*str == 0xed && str[1] > 0x9f) return 3; // str[1] < 0x80 is checked below

c = (unsigned int)((*str++ & 0x0f) << 12);

if ((*str & 0xc0) != 0x80) return 3;

c += (unsigned int)((*str++ & 0x3f) << 6);

if ((*str & 0xc0) != 0x80) return 3;

c += (*str++ & 0x3f);

*out_char = c;

return 3;

}

if ((*str & 0xf8) == 0xf0)

{

*out_char = 0xFFFD; // will be invalid but not end of string

if (in_text_end && in_text_end - (const char*)str < 4) return 0;

if (*str > 0xf4) return 4;

if (*str == 0xf0 && (str[1] < 0x90 || str[1] > 0xbf)) return 4;

if (*str == 0xf4 && str[1] > 0x8f) return 4; // str[1] < 0x80 is checked below

c = (unsigned int)((*str++ & 0x07) << 18);

if ((*str & 0xc0) != 0x80) return 4;

c += (unsigned int)((*str++ & 0x3f) << 12);

if ((*str & 0xc0) != 0x80) return 4;

c += (unsigned int)((*str++ & 0x3f) << 6);

if ((*str & 0xc0) != 0x80) return 4;

c += (*str++ & 0x3f);

// utf-8 encodings of values used in surrogate pairs are invalid

if ((c & 0xFFFFF800) == 0xD800) return 4;

*out_char = c;

return 4;

}

*out_char = 0;

return 0;

}

int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_text_remaining)

{

ImWchar* buf_out = buf;

ImWchar* buf_end = buf + buf_size;

while (buf_out < buf_end-1 && (!in_text_end || in_text < in_text_end) && *in_text)

{

unsigned int c;

in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);

if (c == 0)

break;

if (c < 0x10000) // FIXME: Losing characters that don't fit in 2 bytes

*buf_out++ = (ImWchar)c;

}

*buf_out = 0;

if (in_text_remaining)

*in_text_remaining = in_text;

return (int)(buf_out - buf);

}

int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end)

{

int char_count = 0;

while ((!in_text_end || in_text < in_text_end) && *in_text)

{

unsigned int c;

in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);

if (c == 0)

break;

if (c < 0x10000)

char_count++;

}

return char_count;

}

// Based on stb_to_utf8() from github.com/nothings/stb/

static inline int ImTextCharToUtf8(char* buf, int buf_size, unsigned int c)

{

if (c < 0x80)

{

buf[0] = (char)c;

return 1;

}

if (c < 0x800)

{

if (buf_size < 2) return 0;

buf[0] = (char)(0xc0 + (c >> 6));

buf[1] = (char)(0x80 + (c & 0x3f));

return 2;

}

if (c >= 0xdc00 && c < 0xe000)

{

return 0;

}

if (c >= 0xd800 && c < 0xdc00)

{

if (buf_size < 4) return 0;

buf[0] = (char)(0xf0 + (c >> 18));

buf[1] = (char)(0x80 + ((c >> 12) & 0x3f));

buf[2] = (char)(0x80 + ((c >> 6) & 0x3f));

buf[3] = (char)(0x80 + ((c ) & 0x3f));

return 4;

}

//else if (c < 0x10000)

{

if (buf_size < 3) return 0;