Version number 1.44

Remove inline qualifiers inside .cpp

.gitignore

@@ -1 +0,0 @@
-imgui.ini

README.md

@@ -5,46 +5,51 @@ ImGui
 
 [![Patreon](https://cloud.githubusercontent.com/assets/8225057/5990484/70413560-a9ab-11e4-8942-1a63607c0b00.png)](http://www.patreon.com/imgui) [![PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=5Q73FPZ9C526U)
 
-ImGui is a bloat-free graphical user interface library for C++. It outputs vertex buffers that you can render in your 3D-pipeline enabled application. It is portable, renderer agnostic and carries minimal amount of dependencies. It is based on an "immediate" graphical user interface paradigm which allows you to build user interfaces with ease.
+ImGui is a bloat-free graphical user interface library for C++. It outputs vertex buffers that you can render in your 3D-pipeline enabled application. It is portable, renderer agnostic and self-contained (no external dependencies). It is based on an "immediate mode" graphical user interface paradigm which enables you to build user interfaces with ease.
 
 ImGui is designed to enable fast iteration and allow programmers to create "content creation" or "debug" tools (as opposed to UI for the average end-user). It favors simplicity and productivity toward this goal, and thus lacks certain features normally found in more high-level libraries.
 
-ImGui is particularly suited to integration in 3D applications, fullscreen applications, embedded applications, games, or any applications on consoles platforms where operating system features are non-standard. 
+ImGui is particularly suited to integration in realtime 3D applications, fullscreen applications, embedded applications, games, or any applications on consoles platforms where operating system features are non-standard. 
 
-ImGui is self-contained within 6 files that you can easily copy and compile into your application/engine:
+ImGui is self-contained within a few files that you can easily copy and compile into your application/engine:
 
   - imgui.cpp
   - imgui.h
+  - imgui_demo.cpp
+  - imgui_draw.cpp
+  - imgui_internal.h
   - imconfig.h (empty by default, user-editable)
   - stb_rect_pack.h
   - stb_textedit.h
   - stb_truetype.h
 
+No specific build process is required. You can add the .cpp files to your project or #include them from an existing file.
+
 Your code passes mouse/keyboard inputs and settings to ImGui (see example applications for more details). After ImGui is setup, you can use it like in this example:
 
-![screenshot of sample code alongside its output with ImGui](/web/code_sample_01.png?raw=true)
+![screenshot of sample code alongside its output with ImGui](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/code_sample_01.png)
 
 ImGui outputs vertex buffers and simple command-lists that you can render in your application. Because it doesn't know or touch graphics state directly, you can call ImGui commands anywhere in your code (e.g. in the middle of a running algorithm, or in the middle of your own rendering process). Refer to the sample applications in the examples/ folder for instructions on how to integrate ImGui with your existing codebase. 
 
-ImGui allows you create elaborate tools as well as very short-lived ones. On the extreme side of short-liveness: using the Edit&Continue feature of compilers you can add a few widgets to tweaks variables while your application is running, and remove the code a minute later! ImGui is not just for tweaking values. You can use it to trace a running algorithm by just emitting text commands. You can use it along with your own reflection data to browse your dataset live. You can use it to expose the internals of a subsystem in your engine, to create a logger, an inspection tool, a profiler, a debugger, etc. 
+ImGui allows you create elaborate tools as well as very short-lived ones. On the extreme side of short-liveness: using the Edit&Continue feature of modern compilers you can add a few widgets to tweaks variables while your application is running, and remove the code a minute later! ImGui is not just for tweaking values. You can use it to trace a running algorithm by just emitting text commands. You can use it along with your own reflection data to browse your dataset live. You can use it to expose the internals of a subsystem in your engine, to create a logger, an inspection tool, a profiler, a debugger, etc. 
 
 Demo
 ----
 
 You should be able to build the examples from sources (tested on Windows/Mac/Linux). If you don't, let me know! If you want to have a quick look at the features of ImGui, you can download binaries of the demo app here.
-- [imgui-demo-binaries-20150531.zip](http://www.miracleworld.net/imgui/binaries/imgui-demo-binaries-20150531.zip) (Windows binaries, ImGui 1.40 WIP 2015/05/31, 4 executables, 432 KB)
+- [imgui-demo-binaries-20150716.zip](http://www.miracleworld.net/imgui/binaries/imgui-demo-binaries-20150716.zip) (Windows binaries, ImGui 1.43 WIP 2015/07/16, 4 executables, 475 KB)
 
 
 Gallery
 -------
 
-![screenshot 1](/web/test_window_01.png?raw=true)
-![screenshot 2](/web/test_window_02.png?raw=true)
-![screenshot 3](/web/test_window_03.png?raw=true)
-![screenshot 4](/web/test_window_04.png?raw=true)
-![screenshot 5](/web/test_window_05_menus.png?raw=true)
-![screenshot 6](/web/examples_03.png?raw=true)
-![screenshot 7](/web/examples_02.png?raw=true)
+![screenshot 1](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v143/test_window_01.png)
+![screenshot 2](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v143/test_window_02.png)
+![screenshot 3](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v143/test_window_03.png)
+![screenshot 5](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v140/test_window_05_menus.png)
+![screenshot 4](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v143/skinning_sample_02.png)
+![screenshot 6](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v143/examples_04.png)
+![screenshot 7](https://cloud.githubusercontent.com/assets/8225057/7903336/96f0fb7c-07d0-11e5-95d6-41c6a1595e5a.png)
 
 ImGui can load TTF fonts. UTF-8 is supported for text display and input. Here using Arial Unicode font to display Japanese. Initialize custom font with:
 ```
@@ -55,7 +60,7 @@ For Microsoft IME, pass your HWND to enable IME positioning:
 ```
 io.ImeWindowHandle = my_hwnd;
 ```
-![Japanese screenshot](/web/code_sample_01_jp.png?raw=true)
+![Japanese screenshot](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/code_sample_01.png)
 
 References
 ----------
@@ -72,8 +77,8 @@ Frequently Asked Question
 <b>Where is the documentation?</b>
 
 - The documentation is at the top of imgui.cpp + effectively imgui.h.
-- Example code is in the ImGui::ShowTestWindow() function. It covers most features of ImGui so you can read the code and call the function itself to see its output. 
-- Standalone example applications using OpenGL/DirectX are provided in the examples/ folder. 
+- Example code is in imgui_demo.cpp and particularly the ImGui::ShowTestWindow() function. It covers most features of ImGui so you can read the code and call the function itself to see its output. 
+- Standalone example applications using e.g. OpenGL/DirectX are provided in the examples/ folder. 
 
 <b>How do you use ImGui on a platform that may not have a mouse or keyboard?</b>
 
@@ -85,7 +90,9 @@ In your Render function, try translating your projection matrix by (0.5f,0.5f) o
 
 <b>Can you create elaborate/serious tools with ImGui?</b>
 
-Yes. I have written data browsers, debuggers, profilers and all sort of non-trivial tools with the library. In my experience the simplicity of the API is very empowering. However note that ImGui is programmer centric and the immediate-mode GUI paradigm might requires a bit of adaptation before you can realize its full potential. 
+Yes. I have written data browsers, debuggers, profilers and all sort of non-trivial tools with the library. In my experience the simplicity of the API is very empowering. Your UI runs close to your live data. Make the tools always-on and everybody in the team will be inclined to create new tools (as opposed to more "offline" UI toolkits where only a fraction of your team effectively creates tools).
+
+ImGui is very programmer centric and the immediate-mode GUI paradigm might requires a bit of adaptation before you can realize its full potential. Many programmers have unfortunately been taught by their environment to make unnecessarily complicated things. ImGui is about making things that are simple, efficient and powerful.
 
 <b>Is ImGui fast?</b>
 
@@ -93,11 +100,11 @@ Down to the fundation of its visual design, ImGui is engineered to be fairly per
 
 Mileage may vary but the following screenshot can give you a rough idea of the cost of running and rendering UI code (In the case of a trivial demo application like this one, your driver/os setup are likely to be the bottleneck. Testing performance as part of a real application is recommended).
 
-![performance screenshot](/web/performance_01.png?raw=true)
+![performance screenshot](https://raw.githubusercontent.com/wiki/ocornut/imgui/web/v138/performance_01.png)
 
 This is showing framerate for the full application loop on my 2011 iMac running Windows 7, OpenGL, AMD Radeon HD 6700M with an optimized executable. In contrast, librairies featuring higher-quality rendering and layouting techniques may have a higher resources footprint.
 
-If you intend to display large lists of items (say, 1000+) it can be beneficial for your code to perform clipping manually - using helpers such as CalcListClipping() - in order to avoid submitting them to ImGui in the first place. Even though ImGui will discard your clipped items it still needs to calculate their size and that overhead will add up if you have thousands of items. If you can handle clipping and height positionning yourself then browsing a list with millions of items isn't a problem.
+If you intend to display large lists of items (say, 1000+) it can be beneficial for your code to perform clipping manually - using helpers such as ImGuiListClipper - in order to avoid submitting them to ImGui in the first place. Even though ImGui will discard your clipped items it still needs to calculate their size and that overhead will add up if you have thousands of items. If you can handle clipping and height positionning yourself then browsing a list with millions of items isn't a problem.
 
 <b>Can you reskin the look of ImGui?</b>
 
@@ -107,7 +114,7 @@ You can alter the look of the interface to some degree: changing colors, sizes,
 
 ImGui takes advantage of a few C++ features for convenience but nothing anywhere Boost-insanity/quagmire. In particular, function overloading and default parameters are used to make the API easier to use and code more terse. Doing so I believe the API is sitting on a sweet spot and giving up on those features would make the API more cumbersome. Other features such as namespace, constructors and templates (in the case of the ImVector<> class) are also relied on as a convenience but could be removed.
 
-Shall someone wants to use ImGui from another language, it should be possible to wrap ImGui to be used from a raw C API in the future.
+Shall someone really need to use ImGui from another language, there is an unofficial but reasonably maintained [c-api for ImGui](https://github.com/Extrawurst/cimgui) by Stephan Dilly. I would suggest using your target language functionality to try replicating the function overloading and default parameters used in C++ else the API may be harder to use. It was really designed with C++ in mind and may not make the same amount of sense with another language.
 
 Donate
 ------
@@ -135,7 +142,7 @@ Special supporters:
 - Jetha Chan, Wild Sheep Studio, Pastagames, Mārtiņš Možeiko, Daniel Collin, Stefano Cristiano.
 
 And:
-- Michel Courtine, César Leblic, Dale Kim, Alex Evans, Rui Figueira, Paul Patrashcu, Jerome Lanquetot, Ctrl Alt Ninja, Paul Fleming, Neil Henning, Stephan Dilly.
+- Michel Courtine, César Leblic, Dale Kim, Alex Evans, Rui Figueira, Paul Patrashcu, Jerome Lanquetot, Ctrl Alt Ninja, Paul Fleming, Neil Henning, Stephan Dilly, Neil Blakey-Milner, Aleksei.
 
 And other supporters; thanks!
 

examples/README.txt

@@ -1,18 +1,35 @@
 Those are standalone ready-to-build applications to demonstrate ImGui.
-Unfortunately in 2015 it is still a massive pain to create and maintain portable build files.
-I choose to provide Visual Studio 10 .sln files and Makefile for Linux/OSX. 
-Please let me know if they don't work with your setup!
-You can probably just import the .cpp files into your own system and figure out the linkage from there.
+Binaries of those demos are available from the main GitHub page.
 
+TL;DR; 
+ Refer to 'opengl_example' (not 'opengl3_example') to understand how the library is setup.
+ Copy the imgui_impl_xxx.cpp/.h file you need if you are using one of the rendering backend used in an example.
+ If you are using a different or your own backend, copy opengl_example/imgui_impl_opengl.cpp/.h to get started.
+ 
+
+ImGui is highly portable and only requires a few things to run:
+ - Providing mouse/keyboard inputs
+ - Load the font atlas texture into GPU memory
+ - Providing a render function to render indexed textured triangles
+ - Optional: clipboard support, mouse cursor supports, Windows IME support, etc.
+So this is essentially what those examples are doing + the obligatory cruft for portability.
+
+Unfortunately in 2015 it is still a massive pain to create and maintain portable build files using
+external library like the ones we're using here to provide 3D rendering.
+For most examples here I choose to provide Visual Studio 10 .sln files and Makefile for Linux/OSX. 
+Please let me know if they don't work with your setup!
+You can probably just import the imgui_impl_xxx.cpp/.h files into your own codebase or compile those
+directly with a command-line compiler.
 
 opengl_example/
     OpenGL example, using GLFW + fixed pipeline.
     This is simple and should work for all OpenGL enabled applications.
-    Prefer following this example since it is the shortest one!
+    Prefer following this example to learn how ImGui works!
 
 opengl3_example/
-    OpenGL exemple, using GLFW/GL3W + programmable pipeline.
-    This uses more modern calls and custom shaders.
+    OpenGL example, using GLFW/GL3W + programmable pipeline.
+    This uses more modern OpenGL calls and custom shaders.
+    Even if your application is using modern OpenGL you are better off copying the code from the fixed pipeline version!
     I don't think there is an advantage using this over the simpler example, but it is provided for reference.
 
 directx9_example/
@@ -22,3 +39,12 @@ directx11_example/
     DirectX11 example, Windows only.
     This is quite long and tedious, because: DirectX11.
 	
+ios_example/
+    iOS example.
+    Using Synergy to access keyboard/mouse data from server computer. Synergy keyboard integration is rather hacky.
+
+sdl_opengl_example/
+    SDL2 + OpenGL example.
+
+allegro5_example/
+    Allegro 5 example.

examples/allegro5_example/README.md

@@ -0,0 +1,16 @@
+
+# How to Build
+
+- On Ubuntu 14.04+
+
+```bash
+g++ -I ../imgui main.cpp imgui_impl_a5.cpp ../imgui/imgui*.cpp -lallegro -lallegro_primitives
+```
+
+- On Windows with Visual Studio's CLI
+
+\<a5path\> is your allegro5 folder.
+
+```
+cl /MD /I <a5path\include> /I ..\imgui main.cpp imgui_impl_a5.cpp ..\imgui\imgui*.cpp /link /LIBPATH:<a5path\lib> allegro-5.0.10-monolith-md.lib user32.lib
+```

examples/allegro5_example/imgui_impl_a5.cpp

@@ -0,0 +1,290 @@
+// ImGui Allegro 5 bindings
+// https://github.com/ocornut/imgui
+// by @birthggd
+
+#include <stdint.h>     // uint64_t
+#include <cstring>      // memcpy
+#include <imgui.h>
+#include "imgui_impl_a5.h"
+#include <allegro5/allegro.h>
+#include <allegro5/allegro_primitives.h>
+
+#ifdef _WIN32
+#include <allegro5/allegro_windows.h>
+#endif
+
+// Data
+static ALLEGRO_DISPLAY*         g_Display = NULL;
+static ALLEGRO_BITMAP*          g_Texture = NULL;
+static double                   g_Time = 0.0;
+static ALLEGRO_MOUSE_CURSOR*    g_MouseCursorInvisible = NULL;
+static ALLEGRO_VERTEX_DECL*     g_VertexDecl = NULL;
+
+#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
+
+struct ImDrawVertAllegro
+{
+    ImVec2 pos;
+    ImVec2 uv;
+    ALLEGRO_COLOR col;
+};
+
+static void ImGui_ImplA5_RenderDrawLists(ImDrawData* draw_data)
+{
+    int op, src, dst;
+    al_get_blender(&op, &src, &dst);
+    al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA);
+
+    for (int n = 0; n < draw_data->CmdListsCount; n++) 
+    {
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+
+        // FIXME-OPT: Unfortunately Allegro doesn't support 32-bits packed colors so we have to convert them to 4 floats
+        static ImVector<ImDrawVertAllegro> vertices;
+        vertices.resize(cmd_list->VtxBuffer.size());
+        for (int i = 0; i < cmd_list->VtxBuffer.size(); ++i) 
+        {
+            const ImDrawVert &dv = cmd_list->VtxBuffer[i];
+            ImDrawVertAllegro v;
+            v.pos = dv.pos;
+            v.uv = dv.uv;
+            unsigned char *c = (unsigned char*)&dv.col;
+            v.col = al_map_rgba(c[0], c[1], c[2], c[3]);
+            vertices[i] = v;
+        }
+
+        // FIXME-OPT: Unfortunately Allegro doesn't support 16-bit vertices
+        static ImVector<int> indices;
+        indices.resize(cmd_list->IdxBuffer.size());
+        for (int i = 0; i < cmd_list->IdxBuffer.size(); ++i) 
+            indices[i] = (int)cmd_list->IdxBuffer.Data[i];
+
+        int idx_offset = 0;
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++) 
+        {
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback) 
+            {
+                pcmd->UserCallback(cmd_list, pcmd);
+            }
+            else 
+            {
+                ALLEGRO_BITMAP* texture = (ALLEGRO_BITMAP*)pcmd->TextureId;
+                al_set_clipping_rectangle(pcmd->ClipRect.x, pcmd->ClipRect.y, pcmd->ClipRect.z-pcmd->ClipRect.x, pcmd->ClipRect.w-pcmd->ClipRect.y);
+                al_draw_indexed_prim(&vertices[0], g_VertexDecl, texture, &indices[idx_offset], pcmd->ElemCount, ALLEGRO_PRIM_TRIANGLE_LIST);
+            }
+            idx_offset += pcmd->ElemCount;
+        }
+    }
+
+    // Restore modified state
+    al_set_blender(op, src, dst);
+    al_set_clipping_rectangle(0, 0, al_get_display_width(g_Display), al_get_display_height(g_Display));
+}
+
+bool Imgui_ImplA5_CreateDeviceObjects()
+{
+    ImGuiIO &io = ImGui::GetIO();
+
+    // Build texture
+    unsigned char *pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+
+    // Create texture
+    int flags = al_get_new_bitmap_flags();
+    int fmt = al_get_new_bitmap_format();
+    al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP|ALLEGRO_MIN_LINEAR|ALLEGRO_MAG_LINEAR);
+    al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE);
+    ALLEGRO_BITMAP* img = al_create_bitmap(width, height);
+    al_set_new_bitmap_flags(flags);
+    al_set_new_bitmap_format(fmt);
+    if (!img) 
+        return false;
+
+    ALLEGRO_LOCKED_REGION *locked_img = al_lock_bitmap(img, al_get_bitmap_format(img), ALLEGRO_LOCK_WRITEONLY);
+    if (!locked_img) 
+    {
+        al_destroy_bitmap(img);
+        return false;
+    }
+    memcpy(locked_img->data, pixels, sizeof(int)*width*height);
+    al_unlock_bitmap(img);
+
+    // Convert software texture to hardware texture.
+    ALLEGRO_BITMAP* cloned_img = al_clone_bitmap(img);
+    al_destroy_bitmap(img);
+    if (!cloned_img) 
+        return false;
+
+    // Store our identifier
+    io.Fonts->TexID = (void*)cloned_img;
+    g_Texture = cloned_img;
+
+    // Cleanup (don't clear the input data if you want to append new fonts later)
+    io.Fonts->ClearInputData();
+    io.Fonts->ClearTexData();
+
+    // Create an invisible mouse cursor
+    // Because al_hide_mouse_cursor() seems to mess up with the actual inputs..
+    ALLEGRO_BITMAP* mouse_cursor = al_create_bitmap(8,8);
+    g_MouseCursorInvisible = al_create_mouse_cursor(mouse_cursor, 0, 0);
+    al_destroy_bitmap(mouse_cursor);
+
+    return true;
+}
+
+void ImGui_ImplA5_InvalidateDeviceObjects()
+{
+    if (g_Texture) 
+    {
+        al_destroy_bitmap(g_Texture);
+        ImGui::GetIO().Fonts->TexID = NULL;
+        g_Texture = NULL;
+    }
+    if (g_MouseCursorInvisible)
+    {
+        al_destroy_mouse_cursor(g_MouseCursorInvisible);
+        g_MouseCursorInvisible = NULL;
+    }
+}
+
+bool ImGui_ImplA5_Init(ALLEGRO_DISPLAY* display)
+{
+    g_Display = display;
+   
+    // Create custom vertex declaration. 
+    // Unfortunately Allegro doesn't support 32-bits packed colors so we have to convert them to 4 floats.
+    // We still use a custom declaration to use 'ALLEGRO_PRIM_TEX_COORD' instead of 'ALLEGRO_PRIM_TEX_COORD_PIXEL' else we can't do a reliable conversion.
+    ALLEGRO_VERTEX_ELEMENT elems[] = 
+    {
+        { ALLEGRO_PRIM_POSITION, ALLEGRO_PRIM_FLOAT_2, OFFSETOF(ImDrawVertAllegro, pos) },
+        { ALLEGRO_PRIM_TEX_COORD, ALLEGRO_PRIM_FLOAT_2, OFFSETOF(ImDrawVertAllegro, uv) },
+        { ALLEGRO_PRIM_COLOR_ATTR, 0, OFFSETOF(ImDrawVertAllegro, col) },
+        { 0, 0, 0 }
+    };
+    g_VertexDecl = al_create_vertex_decl(elems, sizeof(ImDrawVertAllegro));
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeyMap[ImGuiKey_Tab] = ALLEGRO_KEY_TAB;
+    io.KeyMap[ImGuiKey_LeftArrow] = ALLEGRO_KEY_LEFT;
+    io.KeyMap[ImGuiKey_RightArrow] = ALLEGRO_KEY_RIGHT;
+    io.KeyMap[ImGuiKey_UpArrow] = ALLEGRO_KEY_UP;
+    io.KeyMap[ImGuiKey_DownArrow] = ALLEGRO_KEY_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = ALLEGRO_KEY_PGUP;
+    io.KeyMap[ImGuiKey_PageDown] = ALLEGRO_KEY_PGDN;
+    io.KeyMap[ImGuiKey_Home] = ALLEGRO_KEY_HOME;
+    io.KeyMap[ImGuiKey_End] = ALLEGRO_KEY_END;
+    io.KeyMap[ImGuiKey_Delete] = ALLEGRO_KEY_DELETE;
+    io.KeyMap[ImGuiKey_Backspace] = ALLEGRO_KEY_BACKSPACE;
+    io.KeyMap[ImGuiKey_Enter] = ALLEGRO_KEY_ENTER;
+    io.KeyMap[ImGuiKey_Escape] = ALLEGRO_KEY_ESCAPE;
+    io.KeyMap[ImGuiKey_A] = ALLEGRO_KEY_A;
+    io.KeyMap[ImGuiKey_C] = ALLEGRO_KEY_C;
+    io.KeyMap[ImGuiKey_V] = ALLEGRO_KEY_V;
+    io.KeyMap[ImGuiKey_X] = ALLEGRO_KEY_X;
+    io.KeyMap[ImGuiKey_Y] = ALLEGRO_KEY_Y;
+    io.KeyMap[ImGuiKey_Z] = ALLEGRO_KEY_Z;
+
+    io.RenderDrawListsFn = ImGui_ImplA5_RenderDrawLists;
+#ifdef _WIN32
+    io.ImeWindowHandle = al_get_win_window_handle(g_Display);
+#endif
+
+    return true;
+}
+
+void ImGui_ImplA5_Shutdown()
+{
+    ImGui_ImplA5_InvalidateDeviceObjects();
+    ImGui::Shutdown();
+}
+
+bool ImGui_ImplA5_ProcessEvent(ALLEGRO_EVENT *ev)
+{
+    ImGuiIO &io = ImGui::GetIO();
+
+    switch (ev->type) 
+    {
+    case ALLEGRO_EVENT_MOUSE_AXES:
+        io.MouseWheel += ev->mouse.dz;
+        return true;
+    case ALLEGRO_EVENT_KEY_CHAR:
+        if (ev->keyboard.display == g_Display) 
+            if (ev->keyboard.unichar > 0 && ev->keyboard.unichar < 0x10000)
+                io.AddInputCharacter((unsigned short)ev->keyboard.unichar);
+        return true;
+    case ALLEGRO_EVENT_KEY_DOWN:
+    case ALLEGRO_EVENT_KEY_UP:
+        if (ev->keyboard.display == g_Display)
+            io.KeysDown[ev->keyboard.keycode] = (ev->type == ALLEGRO_EVENT_KEY_DOWN);
+        return true;
+    }
+    return false;
+}
+
+
+void ImGui_ImplA5_NewFrame()
+{
+    if (!g_Texture) 
+        Imgui_ImplA5_CreateDeviceObjects();
+
+    ImGuiIO &io = ImGui::GetIO();
+
+    // Setup display size (every frame to accommodate for window resizing)
+    int w, h;
+    w = al_get_display_width(g_Display);
+    h = al_get_display_height(g_Display);
+    io.DisplaySize = ImVec2((float)w, (float)h);
+
+    // Setup time step
+    double current_time = al_get_time();
+    io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
+    g_Time = current_time;
+
+    // Setup inputs
+    ALLEGRO_KEYBOARD_STATE keys;
+    al_get_keyboard_state(&keys);
+    io.KeyCtrl = al_key_down(&keys, ALLEGRO_KEY_LCTRL) || al_key_down(&keys, ALLEGRO_KEY_RCTRL);
+    io.KeyShift = al_key_down(&keys, ALLEGRO_KEY_LSHIFT) || al_key_down(&keys, ALLEGRO_KEY_RSHIFT);
+    io.KeyAlt = al_key_down(&keys, ALLEGRO_KEY_ALT) || al_key_down(&keys, ALLEGRO_KEY_ALTGR);
+
+    ALLEGRO_MOUSE_STATE mouse;
+    if (keys.display == g_Display) 
+    {
+        al_get_mouse_state(&mouse);
+        io.MousePos = ImVec2((float)mouse.x, (float)mouse.y);
+    }
+    else 
+    {
+        io.MousePos = ImVec2(-1, -1);
+    }
+
+    al_get_mouse_state(&mouse);
+    io.MouseDown[0] = mouse.buttons & (1 << 0);
+    io.MouseDown[1] = mouse.buttons & (1 << 1);
+    io.MouseDown[2] = mouse.buttons & (1 << 2);
+
+    // Hide OS mouse cursor if ImGui is drawing it
+    if (io.MouseDrawCursor)
+    {
+        al_set_mouse_cursor(g_Display, g_MouseCursorInvisible);
+    }
+    else
+    {
+        ALLEGRO_SYSTEM_MOUSE_CURSOR cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT;
+        switch (ImGui::GetMouseCursor())
+        {
+        case ImGuiMouseCursor_TextInput:    cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_EDIT; break;
+        case ImGuiMouseCursor_Move:         cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_MOVE; break;
+        case ImGuiMouseCursor_ResizeNS:     cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_N; break;
+        case ImGuiMouseCursor_ResizeEW:     cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_E; break;
+        case ImGuiMouseCursor_ResizeNESW:   cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_NE; break;
+        case ImGuiMouseCursor_ResizeNWSE:   cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_NW; break;
+        }
+        al_set_system_mouse_cursor(g_Display, cursor_id);
+    }
+
+    // Start the frame
+    ImGui::NewFrame();
+}

examples/allegro5_example/imgui_impl_a5.h

@@ -0,0 +1,18 @@
+// ImGui Allegro 5 bindings
+// https://github.com/ocornut/imgui
+// by @birthggd
+
+#pragma once
+
+struct ALLEGRO_DISPLAY;
+union ALLEGRO_EVENT;
+
+bool    ImGui_ImplA5_Init(ALLEGRO_DISPLAY* display);
+void    ImGui_ImplA5_Shutdown();
+void    ImGui_ImplA5_NewFrame();
+
+bool    ImGui_ImplA5_ProcessEvent(ALLEGRO_EVENT* event);
+
+// Use if you want to reset your rendering device without losing ImGui state.
+bool    Imgui_ImplA5_CreateDeviceObjects();
+void    ImGui_ImplA5_InvalidateDeviceObjects();

examples/allegro5_example/main.cpp

@@ -0,0 +1,105 @@
+// ImGui - standalone example application for Allegro 5
+
+#include <stdint.h>
+#include <allegro5/allegro.h>
+#include <allegro5/allegro_primitives.h>
+#include <imgui.h>
+#include "imgui_impl_a5.h"
+
+int main(int, char**)
+{
+    // Setup Allegro 
+    al_init();
+    al_install_keyboard();
+    al_install_mouse();
+    al_init_primitives_addon();
+    al_set_new_display_flags(ALLEGRO_RESIZABLE);
+    ALLEGRO_DISPLAY* display = al_create_display(1280, 720);
+    al_set_window_title(display, "ImGui Allegro 5 example");
+    ALLEGRO_EVENT_QUEUE* queue = al_create_event_queue();
+    al_register_event_source(queue, al_get_display_event_source(display));
+    al_register_event_source(queue, al_get_keyboard_event_source());
+    al_register_event_source(queue, al_get_mouse_event_source());
+
+    // Setup ImGui binding
+    ImGui_ImplA5_Init(display);
+
+    // Load Fonts
+    // (see extra_fonts/README.txt for more details)
+    //ImGuiIO& io = ImGui::GetIO();
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+    // Merge glyphs from multiple fonts into one (e.g. combine default font with another with Chinese glyphs, or add icons)
+    //ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
+    //ImFontConfig icons_config; icons_config.MergeMode = true; icons_config.PixelSnapH = true;
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/fontawesome-webfont.ttf", 18.0f, &icons_config, icons_ranges);
+
+    bool show_test_window = true;
+    bool show_another_window = false;
+    ImVec4 clear_color = ImColor(114, 144, 154);
+
+    // Main loop
+    bool running = true;
+    while (running) 
+    {
+        ALLEGRO_EVENT ev;
+        while (al_get_next_event(queue, &ev))
+        {
+            ImGui_ImplA5_ProcessEvent(&ev);
+            if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) running = false;
+            if (ev.type == ALLEGRO_EVENT_DISPLAY_RESIZE)
+            {
+                ImGui_ImplA5_InvalidateDeviceObjects();
+                al_acknowledge_resize(display);
+                Imgui_ImplA5_CreateDeviceObjects();
+            }
+        }
+        ImGui_ImplA5_NewFrame();
+
+        // 1. Show a simple window
+        // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug"
+        {
+            static float f;
+            ImGui::Text("Hello, world!");
+            ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
+            ImGui::ColorEdit3("clear color", (float*)&clear_color);
+            if (ImGui::Button("Test Window")) show_test_window ^= 1;
+            if (ImGui::Button("Another Window")) show_another_window ^= 1;
+            ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f/ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
+        }
+
+        // 2. Show another simple window, this time using an explicit Begin/End pair
+        if (show_another_window) 
+        {
+            ImGui::SetNextWindowSize(ImVec2(200, 100), ImGuiSetCond_FirstUseEver);
+            ImGui::Begin("Another Window", &show_another_window);
+            ImGui::Text("Hello");
+            ImGui::End();
+        }
+
+        // 3. Show the ImGui test window. Most of the sample code is in ImGui::ShowTestWindow()
+        if (show_test_window) 
+        {
+            ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiSetCond_FirstUseEver);
+            ImGui::ShowTestWindow(&show_test_window);
+        }
+
+        // Rendering
+        al_clear_to_color(al_map_rgba_f(clear_color.x, clear_color.y, clear_color.z, clear_color.w));
+        ImGui::Render();
+        al_flip_display();
+    }
+
+    // Cleanup
+    ImGui_ImplA5_Shutdown();
+    al_destroy_event_queue(queue);
+    al_destroy_display(display);
+
+    return 0;
+}

examples/directx11_example/directx11_example.vcxproj

@@ -140,10 +140,13 @@
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h" />
     <ClInclude Include="..\..\imgui.h" />
+    <ClInclude Include="..\..\imgui_internal.h" />
     <ClInclude Include="imgui_impl_dx11.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\imgui.cpp" />
+    <ClCompile Include="..\..\imgui_demo.cpp" />
+    <ClCompile Include="..\..\imgui_draw.cpp" />
     <ClCompile Include="imgui_impl_dx11.cpp" />
     <ClCompile Include="main.cpp" />
   </ItemGroup>

examples/directx11_example/directx11_example.vcxproj.filters

@@ -18,6 +18,9 @@
     <ClInclude Include="imgui_impl_dx11.h">
       <Filter>sources</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\imgui_internal.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\imgui.cpp">
@@ -29,5 +32,11 @@
     <ClCompile Include="imgui_impl_dx11.cpp">
       <Filter>sources</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\imgui_demo.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\imgui_draw.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

examples/directx11_example/imgui_impl_dx11.cpp

@@ -18,6 +18,7 @@ static HWND                     g_hWnd = 0;
 static ID3D11Device*            g_pd3dDevice = NULL;
 static ID3D11DeviceContext*     g_pd3dDeviceContext = NULL;
 static ID3D11Buffer*            g_pVB = NULL;
+static ID3D11Buffer*            g_pIB = NULL;
 static ID3D10Blob *             g_pVertexShaderBlob = NULL;
 static ID3D11VertexShader*      g_pVertexShader = NULL;
 static ID3D11InputLayout*       g_pInputLayout = NULL;
@@ -28,7 +29,8 @@ static ID3D11SamplerState*      g_pFontSampler = NULL;
 static ID3D11ShaderResourceView*g_pFontTextureView = NULL;
 static ID3D11RasterizerState*   g_pRasterizerState = NULL;
 static ID3D11BlendState*        g_pBlendState = NULL;
-static int                      VERTEX_BUFFER_SIZE = 30000;     // TODO: Make vertex buffer smaller and grow dynamically as needed.
+static int                      VERTEX_BUFFER_SIZE = 20000;     // TODO: Make buffers smaller and grow dynamically as needed.
+static int                      INDEX_BUFFER_SIZE = 40000;      // TODO: Make buffers smaller and grow dynamically as needed.
 
 struct VERTEX_CONSTANT_BUFFER
 {
@@ -38,20 +40,26 @@ struct VERTEX_CONSTANT_BUFFER
 // This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
 // If text or lines are blurry when integrating ImGui in your engine:
 // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
-static void ImGui_ImplDX11_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
+static void ImGui_ImplDX11_RenderDrawLists(ImDrawData* draw_data)
 {
     // Copy and convert all vertices into a single contiguous buffer
-    D3D11_MAPPED_SUBRESOURCE mappedResource;
-    if (g_pd3dDeviceContext->Map(g_pVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource) != S_OK)
+    D3D11_MAPPED_SUBRESOURCE vtx_resource, idx_resource;
+    if (g_pd3dDeviceContext->Map(g_pVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &vtx_resource) != S_OK)
         return;
-    ImDrawVert* vtx_dst = (ImDrawVert*)mappedResource.pData;
-    for (int n = 0; n < cmd_lists_count; n++)
+    if (g_pd3dDeviceContext->Map(g_pIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &idx_resource) != S_OK)
+        return;
+    ImDrawVert* vtx_dst = (ImDrawVert*)vtx_resource.pData;
+    ImDrawIdx* idx_dst = (ImDrawIdx*)idx_resource.pData;
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
     {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        memcpy(vtx_dst, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert));
-        vtx_dst += cmd_list->vtx_buffer.size();
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        memcpy(vtx_dst, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
+        memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
+        vtx_dst += cmd_list->VtxBuffer.size();
+        idx_dst += cmd_list->IdxBuffer.size();
     }
     g_pd3dDeviceContext->Unmap(g_pVB, 0);
+    g_pd3dDeviceContext->Unmap(g_pIB, 0);
 
     // Setup orthographic projection matrix into our constant buffer
     {
@@ -93,6 +101,7 @@ static void ImGui_ImplDX11_RenderDrawLists(ImDrawList** const cmd_lists, int cmd
     unsigned int offset = 0;
     g_pd3dDeviceContext->IASetInputLayout(g_pInputLayout);
     g_pd3dDeviceContext->IASetVertexBuffers(0, 1, &g_pVB, &stride, &offset);
+    g_pd3dDeviceContext->IASetIndexBuffer(g_pIB, DXGI_FORMAT_R16_UINT, 0);
     g_pd3dDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
     g_pd3dDeviceContext->VSSetShader(g_pVertexShader, NULL, 0);
     g_pd3dDeviceContext->VSSetConstantBuffers(0, 1, &g_pVertexConstantBuffer);
@@ -106,25 +115,27 @@ static void ImGui_ImplDX11_RenderDrawLists(ImDrawList** const cmd_lists, int cmd
 
     // Render command lists
     int vtx_offset = 0;
-    for (int n = 0; n < cmd_lists_count; n++)
+    int idx_offset = 0;
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
     {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        for (size_t cmd_i = 0; cmd_i < cmd_list->commands.size(); cmd_i++)
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
         {
-            const ImDrawCmd* pcmd = &cmd_list->commands[cmd_i];
-            if (pcmd->user_callback)
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback)
             {
-                pcmd->user_callback(cmd_list, pcmd);
+                pcmd->UserCallback(cmd_list, pcmd);
             }
             else
             {
-                const D3D11_RECT r = { (LONG)pcmd->clip_rect.x, (LONG)pcmd->clip_rect.y, (LONG)pcmd->clip_rect.z, (LONG)pcmd->clip_rect.w };
-                g_pd3dDeviceContext->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&pcmd->texture_id);
+                const D3D11_RECT r = { (LONG)pcmd->ClipRect.x, (LONG)pcmd->ClipRect.y, (LONG)pcmd->ClipRect.z, (LONG)pcmd->ClipRect.w };
+                g_pd3dDeviceContext->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&pcmd->TextureId);
                 g_pd3dDeviceContext->RSSetScissorRects(1, &r); 
-                g_pd3dDeviceContext->Draw(pcmd->vtx_count, vtx_offset);
+                g_pd3dDeviceContext->DrawIndexed(pcmd->ElemCount, idx_offset, vtx_offset);
             }
-            vtx_offset += pcmd->vtx_count;
+            idx_offset += pcmd->ElemCount;
         }
+        vtx_offset += cmd_list->VtxBuffer.size();
     }
 
     // Restore modified state
@@ -368,6 +379,18 @@ bool    ImGui_ImplDX11_CreateDeviceObjects()
             return false;
     }
 
+    // Create the index buffer
+    {
+        D3D11_BUFFER_DESC bufferDesc;
+        memset(&bufferDesc, 0, sizeof(D3D11_BUFFER_DESC));
+        bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+        bufferDesc.ByteWidth = INDEX_BUFFER_SIZE * sizeof(ImDrawIdx);
+        bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
+        bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        if (g_pd3dDevice->CreateBuffer(&bufferDesc, NULL, &g_pIB) < 0)
+            return false;
+    }
+
     ImGui_ImplDX11_CreateFontsTexture();
 
     return true;
@@ -379,7 +402,8 @@ void    ImGui_ImplDX11_InvalidateDeviceObjects()
         return;
 
     if (g_pFontSampler) { g_pFontSampler->Release(); g_pFontSampler = NULL; }
-    if (g_pFontTextureView) { g_pFontTextureView->Release(); ImGui::GetIO().Fonts->TexID = 0; }
+    if (g_pFontTextureView) { g_pFontTextureView->Release(); g_pFontTextureView = NULL; ImGui::GetIO().Fonts->TexID = 0; }
+    if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
     if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
 
     if (g_pBlendState) { g_pBlendState->Release(); g_pBlendState = NULL; }
@@ -409,6 +433,8 @@ bool    ImGui_ImplDX11_Init(void* hwnd, ID3D11Device* device, ID3D11DeviceContex
     io.KeyMap[ImGuiKey_RightArrow] = VK_RIGHT;
     io.KeyMap[ImGuiKey_UpArrow] = VK_UP;
     io.KeyMap[ImGuiKey_DownArrow] = VK_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = VK_PRIOR;
+    io.KeyMap[ImGuiKey_PageDown] = VK_NEXT;
     io.KeyMap[ImGuiKey_Home] = VK_HOME;
     io.KeyMap[ImGuiKey_End] = VK_END;
     io.KeyMap[ImGuiKey_Delete] = VK_DELETE;

examples/directx11_example/main.cpp

@@ -149,13 +149,22 @@ int main(int, char**)
 
     // Setup ImGui binding
     ImGui_ImplDX11_Init(hwnd, g_pd3dDevice, g_pd3dDeviceContext);
+
+    // Load Fonts
+    // (see extra_fonts/README.txt for more details)
     //ImGuiIO& io = ImGui::GetIO();
-    //ImFont* my_font0 = io.Fonts->AddFontDefault();
-    //ImFont* my_font1 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
-    //ImFont* my_font2 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/Karla-Regular.ttf", 16.0f);
-    //ImFont* my_font3 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f); my_font3->DisplayOffset.y += 1;
-    //ImFont* my_font4 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f); my_font4->DisplayOffset.y += 1;
-    //ImFont* my_font5 = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, io.Fonts->GetGlyphRangesJapanese());
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+    // Merge glyphs from multiple fonts into one (e.g. combine default font with another with Chinese glyphs, or add icons)
+    //ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
+    //ImFontConfig icons_config; icons_config.MergeMode = true; icons_config.PixelSnapH = true;
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/fontawesome-webfont.ttf", 18.0f, &icons_config, icons_ranges);
 
     bool show_test_window = true;
     bool show_another_window = false;

examples/directx9_example/directx9_example.vcxproj

@@ -139,12 +139,15 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\..\imgui.cpp" />
+    <ClCompile Include="..\..\imgui_demo.cpp" />
+    <ClCompile Include="..\..\imgui_draw.cpp" />
     <ClCompile Include="imgui_impl_dx9.cpp" />
     <ClCompile Include="main.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h" />
     <ClInclude Include="..\..\imgui.h" />
+    <ClInclude Include="..\..\imgui_internal.h" />
     <ClInclude Include="imgui_impl_dx9.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

examples/directx9_example/directx9_example.vcxproj.filters

@@ -19,6 +19,12 @@
     <ClCompile Include="imgui_impl_dx9.cpp">
       <Filter>sources</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\imgui_demo.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\imgui_draw.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h">
@@ -30,5 +36,8 @@
     <ClInclude Include="imgui_impl_dx9.h">
       <Filter>sources</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\imgui_internal.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

examples/directx9_example/imgui_impl_dx9.cpp

@@ -15,7 +15,9 @@ static INT64                    g_Time = 0;
 static INT64                    g_TicksPerSecond = 0;
 static LPDIRECT3DDEVICE9        g_pd3dDevice = NULL;
 static LPDIRECT3DVERTEXBUFFER9  g_pVB = NULL;
-static int                      VERTEX_BUFFER_SIZE = 30000;     // TODO: Make vertex buffer smaller and grow dynamically as needed.
+static LPDIRECT3DINDEXBUFFER9   g_pIB = NULL;
+static int                      VERTEX_BUFFER_SIZE = 20000;     // TODO: Make buffers smaller and grow dynamically as needed.
+static int                      INDEX_BUFFER_SIZE = 40000;      // TODO: Make buffers smaller and grow dynamically as needed.
 
 struct CUSTOMVERTEX
 {
@@ -28,23 +30,20 @@ struct CUSTOMVERTEX
 // This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
 // If text or lines are blurry when integrating ImGui in your engine:
 // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
-static void ImGui_ImplDX9_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
+static void ImGui_ImplDX9_RenderDrawLists(ImDrawData* draw_data)
 {
-    size_t total_vtx_count = 0;
-    for (int n = 0; n < cmd_lists_count; n++)
-        total_vtx_count += cmd_lists[n]->vtx_buffer.size();
-    if (total_vtx_count == 0)
-        return;
-
     // Copy and convert all vertices into a single contiguous buffer
     CUSTOMVERTEX* vtx_dst;
-    if (g_pVB->Lock(0, (UINT)total_vtx_count, (void**)&vtx_dst, D3DLOCK_DISCARD) < 0)
+    ImDrawIdx* idx_dst;
+    if (g_pVB->Lock(0, (UINT)(draw_data->TotalVtxCount * sizeof(CUSTOMVERTEX)), (void**)&vtx_dst, D3DLOCK_DISCARD) < 0)
         return;
-    for (int n = 0; n < cmd_lists_count; n++)
+    if (g_pIB->Lock(0, (UINT)(draw_data->TotalIdxCount * sizeof(ImDrawIdx)), (void**)&idx_dst, D3DLOCK_DISCARD) < 0)
+        return;
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
     {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        const ImDrawVert* vtx_src = &cmd_list->vtx_buffer[0];
-        for (size_t i = 0; i < cmd_list->vtx_buffer.size(); i++)
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const ImDrawVert* vtx_src = &cmd_list->VtxBuffer[0];
+        for (int i = 0; i < cmd_list->VtxBuffer.size(); i++)
         {
             vtx_dst->pos.x = vtx_src->pos.x;
             vtx_dst->pos.y = vtx_src->pos.y;
@@ -55,9 +54,13 @@ static void ImGui_ImplDX9_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_
             vtx_dst++;
             vtx_src++;
         }
+        memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
+        idx_dst += cmd_list->IdxBuffer.size();
     }
     g_pVB->Unlock();
+    g_pIB->Unlock();
     g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof( CUSTOMVERTEX ) );
+    g_pd3dDevice->SetIndices( g_pIB );
     g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
 
     // Setup render state: fixed-pipeline, alpha-blending, no face culling, no depth testing
@@ -90,25 +93,27 @@ static void ImGui_ImplDX9_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_
 
     // Render command lists
     int vtx_offset = 0;
-    for (int n = 0; n < cmd_lists_count; n++)
+    int idx_offset = 0;
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
     {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        for (size_t cmd_i = 0; cmd_i < cmd_list->commands.size(); cmd_i++)
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
         {
-            const ImDrawCmd* pcmd = &cmd_list->commands[cmd_i];
-            if (pcmd->user_callback)
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback)
             {
-                pcmd->user_callback(cmd_list, pcmd);
+                pcmd->UserCallback(cmd_list, pcmd);
             }
             else
             {
-                const RECT r = { (LONG)pcmd->clip_rect.x, (LONG)pcmd->clip_rect.y, (LONG)pcmd->clip_rect.z, (LONG)pcmd->clip_rect.w };
-                g_pd3dDevice->SetTexture( 0, (LPDIRECT3DTEXTURE9)pcmd->texture_id );
+                const RECT r = { (LONG)pcmd->ClipRect.x, (LONG)pcmd->ClipRect.y, (LONG)pcmd->ClipRect.z, (LONG)pcmd->ClipRect.w };
+                g_pd3dDevice->SetTexture( 0, (LPDIRECT3DTEXTURE9)pcmd->TextureId );
                 g_pd3dDevice->SetScissorRect(&r);
-                g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, vtx_offset, pcmd->vtx_count/3);
+                g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, vtx_offset, 0, (UINT)cmd_list->VtxBuffer.size(), idx_offset, pcmd->ElemCount/3);
             }
-            vtx_offset += pcmd->vtx_count;
+            idx_offset += pcmd->ElemCount;
         }
+        vtx_offset += cmd_list->VtxBuffer.size();
     }
 }
 
@@ -169,6 +174,8 @@ bool    ImGui_ImplDX9_Init(void* hwnd, IDirect3DDevice9* device)
     io.KeyMap[ImGuiKey_RightArrow] = VK_RIGHT;
     io.KeyMap[ImGuiKey_UpArrow] = VK_UP;
     io.KeyMap[ImGuiKey_DownArrow] = VK_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = VK_PRIOR;
+    io.KeyMap[ImGuiKey_PageDown] = VK_NEXT;
     io.KeyMap[ImGuiKey_Home] = VK_HOME;
     io.KeyMap[ImGuiKey_End] = VK_END;
     io.KeyMap[ImGuiKey_Delete] = VK_DELETE;
@@ -238,6 +245,9 @@ bool ImGui_ImplDX9_CreateDeviceObjects()
     if (g_pd3dDevice->CreateVertexBuffer(VERTEX_BUFFER_SIZE * sizeof(CUSTOMVERTEX), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &g_pVB, NULL) < 0)
         return false;
 
+    if (g_pd3dDevice->CreateIndexBuffer(INDEX_BUFFER_SIZE * sizeof(ImDrawIdx), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &g_pIB, NULL) < 0)
+        return false;
+
     ImGui_ImplDX9_CreateFontsTexture();
     return true;
 }
@@ -251,6 +261,11 @@ void ImGui_ImplDX9_InvalidateDeviceObjects()
         g_pVB->Release();
         g_pVB = NULL;
     }
+    if (g_pIB)
+    {
+        g_pIB->Release();
+        g_pIB = NULL;
+    }
     if (LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)ImGui::GetIO().Fonts->TexID)
     {
         tex->Release();

examples/directx9_example/main.cpp

@@ -73,16 +73,22 @@ int main(int, char**)
 
     // Setup ImGui binding
     ImGui_ImplDX9_Init(hwnd, g_pd3dDevice);
-    //ImGuiIO& io = ImGui::GetIO();
-    //ImFont* my_font0 = io.Fonts->AddFontDefault();
-    //ImFont* my_font1 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
-    //ImFont* my_font2 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/Karla-Regular.ttf", 16.0f);
-    //ImFont* my_font3 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f); my_font3->DisplayOffset.y += 1;
-    //ImFont* my_font4 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f); my_font4->DisplayOffset.y += 1;
-    //ImFont* my_font5 = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, io.Fonts->GetGlyphRangesJapanese());
 
-    ShowWindow(hwnd, SW_SHOWDEFAULT);
-    UpdateWindow(hwnd);
+    // Load Fonts
+    // (see extra_fonts/README.txt for more details)
+    //ImGuiIO& io = ImGui::GetIO();
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+    // Merge glyphs from multiple fonts into one (e.g. combine default font with another with Chinese glyphs, or add icons)
+    //ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
+    //ImFontConfig icons_config; icons_config.MergeMode = true; icons_config.PixelSnapH = true;
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/fontawesome-webfont.ttf", 18.0f, &icons_config, icons_ranges);
 
     bool show_test_window = true;
     bool show_another_window = false;
@@ -91,6 +97,8 @@ int main(int, char**)
     // Main loop
     MSG msg;
     ZeroMemory(&msg, sizeof(msg));
+    ShowWindow(hwnd, SW_SHOWDEFAULT);
+    UpdateWindow(hwnd);
     while (msg.message != WM_QUIT)
     {
         if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))

examples/ios_example/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+imguiex.xcodeproj/project.xcworkspace/
+imguiex.xcodeproj/xcuserdata/

examples/ios_example/README.md

@@ -0,0 +1,35 @@
+# iOS example
+
+----
+## Introduction
+
+This example is the default XCode "OpenGL" example code, modified to support ImGui and [Synergy](http://synergy-project.org/). 
+
+Synergy (remote keyboard/mouse) is not required, but it's pretty hard to use ImGui without it. Synergy includes a "uSynergy" library that allows embedding a synergy client, this is what is used here. ImGui supports "TouchPadding", and this is enabled when Synergy is not active.
+
+## How to Use
+----
+
+0. In Synergy, go to Preferences, and uncheck "Use SSL encryption"
+0. Run the example app.
+0. Tap the "servername" button in the corner
+0. Enter the name or the IP of your synergy host
+0. If you had previously connected to a server, you may need to kill and re-start the app.
+
+----
+## Notes and TODOs
+
+Things that would be nice but I didn't get around to doing:
+
+* iOS software keyboard not supported for text inputs
+* iOS hardware (bluetooth) keyboards not supported
+* Graceful disconnect/reconnect from uSynergy.
+* Copy/Paste not well-supported
+
+----
+## C++ on iOS
+ImGui is a c++ library. If you want to include it directly, rename your Obj-C file to have the ".mm" extension. 
+
+Alternatively, you can wrap your debug code in a C interface, this is what I am demonstrating here with the "debug_hud.h" interface. Either approach works, use whatever you prefer.
+
+In my case, most of my game code is already in C++ so it's not really an issue and I can use ImGui directly.

examples/ios_example/imguiex.xcodeproj/project.pbxproj

@@ -0,0 +1,365 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		6D1E39171B35EEF10017B40F /* uSynergy.c in Sources */ = {isa = PBXBuildFile; fileRef = 6D1E39151B35EEF10017B40F /* uSynergy.c */; };
+		6D2FC55A1B2E632000C130BA /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 6D2FC5591B2E632000C130BA /* main.m */; };
+		6D2FC55D1B2E632000C130BA /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 6D2FC55C1B2E632000C130BA /* AppDelegate.m */; };
+		6D2FC55F1B2E632000C130BA /* Shader.fsh in Resources */ = {isa = PBXBuildFile; fileRef = 6D2FC55E1B2E632000C130BA /* Shader.fsh */; };
+		6D2FC5611B2E632000C130BA /* Shader.vsh in Resources */ = {isa = PBXBuildFile; fileRef = 6D2FC5601B2E632000C130BA /* Shader.vsh */; };
+		6D2FC5641B2E632000C130BA /* GameViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 6D2FC5631B2E632000C130BA /* GameViewController.m */; };
+		6D2FC5671B2E632000C130BA /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 6D2FC5651B2E632000C130BA /* Main.storyboard */; };
+		6D2FC5691B2E632000C130BA /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 6D2FC5681B2E632000C130BA /* Images.xcassets */; };
+		6D2FC56C1B2E632000C130BA /* LaunchScreen.xib in Resources */ = {isa = PBXBuildFile; fileRef = 6D2FC56A1B2E632000C130BA /* LaunchScreen.xib */; };
+		6D2FC5831B2E63A100C130BA /* imgui_impl_ios.mm in Sources */ = {isa = PBXBuildFile; fileRef = 6D2FC5811B2E63A100C130BA /* imgui_impl_ios.mm */; };
+		6D2FC5881B2E64AB00C130BA /* imgui.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D2FC5861B2E64AB00C130BA /* imgui.cpp */; };
+		6D2FC58B1B2E6A5500C130BA /* debug_hud.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D2FC5891B2E6A5500C130BA /* debug_hud.cpp */; };
+		6D2FC5911B30773F00C130BA /* CFNetwork.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 6D2FC5901B30773F00C130BA /* CFNetwork.framework */; };
+		6D2FC5931B30774900C130BA /* SystemConfiguration.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 6D2FC5921B30774900C130BA /* SystemConfiguration.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		6D1E39151B35EEF10017B40F /* uSynergy.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = uSynergy.c; sourceTree = "<group>"; };
+		6D1E39161B35EEF10017B40F /* uSynergy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = uSynergy.h; sourceTree = "<group>"; };
+		6D2FC5541B2E632000C130BA /* imguiex.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = imguiex.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		6D2FC5581B2E632000C130BA /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		6D2FC5591B2E632000C130BA /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
+		6D2FC55B1B2E632000C130BA /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
+		6D2FC55C1B2E632000C130BA /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
+		6D2FC55E1B2E632000C130BA /* Shader.fsh */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; name = Shader.fsh; path = Shaders/Shader.fsh; sourceTree = "<group>"; };
+		6D2FC5601B2E632000C130BA /* Shader.vsh */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; name = Shader.vsh; path = Shaders/Shader.vsh; sourceTree = "<group>"; };
+		6D2FC5621B2E632000C130BA /* GameViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GameViewController.h; sourceTree = "<group>"; };
+		6D2FC5631B2E632000C130BA /* GameViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = GameViewController.m; sourceTree = "<group>"; };
+		6D2FC5661B2E632000C130BA /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		6D2FC5681B2E632000C130BA /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Images.xcassets; sourceTree = "<group>"; };
+		6D2FC56B1B2E632000C130BA /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/LaunchScreen.xib; sourceTree = "<group>"; };
+		6D2FC5811B2E63A100C130BA /* imgui_impl_ios.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = imgui_impl_ios.mm; sourceTree = "<group>"; };
+		6D2FC5821B2E63A100C130BA /* imgui_impl_ios.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = imgui_impl_ios.h; sourceTree = "<group>"; };
+		6D2FC5851B2E64AB00C130BA /* imconfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = imconfig.h; path = ../../imconfig.h; sourceTree = "<group>"; };
+		6D2FC5861B2E64AB00C130BA /* imgui.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = imgui.cpp; path = ../../imgui.cpp; sourceTree = "<group>"; };
+		6D2FC5871B2E64AB00C130BA /* imgui.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = imgui.h; path = ../../imgui.h; sourceTree = "<group>"; };
+		6D2FC5891B2E6A5500C130BA /* debug_hud.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = debug_hud.cpp; sourceTree = "<group>"; };
+		6D2FC58A1B2E6A5500C130BA /* debug_hud.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = debug_hud.h; sourceTree = "<group>"; };
+		6D2FC5901B30773F00C130BA /* CFNetwork.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CFNetwork.framework; path = System/Library/Frameworks/CFNetwork.framework; sourceTree = SDKROOT; };
+		6D2FC5921B30774900C130BA /* SystemConfiguration.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SystemConfiguration.framework; path = System/Library/Frameworks/SystemConfiguration.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		6D2FC5511B2E632000C130BA /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				6D2FC5931B30774900C130BA /* SystemConfiguration.framework in Frameworks */,
+				6D2FC5911B30773F00C130BA /* CFNetwork.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		6D1E39141B35EEF10017B40F /* usynergy */ = {
+			isa = PBXGroup;
+			children = (
+				6D1E39151B35EEF10017B40F /* uSynergy.c */,
+				6D1E39161B35EEF10017B40F /* uSynergy.h */,
+			);
+			name = usynergy;
+			path = ../libs/usynergy;
+			sourceTree = "<group>";
+		};
+		6D2FC54B1B2E632000C130BA = {
+			isa = PBXGroup;
+			children = (
+				6D1E39141B35EEF10017B40F /* usynergy */,
+				6D2FC5841B2E648D00C130BA /* imgui */,
+				6D2FC5561B2E632000C130BA /* imguiex */,
+				6D2FC5551B2E632000C130BA /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		6D2FC5551B2E632000C130BA /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				6D2FC5541B2E632000C130BA /* imguiex.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		6D2FC5561B2E632000C130BA /* imguiex */ = {
+			isa = PBXGroup;
+			children = (
+				6D2FC5811B2E63A100C130BA /* imgui_impl_ios.mm */,
+				6D2FC5821B2E63A100C130BA /* imgui_impl_ios.h */,
+				6D2FC5891B2E6A5500C130BA /* debug_hud.cpp */,
+				6D2FC58A1B2E6A5500C130BA /* debug_hud.h */,
+				6D2FC55B1B2E632000C130BA /* AppDelegate.h */,
+				6D2FC55C1B2E632000C130BA /* AppDelegate.m */,
+				6D2FC55E1B2E632000C130BA /* Shader.fsh */,
+				6D2FC5601B2E632000C130BA /* Shader.vsh */,
+				6D2FC5621B2E632000C130BA /* GameViewController.h */,
+				6D2FC5631B2E632000C130BA /* GameViewController.m */,
+				6D2FC5651B2E632000C130BA /* Main.storyboard */,
+				6D2FC5681B2E632000C130BA /* Images.xcassets */,
+				6D2FC56A1B2E632000C130BA /* LaunchScreen.xib */,
+				6D2FC5571B2E632000C130BA /* Supporting Files */,
+			);
+			path = imguiex;
+			sourceTree = "<group>";
+		};
+		6D2FC5571B2E632000C130BA /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				6D2FC5921B30774900C130BA /* SystemConfiguration.framework */,
+				6D2FC5901B30773F00C130BA /* CFNetwork.framework */,
+				6D2FC5581B2E632000C130BA /* Info.plist */,
+				6D2FC5591B2E632000C130BA /* main.m */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		6D2FC5841B2E648D00C130BA /* imgui */ = {
+			isa = PBXGroup;
+			children = (
+				6D2FC5851B2E64AB00C130BA /* imconfig.h */,
+				6D2FC5861B2E64AB00C130BA /* imgui.cpp */,
+				6D2FC5871B2E64AB00C130BA /* imgui.h */,
+			);
+			name = imgui;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		6D2FC5531B2E632000C130BA /* imguiex */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 6D2FC57B1B2E632000C130BA /* Build configuration list for PBXNativeTarget "imguiex" */;
+			buildPhases = (
+				6D2FC5501B2E632000C130BA /* Sources */,
+				6D2FC5511B2E632000C130BA /* Frameworks */,
+				6D2FC5521B2E632000C130BA /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = imguiex;
+			productName = imguiex;
+			productReference = 6D2FC5541B2E632000C130BA /* imguiex.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		6D2FC54C1B2E632000C130BA /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0630;
+				ORGANIZATIONNAME = "Joel Davis";
+				TargetAttributes = {
+					6D2FC5531B2E632000C130BA = {
+						CreatedOnToolsVersion = 6.3.2;
+					};
+				};
+			};
+			buildConfigurationList = 6D2FC54F1B2E632000C130BA /* Build configuration list for PBXProject "imguiex" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 6D2FC54B1B2E632000C130BA;
+			productRefGroup = 6D2FC5551B2E632000C130BA /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				6D2FC5531B2E632000C130BA /* imguiex */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		6D2FC5521B2E632000C130BA /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				6D2FC56C1B2E632000C130BA /* LaunchScreen.xib in Resources */,
+				6D2FC5671B2E632000C130BA /* Main.storyboard in Resources */,
+				6D2FC5691B2E632000C130BA /* Images.xcassets in Resources */,
+				6D2FC5611B2E632000C130BA /* Shader.vsh in Resources */,
+				6D2FC55F1B2E632000C130BA /* Shader.fsh in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		6D2FC5501B2E632000C130BA /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				6D2FC55D1B2E632000C130BA /* AppDelegate.m in Sources */,
+				6D2FC5831B2E63A100C130BA /* imgui_impl_ios.mm in Sources */,
+				6D1E39171B35EEF10017B40F /* uSynergy.c in Sources */,
+				6D2FC5641B2E632000C130BA /* GameViewController.m in Sources */,
+				6D2FC55A1B2E632000C130BA /* main.m in Sources */,
+				6D2FC5881B2E64AB00C130BA /* imgui.cpp in Sources */,
+				6D2FC58B1B2E6A5500C130BA /* debug_hud.cpp in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		6D2FC5651B2E632000C130BA /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				6D2FC5661B2E632000C130BA /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		6D2FC56A1B2E632000C130BA /* LaunchScreen.xib */ = {
+			isa = PBXVariantGroup;
+			children = (
+				6D2FC56B1B2E632000C130BA /* Base */,
+			);
+			name = LaunchScreen.xib;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		6D2FC5791B2E632000C130BA /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		6D2FC57A1B2E632000C130BA /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		6D2FC57C1B2E632000C130BA /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				INFOPLIST_FILE = imguiex/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		6D2FC57D1B2E632000C130BA /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				INFOPLIST_FILE = imguiex/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		6D2FC54F1B2E632000C130BA /* Build configuration list for PBXProject "imguiex" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				6D2FC5791B2E632000C130BA /* Debug */,
+				6D2FC57A1B2E632000C130BA /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		6D2FC57B1B2E632000C130BA /* Build configuration list for PBXNativeTarget "imguiex" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				6D2FC57C1B2E632000C130BA /* Debug */,
+				6D2FC57D1B2E632000C130BA /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 6D2FC54C1B2E632000C130BA /* Project object */;
+}

examples/ios_example/imguiex/AppDelegate.h

@@ -0,0 +1,13 @@
+//
+//  AppDelegate.h
+//  imguiex
+
+#import <UIKit/UIKit.h>
+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (strong, nonatomic) UIWindow *window;
+
+
+@end
+

examples/ios_example/imguiex/AppDelegate.m

@@ -0,0 +1,41 @@
+//
+//  AppDelegate.m
+//  imguiex
+
+#import "AppDelegate.h"
+
+@interface AppDelegate ()
+
+@end
+
+@implementation AppDelegate
+
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    // Override point for customization after application launch.
+    return YES;
+}
+
+- (void)applicationWillResignActive:(UIApplication *)application {
+    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
+    // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
+}
+
+- (void)applicationDidEnterBackground:(UIApplication *)application {
+    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
+    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
+}
+
+- (void)applicationWillEnterForeground:(UIApplication *)application {
+    // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
+}
+
+- (void)applicationDidBecomeActive:(UIApplication *)application {
+    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
+}
+
+- (void)applicationWillTerminate:(UIApplication *)application {
+    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
+}
+
+@end

examples/ios_example/imguiex/Base.lproj/LaunchScreen.xib

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="7706" systemVersion="14D136" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="7703"/>
+        <capability name="Constraints with non-1.0 multipliers" minToolsVersion="5.1"/>
+    </dependencies>
+    <objects>
+        <placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner"/>
+        <placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
+        <view contentMode="scaleToFill" id="iN0-l3-epB">
+            <rect key="frame" x="0.0" y="0.0" width="480" height="480"/>
+            <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+            <subviews>
+                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="imguiex" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines" minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="kId-c2-rCX">
+                    <rect key="frame" x="20" y="140" width="441" height="43"/>
+                    <fontDescription key="fontDescription" type="boldSystem" pointSize="36"/>
+                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
+                    <nil key="highlightedColor"/>
+                </label>
+            </subviews>
+            <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+            <constraints>
+                <constraint firstItem="kId-c2-rCX" firstAttribute="centerY" secondItem="iN0-l3-epB" secondAttribute="bottom" multiplier="1/3" constant="1" id="5cJ-9S-tgC"/>
+                <constraint firstAttribute="centerX" secondItem="kId-c2-rCX" secondAttribute="centerX" id="Koa-jz-hwk"/>
+                <constraint firstItem="kId-c2-rCX" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="fvb-Df-36g"/>
+            </constraints>
+            <nil key="simulatedStatusBarMetrics"/>
+            <freeformSimulatedSizeMetrics key="simulatedDestinationMetrics"/>
+            <point key="canvasLocation" x="548" y="455"/>
+        </view>
+    </objects>
+</document>

examples/ios_example/imguiex/Base.lproj/Main.storyboard

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="7706" systemVersion="14D136" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" initialViewController="BV1-FR-VrT">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="7703"/>
+        <capability name="Constraints to layout margins" minToolsVersion="6.0"/>
+    </dependencies>
+    <scenes>
+        <!--Game View Controller-->
+        <scene sceneID="tXr-a1-R10">
+            <objects>
+                <viewController id="BV1-FR-VrT" customClass="GameViewController" sceneMemberID="viewController">
+                    <layoutGuides>
+                        <viewControllerLayoutGuide type="top" id="8aa-yV-Osq"/>
+                        <viewControllerLayoutGuide type="bottom" id="qHh-Mt-9TT"/>
+                    </layoutGuides>
+                    <view key="view" contentMode="scaleToFill" id="3se-qz-xqx" customClass="GLKView">
+                        <rect key="frame" x="0.0" y="0.0" width="600" height="600"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <button opaque="NO" contentMode="scaleToFill" misplaced="YES" contentHorizontalAlignment="left" contentVerticalAlignment="center" buttonType="roundedRect" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="piS-r7-VWh">
+                                <rect key="frame" x="16" y="550" width="136" height="30"/>
+                                <state key="normal" title="servername">
+                                    <color key="titleShadowColor" white="0.5" alpha="1" colorSpace="calibratedWhite"/>
+                                </state>
+                                <connections>
+                                    <action selector="onServernameTapped:" destination="BV1-FR-VrT" eventType="touchUpInside" id="9sO-yv-0be"/>
+                                </connections>
+                            </button>
+                        </subviews>
+                        <color key="backgroundColor" white="0.0" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+                        <constraints>
+                            <constraint firstItem="qHh-Mt-9TT" firstAttribute="top" secondItem="piS-r7-VWh" secondAttribute="bottom" constant="20" id="JxW-fj-qni"/>
+                            <constraint firstItem="piS-r7-VWh" firstAttribute="leading" secondItem="3se-qz-xqx" secondAttribute="leadingMargin" constant="20" id="w5q-gx-tJj"/>
+                        </constraints>
+                    </view>
+                    <connections>
+                        <outlet property="btnServername" destination="piS-r7-VWh" id="9iV-ef-l6M"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="SZV-WD-TEh" sceneMemberID="firstResponder"/>
+            </objects>
+        </scene>
+    </scenes>
+</document>

examples/ios_example/imguiex/GameViewController.h

@@ -0,0 +1,12 @@
+//
+//  GameViewController.h
+//  imguiex
+
+// This is the OpenGL Example template from XCode, modified to support ImGui
+
+#import <UIKit/UIKit.h>
+#import <GLKit/GLKit.h>
+
+@interface GameViewController : GLKViewController
+
+@end

examples/ios_example/imguiex/GameViewController.m

@@ -0,0 +1,481 @@
+//
+//  GameViewController.m
+//  imguiex
+//
+#import "GameViewController.h"
+#import <OpenGLES/ES2/glext.h>
+
+#import "imgui_impl_ios.h"
+#import "debug_hud.h"
+
+#define BUFFER_OFFSET(i) ((char *)NULL + (i))
+
+#define SERVERNAME_KEY @"ServerName"
+
+#define SERVERNAME_ALERT_TAG (10)
+
+// Uniform index.
+enum
+{
+    UNIFORM_MODELVIEWPROJECTION_MATRIX,
+    UNIFORM_NORMAL_MATRIX,
+    UNIFORM_DIFFUSE_COLOR,
+    
+    NUM_UNIFORMS
+};
+GLint uniforms[NUM_UNIFORMS];
+
+// Attribute index.
+enum
+{
+    ATTRIB_VERTEX,
+    ATTRIB_NORMAL,
+    NUM_ATTRIBUTES
+};
+
+GLfloat gCubeVertexData[216] = 
+{
+    // Data layout for each line below is:
+    // positionX, positionY, positionZ,     normalX, normalY, normalZ,
+    0.5f, -0.5f, -0.5f,        1.0f, 0.0f, 0.0f,
+    0.5f, 0.5f, -0.5f,         1.0f, 0.0f, 0.0f,
+    0.5f, -0.5f, 0.5f,         1.0f, 0.0f, 0.0f,
+    0.5f, -0.5f, 0.5f,         1.0f, 0.0f, 0.0f,
+    0.5f, 0.5f, -0.5f,          1.0f, 0.0f, 0.0f,
+    0.5f, 0.5f, 0.5f,         1.0f, 0.0f, 0.0f,
+    
+    0.5f, 0.5f, -0.5f,         0.0f, 1.0f, 0.0f,
+    -0.5f, 0.5f, -0.5f,        0.0f, 1.0f, 0.0f,
+    0.5f, 0.5f, 0.5f,          0.0f, 1.0f, 0.0f,
+    0.5f, 0.5f, 0.5f,          0.0f, 1.0f, 0.0f,
+    -0.5f, 0.5f, -0.5f,        0.0f, 1.0f, 0.0f,
+    -0.5f, 0.5f, 0.5f,         0.0f, 1.0f, 0.0f,
+    
+    -0.5f, 0.5f, -0.5f,        -1.0f, 0.0f, 0.0f,
+    -0.5f, -0.5f, -0.5f,       -1.0f, 0.0f, 0.0f,
+    -0.5f, 0.5f, 0.5f,         -1.0f, 0.0f, 0.0f,
+    -0.5f, 0.5f, 0.5f,         -1.0f, 0.0f, 0.0f,
+    -0.5f, -0.5f, -0.5f,       -1.0f, 0.0f, 0.0f,
+    -0.5f, -0.5f, 0.5f,        -1.0f, 0.0f, 0.0f,
+    
+    -0.5f, -0.5f, -0.5f,       0.0f, -1.0f, 0.0f,
+    0.5f, -0.5f, -0.5f,        0.0f, -1.0f, 0.0f,
+    -0.5f, -0.5f, 0.5f,        0.0f, -1.0f, 0.0f,
+    -0.5f, -0.5f, 0.5f,        0.0f, -1.0f, 0.0f,
+    0.5f, -0.5f, -0.5f,        0.0f, -1.0f, 0.0f,
+    0.5f, -0.5f, 0.5f,         0.0f, -1.0f, 0.0f,
+    
+    0.5f, 0.5f, 0.5f,          0.0f, 0.0f, 1.0f,
+    -0.5f, 0.5f, 0.5f,         0.0f, 0.0f, 1.0f,
+    0.5f, -0.5f, 0.5f,         0.0f, 0.0f, 1.0f,
+    0.5f, -0.5f, 0.5f,         0.0f, 0.0f, 1.0f,
+    -0.5f, 0.5f, 0.5f,         0.0f, 0.0f, 1.0f,
+    -0.5f, -0.5f, 0.5f,        0.0f, 0.0f, 1.0f,
+    
+    0.5f, -0.5f, -0.5f,        0.0f, 0.0f, -1.0f,
+    -0.5f, -0.5f, -0.5f,       0.0f, 0.0f, -1.0f,
+    0.5f, 0.5f, -0.5f,         0.0f, 0.0f, -1.0f,
+    0.5f, 0.5f, -0.5f,         0.0f, 0.0f, -1.0f,
+    -0.5f, -0.5f, -0.5f,       0.0f, 0.0f, -1.0f,
+    -0.5f, 0.5f, -0.5f,        0.0f, 0.0f, -1.0f
+};
+
+@interface GameViewController () <UIAlertViewDelegate>
+{
+    GLuint _program;
+    
+    GLKMatrix4 _modelViewProjectionMatrix;
+    GLKMatrix3 _normalMatrix;
+    float _rotation;
+    
+    GLuint _vertexArray;
+    GLuint _vertexBuffer;
+    
+    DebugHUD _hud;
+}
+@property (strong, nonatomic) EAGLContext *context;
+@property (strong, nonatomic) GLKBaseEffect *effect;
+@property (strong, nonatomic) ImGuiHelper *imgui;
+@property (weak, nonatomic) IBOutlet UIButton *btnServername;
+
+@property (strong, nonatomic) NSString *serverName;
+
+- (IBAction)onServernameTapped:(id)sender;
+
+- (void)setupGL;
+- (void)tearDownGL;
+
+- (BOOL)loadShaders;
+- (BOOL)compileShader:(GLuint *)shader type:(GLenum)type file:(NSString *)file;
+- (BOOL)linkProgram:(GLuint)prog;
+- (BOOL)validateProgram:(GLuint)prog;
+@end
+
+@implementation GameViewController
+
+- (void)viewDidLoad
+{
+    [super viewDidLoad];
+    
+    self.context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
+
+    if (!self.context) {
+        NSLog(@"Failed to create ES context");
+    }
+    
+    GLKView *view = (GLKView *)self.view;
+    view.context = self.context;
+    view.drawableDepthFormat = GLKViewDrawableDepthFormat24;
+    
+    [self.btnServername setTitleColor:[UIColor whiteColor] forState:UIControlStateNormal];
+    
+    [self setupGL];
+    
+    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
+    self.serverName = [userDefaults objectForKey: SERVERNAME_KEY ];
+    self.imgui = [[ImGuiHelper alloc] initWithView:self.view ];
+    if (self.serverName)
+    {
+        [self.btnServername setTitle:self.serverName forState:UIControlStateNormal];
+        [self.imgui connectServer: self.serverName ];
+    }
+    
+    DebugHUD_InitDefaults( &_hud );
+}
+
+- (void)dealloc
+{    
+    [self tearDownGL];
+    
+    if ([EAGLContext currentContext] == self.context) {
+        [EAGLContext setCurrentContext:nil];
+    }
+}
+
+- (void)didReceiveMemoryWarning
+{
+    [super didReceiveMemoryWarning];
+
+    if ([self isViewLoaded] && ([[self view] window] == nil)) {
+        self.view = nil;
+        
+        [self tearDownGL];
+        
+        if ([EAGLContext currentContext] == self.context) {
+            [EAGLContext setCurrentContext:nil];
+        }
+        self.context = nil;
+    }
+
+    // Dispose of any resources that can be recreated.
+}
+
+
+- (BOOL)prefersStatusBarHidden {
+    return YES;
+}
+
+- (IBAction)onServernameTapped:(id)sender
+{
+    UIAlertView * alert = [[UIAlertView alloc] initWithTitle:@"Set Server" message:@"Enter server name or IP for uSynergy" delegate:self cancelButtonTitle:@"OK" otherButtonTitles:@"Cancel", nil ];
+    alert.alertViewStyle = UIAlertViewStylePlainTextInput;
+    alert.tag = SERVERNAME_ALERT_TAG; // cheezy way to tell which alert view we're responding to
+    [alert show];
+}
+
+- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
+{
+    if ((buttonIndex==0)&&(alertView.tag==SERVERNAME_ALERT_TAG))
+    {
+        // This is really janky. I usually just hardcode the servername since I'm building it anyway.
+        // If you want to properly handle updating the server, you'll want to tear down and recreate
+        // the usynergy stuff in connectServer
+        BOOL serverNameWasSet = self.serverName.length > 0;
+        NSString *serverName = [[alertView textFieldAtIndex:0] text];
+
+        if ([serverName length] > 0) {
+            self.serverName = serverName;
+            NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
+            [userDefaults setObject:serverName forKey:SERVERNAME_KEY ];
+            [userDefaults synchronize];
+            
+            [self.btnServername setTitle:self.serverName forState:UIControlStateNormal];
+            
+            // If we hadn't previously connected, try now
+            if (!serverNameWasSet) {
+                [self.imgui connectServer:self.serverName];
+            }
+            else
+            {
+                UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Servername Updated"
+                                                                message:@"Restart the app to connect the server"
+                                                               delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
+                [alert show];
+            }
+        }
+    }
+}
+
+- (void)setupGL
+{
+    [EAGLContext setCurrentContext:self.context];
+    
+    [self loadShaders];
+    
+    self.effect = [[GLKBaseEffect alloc] init];
+    self.effect.light0.enabled = GL_TRUE;
+    self.effect.light0.diffuseColor = GLKVector4Make(1.0f, 0.4f, 0.4f, 1.0f);
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    glGenVertexArraysOES(1, &_vertexArray);
+    glBindVertexArrayOES(_vertexArray);
+    
+    glGenBuffers(1, &_vertexBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(gCubeVertexData), gCubeVertexData, GL_STATIC_DRAW);
+    
+    glEnableVertexAttribArray(GLKVertexAttribPosition);
+    glVertexAttribPointer(GLKVertexAttribPosition, 3, GL_FLOAT, GL_FALSE, 24, BUFFER_OFFSET(0));
+    glEnableVertexAttribArray(GLKVertexAttribNormal);
+    glVertexAttribPointer(GLKVertexAttribNormal, 3, GL_FLOAT, GL_FALSE, 24, BUFFER_OFFSET(12));
+    
+    glBindVertexArrayOES(0);
+    
+
+}
+
+- (void)tearDownGL
+{
+    [EAGLContext setCurrentContext:self.context];
+    
+    glDeleteBuffers(1, &_vertexBuffer);
+    glDeleteVertexArraysOES(1, &_vertexArray);
+    
+    self.effect = nil;
+    
+    if (_program) {
+        glDeleteProgram(_program);
+        _program = 0;
+    }
+}
+
+#pragma mark - GLKView and GLKViewController delegate methods
+
+- (void)update
+{
+    float aspect = fabs(self.view.bounds.size.width / self.view.bounds.size.height);
+    GLKMatrix4 projectionMatrix = GLKMatrix4MakePerspective(GLKMathDegreesToRadians(65.0f), aspect, 0.1f, 100.0f);
+    
+    self.effect.transform.projectionMatrix = projectionMatrix;
+    
+    GLKMatrix4 baseModelViewMatrix = GLKMatrix4MakeTranslation(0.0f, 0.0f, -4.0f);
+    baseModelViewMatrix = GLKMatrix4Rotate(baseModelViewMatrix, _rotation, 0.0f, 1.0f, 0.0f);
+    
+    // Compute the model view matrix for the object rendered with GLKit
+    GLKMatrix4 modelViewMatrix = GLKMatrix4MakeTranslation(0.0f, 0.0f, -1.5f);
+    modelViewMatrix = GLKMatrix4Rotate(modelViewMatrix, _rotation, 1.0f, 1.0f, 1.0f);
+    modelViewMatrix = GLKMatrix4Multiply(baseModelViewMatrix, modelViewMatrix);
+    
+    self.effect.transform.modelviewMatrix = modelViewMatrix;
+    
+    // Compute the model view matrix for the object rendered with ES2
+    modelViewMatrix = GLKMatrix4MakeTranslation(0.0f, 0.0f, 1.5f);
+    modelViewMatrix = GLKMatrix4Rotate(modelViewMatrix, _rotation, 1.0f, 1.0f, 1.0f);
+    modelViewMatrix = GLKMatrix4Multiply(baseModelViewMatrix, modelViewMatrix);
+    
+    _normalMatrix = GLKMatrix3InvertAndTranspose(GLKMatrix4GetMatrix3(modelViewMatrix), NULL);
+    
+    _modelViewProjectionMatrix = GLKMatrix4Multiply(projectionMatrix, modelViewMatrix);
+    
+    _rotation += self.timeSinceLastUpdate * (_hud.rotation_speed * (M_PI / 180.0));
+}
+
+
+- (void)glkView:(GLKView *)view drawInRect:(CGRect)rect
+{
+    glClearColor(0.65f, 0.65f, 0.65f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    
+    glBindVertexArrayOES(_vertexArray);
+    
+    // Render the object with GLKit
+    [self.effect prepareToDraw];
+    
+    glDrawArrays(GL_TRIANGLES, 0, 36);
+    
+    // Render the object again with ES2
+    glUseProgram(_program);
+    
+    glUniformMatrix4fv(uniforms[UNIFORM_MODELVIEWPROJECTION_MATRIX], 1, 0, _modelViewProjectionMatrix.m);
+    glUniformMatrix3fv(uniforms[UNIFORM_NORMAL_MATRIX], 1, 0, _normalMatrix.m);
+    glUniform3f(uniforms[UNIFORM_DIFFUSE_COLOR], _hud.cubeColor1[0], _hud.cubeColor1[1], _hud.cubeColor1[2] );
+
+    glDrawArrays(GL_TRIANGLES, 0, 36);
+    
+    [self.imgui newFrame];
+    
+    // Now do our ImGUI UI
+    DebugHUD_DoInterface( &_hud );
+    
+    self.effect.light0.diffuseColor = GLKVector4Make( _hud.cubeColor2[0], _hud.cubeColor2[1], _hud.cubeColor2[2], 1.0f);
+    
+    // Now render Imgui
+    [self.imgui render];
+    
+}
+
+#pragma mark -  OpenGL ES 2 shader compilation
+
+- (BOOL)loadShaders
+{
+    GLuint vertShader, fragShader;
+    NSString *vertShaderPathname, *fragShaderPathname;
+    
+    // Create shader program.
+    _program = glCreateProgram();
+    
+    // Create and compile vertex shader.
+    vertShaderPathname = [[NSBundle mainBundle] pathForResource:@"Shader" ofType:@"vsh"];
+    if (![self compileShader:&vertShader type:GL_VERTEX_SHADER file:vertShaderPathname]) {
+        NSLog(@"Failed to compile vertex shader");
+        return NO;
+    }
+    
+    // Create and compile fragment shader.
+    fragShaderPathname = [[NSBundle mainBundle] pathForResource:@"Shader" ofType:@"fsh"];
+    if (![self compileShader:&fragShader type:GL_FRAGMENT_SHADER file:fragShaderPathname]) {
+        NSLog(@"Failed to compile fragment shader");
+        return NO;
+    }
+    
+    // Attach vertex shader to program.
+    glAttachShader(_program, vertShader);
+    
+    // Attach fragment shader to program.
+    glAttachShader(_program, fragShader);
+    
+    // Bind attribute locations.
+    // This needs to be done prior to linking.
+    glBindAttribLocation(_program, GLKVertexAttribPosition, "position");
+    glBindAttribLocation(_program, GLKVertexAttribNormal, "normal");
+    
+    // Link program.
+    if (![self linkProgram:_program]) {
+        NSLog(@"Failed to link program: %d", _program);
+        
+        if (vertShader) {
+            glDeleteShader(vertShader);
+            vertShader = 0;
+        }
+        if (fragShader) {
+            glDeleteShader(fragShader);
+            fragShader = 0;
+        }
+        if (_program) {
+            glDeleteProgram(_program);
+            _program = 0;
+        }
+        
+        return NO;
+    }
+    
+    // Get uniform locations.
+    uniforms[UNIFORM_MODELVIEWPROJECTION_MATRIX] = glGetUniformLocation(_program, "modelViewProjectionMatrix");
+    uniforms[UNIFORM_NORMAL_MATRIX] = glGetUniformLocation(_program, "normalMatrix");
+    uniforms[UNIFORM_DIFFUSE_COLOR] = glGetUniformLocation(_program, "diffuseColor");
+    
+    // Release vertex and fragment shaders.
+    if (vertShader) {
+        glDetachShader(_program, vertShader);
+        glDeleteShader(vertShader);
+    }
+    if (fragShader) {
+        glDetachShader(_program, fragShader);
+        glDeleteShader(fragShader);
+    }
+    
+    return YES;
+}
+
+- (BOOL)compileShader:(GLuint *)shader type:(GLenum)type file:(NSString *)file
+{
+    GLint status;
+    const GLchar *source;
+    
+    source = (GLchar *)[[NSString stringWithContentsOfFile:file encoding:NSUTF8StringEncoding error:nil] UTF8String];
+    if (!source) {
+        NSLog(@"Failed to load vertex shader");
+        return NO;
+    }
+    
+    *shader = glCreateShader(type);
+    glShaderSource(*shader, 1, &source, NULL);
+    glCompileShader(*shader);
+    
+#if defined(DEBUG)
+    GLint logLength;
+    glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength);
+        glGetShaderInfoLog(*shader, logLength, &logLength, log);
+        NSLog(@"Shader compile log:\n%s", log);
+        free(log);
+    }
+#endif
+    
+    glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
+    if (status == 0) {
+        glDeleteShader(*shader);
+        return NO;
+    }
+    
+    return YES;
+}
+
+- (BOOL)linkProgram:(GLuint)prog
+{
+    GLint status;
+    glLinkProgram(prog);
+    
+#if defined(DEBUG)
+    GLint logLength;
+    glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength);
+        glGetProgramInfoLog(prog, logLength, &logLength, log);
+        NSLog(@"Program link log:\n%s", log);
+        free(log);
+    }
+#endif
+    
+    glGetProgramiv(prog, GL_LINK_STATUS, &status);
+    if (status == 0) {
+        return NO;
+    }
+    
+    return YES;
+}
+
+- (BOOL)validateProgram:(GLuint)prog
+{
+    GLint logLength, status;
+    
+    glValidateProgram(prog);
+    glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength);
+        glGetProgramInfoLog(prog, logLength, &logLength, log);
+        NSLog(@"Program validate log:\n%s", log);
+        free(log);
+    }
+    
+    glGetProgramiv(prog, GL_VALIDATE_STATUS, &status);
+    if (status == 0) {
+        return NO;
+    }
+    
+    return YES;
+}
+
+@end

examples/ios_example/imguiex/Images.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,72 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "3x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "icon_imgui_60@2x~iphone.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "icon_imgui_60@3x~iphone.png",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "29x29",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "40x40",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "icon_imgui_76~ipad.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "icon_imgui_76@2x~ipad.png",
+      "scale" : "2x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

examples/ios_example/imguiex/Info.plist

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>org.imgui.example.$(PRODUCT_NAME:rfc1034identifier)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UIStatusBarHidden</key>
+	<true/>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>

examples/ios_example/imguiex/Shaders/Shader.fsh

@@ -0,0 +1,10 @@
+//
+//  Shader.fsh
+//  imguiex
+
+varying lowp vec4 colorVarying;
+
+void main()
+{
+    gl_FragColor = colorVarying;
+}

examples/ios_example/imguiex/Shaders/Shader.vsh

@@ -0,0 +1,25 @@
+//
+//  Shader.vsh
+//  imguiex
+
+attribute vec4 position;
+attribute vec3 normal;
+
+varying lowp vec4 colorVarying;
+
+uniform vec3 diffuseColor;
+uniform mat4 modelViewProjectionMatrix;
+uniform mat3 normalMatrix;
+
+void main()
+{
+    vec3 eyeNormal = normalize(normalMatrix * normal);
+    vec3 lightPosition = vec3(0.0, 0.0, 1.0);
+    
+    float nDotVP = max(0.0, dot(eyeNormal, normalize(lightPosition)));
+    
+    vec3 colorLit = diffuseColor * nDotVP;
+    colorVarying = vec4( colorLit.x, colorLit.y, colorLit.z, 1.0 );
+    
+    gl_Position = modelViewProjectionMatrix * position;
+}

examples/ios_example/imguiex/debug_hud.cpp

@@ -0,0 +1,45 @@
+//
+//  debug_hud.cpp
+//  imguiex
+
+#include <stdio.h>
+
+#include "debug_hud.h"
+#include "imgui.h"
+
+void DebugHUD_InitDefaults( DebugHUD *hud )
+{
+    hud->show_test_window = true;
+    hud->show_example_window = true;
+    hud->rotation_speed = 15.0f;
+    
+    hud->cubeColor1[0] = 0.4f;
+    hud->cubeColor1[1] = 0.4f;
+    hud->cubeColor1[2] = 1.0f;
+    hud->cubeColor1[3] = 1.0f;
+    
+    hud->cubeColor2[0] = 1.0f;
+    hud->cubeColor2[1] = 0.4f;
+    hud->cubeColor2[2] = 0.4f;
+    hud->cubeColor2[3] = 1.0f;
+}
+
+void DebugHUD_DoInterface( DebugHUD *hud )
+{
+    if (hud->show_test_window)
+    {
+        ImGui::SetNextWindowPos( ImVec2( 400, 20 ), ImGuiSetCond_FirstUseEver );
+        ImGui::ShowTestWindow( &hud->show_test_window );
+    }
+    
+    if (hud->show_example_window)
+    {
+        ImGui::SetNextWindowPos( ImVec2( 20, 20 ), ImGuiSetCond_FirstUseEver );
+        ImGui::SetNextWindowSize( ImVec2( 350, 200 ), ImGuiSetCond_FirstUseEver );
+        ImGui::Begin("Another Window", &hud->show_example_window);
+        ImGui::ColorEdit3("Cube 1 Color", hud->cubeColor1);
+        ImGui::ColorEdit3("Cube 2 Color", hud->cubeColor2);
+        ImGui::SliderFloat("Rotation Speed", &hud->rotation_speed, 0.0f, 200.0f);
+        ImGui::End();
+    }
+}

examples/ios_example/imguiex/debug_hud.h

@@ -0,0 +1,25 @@
+//
+//  debug_hud.h
+//  imguiex
+
+#pragma once
+
+typedef struct DebugHUD
+{
+    bool show_test_window;
+    bool show_example_window;
+    float rotation_speed;
+    float cubeColor1[4];
+    float cubeColor2[4];
+} DebugHUD;
+
+#if __cplusplus
+extern "C" {
+#endif
+
+void DebugHUD_InitDefaults( DebugHUD *hud );
+void DebugHUD_DoInterface( DebugHUD *hud );
+
+#if __cplusplus
+}
+#endif

examples/ios_example/imguiex/imgui_impl_ios.h

@@ -0,0 +1,22 @@
+//
+//  imgui_impl_ios.h
+//  imguiex
+//
+//  Joel Davis (joeld42@gmail.com)
+//
+
+#pragma once
+
+#include <Foundation/Foundation.h>
+#include <UIKit/UIKit.h>
+
+@interface ImGuiHelper : NSObject
+
+- (id) initWithView: (UIView *)view;
+
+- (void)connectServer: (NSString*)serverName;
+
+- (void)render;
+- (void)newFrame;
+
+@end

examples/ios_example/imguiex/imgui_impl_ios.mm

@@ -0,0 +1,801 @@
+//
+//  imgui_impl_ios.cpp
+//  imguiex
+
+#import <OpenGLES/ES3/gl.h>
+#import <OpenGLES/ES3/glext.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+#include "imgui_impl_ios.h"
+#include "imgui.h"
+
+#include "uSynergy.h"
+
+// From Carbon HIToolbox/Events.h
+// FIXME: Keyboard mapping is hacked in because Synergy doesn't give us character but only keycode which aren't really portable if you consider keyboard locale. See https://github.com/ocornut/imgui/pull/247
+enum {
+    kVK_ANSI_A                    = 0x00,
+    kVK_ANSI_S                    = 0x01,
+    kVK_ANSI_D                    = 0x02,
+    kVK_ANSI_F                    = 0x03,
+    kVK_ANSI_H                    = 0x04,
+    kVK_ANSI_G                    = 0x05,
+    kVK_ANSI_Z                    = 0x06,
+    kVK_ANSI_X                    = 0x07,
+    kVK_ANSI_C                    = 0x08,
+    kVK_ANSI_V                    = 0x09,
+    kVK_ANSI_B                    = 0x0B,
+    kVK_ANSI_Q                    = 0x0C,
+    kVK_ANSI_W                    = 0x0D,
+    kVK_ANSI_E                    = 0x0E,
+    kVK_ANSI_R                    = 0x0F,
+    kVK_ANSI_Y                    = 0x10,
+    kVK_ANSI_T                    = 0x11,
+    kVK_ANSI_1                    = 0x12,
+    kVK_ANSI_2                    = 0x13,
+    kVK_ANSI_3                    = 0x14,
+    kVK_ANSI_4                    = 0x15,
+    kVK_ANSI_6                    = 0x16,
+    kVK_ANSI_5                    = 0x17,
+    kVK_ANSI_Equal                = 0x18,
+    kVK_ANSI_9                    = 0x19,
+    kVK_ANSI_7                    = 0x1A,
+    kVK_ANSI_Minus                = 0x1B,
+    kVK_ANSI_8                    = 0x1C,
+    kVK_ANSI_0                    = 0x1D,
+    kVK_ANSI_RightBracket         = 0x1E,
+    kVK_ANSI_O                    = 0x1F,
+    kVK_ANSI_U                    = 0x20,
+    kVK_ANSI_LeftBracket          = 0x21,
+    kVK_ANSI_I                    = 0x22,
+    kVK_ANSI_P                    = 0x23,
+    kVK_ANSI_L                    = 0x25,
+    kVK_ANSI_J                    = 0x26,
+    kVK_ANSI_Quote                = 0x27,
+    kVK_ANSI_K                    = 0x28,
+    kVK_ANSI_Semicolon            = 0x29,
+    kVK_ANSI_Backslash            = 0x2A,
+    kVK_ANSI_Comma                = 0x2B,
+    kVK_ANSI_Slash                = 0x2C,
+    kVK_ANSI_N                    = 0x2D,
+    kVK_ANSI_M                    = 0x2E,
+    kVK_ANSI_Period               = 0x2F,
+    kVK_ANSI_Grave                = 0x32,
+    kVK_ANSI_KeypadDecimal        = 0x41,
+    kVK_ANSI_KeypadMultiply       = 0x43,
+    kVK_ANSI_KeypadPlus           = 0x45,
+    kVK_ANSI_KeypadClear          = 0x47,
+    kVK_ANSI_KeypadDivide         = 0x4B,
+    kVK_ANSI_KeypadEnter          = 0x4C,
+    kVK_ANSI_KeypadMinus          = 0x4E,
+    kVK_ANSI_KeypadEquals         = 0x51,
+    kVK_ANSI_Keypad0              = 0x52,
+    kVK_ANSI_Keypad1              = 0x53,
+    kVK_ANSI_Keypad2              = 0x54,
+    kVK_ANSI_Keypad3              = 0x55,
+    kVK_ANSI_Keypad4              = 0x56,
+    kVK_ANSI_Keypad5              = 0x57,
+    kVK_ANSI_Keypad6              = 0x58,
+    kVK_ANSI_Keypad7              = 0x59,
+    kVK_ANSI_Keypad8              = 0x5B,
+    kVK_ANSI_Keypad9              = 0x5C
+};
+
+/* keycodes for keys that are independent of keyboard layout*/
+enum {
+    kVK_Return                    = 0x24,
+    kVK_Tab                       = 0x30,
+    kVK_Space                     = 0x31,
+    kVK_Delete                    = 0x33,
+    kVK_Escape                    = 0x35,
+    kVK_Command                   = 0x37,
+    kVK_Shift                     = 0x38,
+    kVK_CapsLock                  = 0x39,
+    kVK_Option                    = 0x3A,
+    kVK_Control                   = 0x3B,
+    kVK_RightShift                = 0x3C,
+    kVK_RightOption               = 0x3D,
+    kVK_RightControl              = 0x3E,
+    kVK_Function                  = 0x3F,
+    kVK_F17                       = 0x40,
+    kVK_VolumeUp                  = 0x48,
+    kVK_VolumeDown                = 0x49,
+    kVK_Mute                      = 0x4A,
+    kVK_F18                       = 0x4F,
+    kVK_F19                       = 0x50,
+    kVK_F20                       = 0x5A,
+    kVK_F5                        = 0x60,
+    kVK_F6                        = 0x61,
+    kVK_F7                        = 0x62,
+    kVK_F3                        = 0x63,
+    kVK_F8                        = 0x64,
+    kVK_F9                        = 0x65,
+    kVK_F11                       = 0x67,
+    kVK_F13                       = 0x69,
+    kVK_F16                       = 0x6A,
+    kVK_F14                       = 0x6B,
+    kVK_F10                       = 0x6D,
+    kVK_F12                       = 0x6F,
+    kVK_F15                       = 0x71,
+    kVK_Help                      = 0x72,
+    kVK_Home                      = 0x73,
+    kVK_PageUp                    = 0x74,
+    kVK_ForwardDelete             = 0x75,
+    kVK_F4                        = 0x76,
+    kVK_End                       = 0x77,
+    kVK_F2                        = 0x78,
+    kVK_PageDown                  = 0x79,
+    kVK_F1                        = 0x7A,
+    kVK_LeftArrow                 = 0x7B,
+    kVK_RightArrow                = 0x7C,
+    kVK_DownArrow                 = 0x7D,
+    kVK_UpArrow                   = 0x7E
+};
+
+static char g_keycodeCharUnshifted[256] = {};
+static char g_keycodeCharShifted[256] = {};
+
+//static double       g_Time = 0.0f;
+static bool         g_MousePressed[3] = { false, false, false };
+static float        g_mouseWheelX = 0.0f;
+static float        g_mouseWheelY = 0.0f;
+
+static GLuint       g_FontTexture = 0;
+static int          g_ShaderHandle = 0, g_VertHandle = 0, g_FragHandle = 0;
+static int          g_AttribLocationTex = 0, g_AttribLocationProjMtx = 0;
+static int          g_AttribLocationPosition = 0, g_AttribLocationUV = 0, g_AttribLocationColor = 0;
+static size_t       g_VboSize = 0;
+static unsigned int g_VboHandle = 0, g_VaoHandle = 0;
+static float        g_displayScale;
+
+static int usynergy_sockfd;
+static bool g_synergyPtrActive = false;
+static uint16_t g_mousePosX = 0;
+static uint16_t g_mousePosY = 0;
+
+static void ImGui_ImplIOS_RenderDrawLists (ImDrawData *draw_data);
+bool ImGui_ImplIOS_CreateDeviceObjects();
+
+static NSString *g_serverName;
+
+uSynergyBool ImGui_ConnectFunc(uSynergyCookie cookie)
+{
+    // NOTE: You need to turn off "Use SSL Encryption" in Synergy preferences, since
+    // uSynergy does not support SSL.
+    
+    NSLog( @"Connect Func!");
+    struct addrinfo hints, *res;
+    
+    // first, load up address structs with getaddrinfo():
+    memset(&hints, 0, sizeof hints);
+    hints.ai_family = AF_UNSPEC;  // use IPv4 or IPv6, whichever
+    hints.ai_socktype = SOCK_STREAM;
+    
+    // get server address
+    getaddrinfo([g_serverName UTF8String], "24800", &hints, &res);
+    
+    if (!res)
+    {
+        NSLog( @"Could not find server: %@", g_serverName );
+        return USYNERGY_FALSE;
+    }
+    
+    // make a socket:
+    usynergy_sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+    
+    // connect it to the address and port we passed in to getaddrinfo():
+    int ret = connect(usynergy_sockfd, res->ai_addr, res->ai_addrlen);
+    if (!ret) {
+        NSLog( @"Connect suceeded...");
+    } else {
+        NSLog( @"Connect failed, %d", ret );
+    }
+    
+    
+    return USYNERGY_TRUE;
+}
+
+uSynergyBool ImGui_SendFunc(uSynergyCookie cookie, const uint8_t *buffer, int length)
+{
+//    NSLog( @"Send Func" );
+    send( usynergy_sockfd, buffer, length, 0 );
+    
+    return USYNERGY_TRUE;
+}
+
+uSynergyBool ImGui_RecvFunc(uSynergyCookie cookie, uint8_t *buffer, int maxLength, int* outLength)
+{
+    *outLength = (int)recv( usynergy_sockfd, buffer, maxLength, 0 );
+    
+    return USYNERGY_TRUE;
+}
+
+void ImGui_SleepFunc(uSynergyCookie cookie, int timeMs)
+{
+    usleep( timeMs * 1000 );
+}
+
+uint32_t ImGui_GetTimeFunc()
+{
+    struct timeval  tv;
+    gettimeofday(&tv, NULL);
+    
+    return (int32_t)((tv.tv_sec) * 1000 + (tv.tv_usec) / 1000);
+}
+
+void ImGui_TraceFunc(uSynergyCookie cookie, const char *text)
+{
+    puts(text);
+}
+
+void ImGui_ScreenActiveCallback(uSynergyCookie cookie, uSynergyBool active)
+{
+    g_synergyPtrActive = active;
+//    printf( "Synergy: screen activate %s\n", active?"YES":"NO" );
+}
+
+void ImGui_MouseCallback(uSynergyCookie cookie, uint16_t x, uint16_t y, int16_t wheelX, int16_t wheelY,
+                         uSynergyBool buttonLeft, uSynergyBool buttonRight, uSynergyBool buttonMiddle)
+{
+//    printf("Synergy: mouse callback %d %d -- wheel %d %d\n", x, y,  wheelX, wheelY );
+    uSynergyContext *ctx = (uSynergyContext*)cookie;
+    g_mousePosX = x;
+    g_mousePosY = y;
+    g_mouseWheelX = wheelX;
+    g_mouseWheelY = wheelY;
+    g_MousePressed[0] = buttonLeft;
+    g_MousePressed[1] = buttonMiddle;
+    g_MousePressed[2] = buttonRight;
+    
+    ctx->m_mouseWheelX = 0;
+    ctx->m_mouseWheelY = 0;
+}
+
+void ImGui_KeyboardCallback(uSynergyCookie cookie, uint16_t key,
+                            uint16_t modifiers, uSynergyBool down, uSynergyBool repeat)
+{
+    int scanCode = key-1;
+//    printf("Synergy: keyboard callback: 0x%02X (%s)", scanCode, down?"true":"false");
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeysDown[key] = down;
+    io.KeyShift = modifiers & USYNERGY_MODIFIER_SHIFT;
+    io.KeyCtrl = modifiers & USYNERGY_MODIFIER_CTRL;
+    io.KeyAlt = modifiers & USYNERGY_MODIFIER_ALT;
+    
+    
+    // Add this as keyboard input
+    if ((down) && (key) && (scanCode<256) && !(modifiers & USYNERGY_MODIFIER_CTRL)) 
+	{
+        // If this key maps to a character input, apply it
+        int charForKeycode = (modifiers & USYNERGY_MODIFIER_SHIFT) ? g_keycodeCharShifted[scanCode] : g_keycodeCharUnshifted[scanCode];
+        io.AddInputCharacter((unsigned short)charForKeycode);
+    }
+    
+}
+
+void ImGui_JoystickCallback(uSynergyCookie cookie, uint8_t joyNum, uint16_t buttons, int8_t leftStickX, int8_t leftStickY, int8_t rightStickX, int8_t rightStickY)
+{
+    printf("Synergy: joystick callback TODO\n");
+}
+
+void ImGui_ClipboardCallback(uSynergyCookie cookie, enum uSynergyClipboardFormat format, const uint8_t *data, uint32_t size)
+{
+    printf("Synergy: clipboard callback TODO\n" );
+}
+
+
+@interface ImGuiHelper ()
+{
+    BOOL _mouseDown;
+    BOOL _mouseTapped;
+    CGPoint _touchPos;
+
+    uSynergyContext _synergyCtx;
+    dispatch_queue_t _synergyQueue;
+}
+@property (nonatomic, weak) UIView *view;
+@property (nonatomic, strong) NSString *serverName;
+
+@end
+
+@implementation ImGuiHelper
+
+- (id) initWithView: (UIView *)view
+{
+    self = [super init];
+    if (self)
+    {
+        self.view = view;
+
+        [self setupImGuiHooks];
+    }
+    return self;
+}
+
+- (void)setupKeymaps
+{
+    // The keyboard mapping is a big headache. I tried for a while to find a better way to do this,
+    // but this was the best I could come up with. There are some device independent API's available
+    // to convert scan codes to unicode characters, but these are only available on mac and not
+    // on iOS as far as I can tell (it's part of Carbon). I didn't see any better way to do
+    // this or  any way to get the character codes out of usynergy.
+    g_keycodeCharUnshifted[ kVK_ANSI_A ]='a';
+    g_keycodeCharUnshifted[ kVK_ANSI_S ]='s';
+    g_keycodeCharUnshifted[ kVK_ANSI_D ]='d';
+    g_keycodeCharUnshifted[ kVK_ANSI_F ]='f';
+    g_keycodeCharUnshifted[ kVK_ANSI_H ]='h';
+    g_keycodeCharUnshifted[ kVK_ANSI_G ]='g';
+    g_keycodeCharUnshifted[ kVK_ANSI_Z ]='z';
+    g_keycodeCharUnshifted[ kVK_ANSI_X ]='x';
+    g_keycodeCharUnshifted[ kVK_ANSI_C ]='c';
+    g_keycodeCharUnshifted[ kVK_ANSI_V ]='v';
+    g_keycodeCharUnshifted[ kVK_ANSI_B ]='b';
+    g_keycodeCharUnshifted[ kVK_ANSI_Q ]='q';
+    g_keycodeCharUnshifted[ kVK_ANSI_W ]='w';
+    g_keycodeCharUnshifted[ kVK_ANSI_E ]='e';
+    g_keycodeCharUnshifted[ kVK_ANSI_R ]='r';
+    g_keycodeCharUnshifted[ kVK_ANSI_Y ]='y';
+    g_keycodeCharUnshifted[ kVK_ANSI_T ]='t';
+    g_keycodeCharUnshifted[ kVK_ANSI_1 ]='1';
+    g_keycodeCharUnshifted[ kVK_ANSI_2 ]='2';
+    g_keycodeCharUnshifted[ kVK_ANSI_3 ]='3';
+    g_keycodeCharUnshifted[ kVK_ANSI_4 ]='4';
+    g_keycodeCharUnshifted[ kVK_ANSI_6 ]='6';
+    g_keycodeCharUnshifted[ kVK_ANSI_5 ]='5';
+    g_keycodeCharUnshifted[ kVK_ANSI_Equal ]='=';
+    g_keycodeCharUnshifted[ kVK_ANSI_9 ]='9';
+    g_keycodeCharUnshifted[ kVK_ANSI_7 ]='7';
+    g_keycodeCharUnshifted[ kVK_ANSI_Minus ]='-';
+    g_keycodeCharUnshifted[ kVK_ANSI_8 ]='8';
+    g_keycodeCharUnshifted[ kVK_ANSI_0 ]='0';
+    g_keycodeCharUnshifted[ kVK_ANSI_RightBracket ]=']';
+    g_keycodeCharUnshifted[ kVK_ANSI_O ]='o';
+    g_keycodeCharUnshifted[ kVK_ANSI_U ]='u';
+    g_keycodeCharUnshifted[ kVK_ANSI_LeftBracket ]='[';
+    g_keycodeCharUnshifted[ kVK_ANSI_I ]='i';
+    g_keycodeCharUnshifted[ kVK_ANSI_P ]='p';
+    g_keycodeCharUnshifted[ kVK_ANSI_L ]='l';
+    g_keycodeCharUnshifted[ kVK_ANSI_J ]='j';
+    g_keycodeCharUnshifted[ kVK_ANSI_Quote ]='\'';
+    g_keycodeCharUnshifted[ kVK_ANSI_K ]='k';
+    g_keycodeCharUnshifted[ kVK_ANSI_Semicolon ]=';';
+    g_keycodeCharUnshifted[ kVK_ANSI_Backslash ]='\\';
+    g_keycodeCharUnshifted[ kVK_ANSI_Comma ]=',';
+    g_keycodeCharUnshifted[ kVK_ANSI_Slash ]='/';
+    g_keycodeCharUnshifted[ kVK_ANSI_N ]='n';
+    g_keycodeCharUnshifted[ kVK_ANSI_M ]='m';
+    g_keycodeCharUnshifted[ kVK_ANSI_Period ]='.';
+    g_keycodeCharUnshifted[ kVK_ANSI_Grave ]='`';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadDecimal ]='.';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadMultiply ]='*';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadPlus ]='+';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadDivide ]='/';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadEnter ]='\n';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadMinus ]='-';
+    g_keycodeCharUnshifted[ kVK_ANSI_KeypadEquals ]='=';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad0 ]='0';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad1 ]='1';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad2 ]='2';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad3 ]='3';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad4 ]='4';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad5 ]='5';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad6 ]='6';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad7 ]='7';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad8 ]='8';
+    g_keycodeCharUnshifted[ kVK_ANSI_Keypad9 ]='9';
+    g_keycodeCharUnshifted[ kVK_Space ]=' ';
+    
+    g_keycodeCharShifted[ kVK_ANSI_A ]='A';
+    g_keycodeCharShifted[ kVK_ANSI_S ]='S';
+    g_keycodeCharShifted[ kVK_ANSI_D ]='D';
+    g_keycodeCharShifted[ kVK_ANSI_F ]='F';
+    g_keycodeCharShifted[ kVK_ANSI_H ]='H';
+    g_keycodeCharShifted[ kVK_ANSI_G ]='G';
+    g_keycodeCharShifted[ kVK_ANSI_Z ]='Z';
+    g_keycodeCharShifted[ kVK_ANSI_X ]='X';
+    g_keycodeCharShifted[ kVK_ANSI_C ]='C';
+    g_keycodeCharShifted[ kVK_ANSI_V ]='V';
+    g_keycodeCharShifted[ kVK_ANSI_B ]='B';
+    g_keycodeCharShifted[ kVK_ANSI_Q ]='Q';
+    g_keycodeCharShifted[ kVK_ANSI_W ]='W';
+    g_keycodeCharShifted[ kVK_ANSI_E ]='E';
+    g_keycodeCharShifted[ kVK_ANSI_R ]='R';
+    g_keycodeCharShifted[ kVK_ANSI_Y ]='Y';
+    g_keycodeCharShifted[ kVK_ANSI_T ]='T';
+    g_keycodeCharShifted[ kVK_ANSI_1 ]='!';
+    g_keycodeCharShifted[ kVK_ANSI_2 ]='@';
+    g_keycodeCharShifted[ kVK_ANSI_3 ]='#';
+    g_keycodeCharShifted[ kVK_ANSI_4 ]='$';
+    g_keycodeCharShifted[ kVK_ANSI_6 ]='^';
+    g_keycodeCharShifted[ kVK_ANSI_5 ]='%';
+    g_keycodeCharShifted[ kVK_ANSI_Equal ]='+';
+    g_keycodeCharShifted[ kVK_ANSI_9 ]='(';
+    g_keycodeCharShifted[ kVK_ANSI_7 ]='&';
+    g_keycodeCharShifted[ kVK_ANSI_Minus ]='_';
+    g_keycodeCharShifted[ kVK_ANSI_8 ]='*';
+    g_keycodeCharShifted[ kVK_ANSI_0 ]=')';
+    g_keycodeCharShifted[ kVK_ANSI_RightBracket ]='}';
+    g_keycodeCharShifted[ kVK_ANSI_O ]='O';
+    g_keycodeCharShifted[ kVK_ANSI_U ]='U';
+    g_keycodeCharShifted[ kVK_ANSI_LeftBracket ]='{';
+    g_keycodeCharShifted[ kVK_ANSI_I ]='I';
+    g_keycodeCharShifted[ kVK_ANSI_P ]='P';
+    g_keycodeCharShifted[ kVK_ANSI_L ]='L';
+    g_keycodeCharShifted[ kVK_ANSI_J ]='J';
+    g_keycodeCharShifted[ kVK_ANSI_Quote ]='\"';
+    g_keycodeCharShifted[ kVK_ANSI_K ]='K';
+    g_keycodeCharShifted[ kVK_ANSI_Semicolon ]=':';
+    g_keycodeCharShifted[ kVK_ANSI_Backslash ]='|';
+    g_keycodeCharShifted[ kVK_ANSI_Comma ]='<';
+    g_keycodeCharShifted[ kVK_ANSI_Slash ]='?';
+    g_keycodeCharShifted[ kVK_ANSI_N ]='N';
+    g_keycodeCharShifted[ kVK_ANSI_M ]='M';
+    g_keycodeCharShifted[ kVK_ANSI_Period ]='>';
+    g_keycodeCharShifted[ kVK_ANSI_Grave ]='~';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadDecimal ]='.';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadMultiply ]='*';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadPlus ]='+';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadDivide ]='/';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadEnter ]='\n';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadMinus ]='-';
+    g_keycodeCharShifted[ kVK_ANSI_KeypadEquals ]='=';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad0 ]='0';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad1 ]='1';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad2 ]='2';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad3 ]='3';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad4 ]='4';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad5 ]='5';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad6 ]='6';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad7 ]='7';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad8 ]='8';
+    g_keycodeCharShifted[ kVK_ANSI_Keypad9 ]='9';
+    g_keycodeCharShifted[ kVK_Space ]=' ';
+}
+
+- (void)setupImGuiHooks
+{
+    ImGuiIO &io = ImGui::GetIO();
+    
+    [self setupKeymaps];
+    
+    // Account for retina display for glScissor
+    g_displayScale = [[UIScreen mainScreen] scale];
+    
+    ImGuiStyle &style = ImGui::GetStyle();
+    style.TouchExtraPadding = ImVec2( 4.0, 4.0 );
+    
+    io.RenderDrawListsFn = ImGui_ImplIOS_RenderDrawLists;
+    
+    UIPanGestureRecognizer *panRecognizer = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(viewDidPan:) ];
+    [self.view addGestureRecognizer:panRecognizer];
+    
+    UITapGestureRecognizer *tapRecoginzer = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector( viewDidTap:)];
+    [self.view addGestureRecognizer:tapRecoginzer];
+    
+    // Fill out the Synergy key map
+    // (for some reason synergy scan codes are off by 1)
+    io.KeyMap[ImGuiKey_Tab] = kVK_Tab+1;
+    io.KeyMap[ImGuiKey_LeftArrow] = kVK_LeftArrow+1;
+    io.KeyMap[ImGuiKey_RightArrow] = kVK_RightArrow+1;
+    io.KeyMap[ImGuiKey_UpArrow] = kVK_UpArrow+1;
+    io.KeyMap[ImGuiKey_DownArrow] = kVK_DownArrow+1;
+    io.KeyMap[ImGuiKey_Home] = kVK_Home+1;
+    io.KeyMap[ImGuiKey_End] = kVK_End+1;
+    io.KeyMap[ImGuiKey_Delete] = kVK_ForwardDelete+1;
+    io.KeyMap[ImGuiKey_Backspace] = kVK_Delete+1;
+    io.KeyMap[ImGuiKey_Enter] = kVK_Return+1;
+    io.KeyMap[ImGuiKey_Escape] = kVK_Escape+1;
+    io.KeyMap[ImGuiKey_A] = kVK_ANSI_A+1;
+    io.KeyMap[ImGuiKey_C] = kVK_ANSI_C+1;
+    io.KeyMap[ImGuiKey_V] = kVK_ANSI_V+1;
+    io.KeyMap[ImGuiKey_X] = kVK_ANSI_X+1;
+    io.KeyMap[ImGuiKey_Y] = kVK_ANSI_Y+1;
+    io.KeyMap[ImGuiKey_Z] = kVK_ANSI_Z+1;
+}
+
+- (void)connectServer: (NSString*)serverName
+{
+    self.serverName = serverName;
+    g_serverName = serverName;
+    
+    // Init synergy
+    NSString *bundleName = [[[NSBundle mainBundle] infoDictionary] objectForKey:(NSString*)kCFBundleNameKey];
+    
+    uSynergyInit( &_synergyCtx );
+    _synergyCtx.m_clientName = strdup( [bundleName UTF8String] );
+    _synergyCtx.m_clientWidth = self.view.bounds.size.width;
+    _synergyCtx.m_clientHeight = self.view.bounds.size.height;
+    
+    _synergyCtx.m_connectFunc = ImGui_ConnectFunc;
+    _synergyCtx.m_sendFunc = ImGui_SendFunc;
+    _synergyCtx.m_receiveFunc = ImGui_RecvFunc;
+    _synergyCtx.m_sleepFunc = ImGui_SleepFunc;
+    _synergyCtx.m_traceFunc = ImGui_TraceFunc;
+    _synergyCtx.m_getTimeFunc = ImGui_GetTimeFunc;
+    
+    _synergyCtx.m_traceFunc = ImGui_TraceFunc;
+    _synergyCtx.m_screenActiveCallback = ImGui_ScreenActiveCallback;
+    _synergyCtx.m_mouseCallback = ImGui_MouseCallback;
+    _synergyCtx.m_keyboardCallback = ImGui_KeyboardCallback;
+    
+    _synergyCtx.m_cookie = (uSynergyCookie)&_synergyCtx;
+    
+    // Create a background thread for synergy
+    _synergyQueue = dispatch_queue_create( "imgui-usynergy", NULL );
+    dispatch_async( _synergyQueue, ^{
+        while (1) {
+            uSynergyUpdate( &_synergyCtx );
+        }
+    });
+}
+
+
+- (void)viewDidPan: (UIPanGestureRecognizer *)recognizer
+{
+    
+    if ((recognizer.state == UIGestureRecognizerStateBegan) ||
+        (recognizer.state == UIGestureRecognizerStateChanged))
+    {
+        _mouseDown = YES;
+        _touchPos = [recognizer locationInView:self.view];
+    }
+    else
+    {
+        _mouseDown = NO;
+        _touchPos = CGPointMake( -1, -1 );
+    }
+}
+
+- (void)viewDidTap: (UITapGestureRecognizer*)recognizer
+{
+    _touchPos = [recognizer locationInView:self.view];
+    _mouseTapped = YES;
+}
+    
+- (void)render
+{
+    ImGui::Render();
+}
+
+- (void)newFrame
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGuiStyle &style = ImGui::GetStyle();
+    
+    if (!g_FontTexture)
+    {
+        ImGui_ImplIOS_CreateDeviceObjects();
+    }
+    
+    io.DisplaySize = ImVec2( _view.bounds.size.width, _view.bounds.size.height );
+
+    io.MouseDrawCursor = g_synergyPtrActive;
+    if (g_synergyPtrActive)
+    {
+        style.TouchExtraPadding = ImVec2( 0.0, 0.0 );
+        io.MousePos = ImVec2( g_mousePosX, g_mousePosY );
+        for (int i=0; i < 3; i++)
+        {
+            io.MouseDown[i] = g_MousePressed[i];
+        }
+
+        // This is an arbitrary scaling factor that works for me. Not sure what units these
+        // mousewheel values from synergy are supposed to be in
+        io.MouseWheel = g_mouseWheelY / 500.0;
+    }
+    else
+    {
+        // Synergy not active, use touch events
+        style.TouchExtraPadding = ImVec2( 4.0, 4.0 );
+        io.MousePos = ImVec2(_touchPos.x, _touchPos.y );
+        if ((_mouseDown) || (_mouseTapped))
+        {
+            io.MouseDown[0] = true;
+            _mouseTapped = NO;
+        }
+        else
+        {
+            io.MouseDown[0] = false;
+        }
+    }
+    
+    ImGui::NewFrame();
+}
+@end
+
+// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
+// If text or lines are blurry when integrating ImGui in your engine:
+// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
+// NOTE: this is copied pretty much entirely from the opengl3_example, with only minor changes for ES
+static void ImGui_ImplIOS_RenderDrawLists (ImDrawData *draw_data)
+{
+    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
+    GLint last_program, last_texture;
+    glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glEnable(GL_BLEND);
+    glBlendEquation(GL_FUNC_ADD);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+    glActiveTexture(GL_TEXTURE0);
+    
+    // Setup orthographic projection matrix
+    const float width = ImGui::GetIO().DisplaySize.x;
+    const float height = ImGui::GetIO().DisplaySize.y;
+    const float ortho_projection[4][4] =
+    {
+        { 2.0f/width,	0.0f,			0.0f,		0.0f },
+        { 0.0f,			2.0f/-height,	0.0f,		0.0f },
+        { 0.0f,			0.0f,			-1.0f,		0.0f },
+        { -1.0f,		1.0f,			0.0f,		1.0f },
+    };
+    glUseProgram(g_ShaderHandle);
+    glUniform1i(g_AttribLocationTex, 0);
+    glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
+    glBindVertexArray(g_VaoHandle);
+    
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
+    {
+        ImDrawList* cmd_list = draw_data->CmdLists[n];
+        ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front();
+        
+        glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
+        int needed_vtx_size = cmd_list->VtxBuffer.size() * sizeof(ImDrawVert);
+        if (g_VboSize < needed_vtx_size)
+        {
+            // Grow our buffer if needed
+            g_VboSize = needed_vtx_size + 2000 * sizeof(ImDrawVert);
+            glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)g_VboSize, NULL, GL_STREAM_DRAW);
+        }
+
+        unsigned char* vtx_data = (unsigned char*)glMapBufferRange(GL_ARRAY_BUFFER, 0, needed_vtx_size, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
+        if (!vtx_data)
+            continue;
+        memcpy(vtx_data, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
+        glUnmapBuffer(GL_ARRAY_BUFFER);
+        
+        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++)
+        {
+            if (pcmd->UserCallback)
+            {
+                pcmd->UserCallback(cmd_list, pcmd);
+            }
+            else
+            {
+                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                glScissor((int)(pcmd->ClipRect.x * g_displayScale),
+                          (int)((height - pcmd->ClipRect.w) * g_displayScale),
+                          (int)((pcmd->ClipRect.z - pcmd->ClipRect.x) * g_displayScale),
+                          (int)((pcmd->ClipRect.w - pcmd->ClipRect.y) * g_displayScale));
+                glDrawElements( GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer );
+            }
+            idx_buffer += pcmd->ElemCount;
+        }
+    }
+    
+    // Restore modified state
+    glBindVertexArray(0);
+    glBindBuffer( GL_ARRAY_BUFFER, 0);
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+    glUseProgram(last_program);
+    glDisable(GL_SCISSOR_TEST);
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+}
+
+void ImGui_ImplIOS_CreateFontsTexture()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bits for OpenGL3 demo because it is more likely to be compatible with user's existing shader.
+    
+    glGenTextures(1, &g_FontTexture);
+    glBindTexture(GL_TEXTURE_2D, g_FontTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+    
+    // Store our identifier
+    io.Fonts->TexID = (void *)(intptr_t)g_FontTexture;
+    
+    // Cleanup (don't clear the input data if you want to append new fonts later)
+    io.Fonts->ClearInputData();
+    io.Fonts->ClearTexData();
+}
+
+bool ImGui_ImplIOS_CreateDeviceObjects()
+{
+    const GLchar *vertex_shader =
+    "uniform mat4 ProjMtx;\n"
+    "attribute highp vec2 Position;\n"
+    "attribute highp vec2 UV;\n"
+    "attribute highp vec4 Color;\n"
+    "varying vec2 Frag_UV;\n"
+    "varying vec4 Frag_Color;\n"
+    "void main()\n"
+    "{\n"
+    "	Frag_UV = UV;\n"
+    "	Frag_Color = Color;\n"
+    "	gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+    "}\n";
+    
+    const GLchar* fragment_shader =
+    "uniform sampler2D Texture;\n"
+    "varying highp vec2 Frag_UV;\n"
+    "varying highp vec4 Frag_Color;\n"
+    "void main()\n"
+    "{\n"
+    "	gl_FragColor = Frag_Color * texture2D( Texture, Frag_UV.st);\n"
+    "}\n";
+    
+    g_ShaderHandle = glCreateProgram();
+    g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
+    g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(g_VertHandle, 1, &vertex_shader, 0);
+    glShaderSource(g_FragHandle, 1, &fragment_shader, 0);
+    glCompileShader(g_VertHandle);
+    
+#if defined(DEBUG)
+    GLint logLength;
+    glGetShaderiv( g_VertHandle, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength);
+        glGetShaderInfoLog(g_VertHandle, logLength, &logLength, log);
+        NSLog(@"VERTEX Shader compile log:\n%s", log);
+        free(log);
+    }
+#endif
+    
+    glCompileShader(g_FragHandle);
+    
+#if defined(DEBUG)
+    glGetShaderiv( g_FragHandle, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength);
+        glGetShaderInfoLog(g_FragHandle, logLength, &logLength, log);
+        NSLog(@"FRAGMENT Shader compile log:\n%s", log);
+        free(log);
+    }
+#endif
+    
+    
+    glAttachShader(g_ShaderHandle, g_VertHandle);
+    glAttachShader(g_ShaderHandle, g_FragHandle);
+    glLinkProgram(g_ShaderHandle);
+    
+    g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
+    g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
+    g_AttribLocationPosition = glGetAttribLocation(g_ShaderHandle, "Position");
+    g_AttribLocationUV = glGetAttribLocation(g_ShaderHandle, "UV");
+    g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color");
+    
+    glGenBuffers(1, &g_VboHandle);
+    
+    glGenVertexArrays(1, &g_VaoHandle);
+    glBindVertexArray(g_VaoHandle);
+    glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
+    glEnableVertexAttribArray(g_AttribLocationPosition);
+    glEnableVertexAttribArray(g_AttribLocationUV);
+    glEnableVertexAttribArray(g_AttribLocationColor);
+    
+#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
+    glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos));
+    glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv));
+    glVertexAttribPointer(g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col));
+#undef OFFSETOF
+    glBindVertexArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    
+    ImGui_ImplIOS_CreateFontsTexture();
+    
+    return true;
+}

examples/ios_example/imguiex/main.m

@@ -0,0 +1,13 @@
+//
+//  main.m
+//  imguiex
+//
+
+#import <UIKit/UIKit.h>
+#import "AppDelegate.h"
+
+int main(int argc, char * argv[]) {
+    @autoreleasepool {
+        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
+    }
+}

examples/libs/usynergy/uSynergy.c

@@ -0,0 +1,636 @@
+/*
+uSynergy client -- Implementation for the embedded Synergy client library
+  version 1.0.0, July 7th, 2012
+
+Copyright (c) 2012 Alex Evans
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+   1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+   3. This notice may not be removed or altered from any source
+   distribution.
+*/
+#include "uSynergy.h"
+#include <stdio.h>
+#include <string.h>
+
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Internal helpers
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief Read 16 bit integer in network byte order and convert to native byte order
+**/
+static int16_t sNetToNative16(const unsigned char *value)
+{
+#ifdef USYNERGY_LITTLE_ENDIAN
+	return value[1] | (value[0] << 8);
+#else
+	return value[0] | (value[1] << 8);
+#endif
+}
+
+
+
+/**
+@brief Read 32 bit integer in network byte order and convert to native byte order
+**/
+static int32_t sNetToNative32(const unsigned char *value)
+{
+#ifdef USYNERGY_LITTLE_ENDIAN
+	return value[3] | (value[2] << 8) | (value[1] << 16) | (value[0] << 24);
+#else
+	return value[0] | (value[1] << 8) | (value[2] << 16) | (value[3] << 24);
+#endif
+}
+
+
+
+/**
+@brief Trace text to client
+**/
+static void sTrace(uSynergyContext *context, const char* text)
+{
+	// Don't trace if we don't have a trace function
+	if (context->m_traceFunc != 0L)
+		context->m_traceFunc(context->m_cookie, text);
+}
+
+
+
+/**
+@brief Add string to reply packet
+**/
+static void sAddString(uSynergyContext *context, const char *string)
+{
+	size_t len = strlen(string);
+	memcpy(context->m_replyCur, string, len);
+	context->m_replyCur += len;
+}
+
+
+
+/**
+@brief Add uint8 to reply packet
+**/
+static void sAddUInt8(uSynergyContext *context, uint8_t value)
+{
+	*context->m_replyCur++ = value;
+}
+
+
+
+/**
+@brief Add uint16 to reply packet
+**/
+static void sAddUInt16(uSynergyContext *context, uint16_t value)
+{
+	uint8_t *reply = context->m_replyCur;
+	*reply++ = (uint8_t)(value >> 8);
+	*reply++ = (uint8_t)value;
+	context->m_replyCur = reply;
+}
+
+
+
+/**
+@brief Add uint32 to reply packet
+**/
+static void sAddUInt32(uSynergyContext *context, uint32_t value)
+{
+	uint8_t *reply = context->m_replyCur;
+	*reply++ = (uint8_t)(value >> 24);
+	*reply++ = (uint8_t)(value >> 16);
+	*reply++ = (uint8_t)(value >> 8);
+	*reply++ = (uint8_t)value;
+	context->m_replyCur = reply;
+}
+
+
+
+/**
+@brief Send reply packet
+**/
+static uSynergyBool sSendReply(uSynergyContext *context)
+{
+	// Set header size
+	uint8_t		*reply_buf	= context->m_replyBuffer;
+	uint32_t	reply_len	= (uint32_t)(context->m_replyCur - reply_buf);				/* Total size of reply */
+	uint32_t	body_len	= reply_len - 4;											/* Size of body */
+	uSynergyBool ret;
+	reply_buf[0] = (uint8_t)(body_len >> 24);
+	reply_buf[1] = (uint8_t)(body_len >> 16);
+	reply_buf[2] = (uint8_t)(body_len >> 8);
+	reply_buf[3] = (uint8_t)body_len;
+
+	// Send reply
+	ret = context->m_sendFunc(context->m_cookie, context->m_replyBuffer, reply_len);
+
+	// Reset reply buffer write pointer
+	context->m_replyCur = context->m_replyBuffer+4;
+	return ret;
+}
+
+
+
+/**
+@brief Call mouse callback after a mouse event
+**/
+static void sSendMouseCallback(uSynergyContext *context)
+{
+	// Skip if no callback is installed
+	if (context->m_mouseCallback == 0L)
+		return;
+
+	// Send callback
+	context->m_mouseCallback(context->m_cookie, context->m_mouseX, context->m_mouseY, context->m_mouseWheelX,
+		context->m_mouseWheelY, context->m_mouseButtonLeft, context->m_mouseButtonRight, context->m_mouseButtonMiddle);
+}
+
+
+
+/**
+@brief Send keyboard callback when a key has been pressed or released
+**/
+static void sSendKeyboardCallback(uSynergyContext *context, uint16_t key, uint16_t modifiers, uSynergyBool down, uSynergyBool repeat)
+{
+	// Skip if no callback is installed
+	if (context->m_keyboardCallback == 0L)
+		return;
+
+	// Send callback
+	context->m_keyboardCallback(context->m_cookie, key, modifiers, down, repeat);
+}
+
+
+
+/**
+@brief Send joystick callback
+**/
+static void sSendJoystickCallback(uSynergyContext *context, uint8_t joyNum)
+{
+	int8_t *sticks;
+
+	// Skip if no callback is installed
+	if (context->m_joystickCallback == 0L)
+		return;
+
+	// Send callback
+	sticks = context->m_joystickSticks[joyNum];
+	context->m_joystickCallback(context->m_cookie, joyNum, context->m_joystickButtons[joyNum], sticks[0], sticks[1], sticks[2], sticks[3]);
+}
+
+
+
+/**
+@brief Parse a single client message, update state, send callbacks and send replies
+**/
+#define USYNERGY_IS_PACKET(pkt_id)	memcmp(message+4, pkt_id, 4)==0
+static void sProcessMessage(uSynergyContext *context, const uint8_t *message)
+{
+	// We have a packet!
+	if (memcmp(message+4, "Synergy", 7)==0)
+	{
+		// Welcome message
+		//		kMsgHello			= "Synergy%2i%2i"
+		//		kMsgHelloBack		= "Synergy%2i%2i%s"
+		sAddString(context, "Synergy");
+		sAddUInt16(context, USYNERGY_PROTOCOL_MAJOR);
+		sAddUInt16(context, USYNERGY_PROTOCOL_MINOR);
+		sAddUInt32(context, (uint32_t)strlen(context->m_clientName));
+		sAddString(context, context->m_clientName);
+		if (!sSendReply(context))
+		{
+			// Send reply failed, let's try to reconnect
+			sTrace(context, "SendReply failed, trying to reconnect in a second");
+			context->m_connected = USYNERGY_FALSE;
+			context->m_sleepFunc(context->m_cookie, 1000);
+		}
+		else
+		{
+			// Let's assume we're connected
+			char buffer[256+1];
+			sprintf(buffer, "Connected as client \"%s\"", context->m_clientName);
+			sTrace(context, buffer);
+			context->m_hasReceivedHello = USYNERGY_TRUE;
+		}
+		return;
+	}
+	else if (USYNERGY_IS_PACKET("QINF"))
+	{
+		// Screen info. Reply with DINF
+		//		kMsgQInfo			= "QINF"
+		//		kMsgDInfo			= "DINF%2i%2i%2i%2i%2i%2i%2i"
+		uint16_t x = 0, y = 0, warp = 0;
+		sAddString(context, "DINF");
+		sAddUInt16(context, x);
+		sAddUInt16(context, y);
+		sAddUInt16(context, context->m_clientWidth);
+		sAddUInt16(context, context->m_clientHeight);
+		sAddUInt16(context, warp);
+		sAddUInt16(context, 0);		// mx?
+		sAddUInt16(context, 0);		// my?
+		sSendReply(context);
+		return;
+	}
+	else if (USYNERGY_IS_PACKET("CIAK"))
+	{
+		// Do nothing?
+		//		kMsgCInfoAck		= "CIAK"
+		return;
+	}
+	else if (USYNERGY_IS_PACKET("CROP"))
+	{
+		// Do nothing?
+		//		kMsgCResetOptions	= "CROP"
+		return;
+	}
+	else if (USYNERGY_IS_PACKET("CINN"))
+	{
+		// Screen enter. Reply with CNOP
+		//		kMsgCEnter 			= "CINN%2i%2i%4i%2i"
+
+		// Obtain the Synergy sequence number
+		context->m_sequenceNumber = sNetToNative32(message + 12);
+		context->m_isCaptured = USYNERGY_TRUE;
+
+		// Call callback
+		if (context->m_screenActiveCallback != 0L)
+			context->m_screenActiveCallback(context->m_cookie, USYNERGY_TRUE);
+	}
+	else if (USYNERGY_IS_PACKET("COUT"))
+	{
+		// Screen leave
+		//		kMsgCLeave 			= "COUT"
+		context->m_isCaptured = USYNERGY_FALSE;
+
+		// Call callback
+		if (context->m_screenActiveCallback != 0L)
+			context->m_screenActiveCallback(context->m_cookie, USYNERGY_FALSE);
+	}
+	else if (USYNERGY_IS_PACKET("DMDN"))
+	{
+		// Mouse down
+		//		kMsgDMouseDown		= "DMDN%1i"
+		char btn = message[8]-1;
+		if (btn==2)
+			context->m_mouseButtonRight		= USYNERGY_TRUE;
+		else if (btn==1)
+			context->m_mouseButtonMiddle	= USYNERGY_TRUE;
+		else
+			context->m_mouseButtonLeft		= USYNERGY_TRUE;
+		sSendMouseCallback(context);
+	}
+	else if (USYNERGY_IS_PACKET("DMUP"))
+	{
+		// Mouse up
+		//		kMsgDMouseUp		= "DMUP%1i"
+		char btn = message[8]-1;
+		if (btn==2)
+			context->m_mouseButtonRight		= USYNERGY_FALSE;
+		else if (btn==1)
+			context->m_mouseButtonMiddle	= USYNERGY_FALSE;
+		else
+			context->m_mouseButtonLeft		= USYNERGY_FALSE;
+		sSendMouseCallback(context);
+	}
+	else if (USYNERGY_IS_PACKET("DMMV"))
+	{
+		// Mouse move. Reply with CNOP
+		//		kMsgDMouseMove		= "DMMV%2i%2i"
+		context->m_mouseX = sNetToNative16(message+8);
+		context->m_mouseY = sNetToNative16(message+10);
+		sSendMouseCallback(context);
+	}
+	else if (USYNERGY_IS_PACKET("DMWM"))
+	{
+		// Mouse wheel
+		//		kMsgDMouseWheel		= "DMWM%2i%2i"
+		//		kMsgDMouseWheel1_0	= "DMWM%2i"
+		context->m_mouseWheelX += sNetToNative16(message+8);
+		context->m_mouseWheelY += sNetToNative16(message+10);
+		sSendMouseCallback(context);
+	}
+	else if (USYNERGY_IS_PACKET("DKDN"))
+	{
+		// Key down
+		//		kMsgDKeyDown		= "DKDN%2i%2i%2i"
+		//		kMsgDKeyDown1_0		= "DKDN%2i%2i"
+		//uint16_t id = sNetToNative16(message+8);
+		uint16_t mod = sNetToNative16(message+10);
+		uint16_t key = sNetToNative16(message+12);
+		sSendKeyboardCallback(context, key, mod, USYNERGY_TRUE, USYNERGY_FALSE);
+	}
+	else if (USYNERGY_IS_PACKET("DKRP"))
+	{
+		// Key repeat
+		//		kMsgDKeyRepeat		= "DKRP%2i%2i%2i%2i"
+		//		kMsgDKeyRepeat1_0	= "DKRP%2i%2i%2i"
+		uint16_t mod = sNetToNative16(message+10);
+//		uint16_t count = sNetToNative16(message+12);
+		uint16_t key = sNetToNative16(message+14);
+		sSendKeyboardCallback(context, key, mod, USYNERGY_TRUE, USYNERGY_TRUE);
+	}
+	else if (USYNERGY_IS_PACKET("DKUP"))
+	{
+		// Key up
+		//		kMsgDKeyUp			= "DKUP%2i%2i%2i"
+		//		kMsgDKeyUp1_0		= "DKUP%2i%2i"
+		//uint16 id=Endian::sNetToNative(sbuf[4]);
+		uint16_t mod = sNetToNative16(message+10);
+		uint16_t key = sNetToNative16(message+12);
+		sSendKeyboardCallback(context, key, mod, USYNERGY_FALSE, USYNERGY_FALSE);
+	}
+	else if (USYNERGY_IS_PACKET("DGBT"))
+	{
+		// Joystick buttons
+		//		kMsgDGameButtons	= "DGBT%1i%2i";
+		uint8_t	joy_num = message[8];
+		if (joy_num<USYNERGY_NUM_JOYSTICKS)
+		{
+			// Copy button state, then send callback
+			context->m_joystickButtons[joy_num] = (message[9] << 8) | message[10];
+			sSendJoystickCallback(context, joy_num);
+		}
+	}
+	else if (USYNERGY_IS_PACKET("DGST"))
+	{
+		// Joystick sticks
+		//		kMsgDGameSticks		= "DGST%1i%1i%1i%1i%1i";
+		uint8_t	joy_num = message[8];
+		if (joy_num<USYNERGY_NUM_JOYSTICKS)
+		{
+			// Copy stick state, then send callback
+			memcpy(context->m_joystickSticks[joy_num], message+9, 4);
+			sSendJoystickCallback(context, joy_num);
+		}
+	}
+	else if (USYNERGY_IS_PACKET("DSOP"))
+	{
+		// Set options
+		//		kMsgDSetOptions		= "DSOP%4I"
+	}
+	else if (USYNERGY_IS_PACKET("CALV"))
+	{
+		// Keepalive, reply with CALV and then CNOP
+		//		kMsgCKeepAlive		= "CALV"
+		sAddString(context, "CALV");
+		sSendReply(context);
+		// now reply with CNOP
+	}
+	else if (USYNERGY_IS_PACKET("DCLP"))
+	{
+		// Clipboard message
+		//		kMsgDClipboard		= "DCLP%1i%4i%s"
+		//
+		// The clipboard message contains:
+		//		1 uint32:	The size of the message
+		//		4 chars: 	The identifier ("DCLP")
+		//		1 uint8: 	The clipboard index
+		//		1 uint32:	The sequence number. It's zero, because this message is always coming from the server?
+		//		1 uint32:	The total size of the remaining 'string' (as per the Synergy %s string format (which is 1 uint32 for size followed by a char buffer (not necessarily null terminated)).
+		//		1 uint32:	The number of formats present in the message
+		// And then 'number of formats' times the following:
+		//		1 uint32:	The format of the clipboard data
+		//		1 uint32:	The size n of the clipboard data
+		//		n uint8:	The clipboard data
+		const uint8_t *	parse_msg	= message+17;
+		uint32_t		num_formats = sNetToNative32(parse_msg);
+		parse_msg += 4;
+		for (; num_formats; num_formats--)
+		{
+			// Parse clipboard format header
+			uint32_t format	= sNetToNative32(parse_msg);
+			uint32_t size	= sNetToNative32(parse_msg+4);
+			parse_msg += 8;
+			
+			// Call callback
+			if (context->m_clipboardCallback)
+				context->m_clipboardCallback(context->m_cookie, format, parse_msg, size);
+
+			parse_msg += size;
+		}
+	}
+	else
+	{
+		// Unknown packet, could be any of these
+		//		kMsgCNoop 			= "CNOP"
+		//		kMsgCClose 			= "CBYE"
+		//		kMsgCClipboard 		= "CCLP%1i%4i"
+		//		kMsgCScreenSaver 	= "CSEC%1i"
+		//		kMsgDKeyRepeat		= "DKRP%2i%2i%2i%2i"
+		//		kMsgDKeyRepeat1_0	= "DKRP%2i%2i%2i"
+		//		kMsgDMouseRelMove	= "DMRM%2i%2i"
+		//		kMsgEIncompatible	= "EICV%2i%2i"
+		//		kMsgEBusy 			= "EBSY"
+		//		kMsgEUnknown		= "EUNK"
+		//		kMsgEBad			= "EBAD"
+		char buffer[64];
+		sprintf(buffer, "Unknown packet '%c%c%c%c'", message[4], message[5], message[6], message[7]);
+		sTrace(context, buffer);
+		return;
+	}
+
+	// Reply with CNOP maybe?
+	sAddString(context, "CNOP");
+	sSendReply(context);
+}
+#undef USYNERGY_IS_PACKET
+
+
+
+/**
+@brief Mark context as being disconnected
+**/
+static void sSetDisconnected(uSynergyContext *context)
+{
+	context->m_connected		= USYNERGY_FALSE;
+	context->m_hasReceivedHello = USYNERGY_FALSE;
+	context->m_isCaptured		= USYNERGY_FALSE;
+	context->m_replyCur			= context->m_replyBuffer + 4;
+	context->m_sequenceNumber	= 0;
+}
+
+
+
+/**
+@brief Update a connected context
+**/
+static void sUpdateContext(uSynergyContext *context)
+{
+	/* Receive data (blocking) */
+	int receive_size = USYNERGY_RECEIVE_BUFFER_SIZE - context->m_receiveOfs;
+	int num_received = 0;
+	int packlen = 0;
+	if (context->m_receiveFunc(context->m_cookie, context->m_receiveBuffer + context->m_receiveOfs, receive_size, &num_received) == USYNERGY_FALSE)
+	{
+		/* Receive failed, let's try to reconnect */
+		char buffer[128];
+		sprintf(buffer, "Receive failed (%d bytes asked, %d bytes received), trying to reconnect in a second", receive_size, num_received);
+		sTrace(context, buffer);
+		sSetDisconnected(context);
+		context->m_sleepFunc(context->m_cookie, 1000);
+		return;
+	}
+	context->m_receiveOfs += num_received;
+
+	/*	If we didn't receive any data then we're probably still polling to get connected and
+		therefore not getting any data back. To avoid overloading the system with a Synergy
+		thread that would hammer on polling, we let it rest for a bit if there's no data. */
+	if (num_received == 0)
+		context->m_sleepFunc(context->m_cookie, 500);
+
+	/* Check for timeouts */
+	if (context->m_hasReceivedHello)
+	{
+		uint32_t cur_time = context->m_getTimeFunc();
+		if (num_received == 0)
+		{
+			/* Timeout after 2 secs of inactivity (we received no CALV) */
+			if ((cur_time - context->m_lastMessageTime) > USYNERGY_IDLE_TIMEOUT)
+				sSetDisconnected(context);
+		}
+		else
+			context->m_lastMessageTime = cur_time;
+	}
+
+	/* Eat packets */
+	for (;;)
+	{
+		/* Grab packet length and bail out if the packet goes beyond the end of the buffer */
+		packlen = sNetToNative32(context->m_receiveBuffer);
+		if (packlen+4 > context->m_receiveOfs)
+			break;
+
+		/* Process message */
+		sProcessMessage(context, context->m_receiveBuffer);
+
+		/* Move packet to front of buffer */
+		memmove(context->m_receiveBuffer, context->m_receiveBuffer+packlen+4, context->m_receiveOfs-packlen-4);
+		context->m_receiveOfs -= packlen+4;
+	}
+
+	/* Throw away over-sized packets */
+	if (packlen > USYNERGY_RECEIVE_BUFFER_SIZE)
+	{
+		/* Oversized packet, ditch tail end */
+		char buffer[128];
+		sprintf(buffer, "Oversized packet: '%c%c%c%c' (length %d)", context->m_receiveBuffer[4], context->m_receiveBuffer[5], context->m_receiveBuffer[6], context->m_receiveBuffer[7], packlen);
+		sTrace(context, buffer);
+		num_received = context->m_receiveOfs-4; // 4 bytes for the size field
+		while (num_received != packlen)
+		{
+			int buffer_left = packlen - num_received;
+			int to_receive = buffer_left < USYNERGY_RECEIVE_BUFFER_SIZE ? buffer_left : USYNERGY_RECEIVE_BUFFER_SIZE;
+			int ditch_received = 0;
+			if (context->m_receiveFunc(context->m_cookie, context->m_receiveBuffer, to_receive, &ditch_received) == USYNERGY_FALSE)
+			{
+				/* Receive failed, let's try to reconnect */
+				sTrace(context, "Receive failed, trying to reconnect in a second");
+				sSetDisconnected(context);
+				context->m_sleepFunc(context->m_cookie, 1000);
+				break;
+			}
+			else
+			{
+				num_received += ditch_received;
+			}
+		}
+		context->m_receiveOfs = 0;
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Public interface
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief Initialize uSynergy context
+**/
+void uSynergyInit(uSynergyContext *context)
+{
+	/* Zero memory */
+	memset(context, 0, sizeof(uSynergyContext));
+
+	/* Initialize to default state */
+	sSetDisconnected(context);
+}
+
+
+/**
+@brief Update uSynergy
+**/
+void uSynergyUpdate(uSynergyContext *context)
+{
+	if (context->m_connected)
+	{
+		/* Update context, receive data, call callbacks */
+		sUpdateContext(context);
+	}
+	else
+	{
+		/* Try to connect */
+		if (context->m_connectFunc(context->m_cookie))
+			context->m_connected = USYNERGY_TRUE;
+	}
+}
+
+
+
+/**
+@brief Send clipboard data
+**/
+void uSynergySendClipboard(uSynergyContext *context, const char *text)
+{
+	// Calculate maximum size that will fit in a reply packet
+	uint32_t overhead_size =	4 +					/* Message size */
+								4 +					/* Message ID */
+								1 +					/* Clipboard index */
+								4 +					/* Sequence number */
+								4 +					/* Rest of message size (because it's a Synergy string from here on) */
+								4 +					/* Number of clipboard formats */
+								4 +					/* Clipboard format */
+								4;					/* Clipboard data length */
+	uint32_t max_length = USYNERGY_REPLY_BUFFER_SIZE - overhead_size;
+	
+	// Clip text to max length
+	uint32_t text_length = (uint32_t)strlen(text);
+	if (text_length > max_length)
+	{
+		char buffer[128];
+		sprintf(buffer, "Clipboard buffer too small, clipboard truncated at %d characters", max_length);
+		sTrace(context, buffer);
+		text_length = max_length;
+	}
+
+	// Assemble packet
+	sAddString(context, "DCLP");
+	sAddUInt8(context, 0);							/* Clipboard index */
+	sAddUInt32(context, context->m_sequenceNumber);
+	sAddUInt32(context, 4+4+4+text_length);			/* Rest of message size: numFormats, format, length, data */
+	sAddUInt32(context, 1);							/* Number of formats (only text for now) */
+	sAddUInt32(context, USYNERGY_CLIPBOARD_FORMAT_TEXT);
+	sAddUInt32(context, text_length);
+	sAddString(context, text);
+	sSendReply(context);
+}

examples/libs/usynergy/uSynergy.h

@@ -0,0 +1,420 @@
+/*
+uSynergy client -- Interface for the embedded Synergy client library
+  version 1.0.0, July 7th, 2012
+
+Copyright (C) 2012 Synergy Si Ltd.
+Copyright (c) 2012 Alex Evans
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+   1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+   3. This notice may not be removed or altered from any source
+   distribution.
+*/
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Configuration
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief Determine endianness
+**/
+#if defined(USYNERGY_LITTLE_ENDIAN) && defined(USYNERGY_BIG_ENDIAN)
+	/* Ambiguous: both endians specified */
+	#error "Can't define both USYNERGY_LITTLE_ENDIAN and USYNERGY_BIG_ENDIAN"
+#elif !defined(USYNERGY_LITTLE_ENDIAN) && !defined(USYNERGY_BIG_ENDIAN)
+	/* Attempt to auto detect */
+	#if defined(__LITTLE_ENDIAN__) || defined(LITTLE_ENDIAN) || (_BYTE_ORDER == _LITTLE_ENDIAN)
+		#define USYNERGY_LITTLE_ENDIAN
+	#elif defined(__BIG_ENDIAN__) || defined(BIG_ENDIAN) || (_BYTE_ORDER == _BIG_ENDIAN)
+		#define USYNERGY_BIG_ENDIAN
+	#else
+		#error "Can't detect endian-nes, please defined either USYNERGY_LITTLE_ENDIAN or USYNERGY_BIG_ENDIAN";
+	#endif
+#else
+	/* User-specified endian-nes, nothing to do for us */
+#endif
+
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Types and Constants
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief Boolean type
+**/
+typedef int			uSynergyBool;
+#define				USYNERGY_FALSE					0				/* False value */
+#define				USYNERGY_TRUE					1				/* True value */
+
+
+/**
+@brief User context type
+
+The uSynergyCookie type is an opaque type that is used by uSynergy to communicate to the client. It is passed along to
+callback functions as context.
+**/
+typedef struct { int ignored; } *					uSynergyCookie;
+
+
+
+/**
+@brief Clipboard types
+**/
+enum uSynergyClipboardFormat
+{
+	USYNERGY_CLIPBOARD_FORMAT_TEXT					= 0,			/* Text format, UTF-8, newline is LF */
+	USYNERGY_CLIPBOARD_FORMAT_BITMAP				= 1,			/* Bitmap format, BMP 24/32bpp, BI_RGB */
+	USYNERGY_CLIPBOARD_FORMAT_HTML					= 2,			/* HTML format, HTML fragment, UTF-8, newline is LF */
+};
+
+
+
+/**
+@brief Constants and limits
+**/
+#define				USYNERGY_NUM_JOYSTICKS			4				/* Maximum number of supported joysticks */
+
+#define				USYNERGY_PROTOCOL_MAJOR			1				/* Major protocol version */
+#define				USYNERGY_PROTOCOL_MINOR			4				/* Minor protocol version */
+
+#define				USYNERGY_IDLE_TIMEOUT			2000			/* Timeout in milliseconds before reconnecting */
+
+#define				USYNERGY_TRACE_BUFFER_SIZE		1024			/* Maximum length of traced message */
+#define				USYNERGY_REPLY_BUFFER_SIZE		1024			/* Maximum size of a reply packet */
+#define				USYNERGY_RECEIVE_BUFFER_SIZE	4096			/* Maximum size of an incoming packet */
+
+
+
+/**
+@brief Keyboard constants
+**/
+#define				USYNERGY_MODIFIER_SHIFT			0x0001			/* Shift key modifier */
+#define				USYNERGY_MODIFIER_CTRL			0x0002			/* Ctrl key modifier */
+#define				USYNERGY_MODIFIER_ALT			0x0004			/* Alt key modifier */
+#define				USYNERGY_MODIFIER_META			0x0008			/* Meta key modifier */
+#define				USYNERGY_MODIFIER_WIN			0x0010			/* Windows key modifier */
+#define				USYNERGY_MODIFIER_ALT_GR		0x0020			/* AltGr key modifier */
+#define				USYNERGY_MODIFIER_LEVEL5LOCK	0x0040			/* Level5Lock key modifier */
+#define				USYNERGY_MODIFIER_CAPSLOCK		0x1000			/* CapsLock key modifier */
+#define				USYNERGY_MODIFIER_NUMLOCK		0x2000			/* NumLock key modifier */
+#define				USYNERGY_MODIFIER_SCROLLOCK		0x4000			/* ScrollLock key modifier */
+
+
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Functions and Callbacks
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief Connect function
+
+This function is called when uSynergy needs to connect to the host. It doesn't imply a network implementation or
+destination address, that must all be handled on the user side. The function should return USYNERGY_TRUE if a
+connection was established or USYNERGY_FALSE if it could not connect.
+
+When network errors occur (e.g. uSynergySend or uSynergyReceive fail) then the connect call will be called again
+so the implementation of the function must close any old connections and clean up resources before retrying.
+
+@param cookie		Cookie supplied in the Synergy context
+**/
+typedef uSynergyBool (*uSynergyConnectFunc)(uSynergyCookie cookie);
+
+
+
+/**
+@brief Send function
+
+This function is called when uSynergy needs to send something over the default connection. It should return
+USYNERGY_TRUE if sending succeeded and USYNERGY_FALSE otherwise. This function should block until the send
+operation is completed.
+
+@param cookie		Cookie supplied in the Synergy context
+@param buffer		Address of buffer to send
+@param length		Length of buffer to send
+**/
+typedef uSynergyBool (*uSynergySendFunc)(uSynergyCookie cookie, const uint8_t *buffer, int length);
+
+
+
+/**
+@brief Receive function
+
+This function is called when uSynergy needs to receive data from the default connection. It should return
+USYNERGY_TRUE if receiving data succeeded and USYNERGY_FALSE otherwise. This function should block until data
+has been received and wait for data to become available. If @a outLength is set to 0 upon completion it is
+assumed that the connection is alive, but still in a connecting state and needs time to settle.
+
+@param cookie		Cookie supplied in the Synergy context
+@param buffer		Address of buffer to receive data into
+@param maxLength	Maximum amount of bytes to write into the receive buffer
+@param outLength	Address of integer that receives the actual amount of bytes written into @a buffer
+**/
+typedef uSynergyBool (*uSynergyReceiveFunc)(uSynergyCookie cookie, uint8_t *buffer, int maxLength, int* outLength);
+
+
+
+/**
+@brief Thread sleep function
+
+This function is called when uSynergy wants to suspend operation for a while before retrying an operation. It
+is mostly used when a socket times out or disconnect occurs to prevent uSynergy from continuously hammering a
+network connection in case the network is down.
+
+@param cookie		Cookie supplied in the Synergy context
+@param timeMs		Time to sleep the current thread (in milliseconds)
+**/
+typedef void		(*uSynergySleepFunc)(uSynergyCookie cookie, int timeMs);
+
+
+
+/**
+@brief Get time function
+
+This function is called when uSynergy needs to know the current time. This is used to determine when timeouts
+have occured. The time base should be a cyclic millisecond time value.
+
+@returns			Time value in milliseconds
+**/
+typedef uint32_t	(*uSynergyGetTimeFunc)();
+
+
+
+/**
+@brief Trace function
+
+This function is called when uSynergy wants to trace something. It is optional to show these messages, but they
+are often useful when debugging. uSynergy only traces major events like connecting and disconnecting. Usually
+only a single trace is shown when the connection is established and no more trace are called.
+
+@param cookie		Cookie supplied in the Synergy context
+@param text			Text to be traced
+**/
+typedef void		(*uSynergyTraceFunc)(uSynergyCookie cookie, const char *text);
+
+
+
+/**
+@brief Screen active callback
+
+This callback is called when Synergy makes the screen active or inactive. This
+callback is usually sent when the mouse enters or leaves the screen.
+
+@param cookie		Cookie supplied in the Synergy context
+@param active		Activation flag, 1 if the screen has become active, 0 if the screen has become inactive
+**/
+typedef void		(*uSynergyScreenActiveCallback)(uSynergyCookie cookie, uSynergyBool active);
+
+
+
+/**
+@brief Mouse callback
+
+This callback is called when a mouse events happens. The mouse X and Y position,
+wheel and button state is communicated in the message. It's up to the user to
+interpret if this is a mouse up, down, double-click or other message.
+
+@param cookie		Cookie supplied in the Synergy context
+@param x			Mouse X position
+@param y			Mouse Y position
+@param wheelX		Mouse wheel X position
+@param wheelY		Mouse wheel Y position
+@param buttonLeft	Left button pressed status, 0 for released, 1 for pressed
+@param buttonMiddle	Middle button pressed status, 0 for released, 1 for pressed
+@param buttonRight	Right button pressed status, 0 for released, 1 for pressed
+**/
+typedef void		(*uSynergyMouseCallback)(uSynergyCookie cookie, uint16_t x, uint16_t y, int16_t wheelX, int16_t wheelY, uSynergyBool buttonLeft, uSynergyBool buttonRight, uSynergyBool buttonMiddle);
+
+
+
+/**
+@brief Key event callback
+
+This callback is called when a key is pressed or released.
+
+@param cookie		Cookie supplied in the Synergy context
+@param key			Key code of key that was pressed or released
+@param modifiers	Status of modifier keys (alt, shift, etc.)
+@param down			Down or up status, 1 is key is pressed down, 0 if key is released (up)
+@param repeat		Repeat flag, 1 if the key is down because the key is repeating, 0 if the key is initially pressed by the user
+**/
+typedef void		(*uSynergyKeyboardCallback)(uSynergyCookie cookie, uint16_t key, uint16_t modifiers, uSynergyBool down, uSynergyBool repeat);
+
+
+
+/**
+@brief Joystick event callback
+
+This callback is called when a joystick stick or button changes. It is possible that multiple callbacks are
+fired when different sticks or buttons change as these are individual messages in the packet stream. Each
+callback will contain all the valid state for the different axes and buttons. The last callback received will
+represent the most current joystick state.
+
+@param cookie		Cookie supplied in the Synergy context
+@param joyNum		Joystick number, always in the range [0 ... USYNERGY_NUM_JOYSTICKS>
+@param buttons		Button pressed mask
+@param leftStickX	Left stick X position, in range [-127 ... 127]
+@param leftStickY	Left stick Y position, in range [-127 ... 127]
+@param rightStickX	Right stick X position, in range [-127 ... 127]
+@param rightStickY	Right stick Y position, in range [-127 ... 127]
+**/
+typedef void		(*uSynergyJoystickCallback)(uSynergyCookie cookie, uint8_t joyNum, uint16_t buttons, int8_t leftStickX, int8_t leftStickY, int8_t rightStickX, int8_t rightStickY);
+
+
+
+/**
+@brief Clipboard event callback
+
+This callback is called when something is placed on the clipboard. Multiple callbacks may be fired for
+multiple clipboard formats if they are supported. The data provided is read-only and may not be modified
+by the application.
+
+@param cookie		Cookie supplied in the Synergy context
+@param format		Clipboard format
+@param data			Memory area containing the clipboard raw data
+@param size			Size of clipboard data
+**/
+typedef void		(*uSynergyClipboardCallback)(uSynergyCookie cookie, enum uSynergyClipboardFormat format, const uint8_t *data, uint32_t size);
+
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Context
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief uSynergy context
+**/
+typedef struct
+{
+	/* Mandatory configuration data, filled in by client */
+	uSynergyConnectFunc				m_connectFunc;									/* Connect function */
+	uSynergySendFunc				m_sendFunc;										/* Send data function */
+	uSynergyReceiveFunc				m_receiveFunc;									/* Receive data function */
+	uSynergySleepFunc				m_sleepFunc;									/* Thread sleep function */
+	uSynergyGetTimeFunc				m_getTimeFunc;									/* Get current time function */
+	const char*						m_clientName;									/* Name of Synergy Screen / Client */
+	uint16_t						m_clientWidth;									/* Width of screen */
+	uint16_t						m_clientHeight;									/* Height of screen */
+
+	/* Optional configuration data, filled in by client */
+	uSynergyCookie					m_cookie;										/* Cookie pointer passed to callback functions (can be NULL) */
+	uSynergyTraceFunc				m_traceFunc;									/* Function for tracing status (can be NULL) */
+	uSynergyScreenActiveCallback	m_screenActiveCallback;							/* Callback for entering and leaving screen */
+	uSynergyMouseCallback			m_mouseCallback;								/* Callback for mouse events */
+	uSynergyKeyboardCallback		m_keyboardCallback;								/* Callback for keyboard events */
+	uSynergyJoystickCallback		m_joystickCallback;								/* Callback for joystick events */
+	uSynergyClipboardCallback		m_clipboardCallback;							/* Callback for clipboard events */
+
+	/* State data, used internall by client, initialized by uSynergyInit() */
+	uSynergyBool					m_connected;									/* Is our socket connected? */
+	uSynergyBool					m_hasReceivedHello;								/* Have we received a 'Hello' from the server? */
+	uSynergyBool					m_isCaptured;									/* Is Synergy active (i.e. this client is receiving input messages?) */
+	uint32_t						m_lastMessageTime;								/* Time at which last message was received */
+	uint32_t						m_sequenceNumber;								/* Packet sequence number */
+	uint8_t							m_receiveBuffer[USYNERGY_RECEIVE_BUFFER_SIZE];	/* Receive buffer */
+	int								m_receiveOfs;									/* Receive buffer offset */
+	uint8_t							m_replyBuffer[USYNERGY_REPLY_BUFFER_SIZE];		/* Reply buffer */
+	uint8_t*						m_replyCur;										/* Write offset into reply buffer */
+	uint16_t						m_mouseX;										/* Mouse X position */
+	uint16_t						m_mouseY;										/* Mouse Y position */
+	int16_t							m_mouseWheelX;									/* Mouse wheel X position */
+	int16_t							m_mouseWheelY;									/* Mouse wheel Y position */
+	uSynergyBool					m_mouseButtonLeft;								/* Mouse left button */
+	uSynergyBool					m_mouseButtonRight;								/* Mouse right button */
+	uSynergyBool					m_mouseButtonMiddle;							/* Mouse middle button */
+	int8_t							m_joystickSticks[USYNERGY_NUM_JOYSTICKS][4];	/* Joystick stick position in 2 axes for 2 sticks */
+	uint16_t						m_joystickButtons[USYNERGY_NUM_JOYSTICKS];		/* Joystick button state */
+} uSynergyContext;
+
+
+
+//---------------------------------------------------------------------------------------------------------------------
+//	Interface
+//---------------------------------------------------------------------------------------------------------------------
+
+
+
+/**
+@brief Initialize uSynergy context
+
+This function initializes @a context for use. Call this function directly after
+creating the context, before filling in any configuration data in it. Not calling
+this function will cause undefined behavior.
+
+@param context	Context to be initialized
+**/
+extern void		uSynergyInit(uSynergyContext *context);
+
+
+
+/**
+@brief Update uSynergy
+
+This function updates uSynergy and does the bulk of the work. It does connection management,
+receiving data, reconnecting after errors or timeouts and so on. It assumes that networking
+operations are blocking and it can suspend the current thread if it needs to wait. It is
+best practice to call uSynergyUpdate from a background thread so it is responsive.
+
+Because uSynergy relies mostly on blocking calls it will mostly stay in thread sleep state
+waiting for system mutexes and won't eat much memory.
+
+uSynergyUpdate doesn't do any memory allocations or have any side effects beyond those of
+the callbacks it calls.
+
+@param context	Context to be updated
+**/
+extern void		uSynergyUpdate(uSynergyContext *context);
+
+
+
+/**
+@brief Send clipboard data
+
+This function sets new clipboard data and sends it to the server. Use this function if
+your client cuts or copies data onto the clipboard that it needs to share with the
+server.
+
+Currently there is only support for plaintext, but HTML and image data could be
+supported with some effort.
+
+@param context	Context to send clipboard data to
+@param text		Text to set to the clipboard
+**/
+extern void		uSynergySendClipboard(uSynergyContext *context, const char *text);
+
+
+
+#ifdef __cplusplus
+};
+#endif

examples/opengl3_example/Makefile

@@ -11,7 +11,7 @@
 #CXX = g++
 
 OBJS = main.o imgui_impl_glfw_gl3.o
-OBJS += ../../imgui.o
+OBJS += ../../imgui.o ../../imgui_demo.o ../../imgui_draw.o
 OBJS += ../libs/gl3w/GL/gl3w.o
 
 UNAME_S := $(shell uname -s)

examples/opengl3_example/imgui_impl_glfw_gl3.cpp

@@ -23,17 +23,13 @@ static GLuint       g_FontTexture = 0;
 static int          g_ShaderHandle = 0, g_VertHandle = 0, g_FragHandle = 0;
 static int          g_AttribLocationTex = 0, g_AttribLocationProjMtx = 0;
 static int          g_AttribLocationPosition = 0, g_AttribLocationUV = 0, g_AttribLocationColor = 0;
-static size_t       g_VboSize = 0;
-static unsigned int g_VboHandle = 0, g_VaoHandle = 0;
+static unsigned int g_VboHandle = 0, g_VaoHandle = 0, g_ElementsHandle = 0;
 
 // This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
 // If text or lines are blurry when integrating ImGui in your engine:
 // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
-static void ImGui_ImplGlfwGL3_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
+static void ImGui_ImplGlfwGL3_RenderDrawLists(ImDrawData* draw_data)
 {
-    if (cmd_lists_count == 0)
-        return;
-
     // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
     GLint last_program, last_texture;
     glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
@@ -59,58 +55,39 @@ static void ImGui_ImplGlfwGL3_RenderDrawLists(ImDrawList** const cmd_lists, int
     glUseProgram(g_ShaderHandle);
     glUniform1i(g_AttribLocationTex, 0);
     glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
-
-    // Grow our buffer according to what we need
-    size_t total_vtx_count = 0;
-    for (int n = 0; n < cmd_lists_count; n++)
-        total_vtx_count += cmd_lists[n]->vtx_buffer.size();
-    glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
-    size_t needed_vtx_size = total_vtx_count * sizeof(ImDrawVert);
-    if (g_VboSize < needed_vtx_size)
-    {
-        g_VboSize = needed_vtx_size + 5000 * sizeof(ImDrawVert);  // Grow buffer
-        glBufferData(GL_ARRAY_BUFFER, g_VboSize, NULL, GL_STREAM_DRAW);
-    }
-
-    // Copy and convert all vertices into a single contiguous buffer
-    unsigned char* buffer_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
-    if (!buffer_data)
-        return;
-    for (int n = 0; n < cmd_lists_count; n++)
-    {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        memcpy(buffer_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert));
-        buffer_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert);
-    }
-    glUnmapBuffer(GL_ARRAY_BUFFER);
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(g_VaoHandle);
 
-    int cmd_offset = 0;
-    for (int n = 0; n < cmd_lists_count; n++)
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
     {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        int vtx_offset = cmd_offset;
-        const ImDrawCmd* pcmd_end = cmd_list->commands.end();
-        for (const ImDrawCmd* pcmd = cmd_list->commands.begin(); pcmd != pcmd_end; pcmd++)
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const ImDrawIdx* idx_buffer_offset = 0;
+
+        glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
+        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW);
+
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW);
+
+        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++)
         {
-            if (pcmd->user_callback)
+            if (pcmd->UserCallback)
             {
-                pcmd->user_callback(cmd_list, pcmd);
+                pcmd->UserCallback(cmd_list, pcmd);
             }
             else
             {
-                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->texture_id);
-                glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w), (int)(pcmd->clip_rect.z - pcmd->clip_rect.x), (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
-                glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
+                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                glScissor((int)pcmd->ClipRect.x, (int)(height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
+                glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer_offset);
             }
-            vtx_offset += pcmd->vtx_count;
+            idx_buffer_offset += pcmd->ElemCount;
         }
-        cmd_offset = vtx_offset;
     }
 
     // Restore modified state
     glBindVertexArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
     glUseProgram(last_program);
     glDisable(GL_SCISSOR_TEST);
     glBindTexture(GL_TEXTURE_2D, last_texture);
@@ -226,6 +203,7 @@ bool ImGui_ImplGlfwGL3_CreateDeviceObjects()
     g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color");
 
     glGenBuffers(1, &g_VboHandle);
+    glGenBuffers(1, &g_ElementsHandle);
 
     glGenVertexArrays(1, &g_VaoHandle);
     glBindVertexArray(g_VaoHandle);
@@ -257,6 +235,8 @@ bool    ImGui_ImplGlfwGL3_Init(GLFWwindow* window, bool install_callbacks)
     io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
     io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
     io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = GLFW_KEY_PAGE_UP;
+    io.KeyMap[ImGuiKey_PageDown] = GLFW_KEY_PAGE_DOWN;
     io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
     io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
     io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;
@@ -292,8 +272,8 @@ void ImGui_ImplGlfwGL3_Shutdown()
 {
     if (g_VaoHandle) glDeleteVertexArrays(1, &g_VaoHandle);
     if (g_VboHandle) glDeleteBuffers(1, &g_VboHandle);
-    g_VaoHandle = 0;
-    g_VboHandle = 0;
+    if (g_ElementsHandle) glDeleteBuffers(1, &g_ElementsHandle);
+    g_VaoHandle = g_VboHandle = g_ElementsHandle = 0;
 
     glDetachShader(g_ShaderHandle, g_VertHandle);
     glDeleteShader(g_VertHandle);

examples/opengl3_example/main.cpp

@@ -29,13 +29,22 @@ int main(int, char**)
 
     // Setup ImGui binding
     ImGui_ImplGlfwGL3_Init(window, true);
+
+    // Load Fonts
+    // (see extra_fonts/README.txt for more details)
     //ImGuiIO& io = ImGui::GetIO();
-    //ImFont* my_font0 = io.Fonts->AddFontDefault();
-    //ImFont* my_font1 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
-    //ImFont* my_font2 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/Karla-Regular.ttf", 16.0f);
-    //ImFont* my_font3 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f); my_font3->DisplayOffset.y += 1;
-    //ImFont* my_font4 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f); my_font4->DisplayOffset.y += 1;
-    //ImFont* my_font5 = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, io.Fonts->GetGlyphRangesJapanese());
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+    // Merge glyphs from multiple fonts into one (e.g. combine default font with another with Chinese glyphs, or add icons)
+    //ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
+    //ImFontConfig icons_config; icons_config.MergeMode = true; icons_config.PixelSnapH = true;
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/fontawesome-webfont.ttf", 18.0f, &icons_config, icons_ranges);
 
     bool show_test_window = true;
     bool show_another_window = false;

examples/opengl3_example/opengl3_example.vcxproj

@@ -149,6 +149,8 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\..\imgui.cpp" />
+    <ClCompile Include="..\..\imgui_demo.cpp" />
+    <ClCompile Include="..\..\imgui_draw.cpp" />
     <ClCompile Include="..\libs\gl3w\GL\gl3w.c" />
     <ClCompile Include="imgui_impl_glfw_gl3.cpp" />
     <ClCompile Include="main.cpp" />
@@ -156,6 +158,7 @@
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h" />
     <ClInclude Include="..\..\imgui.h" />
+    <ClInclude Include="..\..\imgui_internal.h" />
     <ClInclude Include="..\libs\gl3w\GL\gl3w.h" />
     <ClInclude Include="..\libs\gl3w\GL\glcorearb.h" />
     <ClInclude Include="imgui_impl_glfw_gl3.h" />

examples/opengl3_example/opengl3_example.vcxproj.filters

@@ -25,6 +25,12 @@
     <ClCompile Include="..\libs\gl3w\GL\gl3w.c">
       <Filter>gl3w</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\imgui_demo.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\imgui_draw.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h">
@@ -42,5 +48,8 @@
     <ClInclude Include="..\libs\gl3w\GL\glcorearb.h">
       <Filter>gl3w</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\imgui_internal.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

examples/opengl_example/Makefile

@@ -11,7 +11,7 @@
 #CXX = g++
 
 OBJS = main.o imgui_impl_glfw.o
-OBJS += ../../imgui.o
+OBJS += ../../imgui.o ../../imgui_demo.o ../../imgui_draw.o
 
 UNAME_S := $(shell uname -s)
 

examples/opengl_example/imgui_impl_glfw.cpp

@@ -23,11 +23,8 @@ static GLuint       g_FontTexture = 0;
 // This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
 // If text or lines are blurry when integrating ImGui in your engine:
 // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
-static void ImGui_ImplGlfw_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
+static void ImGui_ImplGlfw_RenderDrawLists(ImDrawData* draw_data)
 {
-    if (cmd_lists_count == 0)
-        return;
-
     // We are using the OpenGL fixed pipeline to make the example code simpler to read!
     // A probable faster way to render would be to collate all vertices from all cmd_lists into a single vertex buffer.
     // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
@@ -56,29 +53,29 @@ static void ImGui_ImplGlfw_RenderDrawLists(ImDrawList** const cmd_lists, int cmd
 
     // Render command lists
     #define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
-    for (int n = 0; n < cmd_lists_count; n++)
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
     {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->vtx_buffer.front();
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front();
+        const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front();
         glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos)));
         glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv)));
         glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col)));
 
-        int vtx_offset = 0;
-        for (size_t cmd_i = 0; cmd_i < cmd_list->commands.size(); cmd_i++)
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
         {
-            const ImDrawCmd* pcmd = &cmd_list->commands[cmd_i];
-            if (pcmd->user_callback)
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback)
             {
-                pcmd->user_callback(cmd_list, pcmd);
+                pcmd->UserCallback(cmd_list, pcmd);
             }
             else
             {
-                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->texture_id);
-                glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w), (int)(pcmd->clip_rect.z - pcmd->clip_rect.x), (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
-                glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
+                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                glScissor((int)pcmd->ClipRect.x, (int)(height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
+                glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer);
             }
-            vtx_offset += pcmd->vtx_count;
+            idx_buffer += pcmd->ElemCount;
         }
     }
     #undef OFFSETOF
@@ -183,6 +180,8 @@ bool    ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks)
     io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
     io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
     io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = GLFW_KEY_PAGE_UP;
+    io.KeyMap[ImGuiKey_PageDown] = GLFW_KEY_PAGE_DOWN;
     io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
     io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
     io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;

examples/opengl_example/main.cpp

@@ -21,13 +21,22 @@ int main(int, char**)
 
     // Setup ImGui binding
     ImGui_ImplGlfw_Init(window, true);
+
+    // Load Fonts
+    // (see extra_fonts/README.txt for more details)
     //ImGuiIO& io = ImGui::GetIO();
-    //ImFont* my_font0 = io.Fonts->AddFontDefault();
-    //ImFont* my_font1 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
-    //ImFont* my_font2 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/Karla-Regular.ttf", 16.0f);
-    //ImFont* my_font3 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f); my_font3->DisplayOffset.y += 1;
-    //ImFont* my_font4 = io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f); my_font4->DisplayOffset.y += 1;
-    //ImFont* my_font5 = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, io.Fonts->GetGlyphRangesJapanese());
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+    // Merge glyphs from multiple fonts into one (e.g. combine default font with another with Chinese glyphs, or add icons)
+    //ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
+    //ImFontConfig icons_config; icons_config.MergeMode = true; icons_config.PixelSnapH = true;
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/fontawesome-webfont.ttf", 18.0f, &icons_config, icons_ranges);
 
     bool show_test_window = true;
     bool show_another_window = false;

examples/opengl_example/opengl_example.vcxproj

@@ -149,12 +149,15 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\..\imgui.cpp" />
+    <ClCompile Include="..\..\imgui_demo.cpp" />
+    <ClCompile Include="..\..\imgui_draw.cpp" />
     <ClCompile Include="imgui_impl_glfw.cpp" />
     <ClCompile Include="main.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h" />
     <ClInclude Include="..\..\imgui.h" />
+    <ClInclude Include="..\..\imgui_internal.h" />
     <ClInclude Include="imgui_impl_glfw.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

examples/opengl_example/opengl_example.vcxproj.filters

@@ -19,6 +19,12 @@
     <ClCompile Include="imgui_impl_glfw.cpp">
       <Filter>sources</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\imgui_demo.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\imgui_draw.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\imconfig.h">
@@ -30,5 +36,8 @@
     <ClInclude Include="imgui_impl_glfw.h">
       <Filter>sources</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\imgui_internal.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

examples/sdl_opengl_example/README.md

@@ -0,0 +1,16 @@
+
+# How to Build
+
+- On Windows with Visual Studio's CLI
+
+\<sdl2path\> is your SDL2 folder.
+
+```
+cl /MD /I <sdl2path\include> /I ..\.. main.cpp imgui_impl_sdl.cpp ..\..\imgui*.cpp /link /LIBPATH:<sdl2path\lib> SDL2.lib SDL2main.lib
+```
+
+- On Linux and similar Unices
+
+```
+c++ `sdl2-config --cflags` -I ../.. main.cpp imgui_impl_sdl.cpp ../../imgui*.cpp `sdl2-config --libs` -lGL -o sdl2example
+```

examples/sdl_opengl_example/imgui_impl_sdl.cpp

@@ -0,0 +1,257 @@
+// ImGui SDL2 binding with OpenGL
+// https://github.com/ocornut/imgui
+
+#include <SDL.h>
+#include <SDL_syswm.h>
+#include <SDL_opengl.h>
+#include <imgui.h>
+#include "imgui_impl_sdl.h"
+
+// Data
+static double       g_Time = 0.0f;
+static bool         g_MousePressed[3] = { false, false, false };
+static float        g_MouseWheel = 0.0f;
+static GLuint       g_FontTexture = 0;
+
+// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
+// If text or lines are blurry when integrating ImGui in your engine:
+// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
+static void ImGui_ImplSdl_RenderDrawLists(ImDrawData* draw_data)
+{
+    // We are using the OpenGL fixed pipeline to make the example code simpler to read!
+    // A probable faster way to render would be to collate all vertices from all cmd_lists into a single vertex buffer.
+    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
+    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glEnable(GL_TEXTURE_2D);
+    //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context
+
+    // Setup orthographic projection matrix
+    const float width = ImGui::GetIO().DisplaySize.x;
+    const float height = ImGui::GetIO().DisplaySize.y;
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    glOrtho(0.0f, width, height, 0.0f, -1.0f, +1.0f);
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+
+    // Render command lists
+    #define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
+    {
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front();
+        const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front();
+        glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos)));
+        glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv)));
+        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col)));
+
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback)
+            {
+                pcmd->UserCallback(cmd_list, pcmd);
+            }
+            else
+            {
+                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                glScissor((int)pcmd->ClipRect.x, (int)(height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
+                glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer);
+            }
+            idx_buffer += pcmd->ElemCount;
+        }
+    }
+    #undef OFFSETOF
+
+    // Restore modified state
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glPopAttrib();
+}
+
+static const char* ImGui_ImplSdl_GetClipboardText()
+{
+	return SDL_GetClipboardText();
+}
+
+static void ImGui_ImplSdl_SetClipboardText(const char* text)
+{
+    SDL_SetClipboardText(text);
+}
+
+bool ImGui_ImplSdl_ProcessEvent(SDL_Event* event)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    switch (event->type)
+    {
+    case SDL_MOUSEWHEEL:
+        {
+            if (event->wheel.y > 0)
+                g_MouseWheel = 1;
+            if (event->wheel.y < 0)
+                g_MouseWheel = -1;
+            return true;
+        }
+    case SDL_MOUSEBUTTONDOWN:
+        {
+            if (event->button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true;
+            if (event->button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true;
+            if (event->button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true;
+            return true;
+        }
+    case SDL_TEXTINPUT:
+        {
+            ImGuiIO& io = ImGui::GetIO();
+            io.AddInputCharactersUTF8(event->text.text);
+            return true;
+        }
+    case SDL_KEYDOWN:
+    case SDL_KEYUP:
+        {
+            int key = event->key.keysym.sym & ~SDLK_SCANCODE_MASK;
+            io.KeysDown[key] = (event->type == SDL_KEYDOWN);
+            io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
+            io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
+            io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
+            return true;
+        }
+    }
+    return false;
+}
+
+bool ImGui_ImplSdl_CreateDeviceObjects()
+{
+    ImGuiIO& io = ImGui::GetIO();
+
+    // Build texture
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsAlpha8(&pixels, &width, &height);
+
+    // Create texture
+    glGenTextures(1, &g_FontTexture);
+    glBindTexture(GL_TEXTURE_2D, g_FontTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, pixels);
+
+    // Store our identifier
+    io.Fonts->TexID = (void *)(intptr_t)g_FontTexture;
+
+    // Cleanup (don't clear the input data if you want to append new fonts later)
+	io.Fonts->ClearInputData();
+	io.Fonts->ClearTexData();
+
+    return true;
+}
+
+void    ImGui_ImplSdl_InvalidateDeviceObjects()
+{
+    if (g_FontTexture)
+    {
+        glDeleteTextures(1, &g_FontTexture);
+        ImGui::GetIO().Fonts->TexID = 0;
+        g_FontTexture = 0;
+    }
+}
+
+bool    ImGui_ImplSdl_Init(SDL_Window *window)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeyMap[ImGuiKey_Tab] = SDLK_TAB;                 // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
+    io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
+    io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
+    io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP;
+    io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP;
+    io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN;
+    io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME;
+    io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END;
+    io.KeyMap[ImGuiKey_Delete] = SDLK_DELETE;
+    io.KeyMap[ImGuiKey_Backspace] = SDLK_BACKSPACE;
+    io.KeyMap[ImGuiKey_Enter] = SDLK_RETURN;
+    io.KeyMap[ImGuiKey_Escape] = SDLK_ESCAPE;
+    io.KeyMap[ImGuiKey_A] = SDLK_a;
+    io.KeyMap[ImGuiKey_C] = SDLK_c;
+    io.KeyMap[ImGuiKey_V] = SDLK_v;
+    io.KeyMap[ImGuiKey_X] = SDLK_x;
+    io.KeyMap[ImGuiKey_Y] = SDLK_y;
+    io.KeyMap[ImGuiKey_Z] = SDLK_z;
+	
+    io.RenderDrawListsFn = ImGui_ImplSdl_RenderDrawLists;
+    io.SetClipboardTextFn = ImGui_ImplSdl_SetClipboardText;
+    io.GetClipboardTextFn = ImGui_ImplSdl_GetClipboardText;
+	
+#ifdef _MSC_VER
+	SDL_SysWMinfo wmInfo;
+	SDL_VERSION(&wmInfo.version);
+	SDL_GetWindowWMInfo(window, &wmInfo);
+    io.ImeWindowHandle = wmInfo.info.win.window;
+#endif
+
+    return true;
+}
+
+void ImGui_ImplSdl_Shutdown()
+{
+    ImGui_ImplSdl_InvalidateDeviceObjects();
+    ImGui::Shutdown();
+}
+
+void ImGui_ImplSdl_NewFrame(SDL_Window *window)
+{
+    if (!g_FontTexture)
+        ImGui_ImplSdl_CreateDeviceObjects();
+
+    ImGuiIO& io = ImGui::GetIO();
+
+    // Setup display size (every frame to accommodate for window resizing)
+    int w, h;
+	SDL_GetWindowSize(window, &w, &h);
+    io.DisplaySize = ImVec2((float)w, (float)h);
+
+    // Setup time step
+	Uint32	time = SDL_GetTicks();
+	double current_time = time / 1000.0;
+    io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
+    g_Time = current_time;
+
+    // Setup inputs
+    // (we already got mouse wheel, keyboard keys & characters from glfw callbacks polled in glfwPollEvents())
+    int mx, my;
+    Uint32 mouseMask = SDL_GetMouseState(&mx, &my);
+    if (SDL_GetWindowFlags(window) & SDL_WINDOW_MOUSE_FOCUS)
+    	io.MousePos = ImVec2((float)mx, (float)my);   // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
+    else
+    	io.MousePos = ImVec2(-1,-1);
+   
+	io.MouseDown[0] = g_MousePressed[0] || (mouseMask & SDL_BUTTON(SDL_BUTTON_LEFT)) != 0;		// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
+	io.MouseDown[1] = g_MousePressed[1] || (mouseMask & SDL_BUTTON(SDL_BUTTON_RIGHT)) != 0;
+	io.MouseDown[2] = g_MousePressed[2] || (mouseMask & SDL_BUTTON(SDL_BUTTON_MIDDLE)) != 0;
+    g_MousePressed[0] = g_MousePressed[1] = g_MousePressed[2] = false;
+
+    io.MouseWheel = g_MouseWheel;
+    g_MouseWheel = 0.0f;
+
+    // Hide OS mouse cursor if ImGui is drawing it
+    SDL_ShowCursor(io.MouseDrawCursor ? 0 : 1);
+
+    // Start the frame
+    ImGui::NewFrame();
+}

examples/sdl_opengl_example/imgui_impl_sdl.h

@@ -0,0 +1,14 @@
+// ImGui SDL2 binding with OpenGL
+// https://github.com/ocornut/imgui
+
+struct SDL_Window;
+typedef union SDL_Event SDL_Event;
+
+bool        ImGui_ImplSdl_Init(SDL_Window *window);
+void        ImGui_ImplSdl_Shutdown();
+void        ImGui_ImplSdl_NewFrame(SDL_Window *window);
+bool        ImGui_ImplSdl_ProcessEvent(SDL_Event* event);
+
+// Use if you want to reset your rendering device without losing ImGui state.
+void        ImGui_ImplSdl_InvalidateDeviceObjects();
+bool        ImGui_ImplSdl_CreateDeviceObjects();

examples/sdl_opengl_example/main.cpp

@@ -0,0 +1,108 @@
+// ImGui - standalone example application for SDL2 + OpenGL
+
+#include <imgui.h>
+#include "imgui_impl_sdl.h"
+#include <stdio.h>
+#include <SDL.h>
+#include <SDL_opengl.h>
+
+int main(int, char**)
+{
+    // Setup SDL
+	if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
+	{
+        printf("Error: %s\n", SDL_GetError());
+        return -1;
+	}
+
+    // Setup window
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
+	SDL_DisplayMode current;
+	SDL_GetCurrentDisplayMode(0, &current);
+	SDL_Window *window = SDL_CreateWindow("ImGui SDL2+OpenGL example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE);
+	SDL_GLContext glcontext = SDL_GL_CreateContext(window);
+
+    // Setup ImGui binding
+    ImGui_ImplSdl_Init(window);
+
+    // Load Fonts
+    // (see extra_fonts/README.txt for more details)
+    //ImGuiIO& io = ImGui::GetIO();
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+    // Merge glyphs from multiple fonts into one (e.g. combine default font with another with Chinese glyphs, or add icons)
+    //ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
+    //ImFontConfig icons_config; icons_config.MergeMode = true; icons_config.PixelSnapH = true;
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../extra_fonts/fontawesome-webfont.ttf", 18.0f, &icons_config, icons_ranges);
+
+    bool show_test_window = true;
+    bool show_another_window = false;
+    ImVec4 clear_color = ImColor(114, 144, 154);
+
+    // Main loop
+	bool done = false;
+    while (!done)
+    {
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            ImGui_ImplSdl_ProcessEvent(&event);
+            if (event.type == SDL_QUIT)
+                done = true;
+        }
+        ImGui_ImplSdl_NewFrame(window);
+
+        // 1. Show a simple window
+        // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug"
+        {
+            static float f = 0.0f;
+            ImGui::Text("Hello, world!");
+            ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
+            ImGui::ColorEdit3("clear color", (float*)&clear_color);
+            if (ImGui::Button("Test Window")) show_test_window ^= 1;
+            if (ImGui::Button("Another Window")) show_another_window ^= 1;
+            ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
+        }
+
+        // 2. Show another simple window, this time using an explicit Begin/End pair
+        if (show_another_window)
+        {
+            ImGui::SetNextWindowSize(ImVec2(200,100), ImGuiSetCond_FirstUseEver);
+            ImGui::Begin("Another Window", &show_another_window);
+            ImGui::Text("Hello");
+            ImGui::End();
+        }
+
+        // 3. Show the ImGui test window. Most of the sample code is in ImGui::ShowTestWindow()
+        if (show_test_window)
+        {
+            ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiSetCond_FirstUseEver);
+            ImGui::ShowTestWindow(&show_test_window);
+        }
+
+        // Rendering
+        glViewport(0, 0, (int)ImGui::GetIO().DisplaySize.x, (int)ImGui::GetIO().DisplaySize.y);
+        glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
+        glClear(GL_COLOR_BUFFER_BIT);
+        ImGui::Render();
+        SDL_GL_SwapWindow(window);
+    }
+
+    // Cleanup
+    ImGui_ImplSdl_Shutdown();
+    SDL_GL_DeleteContext(glcontext);  
+	SDL_DestroyWindow(window);
+	SDL_Quit();
+
+    return 0;
+}

extra_fonts/README.txt

@@ -3,9 +3,75 @@
  Those are only provided as a convenience, you can load your own .TTF files.
 
 ---------------------------------
- INCLUDED FONTS
+ LOADING INSTRUCTIONS
 ---------------------------------
 
+ Load default font with:
+
+   ImGuiIO& io = ImGui::GetIO();
+   io.Fonts->AddFontDefault();
+
+ Load .TTF file with:
+
+   ImGuiIO& io = ImGui::GetIO();
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels);
+  
+ Detailed options:
+
+   ImFontConfig config;
+   config.OversampleH = 3;
+   config.OversampleV = 3;
+   config.GlyphExtraSpacing.x = 1.0f;
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, &config);
+
+ Combine two fonts into one:
+
+   // Load main font
+   io.Fonts->AddFontDefault();
+
+   // Add character ranges and merge into main font
+   ImWchar ranges[] = { 0xf000, 0xf3ff, 0 };
+   ImFontConfig config;
+   config.MergeMode = true;
+   io.Fonts->AddFontFromFileTTF("fontawesome-webfont.ttf", 16.0f, &config, ranges);
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, &config, io.Fonts->GetGlyphRangesJapanese());
+
+ Add a fourth parameter to bake specific font ranges only:
+
+   // Basic Latin, Extended Latin
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, NULL, io.Fonts->GetGlyphRangesDefault());
+   
+   // Include full set of about 21000 CJK Unified Ideographs
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, NULL, io.Fonts->GetGlyphRangesJapanese());
+   
+   // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, NULL, io.Fonts->GetGlyphRangesChinese());
+
+ Offset font vertically by altering the io.Font->DisplayOffset value:
+
+   ImFont* font = io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels);
+   font->DisplayOffset.y += 1;   // Render 1 pixel down
+
+---------------------------------
+ EMBED A FONT IN SOURCE CODE
+---------------------------------
+
+ Compile and use 'binary_to_compressed_c.cpp' to create a compressed C style array. Then load the font with:
+ 
+   ImFont* font = io.Fonts->AddFontFromMemoryCompressedTTF(compressed_data, compressed_data_size, size_pixels, ...);
+   
+ Or 
+ 
+   ImFont* font = io.Fonts->AddFontFromMemoryCompressedBase85TTF(compressed_data_base85, size_pixels, ...);
+
+---------------------------------
+ INCLUDED FONT FILES
+---------------------------------
+
+ Cousine-Regular.ttf
+   Digitized data copyright (c) 2010 Google Corporation.
+   Licensed under the SIL Open Font License, Version 1.1   
+
  DroidSans.ttf
    Copyright (c) Steve Matteson
    Apache License, version 2.0
@@ -26,36 +92,25 @@
    SIL OPEN FONT LICENSE Version 1.1
 
 ---------------------------------
- OTHER FONTS
+ LINKS
 ---------------------------------
 
- For Japanese:
- 
-   M+ fonts by Coji Morishita are free and include most useful Kanjis you would need.
-   mplus-fonts.sourceforge.jp/mplus-outline-fonts/index-en.html
+ Typefaces for source code beautification
+   https://github.com/chrissimpkins/codeface
+
+ Proggy Programming Fonts
+   http://upperbounds.net
    
- For Japanese, Chinese, Korean:
- 
-   You can use Arial Unicode or other Unicode fonts provided with Windows (not sure of their license).
-   Other suggestions?
+ Inconsolata
+   http://www.levien.com/type/myfonts/inconsolata.html
 
----------------------------------
- LOADING INSTRUCTIONS
----------------------------------
+ Adobe Source Code Pro: Monospaced font family for user interface and coding environments
+   https://github.com/adobe-fonts/source-code-pro
 
- Load .TTF file with:
+ Monospace/Fixed Width Programmer's Fonts
+   http://www.lowing.org/fonts/
 
-   ImGuiIO& io = ImGui::GetIO();
-   io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_pixels);
-  
- Add a third parameter to bake specific font ranges:
-
-   io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, io.Fonts->GetGlyphRangesDefault());   // Basic Latin, Extended Latin 
-   io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, io.Fonts->GetGlyphRangesJapanese());  // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
-   io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, io.Fonts->GetGlyphRangesChinese());   // Include full set of about 21000 CJK Unified Ideographs
-
-Offset font by altering the io.Font->DisplayOffset value:
-
-   ImFont* font = io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_pixels);
-   font->DisplayOffset.y += 1;   // Render 1 pixel down
+ (Japanese) M+ fonts by Coji Morishita are free and include most useful Kanjis you would need.
+   http://mplus-fonts.sourceforge.jp/mplus-outline-fonts/index-en.html
 
+ Or use Arial Unicode or other Unicode fonts provided with Windows for full characters coverage (not sure of their licensing).

extra_fonts/binary_to_compressed_c.cpp

@@ -1,8 +1,10 @@
 // ImGui - binary_to_compressed_c.cpp
 // Helper tool to turn a file into a C array.
-// The data is first compressed with stb_compress() to reduce source code size a little.
+// The data is first compressed with stb_compress() to reduce source code size.
+// Then encoded in Base85 to fit in a string so we can fit roughly 4 bytes of compressed data into 5 bytes of source code (suggested by @mmalex)
+// (If we used 32-bits constants it would require take 11 bytes of source code to encode 4 bytes.)
 // Useful if you want to embed fonts into your code.
-// Note that the output array is likely to be bigger than the binary file..
+// Note that even with compression, the output array is likely to be bigger than the binary file..
 // Load compressed TTF fonts with ImGui::GetIO().Fonts->AddFontFromMemoryCompressedTTF()
 
 #define _CRT_SECURE_NO_WARNINGS
@@ -11,28 +13,44 @@
 #include <stdlib.h>
 #include <assert.h>
 
-const int COLUMNS = 12;
-
 // stb_compress* from stb.h - declaration
 typedef unsigned int stb_uint;
 typedef unsigned char stb_uchar;
 stb_uint stb_compress(stb_uchar *out,stb_uchar *in,stb_uint len);
 
-static bool binary_to_compressed_c(const char* filename, const char* symbol);
+static bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding);
 
 int main(int argc, char** argv)
 {
     if (argc < 3)
     {
-        printf("Syntax: %s <inputfile> <symbolname>\n", argv[0]);
+        printf("Syntax: %s [-base85] <inputfile> <symbolname>\n", argv[0]);
         return 0;
     }
 
-    binary_to_compressed_c(argv[1], argv[2]);
+    int argn = 1;
+    bool use_base85_encoding = false;
+    if (argv[argn][0] == '-')
+    {
+        if (strcmp(argv[argn], "-base85") == 0) { use_base85_encoding = true; argn++; }
+        else
+        {
+            printf("Unknown argument: '%s'\n", argv[argn]);
+            return 1;
+        }
+    }
+
+    binary_to_compressed_c(argv[argn], argv[argn+1], use_base85_encoding);
     return 1;
 }
 
-bool binary_to_compressed_c(const char* filename, const char* symbol)
+char Encode85Byte(unsigned int x) 
+{
+    x = (x % 85) + 35;
+    return (x>='\\') ? x+1 : x;
+}
+
+bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding)
 {
     // Read file
     FILE* f = fopen(filename, "rb");
@@ -50,22 +68,38 @@ bool binary_to_compressed_c(const char* filename, const char* symbol)
     int compressed_sz = stb_compress((stb_uchar*)compressed, (stb_uchar*)data, data_sz);
     memset(compressed + compressed_sz, 0, maxlen - compressed_sz);
 
-    // Output
+    // Output as Base85 encoded
     FILE* out = stdout;
     fprintf(out, "// File: '%s' (%d bytes)\n", filename, (int)data_sz);
-    fprintf(out, "// Exported using binary_to_compressed_c\n");
-    fprintf(out, "static const unsigned int %s_compressed_size = %d;\n", symbol, (int)compressed_sz);
-    fprintf(out, "static const unsigned int %s_compressed_data[%d/4] =\n{", symbol, (int)((compressed_sz+3)/4)*4);
-    int column = 0;
-    for (int i = 0; i < compressed_sz; i += 4)
+    fprintf(out, "// Exported using binary_to_compressed_c.cpp\n");
+    if (use_base85_encoding)
     {
-        unsigned int d = *(unsigned int*)(compressed + i);
-        if ((column++ % COLUMNS) == 0)
-            fprintf(out, "\n    0x%08x, ", d);
-        else
-            fprintf(out, "0x%08x, ", d);
+        fprintf(out, "static const char %s_compressed_data_base85[%d+1] =\n    \"", symbol, (int)((compressed_sz+3)/4)*5);
+        int column = 0;
+        for (int i = 0; i < compressed_sz; i += 4)
+        {
+            unsigned int d = *(unsigned int*)(compressed + i);
+            fprintf(out, "%c%c%c%c%c", Encode85Byte(d), Encode85Byte(d/85), Encode85Byte(d/7225), Encode85Byte(d/614125), Encode85Byte(d/52200625));
+            if ((i % 112) == 112-4)
+                fprintf(out, "\"\n    \"");
+        }
+        fprintf(out, "\";\n\n");
+    }
+    else
+    {
+        fprintf(out, "static const unsigned int %s_compressed_size = %d;\n", symbol, (int)compressed_sz);
+        fprintf(out, "static const unsigned int %s_compressed_data[%d/4] =\n{", symbol, (int)((compressed_sz+3)/4)*4);
+        int column = 0;
+        for (int i = 0; i < compressed_sz; i += 4)
+        {
+            unsigned int d = *(unsigned int*)(compressed + i);
+            if ((column++ % 12) == 0)
+                fprintf(out, "\n    0x%08x, ", d);
+            else
+                fprintf(out, "0x%08x, ", d);
+        }
+        fprintf(out, "\n};\n\n");
     }
-    fprintf(out, "\n};\n\n");
 
     // Cleanup
     delete[] data;

imconfig.h

@@ -6,11 +6,6 @@
 
 #pragma once
 
-//---- Define your own ImVector<> type if you don't want to use the provided implementation defined in imgui.h
-//#include <vector>
-//#define ImVector  std::vector
-//#define ImVector  MyVector
-
 //---- Define assertion handler. Defaults to calling assert().
 //#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
 
@@ -35,7 +30,7 @@
 //#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
 
 //---- Implement STB libraries in a namespace to avoid conflicts
-//#define IMGUI_STB_NAMESPACE     ImStb
+//#define IMGUI_STB_NAMESPACE     ImGuiStb
 
 //---- Define constructor and implicit cast operators to convert back<>forth from your math types and ImVec2/ImVec4.
 /*

imgui.h

@@ -1,19 +1,23 @@
-// ImGui library v1.40
-// See .cpp file for documentation.
-// See ImGui::ShowTestWindow() for sample code.
+// ImGui library v1.44
+// Headers
+
+// See imgui.cpp file for documentation.
+// See ImGui::ShowTestWindow() in imgui_demo.cpp for demo code.
 // Read 'Programmer guide' in .cpp for notes on how to setup ImGui in your codebase.
 // Get latest version at https://github.com/ocornut/imgui
 
 #pragma once
 
+#if !defined(IMGUI_DISABLE_INCLUDE_IMCONFIG_H) || defined(IMGUI_INCLUDE_IMCONFIG_H)
 #include "imconfig.h"       // User-editable configuration file
+#endif
 #include <float.h>          // FLT_MAX
 #include <stdarg.h>         // va_list
 #include <stddef.h>         // ptrdiff_t, NULL
 #include <stdlib.h>         // NULL, malloc, free, qsort, atoi
 #include <string.h>         // memset, memmove, memcpy, strlen, strchr, strcpy, strcmp
 
-#define IMGUI_VERSION       "1.40"
+#define IMGUI_VERSION       "1.44"
 
 // Define assertion handler.
 #ifndef IM_ASSERT
@@ -29,6 +33,7 @@
 // Forward declarations
 struct ImDrawCmd;
 struct ImDrawList;
+struct ImDrawData;
 struct ImFont;
 struct ImFontAtlas;
 struct ImGuiIO;
@@ -48,6 +53,7 @@ typedef int ImGuiMouseCursor;       // enum ImGuiMouseCursor_
 typedef int ImGuiWindowFlags;       // enum ImGuiWindowFlags_
 typedef int ImGuiSetCond;           // enum ImGuiSetCond_
 typedef int ImGuiInputTextFlags;    // enum ImGuiInputTextFlags_
+typedef int ImGuiSelectableFlags;   // enum ImGuiSelectableFlags_
 struct ImGuiTextEditCallbackData;   // for advanced uses of InputText() 
 typedef int (*ImGuiTextEditCallback)(ImGuiTextEditCallbackData *data);
 
@@ -57,7 +63,7 @@ struct ImVec2
     ImVec2() { x = y = 0.0f; }
     ImVec2(float _x, float _y) { x = _x; y = _y; }
 
-#ifdef IM_VEC2_CLASS_EXTRA          // Define constructor and implicit cast operators to convert back<>forth from your math types and ImVec2.
+#ifdef IM_VEC2_CLASS_EXTRA          // Define constructor and implicit cast operators in imconfig.h to convert back<>forth from your math types and ImVec2.
     IM_VEC2_CLASS_EXTRA
 #endif
 };
@@ -68,13 +74,13 @@ struct ImVec4
     ImVec4() { x = y = z = w = 0.0f; }
     ImVec4(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }
 
-#ifdef IM_VEC4_CLASS_EXTRA          // Define constructor and implicit cast operators to convert back<>forth from your math types and ImVec4.
+#ifdef IM_VEC4_CLASS_EXTRA          // Define constructor and implicit cast operators in imconfig.h to convert back<>forth from your math types and ImVec4.
     IM_VEC4_CLASS_EXTRA
 #endif
 };
 
 // Helpers at bottom of the file:
-// - class ImVector<>                   // Lightweight std::vector like class. Use '#define ImVector std::vector' if you want to use the STL type or your own type.
+// - class ImVector<>                   // Lightweight std::vector like class.
 // - IMGUI_ONCE_UPON_A_FRAME            // Execute a block of code once per frame only (convenient for creating UI within deep-nested code that runs multiple times)
 // - struct ImGuiTextFilter             // Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
 // - struct ImGuiTextBuffer             // Text buffer for logging/accumulating text
@@ -102,14 +108,14 @@ namespace ImGui
     IMGUI_API void          ShowMetricsWindow(bool* opened = NULL);     // metrics window for debugging imgui
 
     // Window
-    // See implementation in .cpp for details
-    IMGUI_API bool          Begin(const char* name = "Debug", bool* p_opened = NULL, ImGuiWindowFlags flags = 0);                                           // return false when window is collapsed, so you can early out in your code. 'bool* p_opened' creates a widget on the upper-right to close the window (which sets your bool to false). 
+    IMGUI_API bool          Begin(const char* name = "Debug", bool* p_opened = NULL, ImGuiWindowFlags flags = 0);                                           // see .cpp for details. return false when window is collapsed, so you can early out in your code. 'bool* p_opened' creates a widget on the upper-right to close the window (which sets your bool to false). 
     IMGUI_API bool          Begin(const char* name, bool* p_opened, const ImVec2& size_on_first_use, float bg_alpha = -1.0f, ImGuiWindowFlags flags = 0);   // this is the older/longer API. call SetNextWindowSize() instead if you want to set a window size. For regular windows, 'size_on_first_use' only applies to the first time EVER the window is created and probably not what you want! maybe obsolete this API eventually.
     IMGUI_API void          End();
-    IMGUI_API bool          BeginChild(const char* str_id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0);        // size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). size>0.0f: fixed size. each axis can use a different mode, e.g. ImVec2(0,400).
+    IMGUI_API bool          BeginChild(const char* str_id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0);        // begin a scrolling region. size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). size>0.0f: fixed size. each axis can use a different mode, e.g. ImVec2(0,400).
     IMGUI_API bool          BeginChild(ImGuiID id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0);                // "
     IMGUI_API void          EndChild();
     IMGUI_API ImVec2        GetContentRegionMax();                                              // window or current column boundaries, in windows coordinates
+    IMGUI_API ImVec2        GetContentRegionAvail();                                            // == GetContentRegionMax() - GetCursorPos()
     IMGUI_API ImVec2        GetWindowContentRegionMin();                                        // window boundaries, in windows coordinates
     IMGUI_API ImVec2        GetWindowContentRegionMax();
     IMGUI_API ImDrawList*   GetWindowDrawList();                                                // get rendering command-list if you want to append your own draw primitives
@@ -121,10 +127,11 @@ namespace ImGui
     IMGUI_API float         GetWindowWidth();
     IMGUI_API bool          IsWindowCollapsed();
 
-    IMGUI_API void          SetNextWindowPos(const ImVec2& pos, ImGuiSetCond cond = 0);         // set next window position - call before Begin()
-    IMGUI_API void          SetNextWindowSize(const ImVec2& size, ImGuiSetCond cond = 0);       // set next window size. set to ImVec2(0,0) to force an auto-fit
-    IMGUI_API void          SetNextWindowCollapsed(bool collapsed, ImGuiSetCond cond = 0);      // set next window collapsed state
-    IMGUI_API void          SetNextWindowFocus();                                               // set next window to be focused / front-most
+    IMGUI_API void          SetNextWindowPos(const ImVec2& pos, ImGuiSetCond cond = 0);         // set next window position. call before Begin()
+    IMGUI_API void          SetNextWindowPosCenter(ImGuiSetCond cond = 0);                      // set next window position to be centered on screen. call before Begin()
+    IMGUI_API void          SetNextWindowSize(const ImVec2& size, ImGuiSetCond cond = 0);       // set next window size. set to ImVec2(0,0) to force an auto-fit. call before Begin()
+    IMGUI_API void          SetNextWindowCollapsed(bool collapsed, ImGuiSetCond cond = 0);      // set next window collapsed state. call before Begin()
+    IMGUI_API void          SetNextWindowFocus();                                               // set next window to be focused / front-most. call before Begin()
     IMGUI_API void          SetWindowPos(const ImVec2& pos, ImGuiSetCond cond = 0);             // set current window position - call within Begin()/End(). may incur tearing
     IMGUI_API void          SetWindowSize(const ImVec2& size, ImGuiSetCond cond = 0);           // set current window size. set to ImVec2(0,0) to force an auto-fit. may incur tearing
     IMGUI_API void          SetWindowCollapsed(bool collapsed, ImGuiSetCond cond = 0);          // set current window collapsed state
@@ -134,9 +141,11 @@ namespace ImGui
     IMGUI_API void          SetWindowCollapsed(const char* name, bool collapsed, ImGuiSetCond 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.
 
-    IMGUI_API float         GetScrollPosY();                                                    // get scrolling position [0..GetScrollMaxY()]
-    IMGUI_API float         GetScrollMaxY();                                                    // get maximum scrolling position == ContentSize.Y - WindowSize.Y
-    IMGUI_API void          SetScrollPosHere();                                                 // adjust scrolling position to center into the current cursor position
+    IMGUI_API float         GetScrollY();                                                       // get scrolling amount [0..GetScrollMaxY()]
+    IMGUI_API float         GetScrollMaxY();                                                    // get maximum scrolling amount == ContentSize.Y - WindowSize.Y
+    IMGUI_API void          SetScrollY(float scroll_y);                                         // set scrolling amount [0..GetScrollMaxY()]
+    IMGUI_API void          SetScrollHere(float center_y_ratio = 0.5f);                         // adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom.
+    IMGUI_API void          SetScrollFromPosY(float pos_y, float center_y_ratio = 0.5f);        // adjust scrolling amount to make given position valid. use GetCursorPos() or GetCursorStartPos()+offset to get valid positions.
     IMGUI_API void          SetKeyboardFocusHere(int offset = 0);                               // focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget
     IMGUI_API void          SetStateStorage(ImGuiStorage* tree);                                // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it)
     IMGUI_API ImGuiStorage* GetStateStorage();
@@ -161,26 +170,11 @@ namespace ImGui
     IMGUI_API void          PushButtonRepeat(bool repeat);                                      // in 'repeat' mode, Button*() functions return true multiple times as you hold them (uses io.KeyRepeatDelay/io.KeyRepeatRate for now)
     IMGUI_API void          PopButtonRepeat();
 
-    // Tooltip
-    IMGUI_API void          SetTooltip(const char* fmt, ...);                                   // set tooltip under mouse-cursor, typically use with ImGui::IsHovered(). last call wins
-    IMGUI_API void          SetTooltipV(const char* fmt, va_list args);
-    IMGUI_API void          BeginTooltip();                                                     // use to create full-featured tooltip windows that aren't just text
-    IMGUI_API void          EndTooltip();
-
-    // Popup
-    IMGUI_API void          OpenPopup(const char* str_id);                                      // mark popup as open. popup identifiers are relative to the current ID-stack (so OpenPopup and BeginPopup needs to be at the same level). close childs popups if any. will close popup when user click outside, or activate a pressable item, or CloseCurrentPopup() is called within a BeginPopup()/EndPopup() block.
-    IMGUI_API bool          BeginPopup(const char* str_id);                                     // return true if popup if opened and start outputting to it. only call EndPopup() if BeginPopup() returned true!
-    IMGUI_API bool          BeginPopupContextItem(const char* str_id, int mouse_button = 1);    // open and begin popup when clicked on last item
-    IMGUI_API bool          BeginPopupContextWindow(bool also_over_items = true, const char* str_id = NULL, int mouse_button = 1);  // open and begin popup when clicked on current window
-    IMGUI_API bool          BeginPopupContextVoid(const char* str_id = NULL, int mouse_button = 1);                                 // open and begin popup when clicked in void (no window)
-    IMGUI_API void          EndPopup();
-    IMGUI_API void          CloseCurrentPopup();                                                // close the popup we have begin-ed into. clicking on a MenuItem or Selectable automatically close the current popup.
-
     // Cursor / Layout
     IMGUI_API void          BeginGroup();                                                       // once closing a group it is seen as a single item (so you can use IsItemHovered() on a group, SameLine() between groups, etc. 
     IMGUI_API void          EndGroup();
     IMGUI_API void          Separator();                                                        // horizontal line
-    IMGUI_API void          SameLine(int column_x = 0, int spacing_w = -1);                     // call between widgets or groups to layout them horizontally
+    IMGUI_API void          SameLine(float pos_x = 0.0f, float spacing_w = -1.0f);              // call between widgets or groups to layout them horizontally
     IMGUI_API void          Spacing();                                                          // add spacing
     IMGUI_API void          Dummy(const ImVec2& size);                                          // add a dummy item of given size
     IMGUI_API void          Indent();                                                           // move content position toward the right by style.IndentSpacing pixels
@@ -198,6 +192,7 @@ namespace ImGui
     IMGUI_API void          SetCursorPos(const ImVec2& pos);                                    // "
     IMGUI_API void          SetCursorPosX(float x);                                             // "
     IMGUI_API void          SetCursorPosY(float y);                                             // "
+    IMGUI_API ImVec2        GetCursorStartPos();                                                // initial cursor position 
     IMGUI_API ImVec2        GetCursorScreenPos();                                               // cursor position in absolute screen coordinates [0..io.DisplaySize]
     IMGUI_API void          SetCursorScreenPos(const ImVec2& pos);                              // cursor position in absolute screen coordinates [0..io.DisplaySize]
     IMGUI_API void          AlignFirstTextHeightToWidgets();                                    // call once if the first item on the line is a Text() item and you want to vertically lower it to match subsequent (bigger) widgets
@@ -206,12 +201,12 @@ namespace ImGui
     IMGUI_API float         GetItemsLineHeightWithSpacing();                                    // distance (in pixels) between 2 consecutive lines of standard height widgets == GetWindowFontSize() + GetStyle().FramePadding.y*2 + GetStyle().ItemSpacing.y
 
     // ID scopes
-    // If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them
-    // You can also use "##extra" within your widget name to distinguish them from each others (see 'Programmer Guide')
+    // If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them.
+    // You can also use "##extra" within your widget name to distinguish them from each others. Read the FAQ for more details.
     IMGUI_API void          PushID(const char* str_id);                                         // push identifier into the ID stack. IDs are hash of the *entire* stack!
     IMGUI_API void          PushID(const char* str_id_begin, const char* str_id_end);
     IMGUI_API void          PushID(const void* ptr_id);
-    IMGUI_API void          PushID(const int int_id);
+    IMGUI_API void          PushID(int int_id);
     IMGUI_API void          PopID();
     IMGUI_API ImGuiID       GetID(const char* str_id);                                          // calculate unique ID (hash of whole ID stack + given parameter). useful if you want to query into ImGuiStorage yourself. otherwise rarely needed
     IMGUI_API ImGuiID       GetID(const char* str_id_begin, const char* str_id_end);
@@ -236,7 +231,7 @@ namespace ImGui
     IMGUI_API bool          SmallButton(const char* label);
     IMGUI_API bool          InvisibleButton(const char* str_id, const ImVec2& size);
     IMGUI_API void          Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0), const ImVec2& uv1 = ImVec2(1,1), const ImVec4& tint_col = ImVec4(1,1,1,1), const ImVec4& border_col = ImVec4(0,0,0,0));
-    IMGUI_API bool          ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0),  const ImVec2& uv1 = ImVec2(1,1), int frame_padding = -1, const ImVec4& bg_col = ImVec4(0,0,0,1), const ImVec4& tint_col = ImVec4(1,1,1,1));    // <0 frame_padding uses default frame padding settings. 0 for no padding
+    IMGUI_API bool          ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0),  const ImVec2& uv1 = ImVec2(1,1), int frame_padding = -1, const ImVec4& bg_col = ImVec4(0,0,0,0), const ImVec4& tint_col = ImVec4(1,1,1,1));    // <0 frame_padding uses default frame padding settings. 0 for no padding
     IMGUI_API bool          CollapsingHeader(const char* label, const char* str_id = NULL, bool display_frame = true, bool default_open = false);
     IMGUI_API bool          Checkbox(const char* label, bool* v);
     IMGUI_API bool          CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value);
@@ -249,9 +244,9 @@ namespace ImGui
     IMGUI_API bool          ColorEdit3(const char* label, float col[3]);
     IMGUI_API bool          ColorEdit4(const char* label, float col[4], bool show_alpha = true);
     IMGUI_API void          ColorEditMode(ImGuiColorEditMode mode);
-    IMGUI_API void          PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), size_t stride = sizeof(float));
+    IMGUI_API void          PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), int stride = sizeof(float));
     IMGUI_API void          PlotLines(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
-    IMGUI_API void          PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), size_t stride = sizeof(float));
+    IMGUI_API void          PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), int stride = sizeof(float));
     IMGUI_API void          PlotHistogram(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
 
     // Widgets: Drags (tip: ctrl+click on a drag box to input text)
@@ -259,13 +254,16 @@ namespace ImGui
     IMGUI_API bool          DragFloat2(const char* label, float v[2], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
     IMGUI_API bool          DragFloat3(const char* label, float v[3], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
     IMGUI_API bool          DragFloat4(const char* label, float v[4], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+    IMGUI_API bool          DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", const char* display_format_max = NULL, float power = 1.0f);
     IMGUI_API bool          DragInt(const char* label, int* v, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");                                       // If v_min >= v_max we have no bound
     IMGUI_API bool          DragInt2(const char* label, int v[2], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
     IMGUI_API bool          DragInt3(const char* label, int v[3], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
     IMGUI_API bool          DragInt4(const char* label, int v[4], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
+    IMGUI_API bool          DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f", const char* display_format_max = NULL);
 
     // Widgets: Input
     IMGUI_API bool          InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
+    IMGUI_API bool          InputTextMultiline(const char* label, char* buf, size_t buf_size, const ImVec2& size = ImVec2(0,0), ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
     IMGUI_API bool          InputFloat(const char* label, float* v, float step = 0.0f, float step_fast = 0.0f, int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
     IMGUI_API bool          InputFloat2(const char* label, float v[2], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
     IMGUI_API bool          InputFloat3(const char* label, float v[3], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
@@ -300,15 +298,29 @@ namespace ImGui
     IMGUI_API void          SetNextTreeNodeOpened(bool opened, ImGuiSetCond cond = 0);          // set next tree node to be opened.
 
     // Widgets: Selectable / Lists
-    IMGUI_API bool          Selectable(const char* label, bool selected = false, const ImVec2& size = ImVec2(0,0));
-    IMGUI_API bool          Selectable(const char* label, bool* p_selected, const ImVec2& size = ImVec2(0,0));
+    IMGUI_API bool          Selectable(const char* label, bool selected = false, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0,0));  // size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height 
+    IMGUI_API bool          Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0,0));
     IMGUI_API bool          ListBox(const char* label, int* current_item, const char** items, int items_count, int height_in_items = -1);
     IMGUI_API bool          ListBox(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items = -1);
     IMGUI_API bool          ListBoxHeader(const char* label, const ImVec2& size = ImVec2(0,0)); // use if you want to reimplement ListBox() will custom data or interactions. make sure to call ListBoxFooter() afterwards.
     IMGUI_API bool          ListBoxHeader(const char* label, int items_count, int height_in_items = -1); // "
     IMGUI_API void          ListBoxFooter();                                                    // terminate the scrolling region
 
-    // Widgets: Menus
+    // Widgets: Value() Helpers. Output single value in "name: value" format (tip: freely declare more in your code to handle your types. you can add functions to the ImGui namespace)
+    IMGUI_API void          Value(const char* prefix, bool b);
+    IMGUI_API void          Value(const char* prefix, int v);
+    IMGUI_API void          Value(const char* prefix, unsigned int v);
+    IMGUI_API void          Value(const char* prefix, float v, const char* float_format = NULL);
+    IMGUI_API void          Color(const char* prefix, const ImVec4& v);
+    IMGUI_API void          Color(const char* prefix, unsigned int v);
+
+    // Tooltip
+    IMGUI_API void          SetTooltip(const char* fmt, ...);                                   // set tooltip under mouse-cursor, typically use with ImGui::IsHovered(). last call wins
+    IMGUI_API void          SetTooltipV(const char* fmt, va_list args);
+    IMGUI_API void          BeginTooltip();                                                     // use to create full-featured tooltip windows that aren't just text
+    IMGUI_API void          EndTooltip();
+
+    // Menus
     IMGUI_API bool          BeginMainMenuBar();                                                 // create and append to a full screen menu-bar. only call EndMainMenuBar() if this returns true!
     IMGUI_API void          EndMainMenuBar();
     IMGUI_API bool          BeginMenuBar();                                                     // append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set). only call EndMenuBar() if this returns true!
@@ -318,13 +330,15 @@ namespace ImGui
     IMGUI_API bool          MenuItem(const char* label, const char* shortcut = NULL, bool selected = false, bool enabled = true);  // return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
     IMGUI_API bool          MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled = true);              // return true when activated + toggle (*p_selected) if p_selected != NULL
 
-    // Widgets: Value() Helpers. Output single value in "name: value" format (tip: freely declare more in your code to handle your types. you can add functions to the ImGui namespace)
-    IMGUI_API void          Value(const char* prefix, bool b);
-    IMGUI_API void          Value(const char* prefix, int v);
-    IMGUI_API void          Value(const char* prefix, unsigned int v);
-    IMGUI_API void          Value(const char* prefix, float v, const char* float_format = NULL);
-    IMGUI_API void          Color(const char* prefix, const ImVec4& v);
-    IMGUI_API void          Color(const char* prefix, unsigned int v);
+    // Popup
+    IMGUI_API void          OpenPopup(const char* str_id);                                      // mark popup as open. popup identifiers are relative to the current ID-stack (so OpenPopup and BeginPopup needs to be at the same level). close childs popups if any. will close popup when user click outside, or activate a pressable item, or CloseCurrentPopup() is called within a BeginPopup()/EndPopup() block.
+    IMGUI_API bool          BeginPopup(const char* str_id);                                     // return true if popup if opened and start outputting to it. only call EndPopup() if BeginPopup() returned true!
+    IMGUI_API bool          BeginPopupModal(const char* name, bool* p_opened = NULL, ImGuiWindowFlags extra_flags = 0);             // modal dialog (can't close them by clicking outside)
+    IMGUI_API bool          BeginPopupContextItem(const char* str_id, int mouse_button = 1);                                        // helper to open and begin popup when clicked on last item
+    IMGUI_API bool          BeginPopupContextWindow(bool also_over_items = true, const char* str_id = NULL, int mouse_button = 1);  // helper to open and begin popup when clicked on current window
+    IMGUI_API bool          BeginPopupContextVoid(const char* str_id = NULL, int mouse_button = 1);                                 // helper to open and begin popup when clicked in void (no window)
+    IMGUI_API void          EndPopup();
+    IMGUI_API void          CloseCurrentPopup();                                                // close the popup we have begin-ed into. clicking on a MenuItem or Selectable automatically close the current popup.
 
     // Logging: all text output from interface is redirected to tty/file/clipboard. Tree nodes are automatically opened.
     IMGUI_API void          LogToTTY(int max_depth = -1);                                       // start logging to tty
@@ -344,25 +358,12 @@ namespace ImGui
     IMGUI_API ImVec2        GetItemRectMin();                                                   // get bounding rect of last item in screen space
     IMGUI_API ImVec2        GetItemRectMax();                                                   // "
     IMGUI_API ImVec2        GetItemRectSize();                                                  // "
+    IMGUI_API bool          IsWindowHovered();
     IMGUI_API bool          IsWindowFocused();                                                  // is current window focused (differentiate child windows from each others)
     IMGUI_API bool          IsRootWindowFocused();                                              // is current root window focused (top parent window in case of child windows)
     IMGUI_API bool          IsRootWindowOrAnyChildFocused();                                    // is current root window or any of its child (including current window) focused
     IMGUI_API bool          IsRectVisible(const ImVec2& size);                                  // test if rectangle of given size starting from cursor pos is visible (not clipped). to perform coarse clipping on user's side (as an optimization)
-    IMGUI_API bool          IsKeyDown(int key_index);                                           // key_index into the keys_down[512] array, imgui doesn't know the semantic of each entry
-    IMGUI_API bool          IsKeyPressed(int key_index, bool repeat = true);                    // "
-    IMGUI_API bool          IsMouseDown(int button);
-    IMGUI_API bool          IsMouseClicked(int button, bool repeat = false);
-    IMGUI_API bool          IsMouseDoubleClicked(int button);
-    IMGUI_API bool          IsMouseHoveringWindow();                                            // is mouse hovering current window ("window" in API names always refer to current window)
-    IMGUI_API bool          IsMouseHoveringAnyWindow();                                         // is mouse hovering any active imgui window
-    IMGUI_API bool          IsMouseHoveringRect(const ImVec2& rect_min, const ImVec2& rect_max);// is mouse hovering given bounding rect
-    IMGUI_API bool          IsMouseDragging(int button = 0, float lock_threshold = -1.0f);      // is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
     IMGUI_API bool          IsPosHoveringAnyWindow(const ImVec2& pos);                          // is given position hovering any active imgui window
-    IMGUI_API ImVec2        GetMousePos();                                                      // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
-    IMGUI_API ImVec2        GetMouseDragDelta(int button = 0, float lock_threshold = -1.0f);    // dragging amount since clicking, also see: GetItemActiveDragDelta(). 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 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
     IMGUI_API float         GetTime();
     IMGUI_API int           GetFrameCount();
     IMGUI_API const char*   GetStyleColName(ImGuiCol idx);
@@ -370,13 +371,34 @@ namespace ImGui
     IMGUI_API ImVec2        CalcTextSize(const char* text, const char* text_end = NULL, bool hide_text_after_double_hash = false, float wrap_width = -1.0f);
     IMGUI_API void          CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end);    // calculate coarse clipping for large list of evenly sized items. Prefer using the ImGuiListClipper higher-level helper if you can.
 
-    IMGUI_API void          BeginChildFrame(ImGuiID id, const ImVec2& size);                    // helper to create a child window / scrolling region that looks like a normal widget frame
+    IMGUI_API bool          BeginChildFrame(ImGuiID id, const ImVec2& size);                    // helper to create a child window / scrolling region that looks like a normal widget frame
     IMGUI_API void          EndChildFrame();
 
     IMGUI_API ImU32         ColorConvertFloat4ToU32(const ImVec4& in);
     IMGUI_API void          ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v);
     IMGUI_API void          ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b);
 
+    // Inputs
+    IMGUI_API int           GetKeyIndex(ImGuiKey key);                                          // map ImGuiKey_* values into user's key index. == io.KeyMap[key]
+    IMGUI_API bool          IsKeyDown(int key_index);                                           // key_index into the keys_down[] array, imgui doesn't know the semantic of each entry, uses your own indices!
+    IMGUI_API bool          IsKeyPressed(int key_index, bool repeat = true);                    // uses user's key indices as stored in the keys_down[] array. if repeat=true. uses io.KeyRepeatDelay / KeyRepeatRate
+    IMGUI_API bool          IsKeyReleased(int key_index);                                       // "
+    IMGUI_API bool          IsMouseDown(int button);                                            // is mouse button held 
+    IMGUI_API bool          IsMouseClicked(int button, bool repeat = false);                    // did mouse button clicked (went from !Down to Down)
+    IMGUI_API bool          IsMouseDoubleClicked(int button);                                   // did mouse button double-clicked. a double-click returns false in IsMouseClicked(). uses io.MouseDoubleClickTime.
+    IMGUI_API bool          IsMouseReleased(int button);                                        // did mouse button released (went from Down to !Down)
+    IMGUI_API bool          IsMouseHoveringWindow();                                            // is mouse hovering current window ("window" in API names always refer to current window)
+    IMGUI_API bool          IsMouseHoveringAnyWindow();                                         // is mouse hovering any active imgui window
+    IMGUI_API bool          IsMouseHoveringRect(const ImVec2& rect_min, const ImVec2& rect_max);// is mouse hovering given bounding rect
+    IMGUI_API bool          IsMouseDragging(int button = 0, float lock_threshold = -1.0f);      // is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
+    IMGUI_API ImVec2        GetMousePos();                                                      // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
+    IMGUI_API ImVec2        GetMouseDragDelta(int button = 0, float lock_threshold = -1.0f);    // dragging amount since clicking, also see: GetItemActiveDragDelta(). 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 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
+    IMGUI_API void          CaptureKeyboardFromApp();                                           // manually enforce imgui setting the io.WantCaptureKeyboard flag next frame (your application needs to handle it). e.g. capture keyboard when your widget is being hovered.
+    IMGUI_API void          CaptureMouseFromApp();                                              // manually enforce imgui setting the io.WantCaptureMouse flag next frame (your application needs to handle it).
+
     // Helpers functions to access the MemAllocFn/MemFreeFn pointers in ImGui::GetIO()
     IMGUI_API void*         MemAlloc(size_t sz);
     IMGUI_API void          MemFree(void* ptr);
@@ -389,7 +411,6 @@ namespace ImGui
 
     // Obsolete (will be removed)
 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
-    IMGUI_API void          GetDefaultFontData(const void** fnt_data, unsigned int* fnt_size, const void** png_data, unsigned int* png_size);   // OBSOLETE 1.30+
     static inline void      OpenNextNode(bool open) { ImGui::SetNextTreeNodeOpened(open, 0); } // OBSOLETE 1.34+
     static inline bool      GetWindowIsFocused() { return ImGui::IsWindowFocused(); }          // OBSOLETE 1.36+
     static inline bool      GetWindowCollapsed() { return ImGui::IsWindowCollapsed(); }        // OBSOLETE 1.39+
@@ -398,6 +419,7 @@ namespace ImGui
     static inline bool      IsClipped(const ImVec2& size) { return !IsRectVisible(size); }     // OBSOLETE 1.38+
     static inline bool      IsRectClipped(const ImVec2& size) { return !IsRectVisible(size); } // OBSOLETE 1.39+
     static inline bool      IsMouseHoveringBox(const ImVec2& rect_min, const ImVec2& rect_max) { return IsMouseHoveringRect(rect_min, rect_max); }  // OBSOLETE 1.36+
+    static inline void      SetScrollPosHere() { SetScrollHere(); }                            // OBSOLETE 1.42+
 #endif
 
 } // namespace ImGui
@@ -415,7 +437,8 @@ enum ImGuiWindowFlags_
     ImGuiWindowFlags_AlwaysAutoResize       = 1 << 6,   // Resize every window to its content every frame
     ImGuiWindowFlags_ShowBorders            = 1 << 7,   // Show borders around windows and items
     ImGuiWindowFlags_NoSavedSettings        = 1 << 8,   // Never load/save settings in .ini file
-    ImGuiWindowFlags_MenuBar                = 1 << 9,   // Has a menu-bar
+    ImGuiWindowFlags_NoInputs               = 1 << 9,   // Disable catching mouse or keyboard inputs
+    ImGuiWindowFlags_MenuBar                = 1 << 10,  // Has a menu-bar
     // [Internal]
     ImGuiWindowFlags_ChildWindow            = 1 << 20,  // Don't use! For internal use by BeginChild()
     ImGuiWindowFlags_ChildWindowAutoFitX    = 1 << 21,  // Don't use! For internal use by BeginChild()
@@ -423,7 +446,8 @@ enum ImGuiWindowFlags_
     ImGuiWindowFlags_ComboBox               = 1 << 23,  // Don't use! For internal use by ComboBox()
     ImGuiWindowFlags_Tooltip                = 1 << 24,  // Don't use! For internal use by BeginTooltip()
     ImGuiWindowFlags_Popup                  = 1 << 25,  // Don't use! For internal use by BeginPopup()
-    ImGuiWindowFlags_ChildMenu              = 1 << 26   // Don't use! For internal use by BeginMenu()
+    ImGuiWindowFlags_Modal                  = 1 << 26,  // Don't use! For internal use by BeginPopupModal()
+    ImGuiWindowFlags_ChildMenu              = 1 << 27   // Don't use! For internal use by BeginMenu()
 };
 
 // Flags for ImGui::InputText()
@@ -439,29 +463,45 @@ enum ImGuiInputTextFlags_
     ImGuiInputTextFlags_CallbackCompletion  = 1 << 6,   // Call user function on pressing TAB (for completion handling)
     ImGuiInputTextFlags_CallbackHistory     = 1 << 7,   // Call user function on pressing Up/Down arrows (for history handling)
     ImGuiInputTextFlags_CallbackAlways      = 1 << 8,   // Call user function every time
-    ImGuiInputTextFlags_CallbackCharFilter  = 1 << 9    // Call user function to filter character. Modify data->EventChar to replace/filter input, or return 1 to discard character.
+    ImGuiInputTextFlags_CallbackCharFilter  = 1 << 9,   // Call user function to filter character. Modify data->EventChar to replace/filter input, or return 1 to discard character.
+    ImGuiInputTextFlags_AllowTabInput       = 1 << 10,  // Pressing TAB input a '\t' character into the text field
+    ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11,  // In multi-line mode, allow exiting edition by pressing Enter. Ctrl+Enter to add new line (by default adds new lines with Enter).
+    ImGuiInputTextFlags_NoHorizontalScroll  = 1 << 12,  // Disable following the cursor horizontally
+    ImGuiInputTextFlags_AlwaysInsertMode    = 1 << 13,  // Insert mode
+    // [Internal]
+    ImGuiInputTextFlags_Multiline           = 1 << 20   // For internal use by InputTextMultiline()
+};
+
+// Flags for ImGui::Selectable()
+enum ImGuiSelectableFlags_
+{
+    // Default: 0
+    ImGuiSelectableFlags_DontClosePopups    = 1 << 0,   // Clicking this don't close parent popup window
+    ImGuiSelectableFlags_SpanAllColumns     = 1 << 1    // Selectable frame can span all columns (text will still fit in current column)
 };
 
 // User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
 enum ImGuiKey_
 {
-    ImGuiKey_Tab,
-    ImGuiKey_LeftArrow,
-    ImGuiKey_RightArrow,
-    ImGuiKey_UpArrow,
-    ImGuiKey_DownArrow,
-    ImGuiKey_Home,
-    ImGuiKey_End,
-    ImGuiKey_Delete,
-    ImGuiKey_Backspace,
-    ImGuiKey_Enter,
-    ImGuiKey_Escape,
-    ImGuiKey_A,         // for CTRL+A: select all
-    ImGuiKey_C,         // for CTRL+C: copy
-    ImGuiKey_V,         // for CTRL+V: paste
-    ImGuiKey_X,         // for CTRL+X: cut
-    ImGuiKey_Y,         // for CTRL+Y: redo
-    ImGuiKey_Z,         // for CTRL+Z: undo
+    ImGuiKey_Tab,       // for tabbing through fields
+    ImGuiKey_LeftArrow, // for text edit
+    ImGuiKey_RightArrow,// for text edit
+    ImGuiKey_UpArrow,   // for text edit
+    ImGuiKey_DownArrow, // for text edit
+    ImGuiKey_PageUp,
+    ImGuiKey_PageDown,
+    ImGuiKey_Home,      // for text edit
+    ImGuiKey_End,       // for text edit
+    ImGuiKey_Delete,    // for text edit
+    ImGuiKey_Backspace, // for text edit
+    ImGuiKey_Enter,     // for text edit
+    ImGuiKey_Escape,    // for text edit
+    ImGuiKey_A,         // for text edit CTRL+A: select all
+    ImGuiKey_C,         // for text edit CTRL+C: copy
+    ImGuiKey_V,         // for text edit CTRL+V: paste
+    ImGuiKey_X,         // for text edit CTRL+X: cut
+    ImGuiKey_Y,         // for text edit CTRL+Y: redo
+    ImGuiKey_Z,         // for text edit CTRL+Z: undo
     ImGuiKey_COUNT
 };
 
@@ -479,6 +519,7 @@ enum ImGuiCol_
     ImGuiCol_FrameBgActive,
     ImGuiCol_TitleBg,
     ImGuiCol_TitleBgCollapsed,
+    ImGuiCol_TitleBgActive,
     ImGuiCol_MenuBarBg,
     ImGuiCol_ScrollbarBg,
     ImGuiCol_ScrollbarGrab,
@@ -509,6 +550,7 @@ enum ImGuiCol_
     ImGuiCol_PlotHistogramHovered,
     ImGuiCol_TextSelectedBg,
     ImGuiCol_TooltipBg,
+    ImGuiCol_ModalWindowDarkening,  // darken entire screen when a modal window is active
     ImGuiCol_COUNT
 };
 
@@ -536,7 +578,7 @@ enum ImGuiAlign_
     ImGuiAlign_Right    = 1 << 2,
     ImGuiAlign_Top      = 1 << 3,
     ImGuiAlign_VCenter  = 1 << 4,
-    ImGuiAlign_Default  = ImGuiAlign_Left | ImGuiAlign_Top,
+    ImGuiAlign_Default  = ImGuiAlign_Left | ImGuiAlign_Top
 };
 
 // Enumeration for ColorEditMode()
@@ -591,14 +633,17 @@ struct ImGuiStyle
     float       ScrollbarWidth;             // Width of the vertical scrollbar
     float       ScrollbarRounding;          // Radius of grab corners for scrollbar
     float       GrabMinSize;                // Minimum width/height of a grab box for slider/scrollbar
+    float       GrabRounding;               // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
     ImVec2      DisplayWindowPadding;       // Window positions are clamped to be visible within the display area by at least this amount. Only covers regular windows.
     ImVec2      DisplaySafeAreaPadding;     // 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.
+    bool        AntiAliasedLines;           // Enable anti-aliasing on lines/borders. Disable if you are really tight on CPU/GPU.
+    bool        AntiAliasedShapes;          // Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
     ImVec4      Colors[ImGuiCol_COUNT];
 
     IMGUI_API ImGuiStyle();
 };
 
-// This is where your app communicate with ImGui. Call ImGui::GetIO() to access.
+// This is where your app communicate with ImGui. Access via ImGui::GetIO().
 // Read 'Programmer guide' section in .cpp file for general usage.
 struct ImGuiIO
 {
@@ -631,7 +676,7 @@ struct ImGuiIO
 
     // REQUIRED: rendering function. 
     // See example code if you are unsure of how to implement this.
-    void        (*RenderDrawListsFn)(ImDrawList** const draw_lists, int count);      
+    void        (*RenderDrawListsFn)(ImDrawData* data);      
 
     // Optional: access OS clipboard
     // (default to use native Win32 clipboard on Windows, otherwise uses a private clipboard. Override to access OS clipboard on other architectures)
@@ -653,7 +698,7 @@ struct ImGuiIO
     //------------------------------------------------------------------
 
     ImVec2      MousePos;                   // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
-    bool        MouseDown[5];               // Mouse buttons. ImGui itself only uses button 0 (left button). Others buttons allows to track if mouse is being used by your application + available to user as a convenience via IsMouse** API.
+    bool        MouseDown[5];               // Mouse buttons: left, right, middle + extras. ImGui itself mostly only uses left button (BeginPopupContext** are using right button). Others buttons allows us to track if the mouse is being used by your application + available to user as a convenience via IsMouse** API.
     float       MouseWheel;                 // Mouse wheel: 1 unit scrolls about 5 lines text. 
     bool        MouseDrawCursor;            // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor).
     bool        KeyCtrl;                    // Keyboard modifier pressed: Control
@@ -662,8 +707,9 @@ struct ImGuiIO
     bool        KeysDown[512];              // Keyboard keys that are pressed (in whatever storage order you naturally have access to keyboard data)
     ImWchar     InputCharacters[16+1];      // List of characters input (translated by user from keypress+keyboard state). Fill using AddInputCharacter() helper.
 
-    // Function
-    IMGUI_API void AddInputCharacter(ImWchar c); // Helper to add a new character into InputCharacters[]
+    // Functions
+    IMGUI_API void AddInputCharacter(ImWchar c);                    // Helper to add a new character into InputCharacters[]
+    IMGUI_API void AddInputCharactersUTF8(const char* utf8_chars);  // Helper to add new characters into InputCharacters[] from an UTF-8 string
 
     //------------------------------------------------------------------
     // Output - Retrieve after calling NewFrame(), you can use them to discard inputs or hide them from the rest of your application
@@ -673,7 +719,8 @@ struct ImGuiIO
     bool        WantCaptureKeyboard;        // Widget is active (= ImGui will use your keyboard input)
     float       Framerate;                  // Framerate estimation, in frame per second. Rolling average estimation based on IO.DeltaTime over 120 frames
     int         MetricsAllocs;              // Number of active memory allocations
-    int         MetricsRenderVertices;      // Vertices processed during last call to Render()
+    int         MetricsRenderVertices;      // Vertices output during last call to Render()
+    int         MetricsRenderIndices;       // Indices output during last call to Render() = number of triangles * 3
     int         MetricsActiveWindows;       // Number of visible windows (exclude child windows)
 
     //------------------------------------------------------------------
@@ -686,10 +733,13 @@ struct ImGuiIO
     ImVec2      MouseClickedPos[5];         // Position at time of clicking
     float       MouseClickedTime[5];        // Time of last click (used to figure out double-click)
     bool        MouseDoubleClicked[5];      // Has mouse button been double-clicked?
+    bool        MouseReleased[5];           // Mouse button went from Down to !Down
     bool        MouseDownOwned[5];          // Track if button was clicked inside a window. We don't request mouse capture from the application if click started outside ImGui bounds.
-    float       MouseDownTime[5];           // Time the mouse button has been down
+    float       MouseDownDuration[5];       // Duration the mouse button has been down (0.0f == just clicked)
+    float       MouseDownDurationPrev[5];   // Previous time the mouse button has been down
     float       MouseDragMaxDistanceSqr[5]; // Squared maximum distance of how much mouse has traveled from the click point
-    float       KeysDownTime[512];          // Time the keyboard key has been down
+    float       KeysDownDuration[512];      // Duration the keyboard key has been down (0.0f == just pressed)
+    float       KeysDownDurationPrev[512];  // Previous duration the key has been down
 
     IMGUI_API   ImGuiIO();
 };
@@ -699,18 +749,15 @@ struct ImGuiIO
 //-----------------------------------------------------------------------------
 
 // Lightweight std::vector<> like class to avoid dragging dependencies (also: windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug). 
-// Use '#define ImVector std::vector' if you want to use the STL type or your own type.
 // Our implementation does NOT call c++ constructors because we don't use them in ImGui. Don't use this class as a straight std::vector replacement in your code!
-#ifndef ImVector
 template<typename T>
 class ImVector
 {
-protected:
-    size_t                      Size;
-    size_t                      Capacity;
+public:
+    int                         Size;
+    int                         Capacity;
     T*                          Data;
 
-public:
     typedef T                   value_type;
     typedef value_type*         iterator;
     typedef const value_type*   const_iterator;
@@ -719,13 +766,11 @@ public:
     ~ImVector()                 { if (Data) ImGui::MemFree(Data); }
 
     inline bool                 empty() const                   { return Size == 0; }
-    inline size_t               size() const                    { return Size; }
-    inline size_t               capacity() const                { return Capacity; }
+    inline int                  size() const                    { return Size; }
+    inline int                  capacity() const                { return Capacity; }
 
-    inline value_type&          at(size_t i)                    { IM_ASSERT(i < Size); return Data[i]; }
-    inline const value_type&    at(size_t i) const              { IM_ASSERT(i < Size); return Data[i]; }
-    inline value_type&          operator[](size_t i)            { IM_ASSERT(i < Size); return Data[i]; }
-    inline const value_type&    operator[](size_t i) const      { IM_ASSERT(i < Size); return Data[i]; }
+    inline value_type&          operator[](int i)               { IM_ASSERT(i < Size); return Data[i]; }
+    inline const value_type&    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 iterator             begin()                         { return Data; }
@@ -736,16 +781,16 @@ public:
     inline const value_type&    front() const                   { IM_ASSERT(Size > 0); return Data[0]; }
     inline value_type&          back()                          { IM_ASSERT(Size > 0); return Data[Size-1]; }
     inline const value_type&    back() const                    { IM_ASSERT(Size > 0); return Data[Size-1]; }
-    inline void                 swap(ImVector<T>& rhs)          { const size_t rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; const size_t rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
+    inline void                 swap(ImVector<T>& rhs)          { int rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; int rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
 
-    inline size_t               _grow_capacity(size_t new_size) { size_t new_capacity = Capacity ? (Capacity + Capacity/2) : 8; return new_capacity > new_size ? new_capacity : new_size; }
+    inline int                  _grow_capacity(int new_size)    { int new_capacity = Capacity ? (Capacity + Capacity/2) : 8; return new_capacity > new_size ? new_capacity : new_size; }
 
-    inline void                 resize(size_t new_size)         { if (new_size > Capacity) reserve(_grow_capacity(new_size)); Size = new_size; }
-    inline void                 reserve(size_t new_capacity)    
+    inline void                 resize(int new_size)            { if (new_size > Capacity) reserve(_grow_capacity(new_size)); Size = new_size; }
+    inline void                 reserve(int new_capacity)    
     { 
         if (new_capacity <= Capacity) return;
-        T* new_data = (value_type*)ImGui::MemAlloc(new_capacity * sizeof(value_type));
-        memcpy(new_data, Data, Size * sizeof(value_type));
+        T* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(value_type));
+        memcpy(new_data, Data, (size_t)Size * sizeof(value_type));
         ImGui::MemFree(Data);
         Data = new_data;
         Capacity = new_capacity; 
@@ -754,10 +799,9 @@ public:
     inline void                 push_back(const value_type& v)  { if (Size == Capacity) reserve(_grow_capacity(Size+1)); Data[Size++] = v; }
     inline void                 pop_back()                      { IM_ASSERT(Size > 0); Size--; }
 
-    inline iterator             erase(const_iterator it)        { IM_ASSERT(it >= begin() && it < end()); const ptrdiff_t off = it - begin(); memmove(Data + off, Data + off + 1, (Size - (size_t)off - 1) * sizeof(value_type)); Size--; return Data + off; }
-    inline iterator             insert(const_iterator it, const value_type& v)  { IM_ASSERT(it >= begin() && it <= end()); const ptrdiff_t off = it - begin(); if (Size == Capacity) reserve(Capacity ? Capacity * 2 : 4); if (off < (int)Size) memmove(Data + off + 1, Data + off, (Size - (size_t)off) * sizeof(value_type)); Data[off] = v; Size++; return Data + off; }
+    inline iterator             erase(const_iterator it)        { IM_ASSERT(it >= begin() && it < end()); const ptrdiff_t off = it - begin(); memmove(Data + off, Data + off + 1, ((size_t)Size - (size_t)off - 1) * sizeof(value_type)); Size--; return Data + off; }
+    inline iterator             insert(const_iterator it, const value_type& v)  { IM_ASSERT(it >= begin() && it <= end()); const ptrdiff_t off = it - begin(); if (Size == Capacity) reserve(Capacity ? Capacity * 2 : 4); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(value_type)); Data[off] = v; Size++; return Data + off; }
 };
-#endif // #ifndef ImVector
 
 // Helper: execute a block of code once a frame only
 // Convenient if you want to quickly create an UI within deep-nested code that runs multiple times every frame.
@@ -772,7 +816,7 @@ struct ImGuiOnceUponAFrame
 {
     ImGuiOnceUponAFrame() { RefFrame = -1; }
     mutable int RefFrame;
-    operator bool() const { const int current_frame = ImGui::GetFrameCount(); if (RefFrame == current_frame) return false; RefFrame = current_frame; return true; }
+    operator bool() const { int current_frame = ImGui::GetFrameCount(); if (RefFrame == current_frame) return false; RefFrame = current_frame; return true; }
 };
 
 // Helper: Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
@@ -814,7 +858,7 @@ struct ImGuiTextBuffer
     ImGuiTextBuffer()   { Buf.push_back(0); }
     const char*         begin() const { return &Buf.front(); }
     const char*         end() const { return &Buf.back(); }      // Buf is zero-terminated, so end() will point on the zero-terminator
-    size_t              size() const { return Buf.size()-1; }
+    int                 size() const { return Buf.Size-1; }
     bool                empty() { return size() >= 1; }
     void                clear() { Buf.clear(); Buf.push_back(0); }
     IMGUI_API void      append(const char* fmt, ...);
@@ -878,7 +922,7 @@ struct ImGuiTextEditCallbackData
     // Completion,History,Always events:
     ImGuiKey            EventKey;       // Key pressed (Up/Down/TAB)            // Read-only
     char*               Buf;            // Current text                         // Read-write (pointed data only)
-    size_t              BufSize;        //                                      // Read-only
+    int                 BufSize;        //                                      // Read-only
     bool                BufDirty;       // Set if you modify Buf directly       // Write
     int                 CursorPos;      //                                      // Read-write
     int                 SelectionStart; //                                      // Read-write (== to SelectionEnd when no selection)
@@ -887,10 +931,11 @@ struct ImGuiTextEditCallbackData
     // NB: calling those function loses selection.
     void DeleteChars(int pos, int bytes_count);
     void InsertChars(int pos, const char* text, const char* text_end = NULL);
+    bool HasSelection() const { return SelectionStart != SelectionEnd; }
 };
 
 // ImColor() is just a helper that implicity converts to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)
-// None of the ImGui API are using ImColor directly but you can use it as a convenience to pass colors in either formats.
+// 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.
 struct ImColor
 {
     ImVec4              Value;
@@ -913,8 +958,8 @@ struct ImColor
 //    clipper.End();
 struct ImGuiListClipper
 {
-    float ItemsHeight;
-    int ItemsCount, DisplayStart, DisplayEnd;
+    float   ItemsHeight;
+    int     ItemsCount, DisplayStart, DisplayEnd;
 
     ImGuiListClipper()                         { ItemsHeight = 0.0f; ItemsCount = DisplayStart = DisplayEnd = -1; }
     ImGuiListClipper(int count, float height)  { ItemsCount = -1; Begin(count, height); }
@@ -938,15 +983,15 @@ struct ImGuiListClipper
 
 //-----------------------------------------------------------------------------
 // Draw List
-// Hold a series of drawing commands. The user provides a renderer for ImDrawList.
+// Hold a series of drawing commands. The user provides a renderer for ImDrawData which essentially contains an array of ImDrawList.
 //-----------------------------------------------------------------------------
 
 // Draw callbacks for advanced uses.
-// NB- You most likely DO NOT need to care about draw callbacks just to create your own widget or customized UI rendering (you can poke into the draw list for that)
+// NB- You most likely do NOT need to use draw callbacks just to create your own widget or customized UI rendering (you can poke into the draw list for that)
 // Draw callback are useful for example if you want to render a complex 3D scene inside a UI element.
 // The expected behavior from your rendering loop is:
-//   if (cmd.user_callback != NULL)
-//       cmd.user_callback(parent_list, cmd);
+//   if (cmd.UserCallback != NULL)
+//       cmd.UserCallback(parent_list, cmd);
 //   else
 //       RenderTriangles()
 // It is up to you to decide if your rendering loop or the callback should be responsible for backup/restoring rendering state.
@@ -955,13 +1000,16 @@ typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* c
 // Typically, 1 command = 1 gpu draw call (unless command is a callback)
 struct ImDrawCmd
 {
-    unsigned int    vtx_count;                  // Number of vertices (multiple of 3) to be drawn as triangles. The vertices are stored in the callee ImDrawList's vtx_buffer[] array.
-    ImVec4          clip_rect;                  // Clipping rectangle (x1, y1, x2, y2)
-    ImTextureID     texture_id;                 // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas.
-    ImDrawCallback  user_callback;              // If != NULL, call the function instead of rendering the vertices. vtx_count will be 0. clip_rect and texture_id will be set normally.
-    void*           user_callback_data;         // The draw callback code can access this.
+    unsigned int    ElemCount;              // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[].
+    ImVec4          ClipRect;               // Clipping rectangle (x1, y1, x2, y2)
+    ImTextureID     TextureId;              // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas.
+    ImDrawCallback  UserCallback;           // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally.
+    void*           UserCallbackData;       // The draw callback code can access this.
 };
 
+// Vertex index
+typedef unsigned short ImDrawIdx;
+
 // Vertex layout
 #ifndef IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT
 struct ImDrawVert
@@ -977,6 +1025,13 @@ struct ImDrawVert
 IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT;
 #endif
 
+// Draw channels are used by the Columns API to "split" the render list into different channels while building, so items of each column can be batched together.
+struct ImDrawChannel
+{
+    ImVector<ImDrawCmd>     CmdBuffer;
+    ImVector<ImDrawIdx>     IdxBuffer;
+};
+
 // Draw command list
 // This is the low-level list of polygons that ImGui functions are filling. At the end of the frame, all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.
 // At the moment, each ImGui window contains its own ImDrawList but they could potentially be merged in the future.
@@ -987,15 +1042,23 @@ IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT;
 struct ImDrawList
 {
     // This is what you have to render
-    ImVector<ImDrawCmd>     commands;           // Commands. Typically 1 command = 1 gpu draw call.
-    ImVector<ImDrawVert>    vtx_buffer;         // Vertex buffer. Each command consume ImDrawCmd::vtx_count of those
+    ImVector<ImDrawCmd>     CmdBuffer;          // Commands. Typically 1 command = 1 gpu draw call.
+    ImVector<ImDrawIdx>     IdxBuffer;          // Index buffer. Each command consume ImDrawCmd::ElemCount of those
+    ImVector<ImDrawVert>    VtxBuffer;          // Vertex buffer.
 
-    // [Internal to ImGui]
-    ImVector<ImVec4>        clip_rect_stack;    // [Internal]
-    ImVector<ImTextureID>   texture_id_stack;   // [Internal] 
-    ImDrawVert*             vtx_write;          // [Internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much)
+    // [Internal, used while building lists]
+    const char*             _OwnerName;         // Pointer to owner window's name (if any) for debugging
+    unsigned int            _VtxCurrentIdx;     // [Internal] == VtxBuffer.Size
+    ImDrawVert*             _VtxWritePtr;       // [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
+    ImDrawIdx*              _IdxWritePtr;       // [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
+    ImVector<ImVec4>        _ClipRectStack;     // [Internal]
+    ImVector<ImTextureID>   _TextureIdStack;    // [Internal] 
+    ImVector<ImVec2>        _Path;				// [Internal] current path building
+    int                     _ChannelCurrent;    // [Internal] current channel number (0)
+    ImVector<ImDrawChannel> _Channels;          // [Internal] draw channels for columns API
 
-    ImDrawList() { Clear(); }
+    ImDrawList() { _OwnerName = NULL; Clear(); }
+    ~ImDrawList() { ClearFreeMemory(); }
     IMGUI_API void  Clear();
     IMGUI_API void  ClearFreeMemory();
     IMGUI_API void  PushClipRect(const ImVec4& clip_rect);          // Scissoring. The values are x1, y1, x2, y2.
@@ -1008,27 +1071,75 @@ struct ImDrawList
     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 = 0x0F);
     IMGUI_API void  AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners = 0x0F);
+    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  AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
     IMGUI_API void  AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
     IMGUI_API void  AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
-    IMGUI_API void  AddArcFast(const ImVec2& center, float radius, ImU32 col, int a_min_12, int a_max_12, bool filled = false, const ImVec2& third_point_offset = ImVec2(0,0)); // Angles in 0..12 range
-    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 ImVec2* cpu_clip_max = NULL);
+    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& uv0, const ImVec2& uv1, ImU32 col = 0xFFFFFFFF);
+    IMGUI_API void  AddPolyline(const ImVec2* points, const int num_points, ImU32 col, bool closed, float thickness, bool anti_aliased);
+    IMGUI_API void  AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col, bool anti_aliased);
+
+    // Stateful path API, add points then finish with PathFill() or PathStroke()
+    inline    void  PathClear()                                                 { _Path.resize(0); }
+    inline    void  PathLineTo(const ImVec2& p)                                 { _Path.push_back(p); }
+    IMGUI_API void  PathArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments = 10);
+    IMGUI_API void  PathArcToFast(const ImVec2& centre, float radius, int a_min_of_12, int a_max_of_12);
+    IMGUI_API void  PathRect(const ImVec2& a, const ImVec2& b, float rounding = 0.0f, int rounding_corners = 0x0F);
+    inline    void  PathFill(ImU32 col)                                         { AddConvexPolyFilled(_Path.Data, _Path.Size, col, true); PathClear(); }
+    inline    void  PathStroke(ImU32 col, bool closed, float thickness = 1.0f)  { AddPolyline(_Path.Data, _Path.Size, col, closed, thickness, true); PathClear(); }
 
     // Advanced
-    IMGUI_API void  AddCallback(ImDrawCallback callback, void* callback_data);  // Your rendering function must check for 'user_callback' in ImDrawCmd and call the function instead of rendering triangles.
+    IMGUI_API void  AddCallback(ImDrawCallback callback, void* callback_data);  // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles.
     IMGUI_API void  AddDrawCmd();                                               // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
+    IMGUI_API void  ChannelsSplit(int channel_count);
+    IMGUI_API void  ChannelsMerge(int channel_count);
+    IMGUI_API void  ChannelsSetCurrent(int idx);
 
     // Internal helpers
-    IMGUI_API void  PrimReserve(unsigned int vtx_count);
-    IMGUI_API void  PrimTriangle(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
+    // NB: all primitives needs to be reserved via PrimReserve() beforehand!
+    IMGUI_API void  PrimReserve(int idx_count, int vtx_count);
     IMGUI_API void  PrimRect(const ImVec2& a, const ImVec2& b, ImU32 col);
     IMGUI_API void  PrimRectUV(const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col);
-    IMGUI_API void  PrimQuad(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col);
-    IMGUI_API void  PrimLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness = 1.0f);
+    inline    void  PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col)     { PrimWriteIdx((ImDrawIdx)_VtxCurrentIdx); PrimWriteVtx(pos, uv, col); }
+    inline    void  PrimWriteVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col){ _VtxWritePtr->pos = pos; _VtxWritePtr->uv = uv; _VtxWritePtr->col = col; _VtxWritePtr++; _VtxCurrentIdx++; }
+    inline    void  PrimWriteIdx(ImDrawIdx idx)                                 { *_IdxWritePtr = idx; _IdxWritePtr++; }
     IMGUI_API void  UpdateClipRect();
     IMGUI_API void  UpdateTextureID();
-    IMGUI_API void  PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col)  { vtx_write->pos = pos; vtx_write->uv = uv; vtx_write->col = col; vtx_write++; }
+};
+
+// All draw data to render an ImGui frame
+struct ImDrawData
+{
+    ImDrawList**    CmdLists;
+    int             CmdListsCount;
+    int             TotalVtxCount;          // For convenience, sum of all cmd_lists vtx_buffer.Size
+    int             TotalIdxCount;          // For convenience, sum of all cmd_lists idx_buffer.Size
+
+    // Functions
+    void DeIndexAllBuffers();               // For backward compatibility: convert all buffers from indexed to de-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
+};
+
+struct ImFontConfig
+{
+    void*           FontData;                   //          // TTF data
+    int             FontDataSize;               //          // TTF data size
+    bool            FontDataOwnedByAtlas;       // true     // TTF data ownership taken by the container ImFontAtlas (will delete memory itself). Set to true 
+    int             FontNo;                     // 0        // Index of font within TTF file
+    float           SizePixels;                 //          // Size in pixels for rasterizer
+    int             OversampleH, OversampleV;   // 3, 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 character to pixel boundary (if enabled, set OversampleH/V to 1)
+    ImVec2          GlyphExtraSpacing;          // 0, 0     // Extra spacing (in pixels) between glyphs
+    const ImWchar*  GlyphRanges;                //          // List of Unicode range (2 value per range, values are inclusive, zero-terminated list)
+    bool            MergeMode;                  // false    // Merge into previous ImFont, so you can combine multiple inputs font into one ImFont (e.g. ASCII font + icons + Japanese glyphs).
+    bool            MergeGlyphCenterV;          // false    // When merging (multiple ImFontInput for one ImFont), vertically center new glyphs instead of aligning their baseline
+    
+    // [Internal]
+    char            Name[32];                               // Name (strictly for debugging)
+    ImFont*         DstFont;
+
+    IMGUI_API ImFontConfig();
 };
 
 // Load and rasterize multiple TTF fonts into a same texture.
@@ -1043,10 +1154,12 @@ struct ImFontAtlas
 {
     IMGUI_API ImFontAtlas();
     IMGUI_API ~ImFontAtlas();
-    IMGUI_API ImFont*           AddFontDefault();
-    IMGUI_API ImFont*           AddFontFromFileTTF(const char* filename, float size_pixels, const ImWchar* glyph_ranges = NULL, int font_no = 0);
-    IMGUI_API ImFont*           AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float size_pixels, const ImWchar* glyph_ranges = NULL, int font_no = 0); // Transfer ownership of 'ttf_data' to ImFontAtlas, will be deleted after Build()
-    IMGUI_API ImFont*           AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImWchar* glyph_ranges = NULL, int font_no = 0); // 'compressed_ttf_data' untouched and still owned by caller. Compress with binary_to_compressed_c.cpp
+    IMGUI_API ImFont*           AddFont(const ImFontConfig* font_cfg);
+    IMGUI_API ImFont*           AddFontDefault(const ImFontConfig* font_cfg = NULL);
+    IMGUI_API ImFont*           AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);
+    IMGUI_API ImFont*           AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);                                        // Transfer ownership of 'ttf_data' to ImFontAtlas, will be deleted after Build()
+    IMGUI_API ImFont*           AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);  // 'compressed_ttf_data' still owned by caller. Compress with binary_to_compressed_c.cpp
+    IMGUI_API ImFont*           AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);              // 'compressed_ttf_data_base85' still owned by caller. Compress with binary_to_compressed_c.cpp with -base85 paramaeter
     IMGUI_API void              ClearTexData();             // Clear the CPU-side texture data. Saves RAM once the texture has been copied to graphics memory.
     IMGUI_API void              ClearInputData();           // Clear the input TTF data (inc sizes, glyph ranges)
     IMGUI_API void              ClearFonts();               // Clear the ImGui-side font data (glyphs storage, UV coordinates)
@@ -1066,6 +1179,7 @@ struct ImFontAtlas
     IMGUI_API const ImWchar*    GetGlyphRangesDefault();    // Basic Latin, Extended Latin
     IMGUI_API const ImWchar*    GetGlyphRangesJapanese();   // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
     IMGUI_API const ImWchar*    GetGlyphRangesChinese();    // Japanese + full set of about 21000 CJK Unified Ideographs
+    IMGUI_API const ImWchar*    GetGlyphRangesCyrillic();   // Default + about 400 Cyrillic characters
 
     // Members
     // (Access texture data via GetTexData*() calls which will setup a default font for you.)
@@ -1078,55 +1192,54 @@ struct ImFontAtlas
     ImVector<ImFont*>           Fonts;
 
     // Private
-    struct ImFontAtlasData;
-    ImVector<ImFontAtlasData*>  InputData;          // Internal data
+    ImVector<ImFontConfig>      ConfigData;         // Internal data
     IMGUI_API bool              Build();            // Build pixels data. This is automatically for you by the GetTexData*** functions.
     IMGUI_API void              RenderCustomTexData(int pass, void* rects);
 };
 
-// TTF font loading and rendering
+// Font runtime data and rendering
 // ImFontAtlas automatically loads a default embedded font for you when you call GetTexDataAsAlpha8() or GetTexDataAsRGBA32().
-// Kerning isn't supported. At the moment some ImGui code does per-character CalcTextSize calls, need something more state-ful.
 struct ImFont
 {
     // Members: Settings
-    float               FontSize;           // <user set>      // Height of characters, set during loading (don't change after loading)
-    float               Scale;              // = 1.0f          // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
-    ImVec2              DisplayOffset;      // = (0.0f,0.0f)   // Offset font rendering by xx pixels
-    ImWchar             FallbackChar;       // = '?'           // Replacement glyph if one isn't found. Only set via SetFallbackChar()
+    float                       FontSize;           // <user set>      // Height of characters, set during loading (don't change after loading)
+    float                       Scale;              // = 1.0f          // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
+    ImVec2                      DisplayOffset;      // = (0.0f,0.0f)   // Offset font rendering by xx pixels
+    ImWchar                     FallbackChar;       // = '?'           // Replacement glyph if one isn't found. Only set via SetFallbackChar()
+    ImFontConfig*               ConfigData;         //                 // Pointer within ImFontAtlas->ConfigData
+    int                         ConfigDataCount;    //
 
     // Members: Runtime data
     struct Glyph
     {
-        ImWchar         Codepoint;
-        signed short    XAdvance;
-        signed short    Width, Height;
-        signed short    XOffset, YOffset;
-        float           U0, V0, U1, V1;     // Texture coordinates
+        ImWchar                 Codepoint;
+        float                   XAdvance;
+        float                   X0, Y0, X1, Y1;
+        float                   U0, V0, U1, V1;     // Texture coordinates
     };
-    float               BaseLine;           // Distance from top to bottom of e.g. 'A' [0..FontSize]
-    ImFontAtlas*        ContainerAtlas;     // What we has been loaded into
-    ImVector<Glyph>     Glyphs;
-    const Glyph*        FallbackGlyph;      // == FindGlyph(FontFallbackChar)
-    float               FallbackXAdvance;   //
-    ImVector<float>     IndexXAdvance;      // Glyphs->XAdvance directly indexable (for CalcTextSize functions which are often bottleneck in large UI)
-    ImVector<int>       IndexLookup;        // Index glyphs by Unicode code-point
+    float                       Ascent, Descent;    // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize]
+    ImFontAtlas*                ContainerAtlas;     // What we has been loaded into
+    ImVector<Glyph>             Glyphs;
+    const Glyph*                FallbackGlyph;      // == FindGlyph(FontFallbackChar)
+    float                       FallbackXAdvance;   //
+    ImVector<float>             IndexXAdvance;      // Sparse. Glyphs->XAdvance directly indexable (for CalcTextSize functions which are often bottleneck in large UI)
+    ImVector<int>               IndexLookup;        // Sparse. Index glyphs by Unicode code-point
 
     // Methods
     IMGUI_API ImFont();
     IMGUI_API ~ImFont();
     IMGUI_API void              Clear();
     IMGUI_API void              BuildLookupTable();
+    IMGUI_API float             GetCharAdvance(unsigned short c) const  { return ((int)c < IndexXAdvance.Size) ? IndexXAdvance[(int)c] : FallbackXAdvance; }
     IMGUI_API const Glyph*      FindGlyph(unsigned short c) const;
     IMGUI_API void              SetFallbackChar(ImWchar c);
-    IMGUI_API bool              IsLoaded() const        { return ContainerAtlas != NULL; }
+    IMGUI_API bool              IsLoaded() const                        { return ContainerAtlas != NULL; }
 
     // 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
     // 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
     IMGUI_API ImVec2            CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const; // utf8
-    IMGUI_API ImVec2            CalcTextSizeW(float size, float max_width, const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = NULL) const;                 // wchar
-    IMGUI_API void              RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, ImDrawList* draw_list, float wrap_width = 0.0f, const ImVec2* cpu_clip_max = NULL) const;
     IMGUI_API const char*       CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
+    IMGUI_API void              RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, ImDrawList* draw_list, float wrap_width = 0.0f, bool cpu_fine_clip = false) const;
 };
 
 //---- Include imgui_user.h at the end of imgui.h

imgui_internal.h

@@ -0,0 +1,664 @@
+// ImGui library v1.44
+// Internals
+// You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
+
+// Implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
+//   #define IMGUI_DEFINE_MATH_OPERATORS
+
+#pragma once
+
+#include <stdio.h>      // FILE*
+#include <math.h>       // sqrtf()
+
+//-----------------------------------------------------------------------------
+// Forward Declarations
+//-----------------------------------------------------------------------------
+
+struct ImRect;
+struct ImGuiColMod;
+struct ImGuiStyleMod;
+struct ImGuiGroupData;
+struct ImGuiSimpleColumns;
+struct ImGuiDrawContext;
+struct ImGuiTextEditState;
+struct ImGuiIniData;
+struct ImGuiMouseCursorData;
+struct ImGuiPopupRef;
+struct ImGuiState;
+struct ImGuiWindow;
+
+typedef int ImGuiLayoutType;      // enum ImGuiLayoutType_
+typedef int ImGuiButtonFlags;     // enum ImGuiButtonFlags_
+
+//-------------------------------------------------------------------------
+// STB libraries
+//-------------------------------------------------------------------------
+
+namespace ImGuiStb
+{
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+#endif
+
+#undef STB_TEXTEDIT_STRING
+#undef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_STRING             ImGuiTextEditState
+#define STB_TEXTEDIT_CHARTYPE           ImWchar
+#define STB_TEXTEDIT_GETWIDTH_NEWLINE   -1.0f
+#include "stb_textedit.h"
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+} // namespace ImGuiStb
+
+//-----------------------------------------------------------------------------
+// Context
+//-----------------------------------------------------------------------------
+
+extern ImGuiState*  GImGui;
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+#define IM_ARRAYSIZE(_ARR)      ((int)(sizeof(_ARR)/sizeof(*_ARR)))
+#define IM_PI                   3.14159265358979323846f
+
+// Helpers: UTF-8 <> wchar
+int                 ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end);      // return output UTF-8 bytes count
+int                 ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end);          // return input UTF-8 bytes count
+int                 ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL);   // return input UTF-8 bytes count
+int                 ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end);                            // return number of UTF-8 code-points (NOT bytes count)
+int                 ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end);                   // return number of bytes to express string as UTF-8 code-points
+
+// Helpers: Misc
+ImU32               ImHash(const void* data, int data_size, ImU32 seed);
+bool                ImLoadFileToMemory(const char* filename, const char* file_open_mode, void** out_file_data, int* out_file_size = NULL, int padding_bytes = 0);
+bool                ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c);
+static inline bool  ImCharIsSpace(int c)            { return c == ' ' || c == '\t' || c == 0x3000; }
+static inline int   ImUpperPowerOfTwo(int v)        { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
+
+// Helpers: String
+int                 ImStricmp(const char* str1, const char* str2);
+int                 ImStrnicmp(const char* str1, const char* str2, int count);
+char*               ImStrdup(const char* str);
+int                 ImStrlenW(const ImWchar* str);
+const ImWchar*      ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line
+const char*         ImStristr(const char* haystack, const char* needle, const char* needle_end);
+int                 ImFormatString(char* buf, int buf_size, const char* fmt, ...);
+int                 ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args);
+
+// Helpers: Math
+// We are keeping those not leaking to the user by default, in the case the user has implicit cast operators between ImVec2 and its own types (when IM_VEC2_CLASS_EXTRA is defined)
+#ifdef IMGUI_DEFINE_MATH_OPERATORS
+static inline ImVec2 operator*(const ImVec2& lhs, const float rhs)              { return ImVec2(lhs.x*rhs, lhs.y*rhs); }
+static inline ImVec2 operator/(const ImVec2& lhs, const float rhs)              { return ImVec2(lhs.x/rhs, lhs.y/rhs); }
+static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x+rhs.x, lhs.y+rhs.y); }
+static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x-rhs.x, lhs.y-rhs.y); }
+static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x*rhs.x, lhs.y*rhs.y); }
+static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x/rhs.x, lhs.y/rhs.y); }
+static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; }
+static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }
+static inline ImVec2& operator*=(ImVec2& lhs, const float rhs)                  { lhs.x *= rhs; lhs.y *= rhs; return lhs; }
+static inline ImVec2& operator/=(ImVec2& lhs, const float rhs)                  { lhs.x /= rhs; lhs.y /= rhs; return lhs; }
+static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x-rhs.x, lhs.y-rhs.y, lhs.z-rhs.z, lhs.w-lhs.w); }
+#endif
+
+static inline int    ImMin(int lhs, int rhs)                                    { return lhs < rhs ? lhs : rhs; }
+static inline int    ImMax(int lhs, int rhs)                                    { return lhs >= rhs ? lhs : rhs; }
+static inline float  ImMin(float lhs, float rhs)                                { return lhs < rhs ? lhs : rhs; }
+static inline float  ImMax(float lhs, float rhs)                                { return lhs >= rhs ? lhs : rhs; }
+static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(ImMin(lhs.x,rhs.x), ImMin(lhs.y,rhs.y)); }
+static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(ImMax(lhs.x,rhs.x), ImMax(lhs.y,rhs.y)); }
+static inline int    ImClamp(int v, int mn, int mx)                             { return (v < mn) ? mn : (v > mx) ? mx : v; }
+static inline float  ImClamp(float v, float mn, float mx)                       { return (v < mn) ? mn : (v > mx) ? mx : v; }
+static inline ImVec2 ImClamp(const ImVec2& f, const ImVec2& mn, ImVec2 mx)      { return ImVec2(ImClamp(f.x,mn.x,mx.x), ImClamp(f.y,mn.y,mx.y)); }
+static inline float  ImSaturate(float f)                                        { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
+static inline float  ImLerp(float a, float b, float t)                          { return a + (b - a) * t; }
+static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t)  { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
+static inline float  ImLengthSqr(const ImVec2& lhs)                             { return lhs.x*lhs.x + lhs.y*lhs.y; }
+static inline float  ImLengthSqr(const ImVec4& lhs)                             { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; }
+static inline float  ImInvLength(const ImVec2& lhs, float fail_value)           { float d = lhs.x*lhs.x + lhs.y*lhs.y; if (d > 0.0f) return 1.0f / sqrtf(d); return fail_value; }
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+enum ImGuiButtonFlags_
+{
+    ImGuiButtonFlags_Repeat             = 1 << 0,
+    ImGuiButtonFlags_PressedOnClick     = 1 << 1,   // return pressed on click only (default requires click+release)
+    ImGuiButtonFlags_PressedOnRelease   = 1 << 2,   // return pressed on release only (default requires click+release)
+    ImGuiButtonFlags_FlattenChilds      = 1 << 3,
+    ImGuiButtonFlags_DontClosePopups    = 1 << 4,
+    ImGuiButtonFlags_Disabled           = 1 << 5,
+    ImGuiButtonFlags_AlignTextBaseLine  = 1 << 6
+};
+
+enum ImGuiSelectableFlagsPrivate_
+{
+    // NB: need to be in sync with last value of ImGuiSelectableFlags_
+    ImGuiSelectableFlags_Menu               = 1 << 2,
+    ImGuiSelectableFlags_MenuItem           = 1 << 3,
+    ImGuiSelectableFlags_Disabled           = 1 << 4,
+    ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 5
+};
+
+// FIXME: this is in development, not exposed/functional as a generic feature yet.
+enum ImGuiLayoutType_
+{
+    ImGuiLayoutType_Vertical,
+    ImGuiLayoutType_Horizontal
+};
+
+enum ImGuiPlotType
+{
+    ImGuiPlotType_Lines,
+    ImGuiPlotType_Histogram
+};
+
+enum ImGuiDataType
+{
+    ImGuiDataType_Int,
+    ImGuiDataType_Float
+};
+
+// 2D axis aligned bounding-box
+// NB: we can't rely on ImVec2 math operators being available here
+struct ImRect
+{
+    ImVec2          Min;    // Upper-left
+    ImVec2          Max;    // Lower-right
+
+    ImRect()                                        : Min(FLT_MAX,FLT_MAX), Max(-FLT_MAX,-FLT_MAX)  {}
+    ImRect(const ImVec2& min, const ImVec2& max)    : Min(min), Max(max)                            {}
+    ImRect(const ImVec4& v)                         : Min(v.x, v.y), Max(v.z, v.w)                  {}
+    ImRect(float x1, float y1, float x2, float y2)  : Min(x1, y1), Max(x2, y2)                      {}
+
+    ImVec2          GetCenter() const               { return ImVec2((Min.x+Max.x)*0.5f, (Min.y+Max.y)*0.5f); }
+    ImVec2          GetSize() const                 { return ImVec2(Max.x-Min.x, Max.y-Min.y); }
+    float           GetWidth() const                { return Max.x-Min.x; }
+    float           GetHeight() const               { return Max.y-Min.y; }
+    ImVec2          GetTL() const                   { return Min; }
+    ImVec2          GetTR() const                   { return ImVec2(Max.x, Min.y); }
+    ImVec2          GetBL() const                   { return ImVec2(Min.x, Max.y); }
+    ImVec2          GetBR() const                   { return Max; }
+    bool            Contains(const ImVec2& p) const { return p.x >= Min.x     && p.y >= Min.y     && p.x < Max.x     && p.y < Max.y; }
+    bool            Contains(const ImRect& r) const { return r.Min.x >= Min.x && r.Min.y >= Min.y && r.Max.x < Max.x && r.Max.y < Max.y; }
+    bool            Overlaps(const ImRect& r) const { return r.Min.y < Max.y  && r.Max.y > Min.y  && r.Min.x < Max.x && r.Max.x > Min.x; }
+    void            Add(const ImVec2& rhs)          { if (Min.x > rhs.x)     Min.x = rhs.x;     if (Min.y > rhs.y) Min.y = rhs.y;         if (Max.x < rhs.x) Max.x = rhs.x;         if (Max.y < rhs.y) Max.y = rhs.y; }
+    void            Add(const ImRect& rhs)          { if (Min.x > rhs.Min.x) Min.x = rhs.Min.x; if (Min.y > rhs.Min.y) Min.y = rhs.Min.y; if (Max.x < rhs.Max.x) Max.x = rhs.Max.x; if (Max.y < rhs.Max.y) Max.y = rhs.Max.y; }
+    void            Expand(const float amount)      { Min.x -= amount;   Min.y -= amount;   Max.x += amount;   Max.y += amount; }
+    void            Expand(const ImVec2& amount)    { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
+    void            Reduce(const ImVec2& amount)    { Min.x += amount.x; Min.y += amount.y; Max.x -= amount.x; Max.y -= amount.y; }
+    void            Clip(const ImRect& clip)        { if (Min.x < clip.Min.x) Min.x = clip.Min.x; if (Min.y < clip.Min.y) Min.y = clip.Min.y; if (Max.x > clip.Max.x) Max.x = clip.Max.x; if (Max.y > clip.Max.y) Max.y = clip.Max.y; }
+    void            Round()                         { Min.x = (float)(int)Min.x; Min.y = (float)(int)Min.y; Max.x = (float)(int)Max.x; Max.y = (float)(int)Max.y; } 
+    ImVec2          GetClosestPoint(ImVec2 p, bool on_edge) const
+    {
+        if (!on_edge && Contains(p))
+            return p;
+        if (p.x > Max.x) p.x = Max.x;
+        else if (p.x < Min.x) p.x = Min.x;
+        if (p.y > Max.y) p.y = Max.y;
+        else if (p.y < Min.y) p.y = Min.y;
+        return p;
+    }
+};
+
+// Stacked color modifier, backup of modified data so we can restore it
+struct ImGuiColMod
+{
+    ImGuiCol        Col;
+    ImVec4          PreviousValue;
+};
+
+// Stacked style modifier, backup of modified data so we can restore it
+struct ImGuiStyleMod
+{
+    ImGuiStyleVar   Var;
+    ImVec2          PreviousValue;
+};
+
+// Stacked data for BeginGroup()/EndGroup()
+struct ImGuiGroupData
+{
+    ImVec2          BackupCursorPos;
+    ImVec2          BackupCursorMaxPos;
+    float           BackupColumnsStartX;
+    float           BackupCurrentLineHeight;
+    float           BackupCurrentLineTextBaseOffset;
+    float           BackupLogLinePosY;
+    bool            AdvanceCursor;
+};
+
+// Simple column measurement currently used for MenuItem() only. This is very short-sighted for now and not a generic helper.
+struct ImGuiSimpleColumns
+{
+    int             Count;
+    float           Spacing;
+    float           Width, NextWidth;
+    float           Pos[8], NextWidths[8];
+
+    ImGuiSimpleColumns();
+    void            Update(int count, float spacing, bool clear);
+    float           DeclColumns(float w0, float w1, float w2);
+    float           CalcExtraSpace(float avail_w);
+};
+
+// Internal state of the currently focused/edited text input box
+struct ImGuiTextEditState
+{
+    ImGuiID             Id;                             // widget id owning the text state
+    ImVector<ImWchar>   Text;                           // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
+    ImVector<char>      InitialText;                    // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
+    ImVector<char>      TempTextBuffer;
+    int                 CurLenA, CurLenW;               // we need to maintain our buffer length in both UTF-8 and wchar format.
+    int                 BufSizeA;                       // end-user buffer size
+    float               ScrollX;
+    ImGuiStb::STB_TexteditState   StbState;
+    float               CursorAnim;
+    bool                CursorFollow;
+    ImVec2              InputCursorScreenPos;           // Cursor position in screen space to be used by IME callback.
+    bool                SelectedAllMouseLock;
+
+    ImGuiTextEditState()                                { memset(this, 0, sizeof(*this)); }
+    void                CursorAnimReset()               { CursorAnim = -0.30f; }                                   // After a user-input the cursor stays on for a while without blinking
+    bool                HasSelection() const            { return StbState.select_start != StbState.select_end; }
+    void                ClearSelection()                { StbState.select_start = StbState.select_end = StbState.cursor; }
+    void                SelectAll()                     { StbState.select_start = 0; StbState.select_end = CurLenW; StbState.cursor = StbState.select_end; StbState.has_preferred_x = false; }
+    void                OnKeyPressed(int key);
+};
+
+// Data saved in imgui.ini file
+struct ImGuiIniData
+{
+    char*               Name;
+    ImGuiID             ID;
+    ImVec2              Pos;
+    ImVec2              Size;
+    bool                Collapsed;
+};
+
+// Mouse cursor data (used when io.MouseDrawCursor is set)
+struct ImGuiMouseCursorData
+{
+    ImGuiMouseCursor    Type;
+    ImVec2              HotOffset;
+    ImVec2              Size;
+    ImVec2              TexUvMin[2];
+    ImVec2              TexUvMax[2];
+};
+
+// Storage for current popup stack
+struct ImGuiPopupRef
+{
+    ImGuiID             PopupID;        // Set on OpenPopup()
+    ImGuiWindow*        Window;         // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
+    ImGuiWindow*        ParentWindow;   // Set on OpenPopup()
+    ImGuiID             ParentMenuSet;  // Set on OpenPopup()
+
+    ImGuiPopupRef(ImGuiID id, ImGuiWindow* parent_window, ImGuiID parent_menu_set) { PopupID = id; Window = NULL; ParentWindow = parent_window; ParentMenuSet = parent_menu_set; }
+};
+
+// Main state for ImGui
+struct ImGuiState
+{
+    bool                    Initialized;
+    ImGuiIO                 IO;
+    ImGuiStyle              Style;
+    ImFont*                 Font;                               // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
+    float                   FontSize;                           // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize()
+    float                   FontBaseSize;                       // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Size of characters.
+    ImVec2                  FontTexUvWhitePixel;                // (Shortcut) == Font->TexUvForWhite
+
+    float                   Time;
+    int                     FrameCount;
+    int                     FrameCountRendered;
+    ImVector<ImGuiWindow*>  Windows;
+    ImVector<ImGuiWindow*>  WindowsSortBuffer;
+    ImGuiWindow*            CurrentWindow;                      // Being drawn into
+    ImVector<ImGuiWindow*>  CurrentWindowStack;
+    ImGuiWindow*            FocusedWindow;                      // Will catch keyboard inputs
+    ImGuiWindow*            HoveredWindow;                      // Will catch mouse inputs
+    ImGuiWindow*            HoveredRootWindow;                  // Will catch mouse inputs (for focus/move only)
+    ImGuiID                 HoveredId;                          // Hovered widget
+    ImGuiID                 HoveredIdPreviousFrame;
+    ImGuiID                 ActiveId;                           // Active widget
+    ImGuiID                 ActiveIdPreviousFrame;
+    bool                    ActiveIdIsAlive;
+    bool                    ActiveIdIsJustActivated;            // Set at the time of activation for one frame
+    bool                    ActiveIdIsFocusedOnly;              // Set only by active widget. Denote focus but no active interaction
+    ImGuiWindow*            ActiveIdWindow;
+    ImGuiWindow*            MovedWindow;                        // Track the child window we clicked on to move a window. Pointer is only valid if ActiveID is the "#MOVE" identifier of a window.
+    ImVector<ImGuiIniData>  Settings;                           // .ini Settings
+    float                   SettingsDirtyTimer;                 // Save .ini settinngs on disk when time reaches zero
+    int                     DisableHideTextAfterDoubleHash;
+    ImVector<ImGuiColMod>   ColorModifiers;                     // Stack for PushStyleColor()/PopStyleColor()
+    ImVector<ImGuiStyleMod> StyleModifiers;                     // Stack for PushStyleVar()/PopStyleVar()
+    ImVector<ImFont*>       FontStack;                          // Stack for PushFont()/PopFont()
+    ImVector<ImGuiPopupRef> OpenedPopupStack;                   // Which popups are open (persistent)
+    ImVector<ImGuiPopupRef> CurrentPopupStack;                  // Which level of BeginPopup() we are in (reset every frame)
+
+    // Storage for SetNexWindow** and SetNextTreeNode*** functions
+    ImVec2                  SetNextWindowPosVal;
+    ImVec2                  SetNextWindowSizeVal;
+    bool                    SetNextWindowCollapsedVal;
+    ImGuiSetCond            SetNextWindowPosCond;
+    ImGuiSetCond            SetNextWindowSizeCond;
+    ImGuiSetCond            SetNextWindowCollapsedCond;
+    bool                    SetNextWindowFocus;
+    bool                    SetNextTreeNodeOpenedVal;
+    ImGuiSetCond            SetNextTreeNodeOpenedCond;
+
+    // Render
+    ImVector<ImDrawList*>   RenderDrawLists[3];
+    float                   ModalWindowDarkeningRatio;
+    ImDrawList              OverlayDrawList;                    // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays
+    ImGuiMouseCursor        MouseCursor;
+    ImGuiMouseCursorData    MouseCursorData[ImGuiMouseCursor_Count_];
+
+    // Widget state
+    ImGuiTextEditState      InputTextState;
+    ImGuiID                 ScalarAsInputTextId;                // Temporary text input when CTRL+clicking on a slider, etc.
+    ImGuiStorage            ColorEditModeStorage;               // Store user selection of color edit mode
+    ImVec2                  ActiveClickDeltaToCenter;
+    float                   DragCurrentValue;                   // Currently dragged value, always float, not rounded by end-user precision settings
+    ImVec2                  DragLastMouseDelta;
+    float                   DragSpeedDefaultRatio;              // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
+    float                   DragSpeedScaleSlow;
+    float                   DragSpeedScaleFast;
+    float                   ScrollbarClickDeltaToGrabCenter;    // Distance between mouse and center of grab box, normalized in parent space
+    char                    Tooltip[1024];
+    char*                   PrivateClipboard;                   // If no custom clipboard handler is defined
+
+    // Logging
+    bool                    LogEnabled;
+    FILE*                   LogFile;                            // If != NULL log to stdout/ file 
+    ImGuiTextBuffer*        LogClipboard;                       // Else log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
+    int                     LogStartDepth;
+    int                     LogAutoExpandMaxDepth;
+
+    // Misc
+    float                   FramerateSecPerFrame[120];          // calculate estimate of framerate for user
+    int                     FramerateSecPerFrameIdx;
+    float                   FramerateSecPerFrameAccum;
+    bool                    CaptureMouseNextFrame;              // explicit capture via CaptureInputs() sets those flags
+    bool                    CaptureKeyboardNextFrame;
+    char                    TempBuffer[1024*3+1];               // temporary text buffer
+
+    ImGuiState()
+    {
+        Initialized = false;
+        Font = NULL;
+        FontSize = FontBaseSize = 0.0f;
+        FontTexUvWhitePixel = ImVec2(0.0f, 0.0f);
+
+        Time = 0.0f;
+        FrameCount = 0;
+        FrameCountRendered = -1;
+        CurrentWindow = NULL;
+        FocusedWindow = NULL;
+        HoveredWindow = NULL;
+        HoveredRootWindow = NULL;
+        HoveredId = 0;
+        HoveredIdPreviousFrame = 0;
+        ActiveId = 0;
+        ActiveIdPreviousFrame = 0;
+        ActiveIdIsAlive = false;
+        ActiveIdIsJustActivated = false;
+        ActiveIdIsFocusedOnly = false;
+        ActiveIdWindow = NULL;
+        MovedWindow = NULL;
+        SettingsDirtyTimer = 0.0f;
+        DisableHideTextAfterDoubleHash = 0;
+
+        SetNextWindowPosVal = ImVec2(0.0f, 0.0f);
+        SetNextWindowSizeVal = ImVec2(0.0f, 0.0f);
+        SetNextWindowCollapsedVal = false;
+        SetNextWindowPosCond = 0;
+        SetNextWindowSizeCond = 0;
+        SetNextWindowCollapsedCond = 0;
+        SetNextWindowFocus = false;
+        SetNextTreeNodeOpenedVal = false;
+        SetNextTreeNodeOpenedCond = 0;
+
+        ScalarAsInputTextId = 0;
+        ActiveClickDeltaToCenter = ImVec2(0.0f, 0.0f);
+        DragCurrentValue = 0.0f;
+        DragLastMouseDelta = ImVec2(0.0f, 0.0f);
+        DragSpeedDefaultRatio = 0.01f;
+        DragSpeedScaleSlow = 0.01f;
+        DragSpeedScaleFast = 10.0f;
+        ScrollbarClickDeltaToGrabCenter = 0.0f;
+        memset(Tooltip, 0, sizeof(Tooltip));
+        PrivateClipboard = NULL;
+
+        ModalWindowDarkeningRatio = 0.0f;
+        OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging
+        MouseCursor = ImGuiMouseCursor_Arrow;
+
+        LogEnabled = false;
+        LogFile = NULL;
+        LogClipboard = NULL;
+        LogStartDepth = 0;
+        LogAutoExpandMaxDepth = 2;
+
+        memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
+        FramerateSecPerFrameIdx = 0;
+        FramerateSecPerFrameAccum = 0.0f;
+        CaptureMouseNextFrame = CaptureKeyboardNextFrame = false;
+    }
+};
+
+// Transient per-window data, reset at the beginning of the frame
+// FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiDrawContext is quite tenuous and could be reconsidered.
+struct ImGuiDrawContext
+{
+    ImVec2                  CursorPos;
+    ImVec2                  CursorPosPrevLine;
+    ImVec2                  CursorStartPos;
+    ImVec2                  CursorMaxPos;           // Implicitly calculate the size of our contents, always extending. Saved into window->SizeContents at the end of the frame
+    float                   CurrentLineHeight;
+    float                   CurrentLineTextBaseOffset;
+    float                   PrevLineHeight;
+    float                   PrevLineTextBaseOffset;
+    float                   LogLinePosY;
+    int                     TreeDepth;
+    ImGuiID                 LastItemID;
+    ImRect                  LastItemRect;
+    bool                    LastItemHoveredAndUsable;
+    bool                    LastItemHoveredRect;
+    bool                    MenuBarAppending;
+    float                   MenuBarOffsetX;
+    ImVector<ImGuiWindow*>  ChildWindows;
+    ImGuiStorage*           StateStorage;
+    ImGuiLayoutType         LayoutType;
+
+    // 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.
+    bool                    ButtonRepeat;           // == ButtonRepeatStack.back() [empty == false]
+    bool                    AllowKeyboardFocus;     // == AllowKeyboardFocusStack.back() [empty == true]
+    float                   ItemWidth;              // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
+    float                   TextWrapPos;            // == TextWrapPosStack.back() [empty == -1.0f]
+    ImVector<bool>          ButtonRepeatStack;
+    ImVector<bool>          AllowKeyboardFocusStack;
+    ImVector<float>         ItemWidthStack;
+    ImVector<float>         TextWrapPosStack;
+    ImVector<ImGuiGroupData>GroupStack;
+    ImGuiColorEditMode      ColorEditMode;
+    int                     StackSizesBackup[6];    // Store size of various stacks for asserting
+
+    float                   ColumnsStartX;          // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
+    float                   ColumnsOffsetX;         // 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.
+    int                     ColumnsCurrent;
+    int                     ColumnsCount;
+    ImVec2                  ColumnsStartPos;
+    float                   ColumnsCellMinY;
+    float                   ColumnsCellMaxY;
+    bool                    ColumnsShowBorders;
+    ImGuiID                 ColumnsSetID;
+    ImVector<float>         ColumnsOffsetsT;        // Columns offset normalized 0.0 (far left) -> 1.0 (far right)
+
+    ImGuiDrawContext()
+    {
+        CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
+        CurrentLineHeight = PrevLineHeight = 0.0f;
+        CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
+        LogLinePosY = -1.0f;
+        TreeDepth = 0;
+        LastItemID = 0;
+        LastItemRect = ImRect(0.0f,0.0f,0.0f,0.0f);
+        LastItemHoveredAndUsable = LastItemHoveredRect = false;
+        MenuBarAppending = false;
+        MenuBarOffsetX = 0.0f;
+        StateStorage = NULL;
+        LayoutType = ImGuiLayoutType_Vertical;
+        ItemWidth = 0.0f;
+        ButtonRepeat = false;
+        AllowKeyboardFocus = true;
+        TextWrapPos = -1.0f;
+        ColorEditMode = ImGuiColorEditMode_RGB;
+        memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
+
+        ColumnsStartX = 0.0f;
+        ColumnsOffsetX = 0.0f;
+        ColumnsCurrent = 0;
+        ColumnsCount = 1;
+        ColumnsStartPos = ImVec2(0.0f, 0.0f);
+        ColumnsCellMinY = ColumnsCellMaxY = 0.0f;
+        ColumnsShowBorders = true;
+        ColumnsSetID = 0;
+    }
+};
+
+// Windows data
+struct ImGuiWindow
+{
+    char*                   Name;
+    ImGuiID                 ID;
+    ImGuiWindowFlags        Flags;
+    ImVec2                  PosFloat;
+    ImVec2                  Pos;                                // Position rounded-up to nearest pixel
+    ImVec2                  Size;                               // Current size (==SizeFull or collapsed title bar size)
+    ImVec2                  SizeFull;                           // Size when non collapsed
+    ImVec2                  SizeContents;                       // Size of contents (== extents reach of the drawing cursor) from previous frame
+    ImVec2                  WindowPadding;                      // Window padding at the time of begin. We need to lock it, in particular manipulation of the ShowBorder would have an effect
+    ImGuiID                 MoveID;                             // == window->GetID("#MOVE")
+    float                   ScrollY;
+    float                   ScrollTargetRelY;                   // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
+    float                   ScrollTargetCenterRatioY;           // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
+    bool                    ScrollbarY;
+    bool                    Active;                             // Set to true on Begin()
+    bool                    WasActive;
+    bool                    Accessed;                           // Set to true when any widget access the current window
+    bool                    Collapsed;                          // Set when collapsing window to become only title-bar
+    bool                    SkipItems;                          // == Visible && !Collapsed
+    int                     BeginCount;                         // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
+    ImGuiID                 PopupID;                            // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling) 
+    int                     AutoFitFramesX, AutoFitFramesY;
+    bool                    AutoFitOnlyGrows;
+    int                     AutoPosLastDirection;
+    int                     HiddenFrames;
+    int                     SetWindowPosAllowFlags;             // bit ImGuiSetCond_*** specify if SetWindowPos() call will succeed with this particular flag. 
+    int                     SetWindowSizeAllowFlags;            // bit ImGuiSetCond_*** specify if SetWindowSize() call will succeed with this particular flag. 
+    int                     SetWindowCollapsedAllowFlags;       // bit ImGuiSetCond_*** specify if SetWindowCollapsed() call will succeed with this particular flag. 
+    bool                    SetWindowPosCenterWanted;
+
+    ImGuiDrawContext        DC;                                 // Temporary per-window data, reset at the beginning of the frame
+    ImVector<ImGuiID>       IDStack;                            // ID stack. ID are hashes seeded with the value at the top of the stack
+    ImRect                  ClipRect;                           // = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
+    ImRect                  ClippedWindowRect;                  // = ClipRect just after setup in Begin()
+    int                     LastFrameDrawn;
+    float                   ItemWidthDefault;
+    ImGuiSimpleColumns      MenuColumns;                        // Simplified columns storage for menu items
+    ImGuiStorage            StateStorage;
+    float                   FontWindowScale;                    // Scale multiplier per-window
+    ImDrawList*             DrawList;
+    ImGuiWindow*            RootWindow;
+    ImGuiWindow*            RootNonPopupWindow;
+
+    // Focus
+    int                     FocusIdxAllCounter;                 // Start at -1 and increase as assigned via FocusItemRegister()
+    int                     FocusIdxTabCounter;                 // (same, but only count widgets which you can Tab through)
+    int                     FocusIdxAllRequestCurrent;          // Item being requested for focus
+    int                     FocusIdxTabRequestCurrent;          // Tab-able item being requested for focus
+    int                     FocusIdxAllRequestNext;             // Item being requested for focus, for next update (relies on layout to be stable between the frame pressing TAB and the next frame)
+    int                     FocusIdxTabRequestNext;             // "
+
+public:
+    ImGuiWindow(const char* name);
+    ~ImGuiWindow();
+
+    ImGuiID     GetID(const char* str, const char* str_end = NULL);
+    ImGuiID     GetID(const void* ptr);
+
+    ImRect      Rect() const                            { return ImRect(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y); }
+    float       CalcFontSize() const                    { return GImGui->FontBaseSize * FontWindowScale; }
+    float       TitleBarHeight() const                  { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; }
+    ImRect      TitleBarRect() const                    { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
+    float       MenuBarHeight() const                   { return (Flags & ImGuiWindowFlags_MenuBar) ? CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f : 0.0f; }
+    ImRect      MenuBarRect() const                     { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
+    float       ScrollbarWidth() const                  { return ScrollbarY ? GImGui->Style.ScrollbarWidth : 0.0f; }
+    ImU32       Color(ImGuiCol idx, float a=1.f) const  { ImVec4 c = GImGui->Style.Colors[idx]; c.w *= GImGui->Style.Alpha * a; return ImGui::ColorConvertFloat4ToU32(c); }
+    ImU32       Color(const ImVec4& col) const          { ImVec4 c = col; c.w *= GImGui->Style.Alpha; return ImGui::ColorConvertFloat4ToU32(c); }
+};
+
+//-----------------------------------------------------------------------------
+// Internal API
+// No guarantee of forward compatibility here.
+//-----------------------------------------------------------------------------
+
+namespace ImGui
+{
+    IMGUI_API ImGuiWindow*  GetCurrentWindow();
+    IMGUI_API ImGuiWindow*  GetParentWindow();
+    IMGUI_API void          FocusWindow(ImGuiWindow* window);
+
+    IMGUI_API void          SetActiveID(ImGuiID id, ImGuiWindow* window);
+    IMGUI_API void          KeepAliveID(ImGuiID id);
+
+    IMGUI_API void          ItemSize(const ImVec2& size, float text_offset_y = 0.0f);
+    IMGUI_API void          ItemSize(const ImRect& bb, float text_offset_y = 0.0f);
+    IMGUI_API bool          ItemAdd(const ImRect& bb, const ImGuiID* id);
+    IMGUI_API bool          IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged);
+    IMGUI_API bool          IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs = false);
+    IMGUI_API bool          FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop = true);      // 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         CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
+
+    IMGUI_API void          RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
+    IMGUI_API void          RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
+    IMGUI_API void          RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, ImGuiAlign align = ImGuiAlign_Default, const ImVec2* clip_min = NULL, const ImVec2* clip_max = NULL);
+    IMGUI_API void          RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
+    IMGUI_API void          RenderCollapseTriangle(ImVec2 p_min, bool opened, float scale = 1.0f, bool shadow = false);
+    IMGUI_API void          RenderCheckMark(ImVec2 pos, ImU32 col);
+
+    IMGUI_API bool          ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, bool allow_key_modifiers, ImGuiButtonFlags flags = 0);
+    IMGUI_API bool          ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0);
+
+    IMGUI_API bool          SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, bool horizontal);
+    IMGUI_API bool          SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power);
+    IMGUI_API bool          SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format);
+
+    IMGUI_API bool          DragBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_speed, float v_min, float v_max, int decimal_precision, float power);
+    IMGUI_API bool          DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* display_format, float power);
+    IMGUI_API bool          DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format);
+
+    IMGUI_API bool          InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
+    IMGUI_API bool          InputFloatN(const char* label, float* v, int components, int decimal_precision, ImGuiInputTextFlags extra_flags);
+    IMGUI_API bool          InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags);
+    IMGUI_API bool          InputScalarEx(const char* label, ImGuiDataType data_type, void* data_ptr, void* step_ptr, void* step_fast_ptr, const char* scalar_format, ImGuiInputTextFlags extra_flags);
+    IMGUI_API bool          InputScalarAsWidgetReplacement(const ImRect& aabb, const char* label, ImGuiDataType data_type, void* data_ptr, ImGuiID id, int decimal_precision);
+
+    IMGUI_API void          PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size);
+
+    IMGUI_API int           ParseFormatPrecision(const char* fmt, int default_value);
+    IMGUI_API float         RoundScalar(float value, int decimal_precision);
+
+} // namespace ImGuiP
+

stb_textedit.h

@@ -1,3 +1,6 @@
+// [ImGui] this is a slightly modified version of stb_truetype.h 1.4
+// [ImGui] we made a fix for using the END key on multi-line text edit, see https://github.com/ocornut/imgui/issues/275
+
 // stb_textedit.h - v1.4  - public domain - Sean Barrett
 // Development of this library was sponsored by RAD Game Tools
 //
@@ -957,6 +960,8 @@ retry:
          stb_textedit_move_to_first(state);
          stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
          state->cursor = find.first_char + find.length;
+         if (find.length > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) == STB_TEXTEDIT_NEWLINE)
+            state->cursor--;
          state->has_preferred_x = 0;
          break;
       }
@@ -977,6 +982,8 @@ retry:
          stb_textedit_prep_selection_at_cursor(state);
          stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
          state->cursor = state->select_end = find.first_char + find.length;
+         if (find.length > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) == STB_TEXTEDIT_NEWLINE)
+            state->cursor = state->select_end = state->cursor - 1;
          state->has_preferred_x = 0;
          break;
       }