branches/kale/3rdparty/bgfx/3rdparty/ocornut-imgui/imgui.cpp
| r244546 | r244547 | |
|---|
| 1 | | // ImGui library v1.30 |
| 1 | // ImGui library v1.32 wip |
| 2 | 2 | // See ImGui::ShowTestWindow() for sample code. |
| 3 | 3 | // Read 'Programmer guide' below for notes on how to setup ImGui in your codebase. |
| 4 | 4 | // Get latest version at https://github.com/ocornut/imgui |
| r244546 | r244547 | |
|---|
| 17 | 17 | - SAMPLE CODE |
| 18 | 18 | - FONT DATA |
| 19 | 19 | |
| 20 | | |
| 20 | |
| 21 | 21 | MISSION STATEMENT |
| 22 | 22 | ================= |
| 23 | 23 | |
| r244546 | r244547 | |
|---|
| 35 | 35 | - doesn't look fancy, doesn't animate |
| 36 | 36 | - limited layout features, intricate layouts are typically crafted in code |
| 37 | 37 | - occasionally use statically sized buffers for string manipulations - won't crash, but some long text may be clipped |
| 38 | | |
| 39 | 38 | |
| 39 | |
| 40 | 40 | END-USER GUIDE |
| 41 | 41 | ============== |
| 42 | 42 | |
| r244546 | r244547 | |
|---|
| 66 | 66 | - your code creates the UI, if your code doesn't run the UI is gone! == dynamic UI, no construction step, less data retention on your side, no state duplication, less sync, less errors. |
| 67 | 67 | - call and read ImGui::ShowTestWindow() for user-side sample code |
| 68 | 68 | - see examples/ folder for standalone sample applications. |
| 69 | | - customization: use the style editor to tweak the look of the interface (e.g. if you want a more compact UI or a different color scheme), and report values in your code. |
| 69 | - customization: use the style editor or PushStyleColor/PushStyleVar to tweak the look of the interface (e.g. if you want a more compact UI or a different color scheme). |
| 70 | 70 | |
| 71 | |
| 71 | 72 | - getting started: |
| 72 | 73 | - initialisation: call ImGui::GetIO() and fill the 'Settings' data. |
| 73 | | - every frame: |
| 74 | - every frame: |
| 74 | 75 | 1/ in your mainloop or right after you got your keyboard/mouse info, call ImGui::GetIO() and fill the 'Input' data, then call ImGui::NewFrame(). |
| 75 | 76 | 2/ use any ImGui function you want between NewFrame() and Render() |
| 76 | 77 | 3/ ImGui::Render() to render all the accumulated command-lists. it will call your RenderDrawListFn handler that you set in the IO structure. |
| r244546 | r244547 | |
|---|
| 91 | 92 | unsigned char* pixels; |
| 92 | 93 | int width, height, bytes_per_pixels; |
| 93 | 94 | io.Fonts->GetTexDataAsRGBA32(pixels, &width, &height, &bytes_per_pixels); |
| 94 | | // TODO: copy texture to graphics memory. |
| 95 | // TODO: copy texture to graphics memory. |
| 95 | 96 | // TODO: store your texture pointer/identifier in 'io.Fonts->TexID' |
| 96 | 97 | |
| 97 | 98 | // Application main loop |
| r244546 | r244547 | |
|---|
| 99 | 100 | { |
| 100 | 101 | // 1) get low-level input |
| 101 | 102 | // e.g. on Win32, GetKeyboardState(), or poll your events, etc. |
| 102 | | |
| 103 | |
| 103 | 104 | // 2) TODO: fill all fields of IO structure and call NewFrame |
| 104 | 105 | ImGuiIO& io = ImGui::GetIO(); |
| 105 | | io.MousePos = ... |
| 106 | io.MousePos = mouse_pos; |
| 107 | io.MouseDown[0] = mouse_button_0; |
| 106 | 108 | io.KeysDown[i] = ... |
| 107 | 109 | ImGui::NewFrame(); |
| 108 | 110 | |
| r244546 | r244547 | |
|---|
| 118 | 120 | // swap video buffer, etc. |
| 119 | 121 | } |
| 120 | 122 | |
| 121 | | - after calling ImGui::NewFrame() you can read back 'io.WantCaptureMouse' and 'io.WantCaptureKeyboard' to tell |
| 122 | | if ImGui wants to use your inputs. so typically can hide the mouse inputs from the rest of your application if ImGui is using it. |
| 123 | - after calling ImGui::NewFrame() you can read back 'io.WantCaptureMouse' and 'io.WantCaptureKeyboard' to tell if ImGui |
| 124 | wants to use your inputs. if it does you can discard/hide the inputs from the rest of your application. |
| 123 | 125 | |
| 124 | | |
| 125 | 126 | API BREAKING CHANGES |
| 126 | 127 | ==================== |
| 127 | 128 | |
| 128 | 129 | Occasionally introducing changes that are breaking the API. The breakage are generally minor and easy to fix. |
| 129 | 130 | Here is a change-log of API breaking changes, if you are using one of the functions listed, expect to have to fix some code. |
| 130 | | |
| 131 | |
| 132 | - 2015/02/10 (1.32) - renamed GetItemWidth() to CalcItemWidth() to clarify its evolving behavior |
| 133 | - 2015/02/08 (1.31) - renamed GetTextLineSpacing() to GetTextLineHeightWithSpacing() |
| 134 | - 2015/02/01 (1.31) - removed IO.MemReallocFn (unused) |
| 131 | 135 | - 2015/01/19 (1.30) - renamed ImGuiStorage::GetIntPtr()/GetFloatPtr() to GetIntRef()/GetIntRef() because Ptr was conflicting with actual pointer storage functions. |
| 132 | 136 | - 2015/01/11 (1.30) - big font/image API change! now loads TTF file. allow for multiple fonts. no need for a PNG loader. |
| 133 | 137 | (1.30) - removed GetDefaultFontData(). uses io.Fonts->GetTextureData*() API to retrieve uncompressed pixels. |
| r244546 | r244547 | |
|---|
| 167 | 171 | - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f) |
| 168 | 172 | |
| 169 | 173 | If you are confused about the meaning or use of ID in ImGui: |
| 170 | | - some widgets requires state to be carried over multiple frames (most typically ImGui often wants remember what is the "active" widget). |
| 174 | - many widgets requires state to be carried over multiple frames (most typically ImGui often wants remember what is the "active" widget). |
| 171 | 175 | to do so they need an unique ID. unique ID are typically derived from a string label, an indice or a pointer. |
| 172 | 176 | when you call Button("OK") the button shows "OK" and also use "OK" as an ID. |
| 173 | 177 | - ID are uniquely scoped within Windows so no conflict can happen if you have two buttons called "OK" in two different Windows. |
| 174 | | within a same Window, use PushID() / PopID() to easily create scopes and avoid ID conflicts. |
| 178 | within a same Window, use PushID() / PopID() to easily create scopes and avoid ID conflicts. |
| 175 | 179 | so if you have a loop creating "multiple" items, you can use PushID() / PopID() with the index of each item, or their pointer, etc. |
| 176 | 180 | some functions like TreeNode() implicitly creates a scope for you by calling PushID() |
| 177 | 181 | - when dealing with trees, ID are important because you want to preserve the opened/closed state of tree nodes. |
| 178 | 182 | depending on your use cases you may want to use strings, indices or pointers as ID. experiment and see what makes more sense! |
| 179 | | e.g. When displaying a single object, using a static string as ID will preserve your node open/closed state when the targeted object change |
| 183 | e.g. When displaying a single object that may change over time, using a static string as ID will preserve your node open/closed state when the targeted object change |
| 180 | 184 | e.g. When displaying a list of objects, using indices or pointers as ID will preserve the node open/closed state per object |
| 181 | 185 | - when passing a label you can optionally specify extra unique ID information within the same string using "##". This helps solving the simpler collision cases. |
| 182 | 186 | e.g. "Label" display "Label" and uses "Label" as ID |
| 183 | 187 | e.g. "Label##Foobar" display "Label" and uses "Label##Foobar" as ID |
| 184 | 188 | e.g. "##Foobar" display an empty label and uses "##Foobar" as ID |
| 185 | | - read articles about the imgui principles (see web links) to understand the requirement and use of ID. |
| 189 | - read articles about immediate-mode ui principles (see web links) to understand the requirement and use of ID. |
| 186 | 190 | |
| 187 | 191 | If you want to load a different font than the default (ProggyClean.ttf, size 13) |
| 188 | 192 | |
| r244546 | r244547 | |
|---|
| 193 | 197 | |
| 194 | 198 | ImFont* font0 = io.Fonts->AddFontDefault(); |
| 195 | 199 | ImFont* font1 = io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels); |
| 200 | ImFont* font2 = io.Fonts->AddFontFromFileTTF("myfontfile2.ttf", size_in_pixels); |
| 196 | 201 | io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8() |
| 197 | 202 | |
| 198 | 203 | If you want to display Chinese, Japanese, Korean characters, pass custom Unicode ranges when loading a font: |
| r244546 | r244547 | |
|---|
| 224 | 229 | // Set pointer to handler in ImGuiIO structure |
| 225 | 230 | io.ImeSetInputScreenPosFn = ImImpl_ImeSetInputScreenPosFn; |
| 226 | 231 | |
| 227 | | - tip: the construct 'IMGUI_ONCE_UPON_A_FRAME { ... }' will evaluate to a block of code only once a frame. You can use it to quickly add custom UI in the middle of a deep nested inner loop in your code. |
| 228 | | - tip: you can call Render() multiple times (e.g for VR renders), up to you to communicate the extra state to your RenderDrawListFn function. |
| 232 | - tip: the construct 'IMGUI_ONCE_UPON_A_FRAME { ... }' will run the block of code only once a frame. You can use it to quickly add custom UI in the middle of a deep nested inner loop in your code. |
| 229 | 233 | - tip: you can create widgets without a Begin()/End() block, they will go in an implicit window called "Debug" |
| 234 | - tip: you can call Begin() multiple times with the same name during the same frame, it will keep appending to the same window. |
| 235 | - tip: you can call Render() multiple times (e.g for VR renders). |
| 230 | 236 | - tip: call and read the ShowTestWindow() code for more example of how to use ImGui! |
| 231 | 237 | |
| 232 | 238 | |
| r244546 | r244547 | |
|---|
| 234 | 240 | ================== |
| 235 | 241 | |
| 236 | 242 | - misc: merge or clarify ImVec4 / ImGuiAabb, they are essentially duplicate containers |
| 237 | | !- i/o: avoid requesting mouse capture if button held and initial click was out of reach for imgui |
| 238 | 243 | - window: add horizontal scroll |
| 239 | 244 | - window: fix resize grip rendering scaling along with Rounding style setting |
| 240 | 245 | - window: autofit feedback loop when user relies on any dynamic layout (window width multiplier, column). maybe just clearly drop manual autofit? |
| 241 | | - window: add a way for very transient windows (non-saved, temporary overlay over hundreds of objects) to "clean" up from the global window list. |
| 246 | - window: add a way for very transient windows (non-saved, temporary overlay over hundreds of objects) to "clean" up from the global window list. |
| 242 | 247 | - window: allow resizing of child windows (possibly given min/max for each axis?) |
| 243 | 248 | - window: background options for child windows, border option (disable rounding) |
| 244 | 249 | - window: resizing from any sides? + mouse cursor directives for app. |
| 250 | - widgets: clicking on widget b while widget a should activate widget b (doesn't anymore because of hover capture) |
| 245 | 251 | - widgets: display mode: widget-label, label-widget (aligned on column or using fixed size), label-newline-tab-widget etc. |
| 246 | 252 | - widgets: clip text? hover clipped text shows it in a tooltip or in-place overlay |
| 247 | | - main: considering adding EndFrame() - optional, else done in Render(). and Init() |
| 253 | - main: considering adding EndFrame()/Init(). some constructs are awkward in the implementation because of the lack of them. |
| 248 | 254 | - main: IsItemHovered() returns true even if mouse is active on another widget (e.g. dragging outside of sliders). Maybe not a sensible default? Add parameter or alternate function? |
| 249 | 255 | - main: IsItemHovered() make it more consistent for various type of widgets, widgets with multiple components, etc. also effectively IsHovered() region sometimes differs from hot region, e.g tree nodes |
| 250 | 256 | - main: IsItemHovered() info stored in a stack? so that 'if TreeNode() { Text; TreePop; } if IsHovered' return the hover state of the TreeNode? |
| r244546 | r244547 | |
|---|
| 256 | 262 | - input number: use mouse wheel to step up/down |
| 257 | 263 | - input number: non-decimal input. |
| 258 | 264 | - layout: horizontal layout helper (github issue #97) |
| 265 | - layout: more generic alignment state (left/right/centered) for single items? |
| 259 | 266 | - layout: clean up the InputFloatN/SliderFloatN/ColorEdit4 layout code. item width should include frame padding. |
| 260 | 267 | - columns: separator function or parameter that works within the column (currently Separator() bypass all columns) |
| 261 | 268 | - columns: declare column set (each column: fixed size, %, fill, distribute default size among fills) |
| 262 | 269 | - columns: columns header to act as button (~sort op) and allow resize/reorder |
| 263 | 270 | - columns: user specify columns size |
| 264 | 271 | - combo: turn child handling code into pop up helper |
| 265 | | - list selection, concept of a selectable "block" (that can be multiple widgets) |
| 266 | | - menubar, menus |
| 272 | - combo: contents should extends to fit label if combo widget is small |
| 273 | - listbox: multiple selection |
| 274 | - listbox: user may want to initial scroll to focus on the one selected value? |
| 275 | ! menubar, menus |
| 267 | 276 | - tabs |
| 268 | 277 | - gauge: various forms of gauge/loading bars widgets |
| 269 | 278 | - color: better color editor. |
| 270 | | - plot: make it easier for user to draw into the graph (e.g: draw basis, highlight certain points, 2d plots, multiple plots) |
| 271 | | - plot: "smooth" automatic scale, user give an input 0.0(full user scale) 1.0(full derived from value) |
| 279 | - plot: make it easier for user to draw extra stuff into the graph (e.g: draw basis, highlight certain points, 2d plots, multiple plots) |
| 280 | - plot: "smooth" automatic scale over time, user give an input 0.0(full user scale) 1.0(full derived from value) |
| 272 | 281 | - plot: add a helper e.g. Plot(char* label, float value, float time_span=2.0f) that stores values and Plot them for you - probably another function name. and/or automatically allow to plot ANY displayed value (more reliance on stable ID) |
| 273 | | - file selection widget -> build the tool in our codebase to improve model-dialog idioms (may or not lead to ImGui changes) |
| 282 | - file selection widget -> build the tool in our codebase to improve model-dialog idioms |
| 274 | 283 | - slider: allow using the [-]/[+] buttons used by InputFloat()/InputInt() |
| 275 | 284 | - slider: initial absolute click is imprecise. change to relative movement slider? hide mouse cursor, allow more precise input using less screen-space. |
| 276 | | - text edit: clean up the mess caused by converting UTF-8 <> wchar |
| 277 | | - text edit: centered text for slider or input text to it matches typical positioning. |
| 278 | | - text edit: flag to disable live update of the user buffer. |
| 285 | - text edit: clean up the mess caused by converting UTF-8 <> wchar. the code is rather ineficient right now. |
| 286 | - text edit: centered text for slider as input text so it matches typical positioning. |
| 287 | - text edit: flag to disable live update of the user buffer. |
| 279 | 288 | - text edit: field resize behavior - field could stretch when being edited? hover tooltip shows more text? |
| 280 | 289 | - text edit: add multi-line text edit |
| 281 | 290 | - tree: add treenode/treepush int variants? because (void*) cast from int warns on some platforms/settings |
| 282 | 291 | - settings: write more decent code to allow saving/loading new fields |
| 283 | 292 | - settings: api for per-tool simple persistent data (bool,int,float) in .ini file |
| 284 | | ! style: store rounded corners in texture to use 1 quad per corner (filled and wireframe). |
| 285 | | - style: checkbox: padding for "active" color should be a multiplier of the |
| 293 | ! style: store rounded corners in texture to use 1 quad per corner (filled and wireframe). so rounding have minor cost. |
| 294 | - style: checkbox: padding for "active" color should be a multiplier of the |
| 286 | 295 | - style: colorbox not always square? |
| 287 | 296 | - log: LogButtons() options for specifying depth and/or hiding depth slider |
| 288 | 297 | - log: have more control over the log scope (e.g. stop logging when leaving current tree node scope) |
| r244546 | r244547 | |
|---|
| 299 | 308 | - misc: mark printf compiler attributes on relevant functions |
| 300 | 309 | - misc: provide a way to compile out the entire implementation while providing a dummy API (e.g. #define IMGUI_DUMMY_IMPL) |
| 301 | 310 | - misc: double-clicking on title bar to minimize isn't consistent, perhaps move to single-click on left-most collapse icon? |
| 311 | - style editor: have a more global HSV setter (e.g. alter hue on all elements). consider replacing active/hovered by offset in HSV space? |
| 302 | 312 | - style editor: color child window height expressed in multiple of line height. |
| 303 | 313 | - optimization/render: use indexed rendering to reduce vertex data cost (for remote/networked imgui) |
| 304 | | - optimization/render: move clip-rect to vertex data? would allow merging all commands |
| 305 | 314 | - optimization/render: merge command-lists with same clip-rect into one even if they aren't sequential? (as long as in-between clip rectangle don't overlap)? |
| 306 | 315 | - optimization: turn some the various stack vectors into statically-sized arrays |
| 307 | 316 | - optimization: better clipping for multi-component widgets |
| r244546 | r244547 | |
|---|
| 320 | 329 | #include <new> // new (ptr) |
| 321 | 330 | |
| 322 | 331 | #ifdef _MSC_VER |
| 323 | | #pragma warning (disable: 4505) // unreferenced local function has been removed |
| 332 | #pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff) |
| 324 | 333 | #pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen |
| 325 | 334 | #endif |
| 326 | 335 | |
| r244546 | r244547 | |
|---|
| 392 | 401 | // Forward Declarations |
| 393 | 402 | //------------------------------------------------------------------------- |
| 394 | 403 | |
| 395 | | static bool ButtonBehaviour(const ImGuiAabb& bb, const ImGuiID& id, bool* out_hovered, bool* out_held, bool allow_key_modifiers, bool repeat = false); |
| 404 | struct ImGuiAabb; |
| 405 | |
| 406 | static bool ButtonBehaviour(const ImGuiAabb& bb, const ImGuiID& id, bool* out_hovered, bool* out_held, bool allow_key_modifiers, bool repeat = false, bool pressed_on_click = false); |
| 396 | 407 | static void LogText(const ImVec2& ref_pos, const char* text, const char* text_end = NULL); |
| 397 | 408 | |
| 398 | | static void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true, float wrap_width = 0.0f); |
| 409 | static void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true); |
| 410 | static void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width); |
| 411 | static void RenderTextClipped(ImVec2 pos, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& clip_max); |
| 399 | 412 | static void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f); |
| 400 | 413 | static void RenderCollapseTriangle(ImVec2 p_min, bool opened, float scale = 1.0f, bool shadow = false); |
| 401 | 414 | |
| r244546 | r244547 | |
|---|
| 463 | 476 | WindowPadding = ImVec2(8,8); // Padding within a window |
| 464 | 477 | WindowMinSize = ImVec2(32,32); // Minimum window size |
| 465 | 478 | WindowRounding = 9.0f; // Radius of window corners rounding. Set to 0.0f to have rectangular windows |
| 479 | ChildWindowRounding = 0.0f; // Radius of child window corners rounding. Set to 0.0f to have rectangular windows |
| 466 | 480 | FramePadding = ImVec2(4,3); // Padding within a framed rectangle (used by most widgets) |
| 467 | 481 | FrameRounding = 0.0f; // Radius of frame corners rounding. Set to 0.0f to have rectangular frames (used by most widgets). |
| 468 | 482 | ItemSpacing = ImVec2(8,4); // Horizontal and vertical spacing between widgets/lines |
| r244546 | r244547 | |
|---|
| 476 | 490 | |
| 477 | 491 | Colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f); |
| 478 | 492 | Colors[ImGuiCol_WindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f); |
| 493 | Colors[ImGuiCol_ChildWindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); |
| 479 | 494 | Colors[ImGuiCol_Border] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f); |
| 480 | 495 | Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.60f); |
| 481 | 496 | Colors[ImGuiCol_FrameBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.30f); // Background of checkbox, radio button, plot, slider, text input |
| r244546 | r244547 | |
|---|
| 496 | 511 | Colors[ImGuiCol_ButtonActive] = ImVec4(0.80f, 0.50f, 0.50f, 1.00f); |
| 497 | 512 | Colors[ImGuiCol_Header] = ImVec4(0.40f, 0.40f, 0.90f, 0.45f); |
| 498 | 513 | Colors[ImGuiCol_HeaderHovered] = ImVec4(0.45f, 0.45f, 0.90f, 0.80f); |
| 499 | | Colors[ImGuiCol_HeaderActive] = ImVec4(0.60f, 0.60f, 0.80f, 1.00f); |
| 514 | Colors[ImGuiCol_HeaderActive] = ImVec4(0.53f, 0.53f, 0.87f, 0.80f); |
| 500 | 515 | Colors[ImGuiCol_Column] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f); |
| 501 | 516 | Colors[ImGuiCol_ColumnHovered] = ImVec4(0.60f, 0.40f, 0.40f, 1.00f); |
| 502 | 517 | Colors[ImGuiCol_ColumnActive] = ImVec4(0.80f, 0.50f, 0.50f, 1.00f); |
| r244546 | r244547 | |
|---|
| 539 | 554 | // User functions |
| 540 | 555 | RenderDrawListsFn = NULL; |
| 541 | 556 | MemAllocFn = malloc; |
| 542 | | MemReallocFn = realloc; |
| 543 | 557 | MemFreeFn = free; |
| 544 | 558 | GetClipboardTextFn = GetClipboardTextFn_DefaultImpl; // Platform dependent default implementations |
| 545 | 559 | SetClipboardTextFn = SetClipboardTextFn_DefaultImpl; |
| r244546 | r244547 | |
|---|
| 600 | 614 | static inline float ImMax(float lhs, float rhs) { return lhs >= rhs ? lhs : rhs; } |
| 601 | 615 | static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(ImMin(lhs.x,rhs.x), ImMin(lhs.y,rhs.y)); } |
| 602 | 616 | static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(ImMax(lhs.x,rhs.x), ImMax(lhs.y,rhs.y)); } |
| 603 | | static inline float ImClamp(float f, float mn, float mx) { return (f < mn) ? mn : (f > mx) ? mx : f; } |
| 617 | static inline int ImClamp(int v, int mn, int mx) { return (v < mn) ? mn : (v > mx) ? mx : v; } |
| 618 | static inline float ImClamp(float v, float mn, float mx) { return (v < mn) ? mn : (v > mx) ? mx : v; } |
| 604 | 619 | 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)); } |
| 605 | 620 | static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; } |
| 606 | 621 | static inline float ImLerp(float a, float b, float t) { return a + (b - a) * t; } |
| r244546 | r244547 | |
|---|
| 660 | 675 | } |
| 661 | 676 | |
| 662 | 677 | // Pass data_size==0 for zero-terminated string |
| 663 | | static ImU32 ImCrc32(const void* data, size_t data_size, ImU32 seed = 0) |
| 664 | | { |
| 678 | static ImU32 ImCrc32(const void* data, size_t data_size, ImU32 seed = 0) |
| 679 | { |
| 665 | 680 | static ImU32 crc32_lut[256] = { 0 }; |
| 666 | 681 | if (!crc32_lut[1]) |
| 667 | 682 | { |
| 668 | 683 | const ImU32 polynomial = 0xEDB88320; |
| 669 | | for (ImU32 i = 0; i < 256; i++) |
| 670 | | { |
| 671 | | ImU32 crc = i; |
| 672 | | for (ImU32 j = 0; j < 8; j++) |
| 673 | | crc = (crc >> 1) ^ (ImU32(-int(crc & 1)) & polynomial); |
| 674 | | crc32_lut[i] = crc; |
| 684 | for (ImU32 i = 0; i < 256; i++) |
| 685 | { |
| 686 | ImU32 crc = i; |
| 687 | for (ImU32 j = 0; j < 8; j++) |
| 688 | crc = (crc >> 1) ^ (ImU32(-int(crc & 1)) & polynomial); |
| 689 | crc32_lut[i] = crc; |
| 675 | 690 | } |
| 676 | 691 | } |
| 677 | | ImU32 crc = ~seed; |
| 692 | ImU32 crc = ~seed; |
| 678 | 693 | const unsigned char* current = (const unsigned char*)data; |
| 679 | 694 | |
| 680 | 695 | if (data_size > 0) |
| 681 | 696 | { |
| 682 | 697 | // Known size |
| 683 | | while (data_size--) |
| 684 | | crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *current++]; |
| 698 | while (data_size--) |
| 699 | crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *current++]; |
| 685 | 700 | } |
| 686 | 701 | else |
| 687 | 702 | { |
| 688 | 703 | // Zero-terminated string |
| 689 | 704 | while (unsigned char c = *current++) |
| 690 | | crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c]; |
| 705 | crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c]; |
| 691 | 706 | } |
| 692 | | return ~crc; |
| 693 | | } |
| 707 | return ~crc; |
| 708 | } |
| 694 | 709 | |
| 695 | 710 | static size_t ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) |
| 696 | 711 | { |
| r244546 | r244547 | |
|---|
| 743 | 758 | // Convert hsv floats ([0-1],[0-1],[0-1]) to rgb floats ([0-1],[0-1],[0-1]), from Foley & van Dam p593 |
| 744 | 759 | // also http://en.wikipedia.org/wiki/HSL_and_HSV |
| 745 | 760 | void ImGui::ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b) |
| 746 | | { |
| 761 | { |
| 747 | 762 | if (s == 0.0f) |
| 748 | 763 | { |
| 749 | 764 | // gray |
| r244546 | r244547 | |
|---|
| 868 | 883 | bool LastItemHovered; |
| 869 | 884 | ImVector<ImGuiWindow*> ChildWindows; |
| 870 | 885 | ImVector<bool> AllowKeyboardFocus; |
| 871 | | ImVector<float> ItemWidth; |
| 886 | ImVector<float> ItemWidth; // 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window |
| 872 | 887 | ImVector<float> TextWrapPos; |
| 873 | 888 | ImGuiColorEditMode ColorEditMode; |
| 874 | 889 | ImGuiStorage* StateStorage; |
| 875 | | int OpenNextNode; |
| 890 | int OpenNextNode; // FIXME: Reformulate this feature like SetNextWindowCollapsed() API |
| 876 | 891 | |
| 877 | 892 | float ColumnsStartX; // Start position from left of window (increased by TreePush/TreePop, etc.) |
| 878 | 893 | 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. |
| r244546 | r244547 | |
|---|
| 986 | 1001 | |
| 987 | 1002 | // Render |
| 988 | 1003 | ImVector<ImDrawList*> RenderDrawLists; |
| 1004 | ImVector<ImGuiWindow*> RenderSortedWindows; |
| 989 | 1005 | |
| 990 | 1006 | // Widget state |
| 991 | 1007 | ImGuiTextEditState InputTextState; |
| r244546 | r244547 | |
|---|
| 1032 | 1048 | } |
| 1033 | 1049 | }; |
| 1034 | 1050 | |
| 1035 | | static ImGuiState GImGui; |
| 1051 | static ImGuiState GImDefaultState; // Internal state storage |
| 1052 | static ImGuiState* GImGui = &GImDefaultState; // We access everything through this pointer. NB: this pointer is always assumed to be != NULL |
| 1036 | 1053 | |
| 1037 | 1054 | struct ImGuiWindow |
| 1038 | 1055 | { |
| r244546 | r244547 | |
|---|
| 1053 | 1070 | bool SkipItems; // == Visible && !Collapsed |
| 1054 | 1071 | int AutoFitFrames; |
| 1055 | 1072 | bool AutoFitOnlyGrows; |
| 1056 | | int SetWindowPosAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowPos() call is allowed with this particular flag. |
| 1057 | | int SetWindowSizeAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowSize() call is allowed with this particular flag. |
| 1058 | | int SetWindowCollapsedAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowCollapsed() call is allowed with this particular flag. |
| 1073 | int SetWindowPosAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowPos() call is allowed with this particular flag. |
| 1074 | int SetWindowSizeAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowSize() call is allowed with this particular flag. |
| 1075 | int SetWindowCollapsedAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowCollapsed() call is allowed with this particular flag. |
| 1059 | 1076 | |
| 1060 | 1077 | ImGuiDrawContext DC; |
| 1061 | 1078 | ImVector<ImGuiID> IDStack; |
| 1062 | | ImVector<ImVec4> ClipRectStack; |
| 1079 | ImVector<ImVec4> ClipRectStack; // Scissoring / clipping rectangle. x1, y1, x2, y2. |
| 1063 | 1080 | int LastFrameDrawn; |
| 1064 | 1081 | float ItemWidthDefault; |
| 1065 | 1082 | ImGuiStorage StateStorage; |
| r244546 | r244547 | |
|---|
| 1087 | 1104 | void FocusItemUnregister(); |
| 1088 | 1105 | |
| 1089 | 1106 | ImGuiAabb Aabb() const { return ImGuiAabb(Pos, Pos+Size); } |
| 1090 | | ImFont* Font() const { return GImGui.Font; } |
| 1091 | | float FontSize() const { return GImGui.FontSize * FontWindowScale; } |
| 1107 | ImFont* Font() const { return GImGui->Font; } |
| 1108 | float FontSize() const { return GImGui->FontSize * FontWindowScale; } |
| 1092 | 1109 | ImVec2 CursorPos() const { return DC.CursorPos; } |
| 1093 | | float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0 : FontSize() + GImGui.Style.FramePadding.y * 2.0f; } |
| 1110 | float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0 : FontSize() + GImGui->Style.FramePadding.y * 2.0f; } |
| 1094 | 1111 | ImGuiAabb TitleBarAabb() const { return ImGuiAabb(Pos, Pos + ImVec2(SizeFull.x, TitleBarHeight())); } |
| 1095 | | ImVec2 WindowPadding() const { return ((Flags & ImGuiWindowFlags_ChildWindow) && !(Flags & ImGuiWindowFlags_ShowBorders)) ? ImVec2(1,1) : GImGui.Style.WindowPadding; } |
| 1096 | | 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); } |
| 1097 | | ImU32 Color(const ImVec4& col) const { ImVec4 c = col; c.w *= GImGui.Style.Alpha; return ImGui::ColorConvertFloat4ToU32(c); } |
| 1112 | ImVec2 WindowPadding() const { return ((Flags & ImGuiWindowFlags_ChildWindow) && !(Flags & ImGuiWindowFlags_ShowBorders)) ? ImVec2(1,1) : GImGui->Style.WindowPadding; } |
| 1113 | 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); } |
| 1114 | ImU32 Color(const ImVec4& col) const { ImVec4 c = col; c.w *= GImGui->Style.Alpha; return ImGui::ColorConvertFloat4ToU32(c); } |
| 1098 | 1115 | }; |
| 1099 | 1116 | |
| 1100 | 1117 | static ImGuiWindow* GetCurrentWindow() |
| 1101 | 1118 | { |
| 1102 | | IM_ASSERT(GImGui.CurrentWindow != NULL); // ImGui::NewFrame() hasn't been called yet? |
| 1103 | | GImGui.CurrentWindow->Accessed = true; |
| 1104 | | return GImGui.CurrentWindow; |
| 1119 | ImGuiState& g = *GImGui; |
| 1120 | IM_ASSERT(g.CurrentWindow != NULL); // ImGui::NewFrame() hasn't been called yet? |
| 1121 | g.CurrentWindow->Accessed = true; |
| 1122 | return g.CurrentWindow; |
| 1105 | 1123 | } |
| 1106 | 1124 | |
| 1107 | | static void SetActiveId(ImGuiID id) |
| 1125 | static void SetActiveId(ImGuiID id) |
| 1108 | 1126 | { |
| 1109 | | GImGui.ActiveId = id; |
| 1127 | ImGuiState& g = *GImGui; |
| 1128 | g.ActiveId = id; |
| 1110 | 1129 | } |
| 1111 | 1130 | |
| 1112 | 1131 | static void RegisterAliveId(const ImGuiID& id) |
| 1113 | 1132 | { |
| 1114 | | if (GImGui.ActiveId == id) |
| 1115 | | GImGui.ActiveIdIsAlive = true; |
| 1133 | ImGuiState& g = *GImGui; |
| 1134 | if (g.ActiveId == id) |
| 1135 | g.ActiveIdIsAlive = true; |
| 1116 | 1136 | } |
| 1117 | 1137 | |
| 1118 | 1138 | //----------------------------------------------------------------------------- |
| r244546 | r244547 | |
|---|
| 1243 | 1263 | if (width < 0.0f) |
| 1244 | 1264 | { |
| 1245 | 1265 | ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true); |
| 1246 | | width = ImMax(window->Pos.x + ImGui::GetContentRegionMax().x - window->DC.CursorPos.x - (label_size.x + GImGui.Style.ItemSpacing.x*4), 10.0f); |
| 1266 | width = ImMax(window->Pos.x + ImGui::GetContentRegionMax().x - window->DC.CursorPos.x - (label_size.x + GImGui->Style.ItemSpacing.x*4), 10.0f); |
| 1247 | 1267 | } |
| 1248 | 1268 | ImGui::PushItemWidth(width); |
| 1249 | 1269 | ImGui::InputText(label, InputBuf, IM_ARRAYSIZE(InputBuf)); |
| r244546 | r244547 | |
|---|
| 1322 | 1342 | |
| 1323 | 1343 | //----------------------------------------------------------------------------- |
| 1324 | 1344 | |
| 1325 | | // On some platform vsnprintf() takes va_list by reference and modifies it. |
| 1345 | // On some platform vsnprintf() takes va_list by reference and modifies it. |
| 1326 | 1346 | // va_copy is the 'correct' way to copy a va_list but Visual Studio prior to 2013 doesn't have it. |
| 1327 | 1347 | #ifndef va_copy |
| 1328 | 1348 | #define va_copy(dest, src) (dest = src) |
| r244546 | r244547 | |
|---|
| 1363 | 1383 | ImGuiWindow::ImGuiWindow(const char* name) |
| 1364 | 1384 | { |
| 1365 | 1385 | Name = ImStrdup(name); |
| 1366 | | ID = GetID(name); |
| 1386 | ID = GetID(name); |
| 1367 | 1387 | IDStack.push_back(ID); |
| 1368 | 1388 | |
| 1369 | 1389 | PosFloat = Pos = ImVec2(0.0f, 0.0f); |
| r244546 | r244547 | |
|---|
| 1425 | 1445 | |
| 1426 | 1446 | bool ImGuiWindow::FocusItemRegister(bool is_active, bool tab_stop) |
| 1427 | 1447 | { |
| 1428 | | ImGuiState& g = GImGui; |
| 1448 | ImGuiState& g = *GImGui; |
| 1429 | 1449 | ImGuiWindow* window = GetCurrentWindow(); |
| 1430 | 1450 | |
| 1431 | 1451 | const bool allow_keyboard_focus = window->DC.AllowKeyboardFocus.back(); |
| r244546 | r244547 | |
|---|
| 1459 | 1479 | |
| 1460 | 1480 | void ImGuiWindow::AddToRenderList() |
| 1461 | 1481 | { |
| 1462 | | ImGuiState& g = GImGui; |
| 1482 | ImGuiState& g = *GImGui; |
| 1463 | 1483 | |
| 1464 | 1484 | if (!DrawList->commands.empty() && !DrawList->vtx_buffer.empty()) |
| 1465 | 1485 | { |
| r244546 | r244547 | |
|---|
| 1470 | 1490 | for (size_t i = 0; i < DC.ChildWindows.size(); i++) |
| 1471 | 1491 | { |
| 1472 | 1492 | ImGuiWindow* child = DC.ChildWindows[i]; |
| 1473 | | if (child->Visible) // clipped childs may have been marked not Visible |
| 1493 | if (child->Visible) // clipped children may have been marked not Visible |
| 1474 | 1494 | child->AddToRenderList(); |
| 1475 | 1495 | } |
| 1476 | 1496 | } |
| r244546 | r244547 | |
|---|
| 1479 | 1499 | |
| 1480 | 1500 | void* ImGui::MemAlloc(size_t sz) |
| 1481 | 1501 | { |
| 1482 | | return GImGui.IO.MemAllocFn(sz); |
| 1502 | return GImGui->IO.MemAllocFn(sz); |
| 1483 | 1503 | } |
| 1484 | 1504 | |
| 1485 | 1505 | void ImGui::MemFree(void* ptr) |
| 1486 | 1506 | { |
| 1487 | | return GImGui.IO.MemFreeFn(ptr); |
| 1507 | return GImGui->IO.MemFreeFn(ptr); |
| 1488 | 1508 | } |
| 1489 | 1509 | |
| 1490 | | void* ImGui::MemRealloc(void* ptr, size_t sz) |
| 1491 | | { |
| 1492 | | return GImGui.IO.MemReallocFn(ptr, sz); |
| 1493 | | } |
| 1494 | | |
| 1495 | 1510 | static ImGuiIniData* FindWindowSettings(const char* name) |
| 1496 | 1511 | { |
| 1497 | | ImGuiState& g = GImGui; |
| 1512 | ImGuiState& g = *GImGui; |
| 1498 | 1513 | for (size_t i = 0; i != g.Settings.size(); i++) |
| 1499 | 1514 | { |
| 1500 | 1515 | ImGuiIniData* ini = g.Settings[i]; |
| r244546 | r244547 | |
|---|
| 1512 | 1527 | ini->Collapsed = false; |
| 1513 | 1528 | ini->Pos = ImVec2(FLT_MAX,FLT_MAX); |
| 1514 | 1529 | ini->Size = ImVec2(0,0); |
| 1515 | | GImGui.Settings.push_back(ini); |
| 1530 | GImGui->Settings.push_back(ini); |
| 1516 | 1531 | return ini; |
| 1517 | 1532 | } |
| 1518 | 1533 | |
| r244546 | r244547 | |
|---|
| 1520 | 1535 | // FIXME: Write something less rubbish |
| 1521 | 1536 | static void LoadSettings() |
| 1522 | 1537 | { |
| 1523 | | ImGuiState& g = GImGui; |
| 1538 | ImGuiState& g = *GImGui; |
| 1524 | 1539 | const char* filename = g.IO.IniFilename; |
| 1525 | 1540 | if (!filename) |
| 1526 | 1541 | return; |
| r244546 | r244547 | |
|---|
| 1537 | 1552 | const char* line_end = line_start; |
| 1538 | 1553 | while (line_end < buf_end && *line_end != '\n' && *line_end != '\r') |
| 1539 | 1554 | line_end++; |
| 1540 | | |
| 1555 | |
| 1541 | 1556 | if (line_start[0] == '[' && line_end > line_start && line_end[-1] == ']') |
| 1542 | 1557 | { |
| 1543 | 1558 | char name[64]; |
| r244546 | r244547 | |
|---|
| 1566 | 1581 | |
| 1567 | 1582 | static void SaveSettings() |
| 1568 | 1583 | { |
| 1569 | | ImGuiState& g = GImGui; |
| 1584 | ImGuiState& g = *GImGui; |
| 1570 | 1585 | const char* filename = g.IO.IniFilename; |
| 1571 | 1586 | if (!filename) |
| 1572 | 1587 | return; |
| r244546 | r244547 | |
|---|
| 1605 | 1620 | |
| 1606 | 1621 | static void MarkSettingsDirty() |
| 1607 | 1622 | { |
| 1608 | | ImGuiState& g = GImGui; |
| 1623 | ImGuiState& g = *GImGui; |
| 1609 | 1624 | |
| 1610 | 1625 | if (g.SettingsDirtyTimer <= 0.0f) |
| 1611 | 1626 | g.SettingsDirtyTimer = g.IO.IniSavingRate; |
| 1612 | 1627 | } |
| 1613 | 1628 | |
| 1629 | // Internal state access - if you want to share ImGui state between modules (e.g. DLL) or allocate it yourself |
| 1630 | // Note that we still point to some static data and members (such as GFontAtlas), so the state instance you end up using will point to the static data within its module |
| 1631 | void* ImGui::GetInternalState() |
| 1632 | { |
| 1633 | return GImGui; |
| 1634 | } |
| 1635 | |
| 1636 | size_t ImGui::GetInternalStateSize() |
| 1637 | { |
| 1638 | return sizeof(ImGuiState); |
| 1639 | } |
| 1640 | |
| 1641 | void ImGui::SetInternalState(void* state, bool construct) |
| 1642 | { |
| 1643 | if (construct) |
| 1644 | new (state) ImGuiState(); |
| 1645 | |
| 1646 | GImGui = (ImGuiState*)state; |
| 1647 | } |
| 1648 | |
| 1614 | 1649 | ImGuiIO& ImGui::GetIO() |
| 1615 | 1650 | { |
| 1616 | | return GImGui.IO; |
| 1651 | return GImGui->IO; |
| 1617 | 1652 | } |
| 1618 | 1653 | |
| 1619 | 1654 | ImGuiStyle& ImGui::GetStyle() |
| 1620 | 1655 | { |
| 1621 | | return GImGui.Style; |
| 1656 | return GImGui->Style; |
| 1622 | 1657 | } |
| 1623 | 1658 | |
| 1624 | 1659 | void ImGui::NewFrame() |
| 1625 | 1660 | { |
| 1626 | | ImGuiState& g = GImGui; |
| 1661 | ImGuiState& g = *GImGui; |
| 1627 | 1662 | |
| 1628 | 1663 | // Check user data |
| 1629 | 1664 | IM_ASSERT(g.IO.DeltaTime > 0.0f); |
| r244546 | r244547 | |
|---|
| 1702 | 1737 | else |
| 1703 | 1738 | g.HoveredRootWindow = FindHoveredWindow(g.IO.MousePos, true); |
| 1704 | 1739 | |
| 1705 | | // Are we using inputs? Tell user so they can capture/discard them. |
| 1706 | | g.IO.WantCaptureMouse = (g.HoveredWindow != NULL) || (g.ActiveId != 0); |
| 1740 | // Are we using inputs? Tell user so they can capture/discard the inputs away from the rest of their application. |
| 1741 | // When clicking outside of a window we assume the click is owned by the application and won't request capture. |
| 1742 | int mouse_earliest_button_down = -1; |
| 1743 | for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++) |
| 1744 | { |
| 1745 | if (g.IO.MouseClicked[i]) |
| 1746 | g.IO.MouseDownOwned[i] = (g.HoveredWindow != NULL); |
| 1747 | if (g.IO.MouseDown[i]) |
| 1748 | if (mouse_earliest_button_down == -1 || g.IO.MouseClickedTime[mouse_earliest_button_down] > g.IO.MouseClickedTime[i]) |
| 1749 | mouse_earliest_button_down = i; |
| 1750 | } |
| 1751 | bool mouse_owned_by_application = mouse_earliest_button_down != -1 && !g.IO.MouseDownOwned[mouse_earliest_button_down]; |
| 1752 | g.IO.WantCaptureMouse = (!mouse_owned_by_application && g.HoveredWindow != NULL) || (g.ActiveId != 0); |
| 1707 | 1753 | g.IO.WantCaptureKeyboard = (g.ActiveId != 0); |
| 1708 | 1754 | |
| 1755 | // If mouse was first clicked outside of ImGui bounds we also cancel out hovering. |
| 1756 | if (mouse_owned_by_application) |
| 1757 | g.HoveredWindow = g.HoveredRootWindow = NULL; |
| 1758 | |
| 1709 | 1759 | // Scale & Scrolling |
| 1710 | 1760 | if (g.HoveredWindow && g.IO.MouseWheel != 0.0f) |
| 1711 | 1761 | { |
| r244546 | r244547 | |
|---|
| 1756 | 1806 | |
| 1757 | 1807 | // No window should be open at the beginning of the frame. |
| 1758 | 1808 | // But in order to allow the user to call NewFrame() multiple times without calling Render(), we are doing an explicit clear. |
| 1759 | | g.CurrentWindowStack.clear(); |
| 1809 | g.CurrentWindowStack.resize(0); |
| 1760 | 1810 | |
| 1761 | 1811 | // Create implicit window - we will only render it if the user has added something to it. |
| 1762 | 1812 | ImGui::Begin("Debug", NULL, ImVec2(400,400)); |
| r244546 | r244547 | |
|---|
| 1765 | 1815 | // NB: behaviour of ImGui after Shutdown() is not tested/guaranteed at the moment. This function is merely here to free heap allocations. |
| 1766 | 1816 | void ImGui::Shutdown() |
| 1767 | 1817 | { |
| 1768 | | ImGuiState& g = GImGui; |
| 1818 | ImGuiState& g = *GImGui; |
| 1769 | 1819 | if (!g.Initialized) |
| 1770 | 1820 | return; |
| 1771 | 1821 | |
| r244546 | r244547 | |
|---|
| 1814 | 1864 | g.Initialized = false; |
| 1815 | 1865 | } |
| 1816 | 1866 | |
| 1867 | // FIXME: Add a more explicit sort order in the window structure. |
| 1868 | static int ChildWindowComparer(const void* lhs, const void* rhs) |
| 1869 | { |
| 1870 | const ImGuiWindow* a = *(const ImGuiWindow**)lhs; |
| 1871 | const ImGuiWindow* b = *(const ImGuiWindow**)rhs; |
| 1872 | if (int d = (a->Flags & ImGuiWindowFlags_Tooltip) - (b->Flags & ImGuiWindowFlags_Tooltip)) |
| 1873 | return d; |
| 1874 | if (int d = (a->Flags & ImGuiWindowFlags_ComboBox) - (b->Flags & ImGuiWindowFlags_ComboBox)) |
| 1875 | return d; |
| 1876 | return 0; |
| 1877 | } |
| 1878 | |
| 1817 | 1879 | static void AddWindowToSortedBuffer(ImGuiWindow* window, ImVector<ImGuiWindow*>& sorted_windows) |
| 1818 | 1880 | { |
| 1819 | 1881 | sorted_windows.push_back(window); |
| 1820 | 1882 | if (window->Visible) |
| 1821 | 1883 | { |
| 1822 | | for (size_t i = 0; i < window->DC.ChildWindows.size(); i++) |
| 1884 | const size_t count = window->DC.ChildWindows.size(); |
| 1885 | if (count > 1) |
| 1886 | qsort(window->DC.ChildWindows.begin(), count, sizeof(ImGuiWindow*), ChildWindowComparer); |
| 1887 | for (size_t i = 0; i < count; i++) |
| 1823 | 1888 | { |
| 1824 | 1889 | ImGuiWindow* child = window->DC.ChildWindows[i]; |
| 1825 | 1890 | if (child->Visible) |
| r244546 | r244547 | |
|---|
| 1835 | 1900 | ImVec4 cr = clip_rect; |
| 1836 | 1901 | if (clipped && !window->ClipRectStack.empty()) |
| 1837 | 1902 | { |
| 1838 | | // Clip to new clip rect |
| 1903 | // Clip with existing clip rect |
| 1839 | 1904 | const ImVec4 cur_cr = window->ClipRectStack.back(); |
| 1840 | 1905 | cr = ImVec4(ImMax(cr.x, cur_cr.x), ImMax(cr.y, cur_cr.y), ImMin(cr.z, cur_cr.z), ImMin(cr.w, cur_cr.w)); |
| 1841 | 1906 | } |
| r244546 | r244547 | |
|---|
| 1853 | 1918 | |
| 1854 | 1919 | void ImGui::Render() |
| 1855 | 1920 | { |
| 1856 | | ImGuiState& g = GImGui; |
| 1921 | ImGuiState& g = *GImGui; |
| 1857 | 1922 | IM_ASSERT(g.Initialized); // Forgot to call ImGui::NewFrame() |
| 1858 | 1923 | |
| 1859 | 1924 | const bool first_render_of_the_frame = (g.FrameCountRendered != g.FrameCount); |
| 1860 | 1925 | g.FrameCountRendered = g.FrameCount; |
| 1861 | | |
| 1926 | |
| 1862 | 1927 | if (first_render_of_the_frame) |
| 1863 | 1928 | { |
| 1864 | 1929 | // Hide implicit window if it hasn't been used |
| 1865 | | IM_ASSERT(g.CurrentWindowStack.size() == 1); // Mismatched Begin/End |
| 1930 | IM_ASSERT(g.CurrentWindowStack.size() == 1); // Mismatched Begin/End |
| 1866 | 1931 | if (g.CurrentWindow && !g.CurrentWindow->Accessed) |
| 1867 | 1932 | g.CurrentWindow->Visible = false; |
| 1868 | 1933 | ImGui::End(); |
| 1869 | 1934 | |
| 1870 | | // Select window for move/focus when we're done with all our widgets (we only consider non-childs windows here) |
| 1935 | // Select window for move/focus when we're done with all our widgets (we only consider non-child windows here) |
| 1871 | 1936 | if (g.ActiveId == 0 && g.HoveredId == 0 && g.HoveredRootWindow != NULL && g.IO.MouseClicked[0]) |
| 1872 | 1937 | SetActiveId(g.HoveredRootWindow->GetID("#MOVE")); |
| 1873 | 1938 | |
| 1874 | 1939 | // Sort the window list so that all child windows are after their parent |
| 1875 | 1940 | // We cannot do that on FocusWindow() because childs may not exist yet |
| 1876 | | ImVector<ImGuiWindow*> sorted_windows; |
| 1877 | | sorted_windows.reserve(g.Windows.size()); |
| 1941 | g.RenderSortedWindows.resize(0); |
| 1942 | g.RenderSortedWindows.reserve(g.Windows.size()); |
| 1878 | 1943 | for (size_t i = 0; i != g.Windows.size(); i++) |
| 1879 | 1944 | { |
| 1880 | 1945 | ImGuiWindow* window = g.Windows[i]; |
| 1881 | 1946 | if (window->Flags & ImGuiWindowFlags_ChildWindow) // if a child is visible its parent will add it |
| 1882 | 1947 | if (window->Visible) |
| 1883 | 1948 | continue; |
| 1884 | | AddWindowToSortedBuffer(window, sorted_windows); |
| 1949 | AddWindowToSortedBuffer(window, g.RenderSortedWindows); |
| 1885 | 1950 | } |
| 1886 | | IM_ASSERT(g.Windows.size() == sorted_windows.size()); // We done something wrong |
| 1887 | | g.Windows.swap(sorted_windows); |
| 1951 | IM_ASSERT(g.Windows.size() == g.RenderSortedWindows.size()); // we done something wrong |
| 1952 | g.Windows.swap(g.RenderSortedWindows); |
| 1888 | 1953 | |
| 1889 | 1954 | // Clear data for next frame |
| 1890 | 1955 | g.IO.MouseWheel = 0.0f; |
| r244546 | r244547 | |
|---|
| 1953 | 2018 | // Pass text data straight to log (without being displayed) |
| 1954 | 2019 | void ImGui::LogText(const char* fmt, ...) |
| 1955 | 2020 | { |
| 1956 | | ImGuiState& g = GImGui; |
| 2021 | ImGuiState& g = *GImGui; |
| 1957 | 2022 | if (!g.LogEnabled) |
| 1958 | 2023 | return; |
| 1959 | 2024 | |
| r244546 | r244547 | |
|---|
| 1971 | 2036 | } |
| 1972 | 2037 | |
| 1973 | 2038 | // Internal version that takes a position to decide on newline placement and pad items according to their depth. |
| 2039 | // We split text into individual lines to add current tree level padding |
| 1974 | 2040 | static void LogText(const ImVec2& ref_pos, const char* text, const char* text_end) |
| 1975 | 2041 | { |
| 1976 | | ImGuiState& g = GImGui; |
| 2042 | ImGuiState& g = *GImGui; |
| 1977 | 2043 | ImGuiWindow* window = GetCurrentWindow(); |
| 1978 | 2044 | |
| 1979 | 2045 | if (!text_end) |
| r244546 | r244547 | |
|---|
| 2030 | 2096 | wrap_pos_x = ImGui::GetContentRegionMax().x; |
| 2031 | 2097 | if (wrap_pos_x > 0.0f) |
| 2032 | 2098 | wrap_pos_x += window->Pos.x; // wrap_pos_x is provided is window local space |
| 2033 | | |
| 2099 | |
| 2034 | 2100 | const float wrap_width = wrap_pos_x > 0.0f ? ImMax(wrap_pos_x - pos.x, 0.00001f) : 0.0f; |
| 2035 | 2101 | return wrap_width; |
| 2036 | 2102 | } |
| 2037 | 2103 | |
| 2038 | | // Internal ImGui function to render text (called from ImGui::Text(), ImGui::TextUnformatted(), etc.) |
| 2039 | | // RenderText() calls ImDrawList::AddText() calls ImBitmapFont::RenderText() |
| 2040 | | static void RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash, float wrap_width) |
| 2104 | // Internal ImGui functions to render text |
| 2105 | // RenderText***() functions calls ImDrawList::AddText() calls ImBitmapFont::RenderText() |
| 2106 | static void RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash) |
| 2041 | 2107 | { |
| 2042 | | ImGuiState& g = GImGui; |
| 2108 | ImGuiState& g = *GImGui; |
| 2043 | 2109 | ImGuiWindow* window = GetCurrentWindow(); |
| 2044 | 2110 | |
| 2045 | 2111 | // Hide anything after a '##' string |
| r244546 | r244547 | |
|---|
| 2059 | 2125 | if (text_len > 0) |
| 2060 | 2126 | { |
| 2061 | 2127 | // Render |
| 2062 | | window->DrawList->AddText(window->Font(), window->FontSize(), pos, window->Color(ImGuiCol_Text), text, text + text_len, wrap_width); |
| 2128 | window->DrawList->AddText(window->Font(), window->FontSize(), pos, window->Color(ImGuiCol_Text), text, text_display_end); |
| 2063 | 2129 | |
| 2064 | | // Log as text. We split text into individual lines to add current tree level padding |
| 2130 | // Log as text |
| 2065 | 2131 | if (g.LogEnabled) |
| 2066 | 2132 | LogText(pos, text, text_display_end); |
| 2067 | 2133 | } |
| 2068 | 2134 | } |
| 2069 | 2135 | |
| 2136 | static void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width) |
| 2137 | { |
| 2138 | ImGuiState& g = *GImGui; |
| 2139 | ImGuiWindow* window = GetCurrentWindow(); |
| 2140 | |
| 2141 | if (!text_end) |
| 2142 | text_end = text + strlen(text); // FIXME-OPT |
| 2143 | |
| 2144 | const int text_len = (int)(text_end - text); |
| 2145 | if (text_len > 0) |
| 2146 | { |
| 2147 | // Render |
| 2148 | window->DrawList->AddText(window->Font(), window->FontSize(), pos, window->Color(ImGuiCol_Text), text, text_end, wrap_width); |
| 2149 | |
| 2150 | // Log as text |
| 2151 | if (g.LogEnabled) |
| 2152 | LogText(pos, text, text_end); |
| 2153 | } |
| 2154 | } |
| 2155 | |
| 2156 | static void RenderTextClipped(ImVec2 pos, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& clip_max) |
| 2157 | { |
| 2158 | ImGuiState& g = *GImGui; |
| 2159 | ImGuiWindow* window = GetCurrentWindow(); |
| 2160 | |
| 2161 | // Hide anything after a '##' string |
| 2162 | const char* text_display_end = FindTextDisplayEnd(text, text_end); |
| 2163 | const int text_len = (int)(text_display_end - text); |
| 2164 | if (text_len > 0) |
| 2165 | { |
| 2166 | const ImVec2 text_size = text_size_if_known ? *text_size_if_known : ImGui::CalcTextSize(text, text_display_end, false, 0.0f); |
| 2167 | |
| 2168 | // Perform CPU side clipping for single clipped element to avoid using scissor state |
| 2169 | const bool need_clipping = (pos.x + text_size.x >= clip_max.x) || (pos.y + text_size.y >= clip_max.y); |
| 2170 | |
| 2171 | // Render |
| 2172 | window->DrawList->AddText(window->Font(), window->FontSize(), pos, window->Color(ImGuiCol_Text), text, text_display_end, 0.0f, need_clipping ? &clip_max : NULL); |
| 2173 | |
| 2174 | // Log as text |
| 2175 | if (g.LogEnabled) |
| 2176 | LogText(pos, text, text_display_end); |
| 2177 | } |
| 2178 | } |
| 2179 | |
| 2070 | 2180 | // Render a rectangle shaped with optional rounding and borders |
| 2071 | 2181 | static void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding) |
| 2072 | 2182 | { |
| r244546 | r244547 | |
|---|
| 2104 | 2214 | b = center + ImVec2(-0.500f,0.866f)*r; |
| 2105 | 2215 | c = center + ImVec2(-0.500f,-0.866f)*r; |
| 2106 | 2216 | } |
| 2107 | | |
| 2217 | |
| 2108 | 2218 | if (shadow && (window->Flags & ImGuiWindowFlags_ShowBorders) != 0) |
| 2109 | 2219 | window->DrawList->AddTriangleFilled(a+ImVec2(2,2), b+ImVec2(2,2), c+ImVec2(2,2), window->Color(ImGuiCol_BorderShadow)); |
| 2110 | 2220 | window->DrawList->AddTriangleFilled(a, b, c, window->Color(ImGuiCol_Border)); |
| 2111 | 2221 | } |
| 2112 | 2222 | |
| 2113 | 2223 | // Calculate text size. Text can be multi-line. Optionally ignore text after a ## marker. |
| 2114 | | // CalcTextSize("") should return ImVec2(0.0f, GImGui.FontSize) |
| 2224 | // CalcTextSize("") should return ImVec2(0.0f, GImGui->FontSize) |
| 2115 | 2225 | ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width) |
| 2116 | 2226 | { |
| 2117 | 2227 | ImGuiWindow* window = GetCurrentWindow(); |
| r244546 | r244547 | |
|---|
| 2127 | 2237 | ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL); |
| 2128 | 2238 | |
| 2129 | 2239 | // Cancel out character spacing for the last character of a line (it is baked into glyph->XAdvance field) |
| 2130 | | const float font_scale = font_size / font->FontSize; |
| 2240 | const float font_scale = font_size / font->FontSize; |
| 2131 | 2241 | const float character_spacing_x = 1.0f * font_scale; |
| 2132 | 2242 | if (text_size.x > 0.0f) |
| 2133 | 2243 | text_size.x -= character_spacing_x; |
| r244546 | r244547 | |
|---|
| 2135 | 2245 | return text_size; |
| 2136 | 2246 | } |
| 2137 | 2247 | |
| 2248 | // Helper to calculate coarse clipping of large list of evenly sized items. |
| 2249 | // If you are displaying thousands of items and you have a random access to the list, you can perform clipping yourself to save on CPU. |
| 2250 | // { |
| 2251 | // float item_height = ImGui::GetTextLineHeightWithSpacing(); |
| 2252 | // int display_start, display_end; |
| 2253 | // ImGui::CalcListClipping(count, item_height, &display_start, &display_end); // calculate how many to clip/display |
| 2254 | // ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (display_start) * item_height); // advance cursor |
| 2255 | // for (int i = display_start; i < display_end; i++) // display only visible items |
| 2256 | // // TODO: display visible item |
| 2257 | // ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (count - display_end) * item_height); // advance cursor |
| 2258 | // } |
| 2259 | void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end) |
| 2260 | { |
| 2261 | ImGuiState& g = *GImGui; |
| 2262 | ImGuiWindow* window = GetCurrentWindow(); |
| 2263 | |
| 2264 | if (g.LogEnabled) |
| 2265 | { |
| 2266 | // If logging is active, do not perform any clipping |
| 2267 | *out_items_display_start = 0; |
| 2268 | *out_items_display_end = items_count; |
| 2269 | return; |
| 2270 | } |
| 2271 | |
| 2272 | const ImVec2 pos = window->DC.CursorPos; |
| 2273 | const ImVec4 clip_rect = window->ClipRectStack.back(); |
| 2274 | const float clip_y1 = clip_rect.y; |
| 2275 | const float clip_y2 = clip_rect.w; |
| 2276 | |
| 2277 | int start = (int)((clip_y1 - pos.y) / items_height); |
| 2278 | int end = (int)((clip_y2 - pos.y) / items_height); |
| 2279 | start = ImClamp(start, 0, items_count); |
| 2280 | end = ImClamp(end + 1, start, items_count); |
| 2281 | |
| 2282 | *out_items_display_start = start; |
| 2283 | *out_items_display_end = end; |
| 2284 | } |
| 2285 | |
| 2138 | 2286 | // Find window given position, search front-to-back |
| 2139 | 2287 | static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs) |
| 2140 | 2288 | { |
| 2141 | | ImGuiState& g = GImGui; |
| 2289 | ImGuiState& g = *GImGui; |
| 2142 | 2290 | for (int i = (int)g.Windows.size()-1; i >= 0; i--) |
| 2143 | 2291 | { |
| 2144 | 2292 | ImGuiWindow* window = g.Windows[(size_t)i]; |
| r244546 | r244547 | |
|---|
| 2158 | 2306 | // NB- Expand the aabb to be generous on imprecise inputs systems (g.Style.TouchExtraPadding) |
| 2159 | 2307 | static bool IsMouseHoveringBox(const ImGuiAabb& box) |
| 2160 | 2308 | { |
| 2161 | | ImGuiState& g = GImGui; |
| 2309 | ImGuiState& g = *GImGui; |
| 2162 | 2310 | ImGuiWindow* window = GetCurrentWindow(); |
| 2163 | 2311 | |
| 2164 | 2312 | // Clip |
| r244546 | r244547 | |
|---|
| 2181 | 2329 | |
| 2182 | 2330 | bool ImGui::IsMouseHoveringWindow() |
| 2183 | 2331 | { |
| 2184 | | ImGuiState& g = GImGui; |
| 2332 | ImGuiState& g = *GImGui; |
| 2185 | 2333 | ImGuiWindow* window = GetCurrentWindow(); |
| 2186 | 2334 | return g.HoveredWindow == window; |
| 2187 | 2335 | } |
| 2188 | 2336 | |
| 2189 | 2337 | bool ImGui::IsMouseHoveringAnyWindow() |
| 2190 | 2338 | { |
| 2191 | | ImGuiState& g = GImGui; |
| 2339 | ImGuiState& g = *GImGui; |
| 2192 | 2340 | return g.HoveredWindow != NULL; |
| 2193 | 2341 | } |
| 2194 | 2342 | |
| r244546 | r244547 | |
|---|
| 2199 | 2347 | |
| 2200 | 2348 | static bool IsKeyPressedMap(ImGuiKey key, bool repeat) |
| 2201 | 2349 | { |
| 2202 | | ImGuiState& g = GImGui; |
| 2350 | ImGuiState& g = *GImGui; |
| 2203 | 2351 | const int key_index = g.IO.KeyMap[key]; |
| 2204 | 2352 | return ImGui::IsKeyPressed(key_index, repeat); |
| 2205 | 2353 | } |
| 2206 | 2354 | |
| 2207 | 2355 | bool ImGui::IsKeyPressed(int key_index, bool repeat) |
| 2208 | 2356 | { |
| 2209 | | ImGuiState& g = GImGui; |
| 2357 | ImGuiState& g = *GImGui; |
| 2210 | 2358 | IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown)); |
| 2211 | 2359 | const float t = g.IO.KeysDownTime[key_index]; |
| 2212 | 2360 | if (t == 0.0f) |
| r244546 | r244547 | |
|---|
| 2224 | 2372 | |
| 2225 | 2373 | bool ImGui::IsMouseClicked(int button, bool repeat) |
| 2226 | 2374 | { |
| 2227 | | ImGuiState& g = GImGui; |
| 2375 | ImGuiState& g = *GImGui; |
| 2228 | 2376 | IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown)); |
| 2229 | 2377 | const float t = g.IO.MouseDownTime[button]; |
| 2230 | 2378 | if (t == 0.0f) |
| r244546 | r244547 | |
|---|
| 2242 | 2390 | |
| 2243 | 2391 | bool ImGui::IsMouseDoubleClicked(int button) |
| 2244 | 2392 | { |
| 2245 | | ImGuiState& g = GImGui; |
| 2393 | ImGuiState& g = *GImGui; |
| 2246 | 2394 | IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown)); |
| 2247 | 2395 | return g.IO.MouseDoubleClicked[button]; |
| 2248 | 2396 | } |
| 2249 | 2397 | |
| 2250 | 2398 | ImVec2 ImGui::GetMousePos() |
| 2251 | 2399 | { |
| 2252 | | return GImGui.IO.MousePos; |
| 2400 | return GImGui->IO.MousePos; |
| 2253 | 2401 | } |
| 2254 | 2402 | |
| 2255 | 2403 | bool ImGui::IsItemHovered() |
| r244546 | r244547 | |
|---|
| 2260 | 2408 | |
| 2261 | 2409 | bool ImGui::IsItemActive() |
| 2262 | 2410 | { |
| 2263 | | ImGuiState& g = GImGui; |
| 2411 | ImGuiState& g = *GImGui; |
| 2264 | 2412 | if (g.ActiveId) |
| 2265 | 2413 | { |
| 2266 | 2414 | ImGuiWindow* window = GetCurrentWindow(); |
| r244546 | r244547 | |
|---|
| 2284 | 2432 | // Tooltip is stored and turned into a BeginTooltip()/EndTooltip() sequence at the end of the frame. Each call override previous value. |
| 2285 | 2433 | void ImGui::SetTooltipV(const char* fmt, va_list args) |
| 2286 | 2434 | { |
| 2287 | | ImGuiState& g = GImGui; |
| 2435 | ImGuiState& g = *GImGui; |
| 2288 | 2436 | ImFormatStringV(g.Tooltip, IM_ARRAYSIZE(g.Tooltip), fmt, args); |
| 2289 | 2437 | } |
| 2290 | 2438 | |
| r244546 | r244547 | |
|---|
| 2298 | 2446 | |
| 2299 | 2447 | float ImGui::GetTime() |
| 2300 | 2448 | { |
| 2301 | | return GImGui.Time; |
| 2449 | return GImGui->Time; |
| 2302 | 2450 | } |
| 2303 | 2451 | |
| 2304 | 2452 | int ImGui::GetFrameCount() |
| 2305 | 2453 | { |
| 2306 | | return GImGui.FrameCount; |
| 2454 | return GImGui->FrameCount; |
| 2307 | 2455 | } |
| 2308 | 2456 | |
| 2309 | 2457 | void ImGui::BeginTooltip() |
| 2310 | 2458 | { |
| 2311 | | ImGuiState& g = GImGui; |
| 2459 | ImGuiState& g = *GImGui; |
| 2312 | 2460 | ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_AlwaysAutoResize|ImGuiWindowFlags_Tooltip; |
| 2313 | 2461 | ImGui::Begin("##Tooltip", NULL, ImVec2(0,0), g.Style.Colors[ImGuiCol_TooltipBg].w, window_flags); |
| 2314 | 2462 | } |
| r244546 | r244547 | |
|---|
| 2319 | 2467 | ImGui::End(); |
| 2320 | 2468 | } |
| 2321 | 2469 | |
| 2470 | void ImGui::BeginChild(ImGuiID id, ImVec2 size, bool border, ImGuiWindowFlags extra_flags) |
| 2471 | { |
| 2472 | char str_id[32]; |
| 2473 | ImFormatString(str_id, IM_ARRAYSIZE(str_id), "child_%x", id); |
| 2474 | ImGui::BeginChild(str_id, size, border, extra_flags); |
| 2475 | } |
| 2476 | |
| 2322 | 2477 | void ImGui::BeginChild(const char* str_id, ImVec2 size, bool border, ImGuiWindowFlags extra_flags) |
| 2323 | 2478 | { |
| 2324 | | ImGuiState& g = GImGui; |
| 2479 | ImGuiState& g = *GImGui; |
| 2325 | 2480 | ImGuiWindow* window = GetCurrentWindow(); |
| 2326 | 2481 | |
| 2327 | 2482 | ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_ChildWindow; |
| r244546 | r244547 | |
|---|
| 2347 | 2502 | char title[256]; |
| 2348 | 2503 | ImFormatString(title, IM_ARRAYSIZE(title), "%s.%s", window->Name, str_id); |
| 2349 | 2504 | |
| 2350 | | const float alpha = (flags & ImGuiWindowFlags_ComboBox) ? 1.0f : 0.0f; |
| 2505 | const float alpha = 1.0f; |
| 2351 | 2506 | ImGui::Begin(title, NULL, size, alpha, flags); |
| 2352 | 2507 | |
| 2353 | 2508 | if (!(window->Flags & ImGuiWindowFlags_ShowBorders)) |
| r244546 | r244547 | |
|---|
| 2371 | 2526 | sz.x = 0; |
| 2372 | 2527 | if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitY) |
| 2373 | 2528 | sz.y = 0; |
| 2374 | | |
| 2529 | |
| 2375 | 2530 | ImGui::End(); |
| 2376 | 2531 | ItemSize(sz); |
| 2377 | 2532 | } |
| 2378 | 2533 | } |
| 2379 | 2534 | |
| 2535 | // Helper to create a child window / scrolling region that looks like a normal widget frame. |
| 2536 | void ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size) |
| 2537 | { |
| 2538 | ImGuiState& g = *GImGui; |
| 2539 | const ImGuiStyle& style = g.Style; |
| 2540 | ImGui::PushStyleColor(ImGuiCol_ChildWindowBg, style.Colors[ImGuiCol_FrameBg]); |
| 2541 | ImGui::PushStyleVar(ImGuiStyleVar_ChildWindowRounding, style.FrameRounding); |
| 2542 | ImGui::BeginChild(id, size); |
| 2543 | } |
| 2544 | |
| 2545 | void ImGui::EndChildFrame() |
| 2546 | { |
| 2547 | ImGui::EndChild(); |
| 2548 | ImGui::PopStyleVar(); |
| 2549 | ImGui::PopStyleColor(); |
| 2550 | } |
| 2551 | |
| 2380 | 2552 | static ImGuiWindow* FindWindowByName(const char* name) |
| 2381 | 2553 | { |
| 2382 | 2554 | // FIXME-OPT: Consider optimizing this (e.g. sorted hashes to window pointers) |
| 2383 | | ImGuiState& g = GImGui; |
| 2555 | ImGuiState& g = *GImGui; |
| 2384 | 2556 | for (size_t i = 0; i != g.Windows.size(); i++) |
| 2385 | 2557 | if (strcmp(g.Windows[i]->Name, name) == 0) |
| 2386 | 2558 | return g.Windows[i]; |
| r244546 | r244547 | |
|---|
| 2389 | 2561 | |
| 2390 | 2562 | static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags) |
| 2391 | 2563 | { |
| 2392 | | ImGuiState& g = GImGui; |
| 2564 | ImGuiState& g = *GImGui; |
| 2393 | 2565 | |
| 2394 | 2566 | // Create window the first time |
| 2395 | 2567 | ImGuiWindow* window = (ImGuiWindow*)ImGui::MemAlloc(sizeof(ImGuiWindow)); |
| r244546 | r244547 | |
|---|
| 2435 | 2607 | return window; |
| 2436 | 2608 | } |
| 2437 | 2609 | |
| 2438 | | // Push a new ImGui window to add widgets to. |
| 2610 | // Push a new ImGui window to add widgets to. |
| 2439 | 2611 | // - A default window called "Debug" is automatically stacked at the beginning of every frame. |
| 2440 | 2612 | // - This can be called multiple times during the frame with the same window name to append content to the same window. |
| 2441 | 2613 | // - The window name is used as a unique identifier to preserve window information across frames (and save rudimentary information to the .ini file). Note that you can use ## to append unique data that isn't displayed, e.g. "My window##1" will use "My window##1" as unique window ID but display "My window" to the user. |
| r244546 | r244547 | |
|---|
| 2444 | 2616 | // - Passing non-zero 'size' is roughly equivalent to calling SetNextWindowSize(size, ImGuiSetCondition_FirstUseEver) prior to calling Begin(). |
| 2445 | 2617 | bool ImGui::Begin(const char* name, bool* p_opened, ImVec2 size, float fill_alpha, ImGuiWindowFlags flags) |
| 2446 | 2618 | { |
| 2447 | | ImGuiState& g = GImGui; |
| 2619 | ImGuiState& g = *GImGui; |
| 2448 | 2620 | const ImGuiStyle& style = g.Style; |
| 2449 | 2621 | IM_ASSERT(g.Initialized); // Forgot to call ImGui::NewFrame() |
| 2450 | 2622 | IM_ASSERT(name != NULL); // Must pass a name |
| r244546 | r244547 | |
|---|
| 2612 | 2784 | // Collapse window by double-clicking on title bar |
| 2613 | 2785 | if (!(window->Flags & ImGuiWindowFlags_NoTitleBar)) |
| 2614 | 2786 | { |
| 2615 | | if (g.HoveredWindow == window && IsMouseHoveringBox(title_bar_aabb) && g.IO.MouseDoubleClicked[0]) |
| 2787 | if (!(window->Flags & ImGuiWindowFlags_NoCollapse) && g.HoveredWindow == window && IsMouseHoveringBox(title_bar_aabb) && g.IO.MouseDoubleClicked[0]) |
| 2616 | 2788 | { |
| 2617 | 2789 | window->Collapsed = !window->Collapsed; |
| 2618 | 2790 | if (!(window->Flags & ImGuiWindowFlags_NoSavedSettings)) |
| r244546 | r244547 | |
|---|
| 2625 | 2797 | window->Collapsed = false; |
| 2626 | 2798 | } |
| 2627 | 2799 | |
| 2800 | const float window_rounding = (window->Flags & ImGuiWindowFlags_ChildWindow) ? style.ChildWindowRounding : style.WindowRounding; |
| 2628 | 2801 | if (window->Collapsed) |
| 2629 | 2802 | { |
| 2630 | 2803 | // Draw title bar only |
| 2631 | 2804 | window->Size = title_bar_aabb.GetSize(); |
| 2632 | | window->DrawList->AddRectFilled(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_TitleBgCollapsed), style.WindowRounding); |
| 2805 | window->DrawList->AddRectFilled(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_TitleBgCollapsed), window_rounding); |
| 2633 | 2806 | if (window->Flags & ImGuiWindowFlags_ShowBorders) |
| 2634 | 2807 | { |
| 2635 | | window->DrawList->AddRect(title_bar_aabb.GetTL()+ImVec2(1,1), title_bar_aabb.GetBR()+ImVec2(1,1), window->Color(ImGuiCol_BorderShadow), style.WindowRounding); |
| 2636 | | window->DrawList->AddRect(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_Border), style.WindowRounding); |
| 2808 | window->DrawList->AddRect(title_bar_aabb.GetTL()+ImVec2(1,1), title_bar_aabb.GetBR()+ImVec2(1,1), window->Color(ImGuiCol_BorderShadow), window_rounding); |
| 2809 | window->DrawList->AddRect(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_Border), window_rounding); |
| 2637 | 2810 | } |
| 2638 | 2811 | } |
| 2639 | 2812 | else |
| r244546 | r244547 | |
|---|
| 2696 | 2869 | title_bar_aabb = window->TitleBarAabb(); |
| 2697 | 2870 | } |
| 2698 | 2871 | |
| 2699 | | // Title bar + Window box |
| 2872 | // Scrollbar |
| 2873 | window->ScrollbarY = (window->SizeContentsFit.y > window->Size.y) && !(window->Flags & ImGuiWindowFlags_NoScrollbar); |
| 2874 | |
| 2875 | // Window background |
| 2700 | 2876 | if (fill_alpha > 0.0f) |
| 2701 | 2877 | { |
| 2702 | 2878 | if ((window->Flags & ImGuiWindowFlags_ComboBox) != 0) |
| 2703 | | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_ComboBg, fill_alpha), 0); |
| 2879 | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_ComboBg, fill_alpha), window_rounding); |
| 2704 | 2880 | else if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0) |
| 2705 | | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_TooltipBg, fill_alpha), style.WindowRounding); |
| 2881 | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_TooltipBg, fill_alpha), window_rounding); |
| 2882 | else if ((window->Flags & ImGuiWindowFlags_ChildWindow) != 0) |
| 2883 | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size-ImVec2(window->ScrollbarY?style.ScrollBarWidth:0.0f,0.0f), window->Color(ImGuiCol_ChildWindowBg, fill_alpha), window_rounding, window->ScrollbarY ? (1|8) : (0xF)); |
| 2706 | 2884 | else |
| 2707 | | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_WindowBg, fill_alpha), style.WindowRounding); |
| 2885 | window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_WindowBg, fill_alpha), window_rounding); |
| 2708 | 2886 | } |
| 2709 | 2887 | |
| 2888 | // Title bar |
| 2710 | 2889 | if (!(window->Flags & ImGuiWindowFlags_NoTitleBar)) |
| 2711 | | window->DrawList->AddRectFilled(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_TitleBg), style.WindowRounding, 1|2); |
| 2890 | window->DrawList->AddRectFilled(title_bar_aabb.GetTL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_TitleBg), window_rounding, 1|2); |
| 2712 | 2891 | |
| 2713 | 2892 | // Borders |
| 2714 | 2893 | if (window->Flags & ImGuiWindowFlags_ShowBorders) |
| 2715 | 2894 | { |
| 2716 | | const float rounding = (window->Flags & ImGuiWindowFlags_ComboBox) ? 0.0f : style.WindowRounding; |
| 2717 | | window->DrawList->AddRect(window->Pos+ImVec2(1,1), window->Pos+window->Size+ImVec2(1,1), window->Color(ImGuiCol_BorderShadow), rounding); |
| 2718 | | window->DrawList->AddRect(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_Border), rounding); |
| 2895 | window->DrawList->AddRect(window->Pos+ImVec2(1,1), window->Pos+window->Size+ImVec2(1,1), window->Color(ImGuiCol_BorderShadow), window_rounding); |
| 2896 | window->DrawList->AddRect(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_Border), window_rounding); |
| 2719 | 2897 | if (!(window->Flags & ImGuiWindowFlags_NoTitleBar)) |
| 2720 | 2898 | window->DrawList->AddLine(title_bar_aabb.GetBL(), title_bar_aabb.GetBR(), window->Color(ImGuiCol_Border)); |
| 2721 | 2899 | } |
| 2722 | 2900 | |
| 2723 | 2901 | // Scrollbar |
| 2724 | | window->ScrollbarY = (window->SizeContentsFit.y > window->Size.y) && !(window->Flags & ImGuiWindowFlags_NoScrollbar); |
| 2725 | 2902 | if (window->ScrollbarY) |
| 2726 | 2903 | { |
| 2727 | 2904 | ImGuiAabb scrollbar_bb(window->Aabb().Max.x - style.ScrollBarWidth, title_bar_aabb.Max.y+1, window->Aabb().Max.x, window->Aabb().Max.y-1); |
| r244546 | r244547 | |
|---|
| 2743 | 2920 | { |
| 2744 | 2921 | g.HoveredId = scrollbar_id; |
| 2745 | 2922 | const float pos_y_norm = ImSaturate((g.IO.MousePos.y - (scrollbar_bb.Min.y + grab_size_y*0.5f)) / (scrollbar_bb.GetHeight() - grab_size_y)) * (1.0f - grab_size_y_norm); |
| 2746 | | window->ScrollY = pos_y_norm * window->SizeContentsFit.y; |
| 2923 | window->ScrollY = (float)(int)(pos_y_norm * window->SizeContentsFit.y); |
| 2747 | 2924 | window->NextScrollY = window->ScrollY; |
| 2748 | 2925 | } |
| 2749 | 2926 | } |
| r244546 | r244547 | |
|---|
| 2752 | 2929 | const float pos_y_norm = ImSaturate(window->ScrollY / ImMax(0.0f, window->SizeContentsFit.y)); |
| 2753 | 2930 | const ImU32 grab_col = window->Color(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab); |
| 2754 | 2931 | window->DrawList->AddRectFilled( |
| 2755 | | ImVec2(scrollbar_bb.Min.x, ImLerp(scrollbar_bb.Min.y, scrollbar_bb.Max.y, pos_y_norm)), |
| 2932 | ImVec2(scrollbar_bb.Min.x, ImLerp(scrollbar_bb.Min.y, scrollbar_bb.Max.y, pos_y_norm)), |
| 2756 | 2933 | ImVec2(scrollbar_bb.Max.x, ImLerp(scrollbar_bb.Min.y, scrollbar_bb.Max.y, pos_y_norm + grab_size_y_norm)), grab_col); |
| 2757 | 2934 | } |
| 2758 | 2935 | |
| r244546 | r244547 | |
|---|
| 2760 | 2937 | // (after the input handling so we don't have a frame of latency) |
| 2761 | 2938 | if (!(window->Flags & ImGuiWindowFlags_NoResize)) |
| 2762 | 2939 | { |
| 2763 | | const float r = style.WindowRounding; |
| 2940 | const float r = window_rounding; |
| 2764 | 2941 | const ImVec2 br = window->Aabb().GetBR(); |
| 2765 | 2942 | if (r == 0.0f) |
| 2766 | 2943 | { |
| r244546 | r244547 | |
|---|
| 2785 | 2962 | window->DC.CurrentLineHeight = window->DC.PrevLineHeight = 0.0f; |
| 2786 | 2963 | window->DC.LogLineHeight = window->DC.CursorPos.y - 9999.0f; |
| 2787 | 2964 | window->DC.ChildWindows.resize(0); |
| 2788 | | window->DC.ItemWidth.resize(0); |
| 2965 | window->DC.ItemWidth.resize(0); |
| 2789 | 2966 | window->DC.ItemWidth.push_back(window->ItemWidthDefault); |
| 2790 | 2967 | window->DC.AllowKeyboardFocus.resize(0); |
| 2791 | 2968 | window->DC.AllowKeyboardFocus.push_back(true); |
| r244546 | r244547 | |
|---|
| 2808 | 2985 | // Title bar |
| 2809 | 2986 | if (!(window->Flags & ImGuiWindowFlags_NoTitleBar)) |
| 2810 | 2987 | { |
| 2811 | | RenderCollapseTriangle(window->Pos + style.FramePadding, !window->Collapsed, 1.0f, true); |
| 2812 | 2988 | if (p_opened != NULL) |
| 2813 | 2989 | CloseWindowButton(p_opened); |
| 2814 | 2990 | |
| 2991 | ImVec2 text_min = window->Pos + style.FramePadding; |
| 2992 | if (!(window->Flags & ImGuiWindowFlags_NoCollapse)) |
| 2993 | { |
| 2994 | RenderCollapseTriangle(window->Pos + style.FramePadding, !window->Collapsed, 1.0f, true); |
| 2995 | text_min.x += window->FontSize() + style.ItemInnerSpacing.x; |
| 2996 | } |
| 2997 | |
| 2815 | 2998 | const ImVec2 text_size = CalcTextSize(name, NULL, true); |
| 2816 | | const ImVec2 text_min = window->Pos + style.FramePadding + ImVec2(window->FontSize() + style.ItemInnerSpacing.x, 0.0f); |
| 2817 | | const ImVec2 text_max = window->Pos + ImVec2(window->Size.x - (p_opened ? (title_bar_aabb.GetHeight()-3) : style.FramePadding.x), style.FramePadding.y + text_size.y); |
| 2818 | | const bool clip_title = text_size.x > (text_max.x - text_min.x); // only push a clip rectangle if we need to, because it may turn into a separate draw call |
| 2819 | | if (clip_title) |
| 2820 | | PushClipRect(ImVec4(text_min.x, text_min.y, text_max.x, text_max.y)); |
| 2821 | | RenderText(text_min, name); |
| 2822 | | if (clip_title) |
| 2823 | | PopClipRect(); |
| 2999 | const ImVec2 text_max = window->Pos + ImVec2(window->Size.x - (p_opened ? (title_bar_aabb.GetHeight()-3) : style.FramePadding.x), style.FramePadding.y*2 + text_size.y); |
| 3000 | RenderTextClipped(text_min, name, NULL, &text_size, text_max); |
| 2824 | 3001 | } |
| 2825 | 3002 | } |
| 2826 | 3003 | |
| r244546 | r244547 | |
|---|
| 2859 | 3036 | |
| 2860 | 3037 | void ImGui::End() |
| 2861 | 3038 | { |
| 2862 | | ImGuiState& g = GImGui; |
| 3039 | ImGuiState& g = *GImGui; |
| 2863 | 3040 | ImGuiWindow* window = g.CurrentWindow; |
| 2864 | 3041 | |
| 2865 | 3042 | ImGui::Columns(1, "#CloseColumns"); |
| r244546 | r244547 | |
|---|
| 2880 | 3057 | // Moving window to front of display (which happens to be back of our sorted list) |
| 2881 | 3058 | static void FocusWindow(ImGuiWindow* window) |
| 2882 | 3059 | { |
| 2883 | | ImGuiState& g = GImGui; |
| 3060 | ImGuiState& g = *GImGui; |
| 2884 | 3061 | g.FocusedWindow = window; |
| 2885 | 3062 | |
| 2886 | 3063 | if (g.Windows.back() == window) |
| r244546 | r244547 | |
|---|
| 2898 | 3075 | void ImGui::PushItemWidth(float item_width) |
| 2899 | 3076 | { |
| 2900 | 3077 | ImGuiWindow* window = GetCurrentWindow(); |
| 2901 | | item_width = (float)(int)item_width; |
| 2902 | | window->DC.ItemWidth.push_back(item_width > 0.0f ? item_width : window->ItemWidthDefault); |
| 3078 | window->DC.ItemWidth.push_back(item_width == 0.0f ? window->ItemWidthDefault : item_width); |
| 2903 | 3079 | } |
| 2904 | 3080 | |
| 2905 | 3081 | void ImGui::PopItemWidth() |
| r244546 | r244547 | |
|---|
| 2908 | 3084 | window->DC.ItemWidth.pop_back(); |
| 2909 | 3085 | } |
| 2910 | 3086 | |
| 2911 | | float ImGui::GetItemWidth() |
| 3087 | float ImGui::CalcItemWidth() |
| 2912 | 3088 | { |
| 2913 | 3089 | ImGuiWindow* window = GetCurrentWindow(); |
| 2914 | | return window->DC.ItemWidth.back(); |
| 3090 | float w = window->DC.ItemWidth.back(); |
| 3091 | if (w < 0.0f) |
| 3092 | { |
| 3093 | // Align to a right-side limit. We include 1 frame padding in the calculation because this is how the width is always used (we add 2 frame padding to it), but we could move that responsibility to the widget as well. |
| 3094 | ImGuiState& g = *GImGui; |
| 3095 | w = -w; |
| 3096 | float width_to_right_edge = window->Pos.x + ImGui::GetContentRegionMax().x - window->DC.CursorPos.x; |
| 3097 | w = ImMax(1.0f, width_to_right_edge - w - g.Style.FramePadding.x * 2.0f); |
| 3098 | } |
| 3099 | w = (float)(int)w; |
| 3100 | return w; |
| 2915 | 3101 | } |
| 2916 | 3102 | |
| 2917 | 3103 | static void SetFont(ImFont* font) |
| 2918 | 3104 | { |
| 2919 | | ImGuiState& g = GImGui; |
| 3105 | ImGuiState& g = *GImGui; |
| 2920 | 3106 | |
| 2921 | 3107 | IM_ASSERT(font && font->IsLoaded()); |
| 2922 | 3108 | IM_ASSERT(font->Scale > 0.0f); |
| r244546 | r244547 | |
|---|
| 2929 | 3115 | |
| 2930 | 3116 | void ImGui::PushFont(ImFont* font) |
| 2931 | 3117 | { |
| 2932 | | ImGuiState& g = GImGui; |
| 3118 | ImGuiState& g = *GImGui; |
| 2933 | 3119 | |
| 2934 | 3120 | if (!font) |
| 2935 | 3121 | font = g.IO.Fonts->Fonts[0]; |
| r244546 | r244547 | |
|---|
| 2941 | 3127 | |
| 2942 | 3128 | void ImGui::PopFont() |
| 2943 | 3129 | { |
| 2944 | | ImGuiState& g = GImGui; |
| 3130 | ImGuiState& g = *GImGui; |
| 2945 | 3131 | |
| 2946 | 3132 | g.CurrentWindow->DrawList->PopTextureID(); |
| 2947 | 3133 | g.FontStack.pop_back(); |
| r244546 | r244547 | |
|---|
| 2974 | 3160 | |
| 2975 | 3161 | void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col) |
| 2976 | 3162 | { |
| 2977 | | ImGuiState& g = GImGui; |
| 3163 | ImGuiState& g = *GImGui; |
| 2978 | 3164 | |
| 2979 | 3165 | ImGuiColMod backup; |
| 2980 | 3166 | backup.Col = idx; |
| r244546 | r244547 | |
|---|
| 2985 | 3171 | |
| 2986 | 3172 | void ImGui::PopStyleColor(int count) |
| 2987 | 3173 | { |
| 2988 | | ImGuiState& g = GImGui; |
| 3174 | ImGuiState& g = *GImGui; |
| 2989 | 3175 | |
| 2990 | 3176 | while (count > 0) |
| 2991 | 3177 | { |
| r244546 | r244547 | |
|---|
| 2998 | 3184 | |
| 2999 | 3185 | static float* GetStyleVarFloatAddr(ImGuiStyleVar idx) |
| 3000 | 3186 | { |
| 3001 | | ImGuiState& g = GImGui; |
| 3187 | ImGuiState& g = *GImGui; |
| 3002 | 3188 | switch (idx) |
| 3003 | 3189 | { |
| 3004 | 3190 | case ImGuiStyleVar_Alpha: return &g.Style.Alpha; |
| 3005 | 3191 | case ImGuiStyleVar_WindowRounding: return &g.Style.WindowRounding; |
| 3192 | case ImGuiStyleVar_ChildWindowRounding: return &g.Style.ChildWindowRounding; |
| 3006 | 3193 | case ImGuiStyleVar_FrameRounding: return &g.Style.FrameRounding; |
| 3007 | 3194 | case ImGuiStyleVar_TreeNodeSpacing: return &g.Style.TreeNodeSpacing; |
| 3008 | 3195 | } |
| r244546 | r244547 | |
|---|
| 3011 | 3198 | |
| 3012 | 3199 | static ImVec2* GetStyleVarVec2Addr(ImGuiStyleVar idx) |
| 3013 | 3200 | { |
| 3014 | | ImGuiState& g = GImGui; |
| 3201 | ImGuiState& g = *GImGui; |
| 3015 | 3202 | switch (idx) |
| 3016 | 3203 | { |
| 3017 | 3204 | case ImGuiStyleVar_WindowPadding: return &g.Style.WindowPadding; |
| r244546 | r244547 | |
|---|
| 3024 | 3211 | |
| 3025 | 3212 | void ImGui::PushStyleVar(ImGuiStyleVar idx, float val) |
| 3026 | 3213 | { |
| 3027 | | ImGuiState& g = GImGui; |
| 3214 | ImGuiState& g = *GImGui; |
| 3028 | 3215 | |
| 3029 | 3216 | float* pvar = GetStyleVarFloatAddr(idx); |
| 3030 | 3217 | IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a float. |
| r244546 | r244547 | |
|---|
| 3038 | 3225 | |
| 3039 | 3226 | void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val) |
| 3040 | 3227 | { |
| 3041 | | ImGuiState& g = GImGui; |
| 3228 | ImGuiState& g = *GImGui; |
| 3042 | 3229 | |
| 3043 | 3230 | ImVec2* pvar = GetStyleVarVec2Addr(idx); |
| 3044 | 3231 | IM_ASSERT(pvar != NULL); // Called function with wrong-type? Varialble is not a ImVec2. |
| r244546 | r244547 | |
|---|
| 3051 | 3238 | |
| 3052 | 3239 | void ImGui::PopStyleVar(int count) |
| 3053 | 3240 | { |
| 3054 | | ImGuiState& g = GImGui; |
| 3241 | ImGuiState& g = *GImGui; |
| 3055 | 3242 | |
| 3056 | 3243 | while (count > 0) |
| 3057 | 3244 | { |
| r244546 | r244547 | |
|---|
| 3072 | 3259 | { |
| 3073 | 3260 | case ImGuiCol_Text: return "Text"; |
| 3074 | 3261 | case ImGuiCol_WindowBg: return "WindowBg"; |
| 3262 | case ImGuiCol_ChildWindowBg: return "ChildWindowBg"; |
| 3075 | 3263 | case ImGuiCol_Border: return "Border"; |
| 3076 | 3264 | case ImGuiCol_BorderShadow: return "BorderShadow"; |
| 3077 | 3265 | case ImGuiCol_FrameBg: return "FrameBg"; |
| r244546 | r244547 | |
|---|
| 3115 | 3303 | |
| 3116 | 3304 | bool ImGui::GetWindowIsFocused() |
| 3117 | 3305 | { |
| 3118 | | ImGuiState& g = GImGui; |
| 3306 | ImGuiState& g = *GImGui; |
| 3119 | 3307 | ImGuiWindow* window = GetCurrentWindow(); |
| 3120 | 3308 | return g.FocusedWindow == window; |
| 3121 | 3309 | } |
| r244546 | r244547 | |
|---|
| 3192 | 3380 | |
| 3193 | 3381 | void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiSetCondition cond) |
| 3194 | 3382 | { |
| 3195 | | ImGuiState& g = GImGui; |
| 3383 | ImGuiState& g = *GImGui; |
| 3196 | 3384 | g.SetNextWindowPosVal = pos; |
| 3197 | 3385 | g.SetNextWindowPosCond = cond ? cond : ImGuiSetCondition_Always; |
| 3198 | 3386 | } |
| 3199 | 3387 | |
| 3200 | 3388 | void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiSetCondition cond) |
| 3201 | 3389 | { |
| 3202 | | ImGuiState& g = GImGui; |
| 3390 | ImGuiState& g = *GImGui; |
| 3203 | 3391 | g.SetNextWindowSizeVal = size; |
| 3204 | 3392 | g.SetNextWindowSizeCond = cond ? cond : ImGuiSetCondition_Always; |
| 3205 | 3393 | } |
| 3206 | 3394 | |
| 3207 | 3395 | void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiSetCondition cond) |
| 3208 | 3396 | { |
| 3209 | | ImGuiState& g = GImGui; |
| 3397 | ImGuiState& g = *GImGui; |
| 3210 | 3398 | g.SetNextWindowCollapsedVal = collapsed; |
| 3211 | 3399 | g.SetNextWindowCollapsedCond = cond ? cond : ImGuiSetCondition_Always; |
| 3212 | 3400 | } |
| r244546 | r244547 | |
|---|
| 3214 | 3402 | ImVec2 ImGui::GetContentRegionMax() |
| 3215 | 3403 | { |
| 3216 | 3404 | ImGuiWindow* window = GetCurrentWindow(); |
| 3217 | | |
| 3218 | | ImVec2 m = window->Size - window->WindowPadding(); |
| 3405 | ImVec2 mx = window->Size - window->WindowPadding(); |
| 3219 | 3406 | if (window->DC.ColumnsCount != 1) |
| 3220 | 3407 | { |
| 3221 | | m.x = GetColumnOffset(window->DC.ColumnsCurrent + 1); |
| 3222 | | m.x -= GImGui.Style.WindowPadding.x; |
| 3408 | mx.x = ImGui::GetColumnOffset(window->DC.ColumnsCurrent + 1); |
| 3409 | mx.x -= GImGui->Style.WindowPadding.x; |
| 3223 | 3410 | } |
| 3224 | 3411 | else |
| 3225 | 3412 | { |
| 3226 | 3413 | if (window->ScrollbarY) |
| 3227 | | m.x -= GImGui.Style.ScrollBarWidth; |
| 3414 | mx.x -= GImGui->Style.ScrollBarWidth; |
| 3228 | 3415 | } |
| 3229 | | |
| 3230 | | return m; |
| 3416 | return mx; |
| 3231 | 3417 | } |
| 3232 | 3418 | |
| 3233 | 3419 | ImVec2 ImGui::GetWindowContentRegionMin() |
| r244546 | r244547 | |
|---|
| 3241 | 3427 | ImGuiWindow* window = GetCurrentWindow(); |
| 3242 | 3428 | ImVec2 m = window->Size - window->WindowPadding(); |
| 3243 | 3429 | if (window->ScrollbarY) |
| 3244 | | m.x -= GImGui.Style.ScrollBarWidth; |
| 3430 | m.x -= GImGui->Style.ScrollBarWidth; |
| 3245 | 3431 | return m; |
| 3246 | 3432 | } |
| 3247 | 3433 | |
| r244546 | r244547 | |
|---|
| 3251 | 3437 | return window->FontSize(); |
| 3252 | 3438 | } |
| 3253 | 3439 | |
| 3254 | | float ImGui::GetTextLineSpacing() |
| 3440 | float ImGui::GetTextLineHeightWithSpacing() |
| 3255 | 3441 | { |
| 3256 | | ImGuiState& g = GImGui; |
| 3442 | ImGuiState& g = *GImGui; |
| 3257 | 3443 | ImGuiWindow* window = GetCurrentWindow(); |
| 3258 | 3444 | return window->FontSize() + g.Style.ItemSpacing.y; |
| 3259 | 3445 | } |
| r244546 | r244547 | |
|---|
| 3290 | 3476 | return window->DC.CursorPos - window->Pos; |
| 3291 | 3477 | } |
| 3292 | 3478 | |
| 3479 | float ImGui::GetCursorPosX() |
| 3480 | { |
| 3481 | return ImGui::GetCursorPos().x; |
| 3482 | } |
| 3483 | |
| 3484 | float ImGui::GetCursorPosY() |
| 3485 | { |
| 3486 | return ImGui::GetCursorPos().y; |
| 3487 | } |
| 3488 | |
| 3293 | 3489 | void ImGui::SetCursorPos(const ImVec2& pos) |
| 3294 | 3490 | { |
| 3295 | 3491 | ImGuiWindow* window = GetCurrentWindow(); |
| 3296 | 3492 | window->DC.CursorPos = window->Pos + pos; |
| 3493 | window->SizeContentsFit = ImMax(window->SizeContentsFit, pos + ImVec2(0.0f, window->ScrollY)); |
| 3297 | 3494 | } |
| 3298 | 3495 | |
| 3299 | 3496 | void ImGui::SetCursorPosX(float x) |
| 3300 | 3497 | { |
| 3301 | 3498 | ImGuiWindow* window = GetCurrentWindow(); |
| 3302 | 3499 | window->DC.CursorPos.x = window->Pos.x + x; |
| 3500 | window->SizeContentsFit.x = ImMax(window->SizeContentsFit.x, x); |
| 3303 | 3501 | } |
| 3304 | 3502 | |
| 3305 | 3503 | void ImGui::SetCursorPosY(float y) |
| 3306 | 3504 | { |
| 3307 | 3505 | ImGuiWindow* window = GetCurrentWindow(); |
| 3308 | 3506 | window->DC.CursorPos.y = window->Pos.y + y; |
| 3507 | window->SizeContentsFit.y = ImMax(window->SizeContentsFit.y, y + window->ScrollY); |
| 3309 | 3508 | } |
| 3310 | 3509 | |
| 3311 | 3510 | ImVec2 ImGui::GetCursorScreenPos() |
| r244546 | r244547 | |
|---|
| 3396 | 3595 | |
| 3397 | 3596 | void ImGui::TextUnformatted(const char* text, const char* text_end) |
| 3398 | 3597 | { |
| 3399 | | ImGuiState& g = GImGui; |
| 3598 | ImGuiState& g = *GImGui; |
| 3400 | 3599 | ImGuiWindow* window = GetCurrentWindow(); |
| 3401 | 3600 | if (window->SkipItems) |
| 3402 | 3601 | return; |
| r244546 | r244547 | |
|---|
| 3412 | 3611 | { |
| 3413 | 3612 | // Long text! |
| 3414 | 3613 | // Perform manual coarse clipping to optimize for long multi-line text |
| 3415 | | // From this point we will only compute the width of lines that are visible. |
| 3416 | | // Optimization only available when word-wrapping is disabled. |
| 3614 | // From this point we will only compute the width of lines that are visible. Optimization only available when word-wrapping is disabled. |
| 3615 | // We also don't vertically center the text within the line full height, which is unlikely to matter because we are likely the biggest and only item on the line. |
| 3417 | 3616 | const char* line = text; |
| 3418 | 3617 | const float line_height = ImGui::GetTextLineHeight(); |
| 3419 | 3618 | const ImVec2 start_pos = window->DC.CursorPos; |
| r244546 | r244547 | |
|---|
| 3490 | 3689 | if (!ItemAdd(bb, NULL)) |
| 3491 | 3690 | return; |
| 3492 | 3691 | |
| 3493 | | // Render |
| 3494 | | // We don't hide text after ## in this end-user function. |
| 3495 | | RenderText(bb.Min, text_begin, text_end, false, wrap_width); |
| 3692 | // Render (we don't hide text after ## in this end-user function) |
| 3693 | RenderTextWrapped(bb.Min, text_begin, text_end, wrap_width); |
| 3496 | 3694 | } |
| 3497 | 3695 | } |
| 3498 | 3696 | |
| 3499 | 3697 | void ImGui::AlignFirstTextHeightToWidgets() |
| 3500 | 3698 | { |
| 3501 | | ImGuiState& g = GImGui; |
| 3699 | ImGuiState& g = *GImGui; |
| 3502 | 3700 | ImGuiWindow* window = GetCurrentWindow(); |
| 3503 | 3701 | if (window->SkipItems) |
| 3504 | 3702 | return; |
| r244546 | r244547 | |
|---|
| 3511 | 3709 | // Add a label+text combo aligned to other label+value widgets |
| 3512 | 3710 | void ImGui::LabelTextV(const char* label, const char* fmt, va_list args) |
| 3513 | 3711 | { |
| 3514 | | ImGuiState& g = GImGui; |
| 3712 | ImGuiState& g = *GImGui; |
| 3515 | 3713 | ImGuiWindow* window = GetCurrentWindow(); |
| 3516 | 3714 | if (window->SkipItems) |
| 3517 | 3715 | return; |
| 3518 | 3716 | const ImGuiStyle& style = g.Style; |
| 3519 | | const float w = window->DC.ItemWidth.back(); |
| 3717 | const float w = ImGui::CalcItemWidth(); |
| 3520 | 3718 | |
| 3521 | 3719 | static char buf[1024]; |
| 3522 | | const char* text_begin = &buf[0]; |
| 3523 | | const char* text_end = text_begin + ImFormatStringV(buf, IM_ARRAYSIZE(buf), fmt, args); |
| 3720 | const char* value_text_begin = &buf[0]; |
| 3721 | const char* value_text_end = value_text_begin + ImFormatStringV(buf, IM_ARRAYSIZE(buf), fmt, args); |
| 3524 | 3722 | |
| 3525 | 3723 | const ImVec2 text_size = CalcTextSize(label, NULL, true); |
| 3526 | 3724 | const ImGuiAabb value_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + style.FramePadding.x*2, text_size.y)); |
| r244546 | r244547 | |
|---|
| 3530 | 3728 | return; |
| 3531 | 3729 | |
| 3532 | 3730 | // Render |
| 3533 | | RenderText(value_bb.Min, text_begin, text_end); |
| 3731 | RenderTextClipped(value_bb.Min, value_text_begin, value_text_end, NULL, value_bb.Max); |
| 3534 | 3732 | RenderText(ImVec2(value_bb.Max.x + style.ItemInnerSpacing.x, value_bb.Min.y), label); |
| 3535 | 3733 | } |
| 3536 | 3734 | |
| r244546 | r244547 | |
|---|
| 3544 | 3742 | |
| 3545 | 3743 | static bool IsHovered(const ImGuiAabb& bb, const ImGuiID& id) |
| 3546 | 3744 | { |
| 3547 | | ImGuiState& g = GImGui; |
| 3745 | ImGuiState& g = *GImGui; |
| 3548 | 3746 | if (g.HoveredId == 0) |
| 3549 | 3747 | { |
| 3550 | 3748 | ImGuiWindow* window = GetCurrentWindow(); |
| r244546 | r244547 | |
|---|
| 3554 | 3752 | return false; |
| 3555 | 3753 | } |
| 3556 | 3754 | |
| 3557 | | static bool ButtonBehaviour(const ImGuiAabb& bb, const ImGuiID& id, bool* out_hovered, bool* out_held, bool allow_key_modifiers, bool repeat) |
| 3755 | static bool ButtonBehaviour(const ImGuiAabb& bb, const ImGuiID& id, bool* out_hovered, bool* out_held, bool allow_key_modifiers, bool repeat, bool pressed_on_click) |
| 3558 | 3756 | { |
| 3559 | | ImGuiState& g = GImGui; |
| 3757 | ImGuiState& g = *GImGui; |
| 3560 | 3758 | ImGuiWindow* window = GetCurrentWindow(); |
| 3561 | 3759 | |
| 3562 | 3760 | const bool hovered = IsHovered(bb, id); |
| r244546 | r244547 | |
|---|
| 3568 | 3766 | { |
| 3569 | 3767 | if (g.IO.MouseClicked[0]) |
| 3570 | 3768 | { |
| 3571 | | SetActiveId(id); |
| 3769 | if (pressed_on_click) |
| 3770 | { |
| 3771 | pressed = true; |
| 3772 | SetActiveId(0); |
| 3773 | } |
| 3774 | else |
| 3775 | { |
| 3776 | SetActiveId(id); |
| 3777 | } |
| 3572 | 3778 | FocusWindow(window); |
| 3573 | 3779 | } |
| 3574 | 3780 | else if (repeat && g.ActiveId && ImGui::IsMouseClicked(0, true)) |
| r244546 | r244547 | |
|---|
| 3601 | 3807 | |
| 3602 | 3808 | bool ImGui::Button(const char* label, const ImVec2& size_arg, bool repeat_when_held) |
| 3603 | 3809 | { |
| 3604 | | ImGuiState& g = GImGui; |
| 3810 | ImGuiState& g = *GImGui; |
| 3605 | 3811 | ImGuiWindow* window = GetCurrentWindow(); |
| 3606 | 3812 | if (window->SkipItems) |
| 3607 | 3813 | return false; |
| r244546 | r244547 | |
|---|
| 3611 | 3817 | const ImVec2 text_size = CalcTextSize(label, NULL, true); |
| 3612 | 3818 | |
| 3613 | 3819 | const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : text_size.x, size_arg.y != 0.0f ? size_arg.y : text_size.y); |
| 3614 | | |
| 3615 | 3820 | const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + size + style.FramePadding*2.0f); |
| 3616 | 3821 | ItemSize(bb); |
| 3617 | 3822 | if (!ItemAdd(bb, &id)) |
| r244546 | r244547 | |
|---|
| 3624 | 3829 | const ImU32 col = window->Color((hovered && held) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button); |
| 3625 | 3830 | RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding); |
| 3626 | 3831 | |
| 3627 | | if (size.x < text_size.x || size.y < text_size.y) |
| 3628 | | PushClipRect(ImVec4(bb.Min.x+style.FramePadding.x, bb.Min.y+style.FramePadding.y, bb.Max.x, bb.Max.y-style.FramePadding.y)); // Allow extra to draw over the horizontal padding to make it visible that text doesn't fit |
| 3629 | | const ImVec2 off = ImVec2(ImMax(0.0f, size.x - text_size.x) * 0.5f, ImMax(0.0f, size.y - text_size.y) * 0.5f); |
| 3630 | | RenderText(bb.Min + style.FramePadding + off, label); |
| 3631 | | if (size.x < text_size.x || size.y < text_size.y) |
| 3632 | | PopClipRect(); |
| 3832 | const ImVec2 off = ImVec2(ImMax(0.0f, size.x - text_size.x) * 0.5f, ImMax(0.0f, size.y - text_size.y) * 0.5f); // Center (only applies if we explicitly gave a size bigger than the text size, which isn't the common path) |
| 3833 | RenderTextClipped(bb.Min + style.FramePadding + off, label, NULL, &text_size, bb.Max); // Render clip (only applies if we explicitly gave a size smaller than the text size, which isn't the commmon path) |
| 3633 | 3834 | |
| 3634 | 3835 | return pressed; |
| 3635 | 3836 | } |
| r244546 | r244547 | |
|---|
| 3637 | 3838 | // Small buttons fits within text without additional spacing. |
| 3638 | 3839 | bool ImGui::SmallButton(const char* label) |
| 3639 | 3840 | { |
| 3640 | | ImGuiState& g = GImGui; |
| 3841 | ImGuiState& g = *GImGui; |
| 3641 | 3842 | ImGuiWindow* window = GetCurrentWindow(); |
| 3642 | 3843 | if (window->SkipItems) |
| 3643 | 3844 | return false; |
| r244546 | r244547 | |
|---|
| 3740 | 3941 | // frame_padding = 0: no framing |
| 3741 | 3942 | // frame_padding > 0: set framing size |
| 3742 | 3943 | // The color used are the button colors. |
| 3743 | | bool ImGui::ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, int frame_padding, const ImVec4& bg_col) |
| 3944 | bool ImGui::ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col) |
| 3744 | 3945 | { |
| 3745 | | ImGuiState& g = GImGui; |
| 3946 | ImGuiState& g = *GImGui; |
| 3746 | 3947 | ImGuiWindow* window = GetCurrentWindow(); |
| 3747 | 3948 | if (window->SkipItems) |
| 3748 | 3949 | return false; |
| r244546 | r244547 | |
|---|
| 3757 | 3958 | |
| 3758 | 3959 | const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float)frame_padding, (float)frame_padding) : style.FramePadding; |
| 3759 | 3960 | const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + size + padding*2); |
| 3760 | | const ImGuiAabb image_bb(window->DC.CursorPos + padding, window->DC.CursorPos + padding + size); |
| 3961 | const ImGuiAabb image_bb(window->DC.CursorPos + padding, window->DC.CursorPos + padding + size); |
| 3761 | 3962 | ItemSize(bb); |
| 3762 | 3963 | if (!ItemAdd(bb, &id)) |
| 3763 | 3964 | return false; |
| r244546 | r244547 | |
|---|
| 3771 | 3972 | RenderFrame(bb.Min, bb.Max, col); |
| 3772 | 3973 | if (bg_col.w > 0.0f) |
| 3773 | 3974 | window->DrawList->AddRectFilled(image_bb.Min, image_bb.Max, window->Color(bg_col)); |
| 3774 | | window->DrawList->AddImage(user_texture_id, image_bb.Min, image_bb.Max, uv0, uv1); |
| 3975 | window->DrawList->AddImage(user_texture_id, image_bb.Min, image_bb.Max, uv0, uv1, window->Color(tint_col)); |
| 3775 | 3976 | |
| 3776 | 3977 | return pressed; |
| 3777 | 3978 | } |
| r244546 | r244547 | |
|---|
| 3779 | 3980 | // Start logging ImGui output to TTY |
| 3780 | 3981 | void ImGui::LogToTTY(int max_depth) |
| 3781 | 3982 | { |
| 3782 | | ImGuiState& g = GImGui; |
| 3983 | ImGuiState& g = *GImGui; |
| 3783 | 3984 | ImGuiWindow* window = GetCurrentWindow(); |
| 3784 | 3985 | if (g.LogEnabled) |
| 3785 | 3986 | return; |
| r244546 | r244547 | |
|---|
| 3794 | 3995 | // Start logging ImGui output to given file |
| 3795 | 3996 | void ImGui::LogToFile(int max_depth, const char* filename) |
| 3796 | 3997 | { |
| 3797 | | ImGuiState& g = GImGui; |
| 3998 | ImGuiState& g = *GImGui; |
| 3798 | 3999 | ImGuiWindow* window = GetCurrentWindow(); |
| 3799 | 4000 | if (g.LogEnabled) |
| 3800 | 4001 | return; |
| r244546 | r244547 | |
|---|
| 3817 | 4018 | void ImGui::LogToClipboard(int max_depth) |
| 3818 | 4019 | { |
| 3819 | 4020 | ImGuiWindow* window = GetCurrentWindow(); |
| 3820 | | ImGuiState& g = GImGui; |
| 4021 | ImGuiState& g = *GImGui; |
| 3821 | 4022 | if (g.LogEnabled) |
| 3822 | 4023 | return; |
| 3823 | 4024 | |
| r244546 | r244547 | |
|---|
| 3830 | 4031 | |
| 3831 | 4032 | void ImGui::LogFinish() |
| 3832 | 4033 | { |
| 3833 | | ImGuiState& g = GImGui; |
| 4034 | ImGuiState& g = *GImGui; |
| 3834 | 4035 | if (!g.LogEnabled) |
| 3835 | 4036 | return; |
| 3836 | 4037 | |
| r244546 | r244547 | |
|---|
| 3855 | 4056 | // Helper to display logging buttons |
| 3856 | 4057 | void ImGui::LogButtons() |
| 3857 | 4058 | { |
| 3858 | | ImGuiState& g = GImGui; |
| 4059 | ImGuiState& g = *GImGui; |
| 3859 | 4060 | |
| 3860 | 4061 | ImGui::PushID("LogButtons"); |
| 3861 | 4062 | const bool log_to_tty = ImGui::Button("Log To TTY"); |
| 3862 | | ImGui::SameLine(); |
| 4063 | ImGui::SameLine(); |
| 3863 | 4064 | const bool log_to_file = ImGui::Button("Log To File"); |
| 3864 | 4065 | ImGui::SameLine(); |
| 3865 | 4066 | const bool log_to_clipboard = ImGui::Button("Log To Clipboard"); |
| r244546 | r244547 | |
|---|
| 3883 | 4084 | |
| 3884 | 4085 | bool ImGui::CollapsingHeader(const char* label, const char* str_id, const bool display_frame, const bool default_open) |
| 3885 | 4086 | { |
| 3886 | | ImGuiState& g = GImGui; |
| 4087 | ImGuiState& g = *GImGui; |
| 3887 | 4088 | ImGuiWindow* window = GetCurrentWindow(); |
| 3888 | 4089 | if (window->SkipItems) |
| 3889 | 4090 | return false; |
| r244546 | r244547 | |
|---|
| 3929 | 4130 | |
| 3930 | 4131 | // When logging is enabled, if automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behaviour). |
| 3931 | 4132 | // NB- If we are above max depth we still allow manually opened nodes to be logged. |
| 3932 | | if (!display_frame) |
| 4133 | if (!display_frame) |
| 3933 | 4134 | if (g.LogEnabled && window->DC.TreeDepth < g.LogAutoExpandMaxDepth) |
| 3934 | 4135 | opened = true; |
| 3935 | 4136 | |
| r244546 | r244547 | |
|---|
| 3981 | 4182 | // Text with a little bullet aligned to the typical tree node. |
| 3982 | 4183 | void ImGui::BulletTextV(const char* fmt, va_list args) |
| 3983 | 4184 | { |
| 3984 | | ImGuiState& g = GImGui; |
| 4185 | ImGuiState& g = *GImGui; |
| 3985 | 4186 | ImGuiWindow* window = GetCurrentWindow(); |
| 3986 | 4187 | if (window->SkipItems) |
| 3987 | 4188 | return; |
| 3988 | | |
| 4189 | |
| 3989 | 4190 | const ImGuiStyle& style = g.Style; |
| 3990 | 4191 | |
| 3991 | 4192 | static char buf[1024]; |
| r244546 | r244547 | |
|---|
| 4142 | 4343 | |
| 4143 | 4344 | float ref_v = *v; |
| 4144 | 4345 | if (op) |
| 4145 | | if (sscanf(GImGui.InputTextState.InitialText, "%f", &ref_v) < 1) |
| 4346 | if (sscanf(GImGui->InputTextState.InitialText, "%f", &ref_v) < 1) |
| 4146 | 4347 | return; |
| 4147 | 4348 | |
| 4148 | 4349 | float op_v = 0.0f; |
| r244546 | r244547 | |
|---|
| 4167 | 4368 | // Adjust display_format to decorate the value with a prefix or a suffix. |
| 4168 | 4369 | bool ImGui::SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format, float power) |
| 4169 | 4370 | { |
| 4170 | | ImGuiState& g = GImGui; |
| 4371 | ImGuiState& g = *GImGui; |
| 4171 | 4372 | ImGuiWindow* window = GetCurrentWindow(); |
| 4172 | 4373 | if (window->SkipItems) |
| 4173 | 4374 | return false; |
| 4174 | 4375 | |
| 4175 | 4376 | const ImGuiStyle& style = g.Style; |
| 4176 | 4377 | const ImGuiID id = window->GetID(label); |
| 4177 | | const float w = window->DC.ItemWidth.back(); |
| 4378 | const float w = ImGui::CalcItemWidth(); |
| 4178 | 4379 | |
| 4179 | 4380 | if (!display_format) |
| 4180 | 4381 | display_format = "%.3f"; |
| r244546 | r244547 | |
|---|
| 4303 | 4504 | if (!is_unbound) |
| 4304 | 4505 | { |
| 4305 | 4506 | const float normalized_pos = ImClamp((g.IO.MousePos.x - slider_effective_x1) / slider_effective_w, 0.0f, 1.0f); |
| 4306 | | |
| 4507 | |
| 4307 | 4508 | // Linear slider |
| 4308 | 4509 | //float new_value = ImLerp(v_min, v_max, normalized_pos); |
| 4309 | 4510 | |
| r244546 | r244547 | |
|---|
| 4407 | 4608 | // Add multiple sliders on 1 line for compact edition of multiple components |
| 4408 | 4609 | static bool SliderFloatN(const char* label, float v[3], int components, float v_min, float v_max, const char* display_format, float power) |
| 4409 | 4610 | { |
| 4410 | | ImGuiState& g = GImGui; |
| 4611 | ImGuiState& g = *GImGui; |
| 4411 | 4612 | ImGuiWindow* window = GetCurrentWindow(); |
| 4412 | 4613 | if (window->SkipItems) |
| 4413 | 4614 | return false; |
| 4414 | 4615 | |
| 4415 | 4616 | const ImGuiStyle& style = g.Style; |
| 4416 | | const float w_full = window->DC.ItemWidth.back(); |
| 4617 | const float w_full = ImGui::CalcItemWidth(); |
| 4417 | 4618 | const float w_item_one = ImMax(1.0f, (float)(int)((w_full - (style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1)) / (float)components)); |
| 4418 | 4619 | const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1))); |
| 4419 | 4620 | |
| r244546 | r244547 | |
|---|
| 4457 | 4658 | |
| 4458 | 4659 | static bool SliderIntN(const char* label, int v[3], int components, int v_min, int v_max, const char* display_format) |
| 4459 | 4660 | { |
| 4460 | | ImGuiState& g = GImGui; |
| 4661 | ImGuiState& g = *GImGui; |
| 4461 | 4662 | ImGuiWindow* window = GetCurrentWindow(); |
| 4462 | 4663 | if (window->SkipItems) |
| 4463 | 4664 | return false; |
| 4464 | 4665 | |
| 4465 | 4666 | const ImGuiStyle& style = g.Style; |
| 4466 | | const float w_full = window->DC.ItemWidth.back(); |
| 4667 | const float w_full = ImGui::CalcItemWidth(); |
| 4467 | 4668 | const float w_item_one = ImMax(1.0f, (float)(int)((w_full - (style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1)) / (float)components)); |
| 4468 | 4669 | const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1))); |
| 4469 | 4670 | |
| r244546 | r244547 | |
|---|
| 4513 | 4714 | |
| 4514 | 4715 | static void Plot(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) |
| 4515 | 4716 | { |
| 4516 | | ImGuiState& g = GImGui; |
| 4717 | ImGuiState& g = *GImGui; |
| 4517 | 4718 | ImGuiWindow* window = GetCurrentWindow(); |
| 4518 | 4719 | if (window->SkipItems) |
| 4519 | 4720 | return; |
| r244546 | r244547 | |
|---|
| 4522 | 4723 | |
| 4523 | 4724 | const ImVec2 text_size = ImGui::CalcTextSize(label, NULL, true); |
| 4524 | 4725 | if (graph_size.x == 0.0f) |
| 4525 | | graph_size.x = window->DC.ItemWidth.back(); |
| 4726 | graph_size.x = ImGui::CalcItemWidth(); |
| 4526 | 4727 | if (graph_size.y == 0.0f) |
| 4527 | 4728 | graph_size.y = text_size.y; |
| 4528 | 4729 | |
| r244546 | r244547 | |
|---|
| 4563 | 4764 | const float t = ImClamp((g.IO.MousePos.x - graph_bb.Min.x) / (graph_bb.Max.x - graph_bb.Min.x), 0.0f, 0.9999f); |
| 4564 | 4765 | const int v_idx = (int)(t * (values_count + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0))); |
| 4565 | 4766 | IM_ASSERT(v_idx >= 0 && v_idx < values_count); |
| 4566 | | |
| 4767 | |
| 4567 | 4768 | const float v0 = values_getter(data, (v_idx + values_offset) % values_count); |
| 4568 | 4769 | const float v1 = values_getter(data, (v_idx + 1 + values_offset) % values_count); |
| 4569 | 4770 | if (plot_type == ImGuiPlotType_Lines) |
| r244546 | r244547 | |
|---|
| 4646 | 4847 | |
| 4647 | 4848 | bool ImGui::Checkbox(const char* label, bool* v) |
| 4648 | 4849 | { |
| 4649 | | ImGuiState& g = GImGui; |
| 4850 | ImGuiState& g = *GImGui; |
| 4650 | 4851 | ImGuiWindow* window = GetCurrentWindow(); |
| 4651 | 4852 | if (window->SkipItems) |
| 4652 | 4853 | return false; |
| r244546 | r244547 | |
|---|
| 4704 | 4905 | |
| 4705 | 4906 | bool ImGui::RadioButton(const char* label, bool active) |
| 4706 | 4907 | { |
| 4707 | | ImGuiState& g = GImGui; |
| 4908 | ImGuiState& g = *GImGui; |
| 4708 | 4909 | ImGuiWindow* window = GetCurrentWindow(); |
| 4709 | 4910 | if (window->SkipItems) |
| 4710 | 4911 | return false; |
| r244546 | r244547 | |
|---|
| 4835 | 5036 | #endif |
| 4836 | 5037 | |
| 4837 | 5038 | void ImGuiTextEditState::OnKeyPressed(int key) |
| 4838 | | { |
| 4839 | | stb_textedit_key(this, &StbState, key); |
| 4840 | | CursorAnimReset(); |
| 5039 | { |
| 5040 | stb_textedit_key(this, &StbState, key); |
| 5041 | CursorAnimReset(); |
| 4841 | 5042 | } |
| 4842 | 5043 | |
| 4843 | 5044 | void ImGuiTextEditState::UpdateScrollOffset() |
| r244546 | r244547 | |
|---|
| 4846 | 5047 | const float scroll_x_increment = Width * 0.25f; |
| 4847 | 5048 | const float cursor_offset_x = Font->CalcTextSizeW(FontSize, FLT_MAX, Text, Text+StbState.cursor, NULL).x; |
| 4848 | 5049 | if (ScrollX > cursor_offset_x) |
| 4849 | | ScrollX = ImMax(0.0f, cursor_offset_x - scroll_x_increment); |
| 5050 | ScrollX = ImMax(0.0f, cursor_offset_x - scroll_x_increment); |
| 4850 | 5051 | else if (ScrollX < cursor_offset_x - Width) |
| 4851 | 5052 | ScrollX = cursor_offset_x - Width + scroll_x_increment; |
| 4852 | 5053 | } |
| r244546 | r244547 | |
|---|
| 4902 | 5103 | const float clip_end = (text_end[0] != '\0' && text_end > text_start) ? symbol_w : 0.0f; |
| 4903 | 5104 | |
| 4904 | 5105 | // Draw text |
| 4905 | | RenderText(pos+ImVec2(clip_begin,0), text_start+(clip_begin>0.0f?1:0), text_end-(clip_end>0.0f?1:0), false);//, &text_params_with_clipping); |
| 5106 | RenderText(pos+ImVec2(clip_begin,0), text_start+(clip_begin>0.0f?1:0), text_end-(clip_end>0.0f?1:0), false); |
| 4906 | 5107 | |
| 4907 | 5108 | // Draw the clip symbol |
| 4908 | 5109 | const char s[2] = {symbol_c,'\0'}; |
| r244546 | r244547 | |
|---|
| 4914 | 5115 | |
| 4915 | 5116 | bool ImGui::InputFloat(const char* label, float *v, float step, float step_fast, int decimal_precision, ImGuiInputTextFlags extra_flags) |
| 4916 | 5117 | { |
| 4917 | | ImGuiState& g = GImGui; |
| 5118 | ImGuiState& g = *GImGui; |
| 4918 | 5119 | ImGuiWindow* window = GetCurrentWindow(); |
| 4919 | 5120 | if (window->SkipItems) |
| 4920 | 5121 | return false; |
| 4921 | 5122 | |
| 4922 | 5123 | const ImGuiStyle& style = g.Style; |
| 4923 | | const float w = window->DC.ItemWidth.back(); |
| 5124 | const float w = ImGui::CalcItemWidth(); |
| 4924 | 5125 | const ImVec2 text_size = CalcTextSize(label, NULL, true); |
| 4925 | 5126 | const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f); |
| 4926 | 5127 | |
| r244546 | r244547 | |
|---|
| 5026 | 5227 | if (c < 128 && c != ' ' && !isprint((int)(c & 0xFF))) |
| 5027 | 5228 | return true; |
| 5028 | 5229 | |
| 5230 | if (c >= 0xE000 && c <= 0xF8FF) // Filter private Unicode range. I don't imagine anybody would want to input them. GLFW on OSX seems to send private characters for special keys like arrow keys. |
| 5231 | return true; |
| 5232 | |
| 5029 | 5233 | if (flags & ImGuiInputTextFlags_CharsDecimal) |
| 5030 | 5234 | if (!(c >= '0' && c <= '9') && (c != '.') && (c != '-') && (c != '+') && (c != '*') && (c != '/')) |
| 5031 | 5235 | return true; |
| r244546 | r244547 | |
|---|
| 5040 | 5244 | // Edit a string of text |
| 5041 | 5245 | bool ImGui::InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, void (*callback)(ImGuiTextEditCallbackData*), void* user_data) |
| 5042 | 5246 | { |
| 5043 | | ImGuiState& g = GImGui; |
| 5247 | ImGuiState& g = *GImGui; |
| 5044 | 5248 | ImGuiWindow* window = GetCurrentWindow(); |
| 5045 | 5249 | if (window->SkipItems) |
| 5046 | 5250 | return false; |
| r244546 | r244547 | |
|---|
| 5049 | 5253 | const ImGuiStyle& style = g.Style; |
| 5050 | 5254 | |
| 5051 | 5255 | const ImGuiID id = window->GetID(label); |
| 5052 | | const float w = window->DC.ItemWidth.back(); |
| 5256 | const float w = ImGui::CalcItemWidth(); |
| 5053 | 5257 | |
| 5054 | 5258 | const ImVec2 text_size = CalcTextSize(label, NULL, true); |
| 5055 | 5259 | const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f); |
| r244546 | r244547 | |
|---|
| 5081 | 5285 | ImTextStrFromUtf8(edit_state.Text, IM_ARRAYSIZE(edit_state.Text), buf, NULL); |
| 5082 | 5286 | edit_state.ScrollX = 0.0f; |
| 5083 | 5287 | edit_state.Width = w; |
| 5084 | | stb_textedit_initialize_state(&edit_state.StbState, true); |
| 5288 | stb_textedit_initialize_state(&edit_state.StbState, true); |
| 5085 | 5289 | edit_state.CursorAnimReset(); |
| 5086 | 5290 | edit_state.LastCursorPos = ImVec2(-1.f,-1.f); |
| 5087 | 5291 | |
| r244546 | r244547 | |
|---|
| 5110 | 5314 | edit_state.BufSize = buf_size < IM_ARRAYSIZE(edit_state.Text) ? buf_size : IM_ARRAYSIZE(edit_state.Text); |
| 5111 | 5315 | edit_state.Font = window->Font(); |
| 5112 | 5316 | edit_state.FontSize = window->FontSize(); |
| 5113 | | |
| 5317 | |
| 5114 | 5318 | const float mx = g.IO.MousePos.x - frame_bb.Min.x - style.FramePadding.x; |
| 5115 | 5319 | const float my = window->FontSize()*0.5f; // Flatten mouse because we are doing a single-line edit |
| 5116 | 5320 | |
| r244546 | r244547 | |
|---|
| 5286 | 5490 | } |
| 5287 | 5491 | } |
| 5288 | 5492 | } |
| 5289 | | |
| 5493 | |
| 5290 | 5494 | RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding); |
| 5291 | 5495 | |
| 5292 | 5496 | const ImVec2 font_off_up = ImVec2(0.0f,window->FontSize()+1.0f); // FIXME: those offsets are part of the style or font API |
| r244546 | r244547 | |
|---|
| 5315 | 5519 | // Draw blinking cursor |
| 5316 | 5520 | if (g.InputTextState.CursorIsVisible()) |
| 5317 | 5521 | window->DrawList->AddRect(cursor_pos - font_off_up + ImVec2(0,2), cursor_pos + font_off_dn - ImVec2(0,3), window->Color(ImGuiCol_Text)); |
| 5318 | | |
| 5522 | |
| 5319 | 5523 | // Notify OS of text input position |
| 5320 | 5524 | if (io.ImeSetInputScreenPosFn && ImLengthSqr(edit_state.LastCursorPos - cursor_pos) > 0.0001f) |
| 5321 | 5525 | io.ImeSetInputScreenPosFn((int)cursor_pos.x - 1, (int)(cursor_pos.y - window->FontSize())); // -1 x offset so that Windows IME can cover our cursor. Bit of an extra nicety. |
| r244546 | r244547 | |
|---|
| 5333 | 5537 | |
| 5334 | 5538 | static bool InputFloatN(const char* label, float* v, int components, int decimal_precision) |
| 5335 | 5539 | { |
| 5336 | | ImGuiState& g = GImGui; |
| 5540 | ImGuiState& g = *GImGui; |
| 5337 | 5541 | ImGuiWindow* window = GetCurrentWindow(); |
| 5338 | 5542 | if (window->SkipItems) |
| 5339 | 5543 | return false; |
| 5340 | 5544 | |
| 5341 | 5545 | const ImGuiStyle& style = g.Style; |
| 5342 | | const float w_full = window->DC.ItemWidth.back(); |
| 5546 | const float w_full = ImGui::CalcItemWidth(); |
| 5343 | 5547 | const float w_item_one = ImMax(1.0f, (float)(int)((w_full - (style.FramePadding.x*2.0f + style.ItemInnerSpacing.x) * (components-1)) / (float)components)); |
| 5344 | 5548 | const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.FramePadding.x*2.0f + style.ItemInnerSpacing.x) * (components-1))); |
| 5345 | 5549 | |
| r244546 | r244547 | |
|---|
| 5381 | 5585 | return InputFloatN(label, v, 4, decimal_precision); |
| 5382 | 5586 | } |
| 5383 | 5587 | |
| 5384 | | static bool Combo_ArrayGetter(void* data, int idx, const char** out_text) |
| 5588 | static bool Items_ArrayGetter(void* data, int idx, const char** out_text) |
| 5385 | 5589 | { |
| 5386 | 5590 | const char** items = (const char**)data; |
| 5387 | 5591 | if (out_text) |
| r244546 | r244547 | |
|---|
| 5389 | 5593 | return true; |
| 5390 | 5594 | } |
| 5391 | 5595 | |
| 5392 | | // Combo box helper allowing to pass an array of strings. |
| 5393 | | bool ImGui::Combo(const char* label, int* current_item, const char** items, int items_count, int popup_height_items) |
| 5596 | static bool Items_SingleStringGetter(void* data, int idx, const char** out_text) |
| 5394 | 5597 | { |
| 5395 | | const bool value_changed = Combo(label, current_item, Combo_ArrayGetter, (void*)items, items_count, popup_height_items); |
| 5396 | | return value_changed; |
| 5397 | | } |
| 5398 | | |
| 5399 | | static bool Combo_StringListGetter(void* data, int idx, const char** out_text) |
| 5400 | | { |
| 5401 | | // FIXME-OPT: we could precompute the indices to fasten this. But only 1 active combo means the waste is limited. |
| 5598 | // FIXME-OPT: we could pre-compute the indices to fasten this. But only 1 active combo means the waste is limited. |
| 5402 | 5599 | const char* items_separated_by_zeros = (const char*)data; |
| 5403 | 5600 | int items_count = 0; |
| 5404 | 5601 | const char* p = items_separated_by_zeros; |
| r244546 | r244547 | |
|---|
| 5416 | 5613 | return true; |
| 5417 | 5614 | } |
| 5418 | 5615 | |
| 5616 | // Combo box helper allowing to pass an array of strings. |
| 5617 | bool ImGui::Combo(const char* label, int* current_item, const char** items, int items_count, int height_in_items) |
| 5618 | { |
| 5619 | const bool value_changed = Combo(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_in_items); |
| 5620 | return value_changed; |
| 5621 | } |
| 5622 | |
| 5419 | 5623 | // Combo box helper allowing to pass all items in a single string. |
| 5420 | | bool ImGui::Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int popup_height_items) |
| 5624 | bool ImGui::Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items) |
| 5421 | 5625 | { |
| 5422 | 5626 | int items_count = 0; |
| 5423 | | const char* p = items_separated_by_zeros; |
| 5627 | const char* p = items_separated_by_zeros; // FIXME-OPT: Avoid computing this |
| 5424 | 5628 | while (*p) |
| 5425 | 5629 | { |
| 5426 | 5630 | p += strlen(p) + 1; |
| 5427 | 5631 | items_count++; |
| 5428 | 5632 | } |
| 5429 | | bool value_changed = Combo(label, current_item, Combo_StringListGetter, (void*)items_separated_by_zeros, items_count, popup_height_items); |
| 5633 | bool value_changed = Combo(label, current_item, Items_SingleStringGetter, (void*)items_separated_by_zeros, items_count, height_in_items); |
| 5430 | 5634 | return value_changed; |
| 5431 | 5635 | } |
| 5432 | 5636 | |
| 5433 | 5637 | // Combo box function. |
| 5434 | | bool ImGui::Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int popup_height_items) |
| 5638 | bool ImGui::Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items) |
| 5435 | 5639 | { |
| 5436 | | ImGuiState& g = GImGui; |
| 5640 | ImGuiState& g = *GImGui; |
| 5437 | 5641 | ImGuiWindow* window = GetCurrentWindow(); |
| 5438 | 5642 | if (window->SkipItems) |
| 5439 | 5643 | return false; |
| 5440 | 5644 | |
| 5441 | 5645 | const ImGuiStyle& style = g.Style; |
| 5442 | 5646 | const ImGuiID id = window->GetID(label); |
| 5443 | | const float w = window->DC.ItemWidth.back(); |
| 5647 | const float w = ImGui::CalcItemWidth(); |
| 5444 | 5648 | |
| 5445 | 5649 | const ImVec2 text_size = CalcTextSize(label, NULL, true); |
| 5446 | 5650 | const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f); |
| r244546 | r244547 | |
|---|
| 5453 | 5657 | const bool hovered = IsHovered(frame_bb, id); |
| 5454 | 5658 | |
| 5455 | 5659 | bool value_changed = false; |
| 5660 | const ImGuiAabb value_bb(frame_bb.Min, frame_bb.Max - ImVec2(arrow_size, 0.0f)); |
| 5456 | 5661 | RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding); |
| 5457 | 5662 | RenderFrame(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y), frame_bb.Max, window->Color(hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button), true, style.FrameRounding); // FIXME-ROUNDING |
| 5458 | 5663 | RenderCollapseTriangle(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y) + style.FramePadding, true); |
| r244546 | r244547 | |
|---|
| 5461 | 5666 | { |
| 5462 | 5667 | const char* item_text; |
| 5463 | 5668 | if (items_getter(data, *current_item, &item_text)) |
| 5464 | | RenderText(frame_bb.Min + style.FramePadding, item_text, NULL, false); |
| 5669 | RenderTextClipped(frame_bb.Min + style.FramePadding, item_text, NULL, NULL, value_bb.Max); |
| 5465 | 5670 | } |
| 5466 | 5671 | |
| 5467 | 5672 | // Empty text doesn't add padding |
| r244546 | r244547 | |
|---|
| 5484 | 5689 | FocusWindow(window); |
| 5485 | 5690 | } |
| 5486 | 5691 | } |
| 5487 | | |
| 5692 | |
| 5488 | 5693 | if (g.ActiveComboID == id) |
| 5489 | 5694 | { |
| 5695 | // Size default to hold ~7 items |
| 5696 | if (height_in_items < 0) |
| 5697 | height_in_items = 7; |
| 5698 | |
| 5490 | 5699 | const ImVec2 backup_pos = ImGui::GetCursorPos(); |
| 5491 | 5700 | const float popup_off_x = 0.0f;//style.ItemInnerSpacing.x; |
| 5492 | | const float popup_height = (text_size.y + style.ItemSpacing.y) * ImMin(items_count, popup_height_items) + style.WindowPadding.y; |
| 5701 | const float popup_height = (text_size.y + style.ItemSpacing.y) * ImMin(items_count, height_in_items) + style.WindowPadding.y; |
| 5493 | 5702 | const ImGuiAabb popup_aabb(ImVec2(frame_bb.Min.x+popup_off_x, frame_bb.Max.y), ImVec2(frame_bb.Max.x+popup_off_x, frame_bb.Max.y + popup_height)); |
| 5494 | 5703 | ImGui::SetCursorPos(popup_aabb.Min - window->Pos); |
| 5495 | 5704 | |
| 5496 | 5705 | const ImGuiWindowFlags flags = ImGuiWindowFlags_ComboBox | ((window->Flags & ImGuiWindowFlags_ShowBorders) ? ImGuiWindowFlags_ShowBorders : 0); |
| 5497 | 5706 | ImGui::BeginChild("#ComboBox", popup_aabb.GetSize(), false, flags); |
| 5498 | | ImGuiWindow* child_window = GetCurrentWindow(); |
| 5499 | 5707 | ImGui::Spacing(); |
| 5500 | 5708 | |
| 5501 | 5709 | bool combo_item_active = false; |
| 5502 | | combo_item_active |= (g.ActiveId == child_window->GetID("#SCROLLY")); |
| 5710 | combo_item_active |= (g.ActiveId == GetCurrentWindow()->GetID("#SCROLLY")); |
| 5503 | 5711 | |
| 5504 | 5712 | // Display items |
| 5505 | | for (int item_idx = 0; item_idx < items_count; item_idx++) |
| 5713 | for (int i = 0; i < items_count; i++) |
| 5506 | 5714 | { |
| 5507 | | const float item_h = child_window->FontSize(); |
| 5508 | | const float spacing_up = (float)(int)(style.ItemSpacing.y/2); |
| 5509 | | const float spacing_dn = style.ItemSpacing.y - spacing_up; |
| 5510 | | const ImGuiAabb item_aabb(ImVec2(popup_aabb.Min.x, child_window->DC.CursorPos.y - spacing_up), ImVec2(popup_aabb.Max.x, child_window->DC.CursorPos.y + item_h + spacing_dn)); |
| 5511 | | const ImGuiID item_id = child_window->GetID((void*)(intptr_t)item_idx); |
| 5512 | | |
| 5513 | | bool item_hovered, item_held; |
| 5514 | | bool item_pressed = ButtonBehaviour(item_aabb, item_id, &item_hovered, &item_held, true); |
| 5515 | | bool item_selected = (item_idx == *current_item); |
| 5516 | | |
| 5517 | | if (item_hovered || item_selected) |
| 5518 | | { |
| 5519 | | const ImU32 col = window->Color((item_held && item_hovered) ? ImGuiCol_HeaderActive : item_hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header); |
| 5520 | | RenderFrame(item_aabb.Min, item_aabb.Max, col, false); |
| 5521 | | } |
| 5522 | | |
| 5715 | ImGui::PushID((void*)(intptr_t)i); |
| 5716 | const bool item_selected = (i == *current_item); |
| 5523 | 5717 | const char* item_text; |
| 5524 | | if (!items_getter(data, item_idx, &item_text)) |
| 5718 | if (!items_getter(data, i, &item_text)) |
| 5525 | 5719 | item_text = "*Unknown item*"; |
| 5526 | | ImGui::TextUnformatted(item_text); |
| 5527 | | |
| 5528 | | if (item_selected) |
| 5720 | if (ImGui::Selectable(item_text, item_selected)) |
| 5529 | 5721 | { |
| 5530 | | if (menu_toggled) |
| 5531 | | ImGui::SetScrollPosHere(); |
| 5532 | | } |
| 5533 | | if (item_pressed) |
| 5534 | | { |
| 5535 | 5722 | SetActiveId(0); |
| 5536 | 5723 | g.ActiveComboID = 0; |
| 5537 | 5724 | value_changed = true; |
| 5538 | | *current_item = item_idx; |
| 5725 | *current_item = i; |
| 5539 | 5726 | } |
| 5540 | | |
| 5541 | | combo_item_active |= (g.ActiveId == item_id); |
| 5727 | if (item_selected && menu_toggled) |
| 5728 | ImGui::SetScrollPosHere(); |
| 5729 | combo_item_active |= ImGui::IsItemActive(); |
| 5730 | ImGui::PopID(); |
| 5542 | 5731 | } |
| 5543 | 5732 | ImGui::EndChild(); |
| 5544 | 5733 | ImGui::SetCursorPos(backup_pos); |
| 5545 | | |
| 5734 | |
| 5546 | 5735 | if (!combo_item_active && g.ActiveId != 0) |
| 5547 | 5736 | g.ActiveComboID = 0; |
| 5548 | 5737 | } |
| r244546 | r244547 | |
|---|
| 5552 | 5741 | return value_changed; |
| 5553 | 5742 | } |
| 5554 | 5743 | |
| 5744 | // Tip: pass an empty label (e.g. "##dummy") then you can use the space to draw other text or image. |
| 5745 | // But you need to make sure the ID is unique, e.g. enclose calls in PushID/PopID. |
| 5746 | bool ImGui::Selectable(const char* label, bool selected, const ImVec2& size_arg) |
| 5747 | { |
| 5748 | ImGuiState& g = *GImGui; |
| 5749 | ImGuiWindow* window = GetCurrentWindow(); |
| 5750 | if (window->SkipItems) |
| 5751 | return false; |
| 5752 | |
| 5753 | const ImGuiStyle& style = g.Style; |
| 5754 | const ImGuiID id = window->GetID(label); |
| 5755 | const ImVec2 text_size = CalcTextSize(label, NULL, true); |
| 5756 | |
| 5757 | const float w = window->Pos.x + ImGui::GetContentRegionMax().x - window->DC.CursorPos.x; |
| 5758 | const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : w, size_arg.y != 0.0f ? size_arg.y : text_size.y); |
| 5759 | const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + size); |
| 5760 | ItemSize(bb); |
| 5761 | |
| 5762 | // Selectables are meant to be tightly packed together. So for both rendering and collision we extend to compensate for spacing. |
| 5763 | ImGuiAabb bb_with_spacing = bb; |
| 5764 | const float spacing_L = (float)(int)(style.ItemSpacing.x * 0.5f); |
| 5765 | const float spacing_U = (float)(int)(style.ItemSpacing.y * 0.5f); |
| 5766 | const float spacing_R = style.ItemSpacing.x - spacing_L; |
| 5767 | const float spacing_D = style.ItemSpacing.y - spacing_U; |
| 5768 | bb_with_spacing.Min.x -= spacing_L; |
| 5769 | bb_with_spacing.Min.y -= spacing_U; |
| 5770 | bb_with_spacing.Max.x += spacing_R; |
| 5771 | bb_with_spacing.Max.y += spacing_D; |
| 5772 | if (!ItemAdd(bb_with_spacing, &id)) |
| 5773 | return false; |
| 5774 | |
| 5775 | bool hovered, held; |
| 5776 | bool pressed = ButtonBehaviour(bb_with_spacing, id, &hovered, &held, true, false, false); |
| 5777 | |
| 5778 | // Render |
| 5779 | if (hovered || selected) |
| 5780 | { |
| 5781 | const ImU32 col = window->Color((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header); |
| 5782 | RenderFrame(bb_with_spacing.Min, bb_with_spacing.Max, col, false, style.FrameRounding); |
| 5783 | } |
| 5784 | |
| 5785 | //const ImVec2 off = ImVec2(ImMax(0.0f, size.x - text_size.x) * 0.5f, ImMax(0.0f, size.y - text_size.y) * 0.5f); |
| 5786 | RenderTextClipped(bb.Min, label, NULL, &text_size, bb_with_spacing.Max); |
| 5787 | |
| 5788 | return pressed; |
| 5789 | } |
| 5790 | |
| 5791 | bool ImGui::Selectable(const char* label, bool* p_selected, const ImVec2& size_arg) |
| 5792 | { |
| 5793 | if (ImGui::Selectable(label, *p_selected, size_arg)) |
| 5794 | { |
| 5795 | *p_selected = !*p_selected; |
| 5796 | return true; |
| 5797 | } |
| 5798 | return false; |
| 5799 | } |
| 5800 | |
| 5801 | // Helper to calculate the size of a listbox and display a label on the right. |
| 5802 | // Tip: To have a list filling the entire window width, PushItemWidth(-1) and pass an empty label "##empty" |
| 5803 | bool ImGui::ListBoxHeader(const char* label, const ImVec2& size_arg) |
| 5804 | { |
| 5805 | ImGuiWindow* window = GetCurrentWindow(); |
| 5806 | if (window->SkipItems) |
| 5807 | return false; |
| 5808 | |
| 5809 | const ImGuiStyle& style = ImGui::GetStyle(); |
| 5810 | const ImGuiID id = ImGui::GetID(label); |
| 5811 | const ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true); |
| 5812 | |
| 5813 | // Size default to hold ~7 items. Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar. |
| 5814 | ImVec2 size; |
| 5815 | size.x = (size_arg.x != 0.0f) ? size_arg.x : ImGui::CalcItemWidth() + style.FramePadding.x * 2.0f; |
| 5816 | size.y = (size_arg.y != 0.0f) ? size_arg.y : ImGui::GetTextLineHeightWithSpacing() * 7.4f + style.ItemSpacing.y; |
| 5817 | const ImVec2 frame_size = ImVec2(size.x, ImMax(size.y, label_size.y)); |
| 5818 | const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size); |
| 5819 | |
| 5820 | if (label_size.x > 0) |
| 5821 | RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label); |
| 5822 | |
| 5823 | ImGui::BeginChildFrame(id, frame_bb.GetSize()); |
| 5824 | return true; |
| 5825 | } |
| 5826 | |
| 5827 | bool ImGui::ListBoxHeader(const char* label, int items_count, int height_in_items) |
| 5828 | { |
| 5829 | // Size default to hold ~7 items. Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar. |
| 5830 | // However we don't add +0.40f if items_count <= height_in_items. It is slightly dodgy, because it means a dynamic list of items will make the widget resize occasionally when it crosses that size. |
| 5831 | // I am expecting that someone will come and complain about this behavior in a remote future, then we can advise on a better solution. |
| 5832 | if (height_in_items < 0) |
| 5833 | height_in_items = ImMin(items_count, 7); |
| 5834 | float height_in_items_f = height_in_items < items_count ? (height_in_items + 0.40f) : (height_in_items + 0.00f); |
| 5835 | |
| 5836 | // We include ItemSpacing.y so that a list sized for the exact number of items doesn't make a scrollbar appears. We could also enforce that by passing a flag to BeginChild(). |
| 5837 | ImVec2 size; |
| 5838 | size.x = 0.0f; |
| 5839 | size.y = ImGui::GetTextLineHeightWithSpacing() * height_in_items_f + ImGui::GetStyle().ItemSpacing.y; |
| 5840 | return ImGui::ListBoxHeader(label, size); |
| 5841 | } |
| 5842 | |
| 5843 | void ImGui::ListBoxFooter() |
| 5844 | { |
| 5845 | ImGui::EndChildFrame(); |
| 5846 | } |
| 5847 | |
| 5848 | bool ImGui::ListBox(const char* label, int* current_item, const char** items, int items_count, int height_items) |
| 5849 | { |
| 5850 | const bool value_changed = ListBox(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_items); |
| 5851 | return value_changed; |
| 5852 | } |
| 5853 | |
| 5854 | bool ImGui::ListBox(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items) |
| 5855 | { |
| 5856 | if (!ImGui::ListBoxHeader(label, items_count, height_in_items)) |
| 5857 | return false; |
| 5858 | |
| 5859 | bool value_changed = false; |
| 5860 | for (int i = 0; i < items_count; i++) |
| 5861 | { |
| 5862 | const bool item_selected = (i == *current_item); |
| 5863 | const char* item_text; |
| 5864 | if (!items_getter(data, i, &item_text)) |
| 5865 | item_text = "*Unknown item*"; |
| 5866 | |
| 5867 | ImGui::PushID(i); |
| 5868 | if (ImGui::Selectable(item_text, item_selected)) |
| 5869 | { |
| 5870 | *current_item = i; |
| 5871 | value_changed = true; |
| 5872 | } |
| 5873 | ImGui::PopID(); |
| 5874 | } |
| 5875 | |
| 5876 | ImGui::ListBoxFooter(); |
| 5877 | return value_changed; |
| 5878 | } |
| 5879 | |
| 5555 | 5880 | // A little colored square. Return true when clicked. |
| 5556 | 5881 | bool ImGui::ColorButton(const ImVec4& col, bool small_height, bool outline_border) |
| 5557 | 5882 | { |
| 5558 | | ImGuiState& g = GImGui; |
| 5883 | ImGuiState& g = *GImGui; |
| 5559 | 5884 | ImGuiWindow* window = GetCurrentWindow(); |
| 5560 | 5885 | if (window->SkipItems) |
| 5561 | 5886 | return false; |
| r244546 | r244547 | |
|---|
| 5602 | 5927 | // Use CTRL-Click to input value and TAB to go to next item. |
| 5603 | 5928 | bool ImGui::ColorEdit4(const char* label, float col[4], bool alpha) |
| 5604 | 5929 | { |
| 5605 | | ImGuiState& g = GImGui; |
| 5930 | ImGuiState& g = *GImGui; |
| 5606 | 5931 | ImGuiWindow* window = GetCurrentWindow(); |
| 5607 | 5932 | if (window->SkipItems) |
| 5608 | 5933 | return false; |
| 5609 | 5934 | |
| 5610 | 5935 | const ImGuiStyle& style = g.Style; |
| 5611 | 5936 | const ImGuiID id = window->GetID(label); |
| 5612 | | const float w_full = window->DC.ItemWidth.back(); |
| 5937 | const float w_full = ImGui::CalcItemWidth(); |
| 5613 | 5938 | const float square_sz = (window->FontSize() + style.FramePadding.x * 2.0f); |
| 5614 | 5939 | |
| 5615 | 5940 | ImGuiColorEditMode edit_mode = window->DC.ColorEditMode; |
| r244546 | r244547 | |
|---|
| 5681 | 6006 | value_changed |= ImGui::InputText("##Text", buf, IM_ARRAYSIZE(buf), ImGuiInputTextFlags_CharsHexadecimal); |
| 5682 | 6007 | ImGui::PopItemWidth(); |
| 5683 | 6008 | char* p = buf; |
| 5684 | | while (*p == '#' || *p == ' ' || *p == '\t') |
| 6009 | while (*p == '#' || *p == ' ' || *p == '\t') |
| 5685 | 6010 | p++; |
| 5686 | 6011 | |
| 5687 | 6012 | // Treat at unsigned (%X is unsigned) |
| r244546 | r244547 | |
|---|
| 5785 | 6110 | // Advance cursor given item size. |
| 5786 | 6111 | static void ItemSize(ImVec2 size, ImVec2* adjust_vertical_offset) |
| 5787 | 6112 | { |
| 5788 | | ImGuiState& g = GImGui; |
| 6113 | ImGuiState& g = *GImGui; |
| 5789 | 6114 | ImGuiWindow* window = GetCurrentWindow(); |
| 5790 | 6115 | if (window->SkipItems) |
| 5791 | 6116 | return; |
| r244546 | r244547 | |
|---|
| 5804 | 6129 | window->DC.CurrentLineHeight = 0.0f; |
| 5805 | 6130 | } |
| 5806 | 6131 | |
| 5807 | | static void ItemSize(const ImGuiAabb& aabb, ImVec2* adjust_start_offset) |
| 5808 | | { |
| 5809 | | ItemSize(aabb.GetSize(), adjust_start_offset); |
| 6132 | static void ItemSize(const ImGuiAabb& aabb, ImVec2* adjust_start_offset) |
| 6133 | { |
| 6134 | ItemSize(aabb.GetSize(), adjust_start_offset); |
| 5810 | 6135 | } |
| 5811 | 6136 | |
| 5812 | 6137 | static bool IsClipped(const ImGuiAabb& bb) |
| 5813 | 6138 | { |
| 5814 | | ImGuiState& g = GImGui; |
| 6139 | ImGuiState& g = *GImGui; |
| 5815 | 6140 | ImGuiWindow* window = GetCurrentWindow(); |
| 5816 | 6141 | |
| 5817 | 6142 | if (!bb.Overlaps(ImGuiAabb(window->ClipRectStack.back())) && !g.LogEnabled) |
| r244546 | r244547 | |
|---|
| 5846 | 6171 | // spacing_w >= 0 : enforce spacing |
| 5847 | 6172 | void ImGui::SameLine(int column_x, int spacing_w) |
| 5848 | 6173 | { |
| 5849 | | ImGuiState& g = GImGui; |
| 6174 | ImGuiState& g = *GImGui; |
| 5850 | 6175 | ImGuiWindow* window = GetCurrentWindow(); |
| 5851 | 6176 | if (window->SkipItems) |
| 5852 | 6177 | return; |
| 5853 | | |
| 6178 | |
| 5854 | 6179 | float x, y; |
| 5855 | 6180 | if (column_x != 0) |
| 5856 | 6181 | { |
| r244546 | r244547 | |
|---|
| 5870 | 6195 | |
| 5871 | 6196 | void ImGui::NextColumn() |
| 5872 | 6197 | { |
| 5873 | | ImGuiState& g = GImGui; |
| 6198 | ImGuiState& g = *GImGui; |
| 5874 | 6199 | ImGuiWindow* window = GetCurrentWindow(); |
| 5875 | 6200 | if (window->SkipItems) |
| 5876 | 6201 | return; |
| r244546 | r244547 | |
|---|
| 5900 | 6225 | } |
| 5901 | 6226 | } |
| 5902 | 6227 | |
| 6228 | // FIMXE-OPT: This is called too often. We need to cache offset for active columns set. |
| 5903 | 6229 | float ImGui::GetColumnOffset(int column_index) |
| 5904 | 6230 | { |
| 5905 | | ImGuiState& g = GImGui; |
| 6231 | ImGuiState& g = *GImGui; |
| 5906 | 6232 | ImGuiWindow* window = GetCurrentWindow(); |
| 5907 | 6233 | if (column_index < 0) |
| 5908 | 6234 | column_index = window->DC.ColumnsCurrent; |
| r244546 | r244547 | |
|---|
| 5918 | 6244 | |
| 5919 | 6245 | void ImGui::SetColumnOffset(int column_index, float offset) |
| 5920 | 6246 | { |
| 5921 | | ImGuiState& g = GImGui; |
| 6247 | ImGuiState& g = *GImGui; |
| 5922 | 6248 | ImGuiWindow* window = GetCurrentWindow(); |
| 5923 | 6249 | if (column_index < 0) |
| 5924 | 6250 | column_index = window->DC.ColumnsCurrent; |
| r244546 | r244547 | |
|---|
| 5951 | 6277 | |
| 5952 | 6278 | void ImGui::Columns(int columns_count, const char* id, bool border) |
| 5953 | 6279 | { |
| 5954 | | ImGuiState& g = GImGui; |
| 6280 | ImGuiState& g = *GImGui; |
| 5955 | 6281 | ImGuiWindow* window = GetCurrentWindow(); |
| 5956 | 6282 | if (window->SkipItems) |
| 5957 | 6283 | return; |
| r244546 | r244547 | |
|---|
| 5975 | 6301 | for (int i = 1; i < window->DC.ColumnsCount; i++) |
| 5976 | 6302 | { |
| 5977 | 6303 | float x = window->Pos.x + GetColumnOffset(i); |
| 5978 | | |
| 6304 | |
| 5979 | 6305 | const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(i); |
| 5980 | 6306 | const ImGuiAabb column_aabb(ImVec2(x-4,y1),ImVec2(x+4,y2)); |
| 5981 | 6307 | |
| r244546 | r244547 | |
|---|
| 6019 | 6345 | |
| 6020 | 6346 | void ImGui::TreePush(const char* str_id) |
| 6021 | 6347 | { |
| 6022 | | ImGuiState& g = GImGui; |
| 6348 | ImGuiState& g = *GImGui; |
| 6023 | 6349 | ImGuiWindow* window = GetCurrentWindow(); |
| 6024 | 6350 | window->DC.ColumnsStartX += g.Style.TreeNodeSpacing; |
| 6025 | 6351 | window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX; |
| r244546 | r244547 | |
|---|
| 6029 | 6355 | |
| 6030 | 6356 | void ImGui::TreePush(const void* ptr_id) |
| 6031 | 6357 | { |
| 6032 | | ImGuiState& g = GImGui; |
| 6358 | ImGuiState& g = *GImGui; |
| 6033 | 6359 | ImGuiWindow* window = GetCurrentWindow(); |
| 6034 | 6360 | window->DC.ColumnsStartX += g.Style.TreeNodeSpacing; |
| 6035 | 6361 | window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX; |
| r244546 | r244547 | |
|---|
| 6039 | 6365 | |
| 6040 | 6366 | void ImGui::TreePop() |
| 6041 | 6367 | { |
| 6042 | | ImGuiState& g = GImGui; |
| 6368 | ImGuiState& g = *GImGui; |
| 6043 | 6369 | ImGuiWindow* window = GetCurrentWindow(); |
| 6044 | 6370 | window->DC.ColumnsStartX -= g.Style.TreeNodeSpacing; |
| 6045 | 6371 | window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX; |
| r244546 | r244547 | |
|---|
| 6151 | 6477 | } |
| 6152 | 6478 | } |
| 6153 | 6479 | |
| 6480 | // Scissoring. The values in clip_rect are x1, y1, x2, y2. |
| 6154 | 6481 | void ImDrawList::PushClipRect(const ImVec4& clip_rect) |
| 6155 | 6482 | { |
| 6156 | 6483 | clip_rect_stack.push_back(clip_rect); |
| r244546 | r244547 | |
|---|
| 6206 | 6533 | { |
| 6207 | 6534 | vtx_write->pos = pos; |
| 6208 | 6535 | vtx_write->col = col; |
| 6209 | | vtx_write->uv = GImGui.FontTexUvWhitePixel; |
| 6536 | vtx_write->uv = GImGui->FontTexUvWhitePixel; |
| 6210 | 6537 | vtx_write++; |
| 6211 | 6538 | } |
| 6212 | 6539 | |
| r244546 | r244547 | |
|---|
| 6261 | 6588 | } |
| 6262 | 6589 | circle_vtx_builds = true; |
| 6263 | 6590 | } |
| 6264 | | |
| 6591 | |
| 6265 | 6592 | if (tris) |
| 6266 | 6593 | { |
| 6267 | 6594 | ReserveVertices((unsigned int)(a_max-a_min) * 3); |
| r244546 | r244547 | |
|---|
| 6341 | 6668 | AddVtx(ImVec2(a.x+r,a.y), col); |
| 6342 | 6669 | AddVtx(ImVec2(b.x-r,b.y), col); |
| 6343 | 6670 | AddVtx(ImVec2(a.x+r,b.y), col); |
| 6344 | | |
| 6671 | |
| 6345 | 6672 | float top_y = (rounding_corners & 1) ? a.y+r : a.y; |
| 6346 | 6673 | float bot_y = (rounding_corners & 8) ? b.y-r : b.y; |
| 6347 | 6674 | AddVtx(ImVec2(a.x,top_y), col); |
| r244546 | r244547 | |
|---|
| 6412 | 6739 | } |
| 6413 | 6740 | } |
| 6414 | 6741 | |
| 6415 | | void ImDrawList::AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width) |
| 6742 | void ImDrawList::AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width, const ImVec2* cpu_clip_max) |
| 6416 | 6743 | { |
| 6417 | 6744 | if ((col >> 24) == 0) |
| 6418 | 6745 | return; |
| r244546 | r244547 | |
|---|
| 6428 | 6755 | const size_t vtx_begin = vtx_buffer.size(); |
| 6429 | 6756 | ReserveVertices(vtx_count_max); |
| 6430 | 6757 | |
| 6431 | | font->RenderText(font_size, pos, col, clip_rect_stack.back(), text_begin, text_end, vtx_write, wrap_width); |
| 6758 | font->RenderText(font_size, pos, col, clip_rect_stack.back(), text_begin, text_end, vtx_write, wrap_width, cpu_clip_max); |
| 6432 | 6759 | |
| 6433 | 6760 | // give back unused vertices |
| 6434 | 6761 | vtx_buffer.resize((size_t)(vtx_write - &vtx_buffer.front())); |
| r244546 | r244547 | |
|---|
| 6516 | 6843 | |
| 6517 | 6844 | void ImFontAtlas::Clear() |
| 6518 | 6845 | { |
| 6519 | | ClearInputData(); |
| 6846 | ClearInputData(); |
| 6520 | 6847 | ClearTexData(); |
| 6521 | 6848 | for (size_t i = 0; i < Fonts.size(); i++) |
| 6522 | 6849 | { |
| r244546 | r244547 | |
|---|
| 6655 | 6982 | IM_ASSERT(data.OutFont && !data.OutFont->IsLoaded()); |
| 6656 | 6983 | const int font_offset = stbtt_GetFontOffsetForIndex((unsigned char*)data.TTFData, data.FontNo); |
| 6657 | 6984 | IM_ASSERT(font_offset >= 0); |
| 6658 | | if (!stbtt_InitFont(&data.FontInfo, (unsigned char*)data.TTFData, font_offset)) |
| 6985 | if (!stbtt_InitFont(&data.FontInfo, (unsigned char*)data.TTFData, font_offset)) |
| 6659 | 6986 | return false; |
| 6660 | 6987 | |
| 6661 | 6988 | if (!data.GlyphRanges) |
| r244546 | r244547 | |
|---|
| 6678 | 7005 | |
| 6679 | 7006 | // Pack our extra data rectangle first, so it will be on the upper-left corner of our texture (UV will have small values). |
| 6680 | 7007 | stbrp_rect extra_rect; |
| 6681 | | extra_rect.w = (int)TEX_ATLAS_SIZE.x; |
| 6682 | | extra_rect.h = (int)TEX_ATLAS_SIZE.y; |
| 7008 | extra_rect.w = (stbrp_coord)TEX_ATLAS_SIZE.x; |
| 7009 | extra_rect.h = (stbrp_coord)TEX_ATLAS_SIZE.y; |
| 6683 | 7010 | stbrp_pack_rects((stbrp_context*)spc.pack_info, &extra_rect, 1); |
| 6684 | 7011 | TexExtraDataPos = ImVec2(extra_rect.x, extra_rect.y); |
| 6685 | 7012 | |
| r244546 | r244547 | |
|---|
| 6900 | 7227 | { |
| 6901 | 7228 | // Store the 1946 ideograms code points as successive offsets from the initial unicode codepoint 0x4E00. Each offset has an implicit +1. |
| 6902 | 7229 | // This encoding helps us reduce the source code size. |
| 6903 | | static const short offsets_from_0x4E00[] = |
| 7230 | static const short offsets_from_0x4E00[] = |
| 6904 | 7231 | { |
| 6905 | 7232 | -1,0,1,3,0,0,0,0,1,0,5,1,1,0,7,4,6,10,0,1,9,9,7,1,3,19,1,10,7,1,0,1,0,5,1,0,6,4,2,6,0,0,12,6,8,0,3,5,0,1,0,9,0,0,8,1,1,3,4,5,13,0,0,8,2,17, |
| 6906 | 7233 | 4,3,1,1,9,6,0,0,0,2,1,3,2,22,1,9,11,1,13,1,3,12,0,5,9,2,0,6,12,5,3,12,4,1,2,16,1,1,4,6,5,3,0,6,13,15,5,12,8,14,0,0,6,15,3,6,0,18,8,1,6,14,1, |
| r244546 | r244547 | |
|---|
| 6941 | 7268 | 0x0020, 0x00FF, // Basic Latin + Latin Supplement |
| 6942 | 7269 | 0x3040, 0x309F, // Hiragana, Katakana |
| 6943 | 7270 | 0xFF00, 0xFFEF, // Half-width characters |
| 6944 | | 0, |
| 7271 | 0, |
| 6945 | 7272 | }; |
| 6946 | 7273 | if (!ranges_unpacked) |
| 6947 | 7274 | { |
| r244546 | r244547 | |
|---|
| 7007 | 7334 | *out_char = c; |
| 7008 | 7335 | return 1; |
| 7009 | 7336 | } |
| 7010 | | if ((*str & 0xe0) == 0xc0) |
| 7337 | if ((*str & 0xe0) == 0xc0) |
| 7011 | 7338 | { |
| 7012 | 7339 | if (in_text_end && in_text_end - (const char*)str < 2) return -1; |
| 7013 | 7340 | if (*str < 0xc2) return -1; |
| r244546 | r244547 | |
|---|
| 7017 | 7344 | *out_char = c; |
| 7018 | 7345 | return 2; |
| 7019 | 7346 | } |
| 7020 | | if ((*str & 0xf0) == 0xe0) |
| 7347 | if ((*str & 0xf0) == 0xe0) |
| 7021 | 7348 | { |
| 7022 | 7349 | if (in_text_end && in_text_end - (const char*)str < 3) return -1; |
| 7023 | 7350 | if (*str == 0xe0 && (str[1] < 0xa0 || str[1] > 0xbf)) return -1; |
| r244546 | r244547 | |
|---|
| 7030 | 7357 | *out_char = c; |
| 7031 | 7358 | return 3; |
| 7032 | 7359 | } |
| 7033 | | if ((*str & 0xf8) == 0xf0) |
| 7360 | if ((*str & 0xf8) == 0xf0) |
| 7034 | 7361 | { |
| 7035 | 7362 | if (in_text_end && in_text_end - (const char*)str < 4) return -1; |
| 7036 | 7363 | if (*str > 0xf4) return -1; |
| r244546 | r244547 | |
|---|
| 7088 | 7415 | { |
| 7089 | 7416 | size_t i = 0; |
| 7090 | 7417 | size_t n = buf_size; |
| 7091 | | if (c < 0x80) |
| 7418 | if (c < 0x80) |
| 7092 | 7419 | { |
| 7093 | 7420 | if (i+1 > n) return 0; |
| 7094 | 7421 | buf[i++] = (char)c; |
| 7095 | 7422 | return 1; |
| 7096 | | } |
| 7097 | | else if (c < 0x800) |
| 7423 | } |
| 7424 | else if (c < 0x800) |
| 7098 | 7425 | { |
| 7099 | 7426 | if (i+2 > n) return 0; |
| 7100 | 7427 | buf[i++] = (char)(0xc0 + (c >> 6)); |
| r244546 | r244547 | |
|---|
| 7104 | 7431 | else if (c >= 0xdc00 && c < 0xe000) |
| 7105 | 7432 | { |
| 7106 | 7433 | return 0; |
| 7107 | | } |
| 7108 | | else if (c >= 0xd800 && c < 0xdc00) |
| 7434 | } |
| 7435 | else if (c >= 0xd800 && c < 0xdc00) |
| 7109 | 7436 | { |
| 7110 | 7437 | if (i+4 > n) return 0; |
| 7111 | 7438 | buf[i++] = (char)(0xf0 + (c >> 18)); |
| r244546 | r244547 | |
|---|
| 7287 | 7614 | unsigned int c; |
| 7288 | 7615 | const int bytes_count = ImTextCharFromUtf8(&c, s, text_end); |
| 7289 | 7616 | s += bytes_count > 0 ? bytes_count : 1; |
| 7290 | | |
| 7617 | |
| 7291 | 7618 | if (c == '\n') |
| 7292 | 7619 | { |
| 7293 | 7620 | text_size.x = ImMax(text_size.x, line_width); |
| r244546 | r244547 | |
|---|
| 7295 | 7622 | line_width = 0.0f; |
| 7296 | 7623 | continue; |
| 7297 | 7624 | } |
| 7298 | | |
| 7625 | |
| 7299 | 7626 | float char_width = 0.0f; |
| 7300 | 7627 | if (const Glyph* glyph = FindGlyph((unsigned short)c)) |
| 7301 | 7628 | char_width = glyph->XAdvance * scale; |
| r244546 | r244547 | |
|---|
| 7342 | 7669 | line_width = 0.0f; |
| 7343 | 7670 | continue; |
| 7344 | 7671 | } |
| 7345 | | |
| 7672 | |
| 7346 | 7673 | float char_width = 0.0f; |
| 7347 | 7674 | if (const Glyph* glyph = FindGlyph((unsigned short)c)) |
| 7348 | 7675 | char_width = glyph->XAdvance * scale; |
| r244546 | r244547 | |
|---|
| 7366 | 7693 | return text_size; |
| 7367 | 7694 | } |
| 7368 | 7695 | |
| 7369 | | void ImFont::RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect_ref, const char* text_begin, const char* text_end, ImDrawVert*& out_vertices, float wrap_width) const |
| 7696 | void ImFont::RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect_ref, const char* text_begin, const char* text_end, ImDrawVert*& out_vertices, float wrap_width, const ImVec2* cpu_clip_max) const |
| 7370 | 7697 | { |
| 7371 | 7698 | if (!text_end) |
| 7372 | 7699 | text_end = text_begin + strlen(text_begin); |
| r244546 | r244547 | |
|---|
| 7381 | 7708 | const bool word_wrap_enabled = (wrap_width > 0.0f); |
| 7382 | 7709 | const char* word_wrap_eol = NULL; |
| 7383 | 7710 | |
| 7384 | | const ImVec4 clip_rect = clip_rect_ref; |
| 7711 | ImVec4 clip_rect = clip_rect_ref; |
| 7712 | if (cpu_clip_max) |
| 7713 | { |
| 7714 | clip_rect.z = ImMin(clip_rect.z, cpu_clip_max->x); |
| 7715 | clip_rect.w = ImMin(clip_rect.w, cpu_clip_max->y); |
| 7716 | } |
| 7385 | 7717 | float x = pos.x; |
| 7386 | 7718 | float y = pos.y; |
| 7387 | 7719 | |
| r244546 | r244547 | |
|---|
| 7433 | 7765 | if (c != ' ' && c != '\t') |
| 7434 | 7766 | { |
| 7435 | 7767 | // Clipping on Y is more likely |
| 7436 | | const float y1 = (float)(y + glyph->YOffset * scale); |
| 7437 | | const float y2 = (float)(y1 + glyph->Height * scale); |
| 7768 | float y1 = (float)(y + glyph->YOffset * scale); |
| 7769 | float y2 = (float)(y1 + glyph->Height * scale); |
| 7438 | 7770 | if (y1 <= clip_rect.w && y2 >= clip_rect.y) |
| 7439 | 7771 | { |
| 7440 | | const float x1 = (float)(x + glyph->XOffset * scale); |
| 7441 | | const float x2 = (float)(x1 + glyph->Width * scale); |
| 7772 | float x1 = (float)(x + glyph->XOffset * scale); |
| 7773 | float x2 = (float)(x1 + glyph->Width * scale); |
| 7442 | 7774 | if (x1 <= clip_rect.z && x2 >= clip_rect.x) |
| 7443 | 7775 | { |
| 7444 | 7776 | // Render a character |
| 7445 | | const float u0 = glyph->U0; |
| 7446 | | const float v0 = glyph->V0; |
| 7447 | | const float u1 = glyph->U1; |
| 7448 | | const float v1 = glyph->V1; |
| 7777 | float u1 = glyph->U0; |
| 7778 | float v1 = glyph->V0; |
| 7779 | float u2 = glyph->U1; |
| 7780 | float v2 = glyph->V1; |
| 7449 | 7781 | |
| 7782 | // CPU side clipping used to fit text in their frame when the frame is too small. Only does clipping for axis aligned quad and in the "max" direction (bottom-right) |
| 7783 | if (cpu_clip_max) |
| 7784 | { |
| 7785 | if (x2 > cpu_clip_max->x) |
| 7786 | { |
| 7787 | const float clip_tx = (cpu_clip_max->x - x1) / (x2 - x1); |
| 7788 | x2 = cpu_clip_max->x; |
| 7789 | u2 = u1 + clip_tx * (u2 - u1); |
| 7790 | } |
| 7791 | if (y2 > cpu_clip_max->y) |
| 7792 | { |
| 7793 | const float clip_ty = (cpu_clip_max->y - y1) / (y2 - y1); |
| 7794 | y2 = cpu_clip_max->y; |
| 7795 | v2 = v1 + clip_ty * (v2 - v1); |
| 7796 | } |
| 7797 | } |
| 7798 | |
| 7450 | 7799 | out_vertices[0].pos = ImVec2(x1, y1); |
| 7451 | | out_vertices[0].uv = ImVec2(u0, v0); |
| 7800 | out_vertices[0].uv = ImVec2(u1, v1); |
| 7452 | 7801 | out_vertices[0].col = col; |
| 7453 | 7802 | |
| 7454 | 7803 | out_vertices[1].pos = ImVec2(x2, y1); |
| 7455 | | out_vertices[1].uv = ImVec2(u1, v0); |
| 7804 | out_vertices[1].uv = ImVec2(u2, v1); |
| 7456 | 7805 | out_vertices[1].col = col; |
| 7457 | 7806 | |
| 7458 | 7807 | out_vertices[2].pos = ImVec2(x2, y2); |
| 7459 | | out_vertices[2].uv = ImVec2(u1, v1); |
| 7808 | out_vertices[2].uv = ImVec2(u2, v2); |
| 7460 | 7809 | out_vertices[2].col = col; |
| 7461 | 7810 | |
| 7462 | 7811 | out_vertices[3] = out_vertices[0]; |
| 7463 | 7812 | out_vertices[4] = out_vertices[2]; |
| 7464 | 7813 | |
| 7465 | 7814 | out_vertices[5].pos = ImVec2(x1, y2); |
| 7466 | | out_vertices[5].uv = ImVec2(u0, v1); |
| 7815 | out_vertices[5].uv = ImVec2(u1, v2); |
| 7467 | 7816 | out_vertices[5].col = col; |
| 7468 | 7817 | |
| 7469 | 7818 | out_vertices += 6; |
| r244546 | r244547 | |
|---|
| 7494 | 7843 | ImGui::MemFree(buf_local); |
| 7495 | 7844 | buf_local = NULL; |
| 7496 | 7845 | } |
| 7497 | | if (!OpenClipboard(NULL)) |
| 7846 | if (!OpenClipboard(NULL)) |
| 7498 | 7847 | return NULL; |
| 7499 | | HANDLE buf_handle = GetClipboardData(CF_TEXT); |
| 7848 | HANDLE buf_handle = GetClipboardData(CF_TEXT); |
| 7500 | 7849 | if (buf_handle == NULL) |
| 7501 | 7850 | return NULL; |
| 7502 | 7851 | if (char* buf_global = (char*)GlobalLock(buf_handle)) |
| 7503 | 7852 | buf_local = ImStrdup(buf_global); |
| 7504 | | GlobalUnlock(buf_handle); |
| 7505 | | CloseClipboard(); |
| 7853 | GlobalUnlock(buf_handle); |
| 7854 | CloseClipboard(); |
| 7506 | 7855 | return buf_local; |
| 7507 | 7856 | } |
| 7508 | 7857 | |
| r244546 | r244547 | |
|---|
| 7513 | 7862 | return; |
| 7514 | 7863 | const char* text_end = text + strlen(text); |
| 7515 | 7864 | const int buf_length = (int)(text_end - text) + 1; |
| 7516 | | HGLOBAL buf_handle = GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)buf_length * sizeof(char)); |
| 7865 | HGLOBAL buf_handle = GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)buf_length * sizeof(char)); |
| 7517 | 7866 | if (buf_handle == NULL) |
| 7518 | 7867 | return; |
| 7519 | | char* buf_global = (char *)GlobalLock(buf_handle); |
| 7868 | char* buf_global = (char *)GlobalLock(buf_handle); |
| 7520 | 7869 | memcpy(buf_global, text, (size_t)(text_end - text)); |
| 7521 | 7870 | buf_global[text_end - text] = 0; |
| 7522 | | GlobalUnlock(buf_handle); |
| 7871 | GlobalUnlock(buf_handle); |
| 7523 | 7872 | EmptyClipboard(); |
| 7524 | 7873 | SetClipboardData(CF_TEXT, buf_handle); |
| 7525 | 7874 | CloseClipboard(); |
| r244546 | r244547 | |
|---|
| 7530 | 7879 | // Local ImGui-only clipboard implementation, if user hasn't defined better clipboard handlers |
| 7531 | 7880 | static const char* GetClipboardTextFn_DefaultImpl() |
| 7532 | 7881 | { |
| 7533 | | return GImGui.PrivateClipboard; |
| 7882 | return GImGui->PrivateClipboard; |
| 7534 | 7883 | } |
| 7535 | 7884 | |
| 7536 | 7885 | // Local ImGui-only clipboard implementation, if user hasn't defined better clipboard handlers |
| 7537 | 7886 | static void SetClipboardTextFn_DefaultImpl(const char* text) |
| 7538 | 7887 | { |
| 7539 | | if (GImGui.PrivateClipboard) |
| 7888 | ImGuiState& g = *GImGui; |
| 7889 | if (g.PrivateClipboard) |
| 7540 | 7890 | { |
| 7541 | | ImGui::MemFree(GImGui.PrivateClipboard); |
| 7542 | | GImGui.PrivateClipboard = NULL; |
| 7891 | ImGui::MemFree(g.PrivateClipboard); |
| 7892 | g.PrivateClipboard = NULL; |
| 7543 | 7893 | } |
| 7544 | 7894 | const char* text_end = text + strlen(text); |
| 7545 | | GImGui.PrivateClipboard = (char*)ImGui::MemAlloc((size_t)(text_end - text) + 1); |
| 7546 | | memcpy(GImGui.PrivateClipboard, text, (size_t)(text_end - text)); |
| 7547 | | GImGui.PrivateClipboard[(size_t)(text_end - text)] = 0; |
| 7895 | g.PrivateClipboard = (char*)ImGui::MemAlloc((size_t)(text_end - text) + 1); |
| 7896 | memcpy(g.PrivateClipboard, text, (size_t)(text_end - text)); |
| 7897 | g.PrivateClipboard[(size_t)(text_end - text)] = 0; |
| 7548 | 7898 | } |
| 7549 | 7899 | |
| 7550 | 7900 | #endif |
| r244546 | r244547 | |
|---|
| 7555 | 7905 | |
| 7556 | 7906 | void ImGui::ShowUserGuide() |
| 7557 | 7907 | { |
| 7558 | | ImGuiState& g = GImGui; |
| 7908 | ImGuiState& g = *GImGui; |
| 7559 | 7909 | |
| 7560 | 7910 | ImGui::BulletText("Double-click on title bar to collapse window."); |
| 7561 | 7911 | ImGui::BulletText("Click and drag on lower right corner to resize window."); |
| r244546 | r244547 | |
|---|
| 7579 | 7929 | |
| 7580 | 7930 | void ImGui::ShowStyleEditor(ImGuiStyle* ref) |
| 7581 | 7931 | { |
| 7582 | | ImGuiState& g = GImGui; |
| 7932 | ImGuiState& g = *GImGui; |
| 7583 | 7933 | ImGuiStyle& style = g.Style; |
| 7584 | 7934 | |
| 7585 | 7935 | const ImGuiStyle def; // Default style |
| r244546 | r244547 | |
|---|
| 7600 | 7950 | ImGui::SliderFloat("Alpha", &style.Alpha, 0.20f, 1.0f, "%.2f"); // Not exposing zero here so user doesn't "lose" the UI. But application code could have a toggle to switch between zero and non-zero. |
| 7601 | 7951 | ImGui::SliderFloat2("WindowPadding", (float*)&style.WindowPadding, 0.0f, 20.0f, "%.0f"); |
| 7602 | 7952 | ImGui::SliderFloat("WindowRounding", &style.WindowRounding, 0.0f, 16.0f, "%.0f"); |
| 7953 | ImGui::SliderFloat("ChildWindowRounding", &style.ChildWindowRounding, 0.0f, 16.0f, "%.0f"); |
| 7603 | 7954 | ImGui::SliderFloat2("FramePadding", (float*)&style.FramePadding, 0.0f, 20.0f, "%.0f"); |
| 7604 | 7955 | ImGui::SliderFloat("FrameRounding", &style.FrameRounding, 0.0f, 16.0f, "%.0f"); |
| 7605 | 7956 | ImGui::SliderFloat2("ItemSpacing", (float*)&style.ItemSpacing, 0.0f, 20.0f, "%.0f"); |
| r244546 | r244547 | |
|---|
| 7687 | 8038 | static bool no_resize = false; |
| 7688 | 8039 | static bool no_move = false; |
| 7689 | 8040 | static bool no_scrollbar = false; |
| 8041 | static bool no_collapse = false; |
| 7690 | 8042 | static float fill_alpha = 0.65f; |
| 7691 | 8043 | |
| 7692 | | const ImGuiWindowFlags layout_flags = (no_titlebar ? ImGuiWindowFlags_NoTitleBar : 0) | (no_border ? 0 : ImGuiWindowFlags_ShowBorders) | (no_resize ? ImGuiWindowFlags_NoResize : 0) | (no_move ? ImGuiWindowFlags_NoMove : 0) | (no_scrollbar ? ImGuiWindowFlags_NoScrollbar : 0); |
| 7693 | | if (!ImGui::Begin("ImGui Test", opened, ImVec2(550,680), fill_alpha, layout_flags)) |
| 8044 | // Demonstrate the various window flags. Typically you would just use the default. |
| 8045 | ImGuiWindowFlags window_flags = 0; |
| 8046 | if (no_titlebar) window_flags |= ImGuiWindowFlags_NoTitleBar; |
| 8047 | if (!no_border) window_flags |= ImGuiWindowFlags_ShowBorders; |
| 8048 | if (no_resize) window_flags |= ImGuiWindowFlags_NoResize; |
| 8049 | if (no_move) window_flags |= ImGuiWindowFlags_NoMove; |
| 8050 | if (no_scrollbar) window_flags |= ImGuiWindowFlags_NoScrollbar; |
| 8051 | if (no_collapse) window_flags |= ImGuiWindowFlags_NoCollapse; |
| 8052 | if (!ImGui::Begin("ImGui Test", opened, ImVec2(550,680), fill_alpha, window_flags)) |
| 7694 | 8053 | { |
| 7695 | 8054 | // Early out if the window is collapsed, as an optimization. |
| 7696 | 8055 | ImGui::End(); |
| r244546 | r244547 | |
|---|
| 7701 | 8060 | ImGui::Text("ImGui says hello."); |
| 7702 | 8061 | //ImGui::Text("MousePos (%g, %g)", ImGui::GetIO().MousePos.x, ImGui::GetIO().MousePos.y); |
| 7703 | 8062 | //ImGui::Text("MouseWheel %d", ImGui::GetIO().MouseWheel); |
| 8063 | //ImGui::Text("WantCaptureMouse: %d", ImGui::GetIO().WantCaptureMouse); |
| 8064 | //ImGui::Text("WantCaptureKeyboard: %d", ImGui::GetIO().WantCaptureKeyboard); |
| 7704 | 8065 | |
| 7705 | 8066 | ImGui::Spacing(); |
| 7706 | 8067 | if (ImGui::CollapsingHeader("Help")) |
| r244546 | r244547 | |
|---|
| 7713 | 8074 | { |
| 7714 | 8075 | ImGui::Checkbox("no titlebar", &no_titlebar); ImGui::SameLine(150); |
| 7715 | 8076 | ImGui::Checkbox("no border", &no_border); ImGui::SameLine(300); |
| 7716 | | ImGui::Checkbox("no resize", &no_resize); |
| 8077 | ImGui::Checkbox("no resize", &no_resize); |
| 7717 | 8078 | ImGui::Checkbox("no move", &no_move); ImGui::SameLine(150); |
| 7718 | | ImGui::Checkbox("no scrollbar", &no_scrollbar); |
| 8079 | ImGui::Checkbox("no scrollbar", &no_scrollbar); ImGui::SameLine(300); |
| 8080 | ImGui::Checkbox("no collapse", &no_collapse); |
| 7719 | 8081 | ImGui::SliderFloat("fill alpha", &fill_alpha, 0.0f, 1.0f); |
| 7720 | 8082 | |
| 7721 | 8083 | if (ImGui::TreeNode("Style")) |
| r244546 | r244547 | |
|---|
| 7763 | 8125 | if (ImGui::Button("Button")) { printf("Clicked\n"); a ^= 1; } |
| 7764 | 8126 | if (a) |
| 7765 | 8127 | { |
| 7766 | | ImGui::SameLine(); |
| 8128 | ImGui::SameLine(); |
| 7767 | 8129 | ImGui::Text("Thanks for clicking me!"); |
| 7768 | 8130 | } |
| 7769 | 8131 | |
| r244546 | r244547 | |
|---|
| 7841 | 8203 | ImGui::TreePop(); |
| 7842 | 8204 | } |
| 7843 | 8205 | |
| 8206 | if (ImGui::TreeNode("Clipping")) |
| 8207 | { |
| 8208 | static ImVec2 size(80, 20); |
| 8209 | ImGui::TextWrapped("On a per-widget basis we are occasionally clipping text if it won't fit in its frame."); |
| 8210 | ImGui::SliderFloat2("size", (float*)&size, 5.0f, 200.0f); |
| 8211 | ImGui::Button("Line 1 hello\nLine 2 clip me!", size); |
| 8212 | ImGui::TextWrapped("Otherwise we are doing coarser clipping + passing a scissor rectangle to the renderer. The system is designed to try minimizing both execution and rendering cost."); |
| 8213 | ImGui::TreePop(); |
| 8214 | } |
| 8215 | |
| 7844 | 8216 | if (ImGui::TreeNode("Images")) |
| 7845 | 8217 | { |
| 7846 | 8218 | ImGui::TextWrapped("Below we are displaying the font texture (which is the only texture we have access to in this demo). Use the 'ImTextureID' type as storage to pass pointers or identifier to your own texture data. Hover the texture for a zoomed view!"); |
| r244546 | r244547 | |
|---|
| 7878 | 8250 | ImGui::TreePop(); |
| 7879 | 8251 | } |
| 7880 | 8252 | |
| 8253 | if (ImGui::TreeNode("Selectables")) |
| 8254 | { |
| 8255 | if (ImGui::TreeNode("Basic")) |
| 8256 | { |
| 8257 | static bool selected[3] = { false, true, false }; |
| 8258 | ImGui::Selectable("1. I am selectable", &selected[0]); |
| 8259 | ImGui::Selectable("2. I am selectable", &selected[1]); |
| 8260 | ImGui::Text("3. I am normal text"); |
| 8261 | ImGui::Selectable("4. I am selectable", &selected[2]); |
| 8262 | ImGui::TreePop(); |
| 8263 | } |
| 8264 | if (ImGui::TreeNode("Rendering more text into the same block")) |
| 8265 | { |
| 8266 | static bool selected[3] = { false, false, false }; |
| 8267 | ImGui::Selectable("main.c", &selected[0]); ImGui::SameLine(300); ImGui::Text(" 2,345 bytes"); |
| 8268 | ImGui::Selectable("Hello.cpp", &selected[1]); ImGui::SameLine(300); ImGui::Text("12,345 bytes"); |
| 8269 | ImGui::Selectable("Hello.h", &selected[2]); ImGui::SameLine(300); ImGui::Text(" 2,345 bytes"); |
| 8270 | ImGui::TreePop(); |
| 8271 | } |
| 8272 | if (ImGui::TreeNode("Grid")) |
| 8273 | { |
| 8274 | static bool selected[16] = { true, false, false, false, false, true, false, false, false, false, true, false, false, false, false, true }; |
| 8275 | for (int i = 0; i < 16; i++) |
| 8276 | { |
| 8277 | ImGui::PushID(i); |
| 8278 | if (ImGui::Selectable("Me", &selected[i], ImVec2(50,50))) |
| 8279 | { |
| 8280 | int x = i % 4, y = i / 4; |
| 8281 | if (x > 0) selected[i - 1] ^= 1; |
| 8282 | if (x < 3) selected[i + 1] ^= 1; |
| 8283 | if (y > 0) selected[i - 4] ^= 1; |
| 8284 | if (y < 3) selected[i + 4] ^= 1; |
| 8285 | } |
| 8286 | if ((i % 4) < 3) ImGui::SameLine(); |
| 8287 | ImGui::PopID(); |
| 8288 | } |
| 8289 | ImGui::TreePop(); |
| 8290 | } |
| 8291 | ImGui::TreePop(); |
| 8292 | } |
| 8293 | |
| 7881 | 8294 | static bool check = true; |
| 7882 | 8295 | ImGui::Checkbox("checkbox", &check); |
| 7883 | 8296 | |
| r244546 | r244547 | |
|---|
| 7974 | 8387 | static float col2[4] = { 0.4f,0.7f,0.0f,0.5f }; |
| 7975 | 8388 | ImGui::ColorEdit3("color 1", col1); |
| 7976 | 8389 | ImGui::ColorEdit4("color 2", col2); |
| 8390 | |
| 8391 | const char* listbox_items[] = { "Apple", "Banana", "Cherry", "Kiwi", "Mango", "Orange", "Pineapple", "Strawberry", "Watermelon" }; |
| 8392 | static int listbox_item_current = 1; |
| 8393 | ImGui::ListBox("listbox\n(single select)", &listbox_item_current, listbox_items, IM_ARRAYSIZE(listbox_items), 4); |
| 8394 | |
| 8395 | //ImGui::PushItemWidth(-1); |
| 8396 | //ImGui::ListBox("##listbox2", &listbox_item_current2, listbox_items, IM_ARRAYSIZE(listbox_items), 4); |
| 8397 | //ImGui::PopItemWidth(); |
| 7977 | 8398 | } |
| 7978 | 8399 | |
| 7979 | 8400 | if (ImGui::CollapsingHeader("Graphs widgets")) |
| r244546 | r244547 | |
|---|
| 7982 | 8403 | ImGui::PlotLines("Frame Times", arr, IM_ARRAYSIZE(arr)); |
| 7983 | 8404 | |
| 7984 | 8405 | static bool pause; |
| 7985 | | static ImVector<float> values; if (values.empty()) { values.resize(100); memset(&values.front(), 0, values.size()*sizeof(float)); } |
| 7986 | | static size_t values_offset = 0; |
| 7987 | | if (!pause) |
| 7988 | | { |
| 8406 | static ImVector<float> values; if (values.empty()) { values.resize(100); memset(&values.front(), 0, values.size()*sizeof(float)); } |
| 8407 | static size_t values_offset = 0; |
| 8408 | if (!pause) |
| 8409 | { |
| 7989 | 8410 | // create dummy data at fixed 60 hz rate |
| 7990 | 8411 | static float refresh_time = -1.0f; |
| 7991 | 8412 | if (ImGui::GetTime() > refresh_time + 1.0f/60.0f) |
| 7992 | 8413 | { |
| 7993 | 8414 | refresh_time = ImGui::GetTime(); |
| 7994 | 8415 | static float phase = 0.0f; |
| 7995 | | values[values_offset] = cosf(phase); |
| 7996 | | values_offset = (values_offset+1)%values.size(); |
| 7997 | | phase += 0.10f*values_offset; |
| 8416 | values[values_offset] = cosf(phase); |
| 8417 | values_offset = (values_offset+1)%values.size(); |
| 8418 | phase += 0.10f*values_offset; |
| 7998 | 8419 | } |
| 7999 | 8420 | } |
| 8000 | 8421 | ImGui::PlotLines("Frame Times", &values.front(), (int)values.size(), (int)values_offset, "avg 0.0", -1.0f, 1.0f, ImVec2(0,70)); |
| r244546 | r244547 | |
|---|
| 8049 | 8470 | ImGui::Text("Without border"); |
| 8050 | 8471 | static int line = 50; |
| 8051 | 8472 | bool goto_line = ImGui::Button("Goto"); |
| 8052 | | ImGui::SameLine(); |
| 8473 | ImGui::SameLine(); |
| 8053 | 8474 | ImGui::PushItemWidth(100); |
| 8054 | 8475 | goto_line |= ImGui::InputInt("##Line", &line, 0, 0, ImGuiInputTextFlags_EnterReturnsTrue); |
| 8055 | 8476 | ImGui::PopItemWidth(); |
| r244546 | r244547 | |
|---|
| 8066 | 8487 | |
| 8067 | 8488 | ImGui::SameLine(); |
| 8068 | 8489 | |
| 8490 | ImGui::PushStyleVar(ImGuiStyleVar_ChildWindowRounding, 5.0f); |
| 8069 | 8491 | ImGui::BeginChild("Sub2", ImVec2(0,300), true); |
| 8070 | 8492 | ImGui::Text("With border"); |
| 8071 | 8493 | ImGui::Columns(2); |
| r244546 | r244547 | |
|---|
| 8078 | 8500 | ImGui::Button(buf); |
| 8079 | 8501 | } |
| 8080 | 8502 | ImGui::EndChild(); |
| 8503 | ImGui::PopStyleVar(); |
| 8081 | 8504 | } |
| 8082 | 8505 | |
| 8083 | 8506 | if (ImGui::CollapsingHeader("Columns")) |
| r244546 | r244547 | |
|---|
| 8111 | 8534 | |
| 8112 | 8535 | // Create multiple items in a same cell because switching to next column |
| 8113 | 8536 | static int e = 0; |
| 8114 | | ImGui::Text("Hello"); |
| 8537 | ImGui::Text("Hello"); |
| 8115 | 8538 | ImGui::Button("Banana"); |
| 8116 | | ImGui::RadioButton("radio a", &e, 0); |
| 8539 | ImGui::RadioButton("radio a", &e, 0); |
| 8117 | 8540 | ImGui::NextColumn(); |
| 8118 | 8541 | |
| 8119 | | ImGui::Text("ImGui"); |
| 8542 | ImGui::Text("ImGui"); |
| 8120 | 8543 | ImGui::Button("Apple"); |
| 8121 | 8544 | ImGui::RadioButton("radio b", &e, 1); |
| 8122 | 8545 | ImGui::Text("An extra line here."); |
| 8123 | 8546 | ImGui::NextColumn(); |
| 8124 | | |
| 8547 | |
| 8125 | 8548 | ImGui::Text("World!"); |
| 8126 | 8549 | ImGui::Button("Corniflower"); |
| 8127 | 8550 | ImGui::RadioButton("radio c", &e, 2); |
| r244546 | r244547 | |
|---|
| 8143 | 8566 | ImGui::Columns(1); |
| 8144 | 8567 | |
| 8145 | 8568 | ImGui::Separator(); |
| 8146 | | |
| 8569 | |
| 8570 | ImGui::Columns(2, "tree items"); |
| 8571 | if (ImGui::TreeNode("Hello")) { ImGui::BulletText("World"); ImGui::TreePop(); } ImGui::NextColumn(); |
| 8572 | if (ImGui::TreeNode("Bonjour")) { ImGui::BulletText("Monde"); ImGui::TreePop(); } |
| 8573 | ImGui::Columns(1); |
| 8574 | ImGui::Separator(); |
| 8575 | |
| 8147 | 8576 | ImGui::Columns(2, "word wrapping"); |
| 8148 | 8577 | ImGui::TextWrapped("The quick brown fox jumps over the lazy dog."); |
| 8149 | 8578 | ImGui::Text("Hello Left"); |
| r244546 | r244547 | |
|---|
| 8227 | 8656 | bool focus_3 = ImGui::Button("Focus on 3"); |
| 8228 | 8657 | int has_focus = 0; |
| 8229 | 8658 | static char buf[128] = "click on a button to set focus"; |
| 8230 | | |
| 8659 | |
| 8231 | 8660 | if (focus_1) ImGui::SetKeyboardFocusHere(); |
| 8232 | 8661 | ImGui::InputText("1", buf, IM_ARRAYSIZE(buf)); |
| 8233 | 8662 | if (ImGui::IsItemActive()) has_focus = 1; |
| 8234 | | |
| 8663 | |
| 8235 | 8664 | if (focus_2) ImGui::SetKeyboardFocusHere(); |
| 8236 | 8665 | ImGui::InputText("2", buf, IM_ARRAYSIZE(buf)); |
| 8237 | 8666 | if (ImGui::IsItemActive()) has_focus = 2; |
| r244546 | r244547 | |
|---|
| 8243 | 8672 | ImGui::PopAllowKeyboardFocus(); |
| 8244 | 8673 | if (has_focus) |
| 8245 | 8674 | ImGui::Text("Item with focus: %d", has_focus); |
| 8246 | | else |
| 8675 | else |
| 8247 | 8676 | ImGui::Text("Item with focus: <none>"); |
| 8248 | 8677 | ImGui::TreePop(); |
| 8249 | 8678 | } |
| r244546 | r244547 | |
|---|
| 8304 | 8733 | ImGui::SetWindowPos(ImVec2(10,10)); |
| 8305 | 8734 | ImGui::Text("Simple overlay\non the top-left side of the screen."); |
| 8306 | 8735 | ImGui::Separator(); |
| 8307 | | ImGui::Text("Mouse Position: (%.1f,%.1f)", ImGui::GetIO().MousePos.x, ImGui::GetIO().MousePos.y); |
| 8736 | ImGui::Text("Mouse Position: (%.1f,%.1f)", ImGui::GetIO().MousePos.x, ImGui::GetIO().MousePos.y); |
| 8308 | 8737 | |
| 8309 | 8738 | ImGui::End(); |
| 8310 | 8739 | } |
| r244546 | r244547 | |
|---|
| 8333 | 8762 | |
| 8334 | 8763 | // Here we are using InvisibleButton() as a convenience to 1) advance the cursor and 2) allows us to use IsItemHovered() |
| 8335 | 8764 | // However you can draw directly and poll mouse/keyboard by yourself. You can manipulate the cursor using GetCursorPos() and SetCursorPos(). |
| 8336 | | // If you only use the ImDrawList API, you can notify the owner window of its extends by using SetCursorPos(max) followed by an empty Text("") statement. |
| 8765 | // If you only use the ImDrawList API, you can notify the owner window of its extends by using SetCursorPos(max). |
| 8337 | 8766 | ImVec2 canvas_pos = ImGui::GetCursorScreenPos(); // ImDrawList API uses screen coordinates! |
| 8338 | 8767 | ImVec2 canvas_size = ImVec2(ImMax(50.0f,ImGui::GetWindowContentRegionMax().x-ImGui::GetCursorPos().x), ImMax(50.0f,ImGui::GetWindowContentRegionMax().y-ImGui::GetCursorPos().y)); // Resize canvas what's available |
| 8339 | 8768 | draw_list->AddRect(canvas_pos, ImVec2(canvas_pos.x + canvas_size.x, canvas_pos.y + canvas_size.y), 0xFFFFFFFF); |
| r244546 | r244547 | |
|---|
| 8391 | 8820 | ~ExampleAppConsole() |
| 8392 | 8821 | { |
| 8393 | 8822 | ClearLog(); |
| 8394 | | for (size_t i = 0; i < Items.size(); i++) |
| 8395 | | ImGui::MemFree(History[i]); |
| 8823 | for (size_t i = 0; i < Items.size(); i++) |
| 8824 | ImGui::MemFree(History[i]); |
| 8396 | 8825 | } |
| 8397 | 8826 | |
| 8398 | 8827 | void ClearLog() |
| 8399 | 8828 | { |
| 8400 | | for (size_t i = 0; i < Items.size(); i++) |
| 8401 | | ImGui::MemFree(Items[i]); |
| 8829 | for (size_t i = 0; i < Items.size(); i++) |
| 8830 | ImGui::MemFree(Items[i]); |
| 8402 | 8831 | Items.clear(); |
| 8403 | 8832 | ScrollToBottom = true; |
| 8404 | 8833 | } |
| r244546 | r244547 | |
|---|
| 8428 | 8857 | // TODO: display from bottom |
| 8429 | 8858 | // TODO: clip manually |
| 8430 | 8859 | |
| 8431 | | if (ImGui::SmallButton("Add Dummy Text")) AddLog("some text\nsome more text\ndisplay very important message here!\n"); ImGui::SameLine(); |
| 8432 | | if (ImGui::SmallButton("Add Dummy Error")) AddLog("[error] something went wrong"); ImGui::SameLine(); |
| 8860 | if (ImGui::SmallButton("Add Dummy Text")) { AddLog("%d some text", Items.size()); AddLog("some more text"); AddLog("display very important message here!"); } ImGui::SameLine(); |
| 8861 | if (ImGui::SmallButton("Add Dummy Error")) AddLog("[error] something went wrong"); ImGui::SameLine(); |
| 8433 | 8862 | if (ImGui::SmallButton("Clear")) ClearLog(); |
| 8434 | 8863 | ImGui::Separator(); |
| 8435 | 8864 | |
| r244546 | r244547 | |
|---|
| 8441 | 8870 | ImGui::Separator(); |
| 8442 | 8871 | |
| 8443 | 8872 | // Display every line as a separate entry so we can change their color or add custom widgets. If you only want raw text you can use ImGui::TextUnformatted(log.begin(), log.end()); |
| 8444 | | // NB- if you have lots of text this approach may be too inefficient. You can seek and display only the lines that are on display using a technique similar to what TextUnformatted() does, |
| 8445 | | // or faster if your entries are already stored into a table. |
| 8446 | | ImGui::BeginChild("ScrollingRegion", ImVec2(0,-ImGui::GetTextLineSpacing()*2)); |
| 8873 | // NB- if you have thousands of entries this approach may be too inefficient. You can seek and display only the lines that are visible - CalcListClipping() is a helper to compute this information. |
| 8874 | // If your items are of variable size you may want to implement code similar to what CalcListClipping() does. Or split your data into fixed height items to allow random-seeking into your list. |
| 8875 | ImGui::BeginChild("ScrollingRegion", ImVec2(0,-ImGui::GetTextLineHeightWithSpacing()*2)); |
| 8447 | 8876 | ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4,1)); // Tighten spacing |
| 8448 | 8877 | for (size_t i = 0; i < Items.size(); i++) |
| 8449 | 8878 | { |
| r244546 | r244547 | |
|---|
| 8637 | 9066 | return; |
| 8638 | 9067 | } |
| 8639 | 9068 | |
| 9069 | static int test_type = 0; |
| 8640 | 9070 | static ImGuiTextBuffer log; |
| 8641 | 9071 | static int lines = 0; |
| 8642 | 9072 | ImGui::Text("Printing unusually long amount of text."); |
| 9073 | ImGui::Combo("Test type", &test_type, "Single call to TextUnformatted()\0Multiple calls to Text(), clipped manually\0Multiple calls to Text(), not clipped"); |
| 8643 | 9074 | ImGui::Text("Buffer contents: %d lines, %d bytes", lines, log.size()); |
| 8644 | 9075 | if (ImGui::Button("Clear")) { log.clear(); lines = 0; } |
| 8645 | 9076 | ImGui::SameLine(); |
| r244546 | r244547 | |
|---|
| 8650 | 9081 | lines += 1000; |
| 8651 | 9082 | } |
| 8652 | 9083 | ImGui::BeginChild("Log"); |
| 8653 | | ImGui::TextUnformatted(log.begin(), log.end()); |
| 9084 | switch (test_type) |
| 9085 | { |
| 9086 | case 0: |
| 9087 | // Single call to TextUnformatted() with a big buffer |
| 9088 | ImGui::TextUnformatted(log.begin(), log.end()); |
| 9089 | break; |
| 9090 | case 1: |
| 9091 | // Multiple calls to Text(), manually coarsely clipped - demonstrate how to use the CalcListClipping() helper. |
| 9092 | ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0,0)); |
| 9093 | int display_start, display_end; |
| 9094 | ImGui::CalcListClipping(lines, ImGui::GetTextLineHeight(), &display_start, &display_end); |
| 9095 | ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (display_start) * ImGui::GetTextLineHeight()); |
| 9096 | for (int i = display_start; i < display_end; i++) |
| 9097 | ImGui::Text("%i The quick brown fox jumps over the lazy dog\n", i); |
| 9098 | ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (lines - display_end) * ImGui::GetTextLineHeight()); |
| 9099 | ImGui::PopStyleVar(); |
| 9100 | break; |
| 9101 | case 2: |
| 9102 | // Multiple calls to Text(), not clipped |
| 9103 | ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0,0)); |
| 9104 | for (int i = 0; i < lines; i++) |
| 9105 | ImGui::Text("%i The quick brown fox jumps over the lazy dog\n", i); |
| 9106 | ImGui::PopStyleVar(); |
| 9107 | break; |
| 9108 | } |
| 8654 | 9109 | ImGui::EndChild(); |
| 8655 | | |
| 8656 | 9110 | ImGui::End(); |
| 8657 | 9111 | } |
| 8658 | 9112 | |
| r244546 | r244547 | |
|---|
| 8748 | 9202 | buflen -= blocklen; |
| 8749 | 9203 | blocklen = 5552; |
| 8750 | 9204 | } |
| 8751 | | return (s2 << 16) + s1; |
| 9205 | return (unsigned int)(s2 << 16) + (unsigned int)s1; |
| 8752 | 9206 | } |
| 8753 | 9207 | |
| 8754 | 9208 | static unsigned int stb_decompress(unsigned char *output, unsigned char *i, unsigned int length) |
| r244546 | r244547 | |
|---|
| 8764 | 9218 | i += 16; |
| 8765 | 9219 | |
| 8766 | 9220 | stb__dout = output; |
| 8767 | | while (1) { |
| 9221 | for (;;) { |
| 8768 | 9222 | unsigned char *old_i = i; |
| 8769 | 9223 | i = stb_decompress_token(i); |
| 8770 | 9224 | if (i == old_i) { |
| r244546 | r244547 | |
|---|
| 8779 | 9233 | return 0; |
| 8780 | 9234 | } |
| 8781 | 9235 | } |
| 8782 | | assert(stb__dout <= output + olen); |
| 9236 | assert(stb__dout <= output + olen); |
| 8783 | 9237 | if (stb__dout > output + olen) |
| 8784 | 9238 | return 0; |
| 8785 | 9239 | } |
| r244546 | r244547 | |
|---|
| 8788 | 9242 | static const unsigned int proggy_clean_ttf_compressed_size = 9583; |
| 8789 | 9243 | static const unsigned int proggy_clean_ttf_compressed_data[9584/4] = |
| 8790 | 9244 | { |
| 8791 | | 0x0000bc57, 0x00000000, 0xf8a00000, 0x00000400, 0x00010037, 0x000c0000, 0x00030080, 0x2f534f40, 0x74eb8832, 0x01000090, 0x2c158248, 0x616d634e, |
| 8792 | | 0x23120270, 0x03000075, 0x241382a0, 0x74766352, 0x82178220, 0xfc042102, 0x02380482, 0x66796c67, 0x5689af12, 0x04070000, 0x80920000, 0x64616568, |
| 8793 | | 0xd36691d7, 0xcc201b82, 0x36210382, 0x27108268, 0xc3014208, 0x04010000, 0x243b0f82, 0x78746d68, 0x807e008a, 0x98010000, 0x06020000, 0x61636f6c, |
| 8794 | | 0xd8b0738c, 0x82050000, 0x0402291e, 0x7078616d, 0xda00ae01, 0x28201f82, 0x202c1082, 0x656d616e, 0x96bb5925, 0x84990000, 0x9e2c1382, 0x74736f70, |
| 8795 | | 0xef83aca6, 0x249b0000, 0xd22c3382, 0x70657270, 0x12010269, 0xf4040000, 0x08202f82, 0x012ecb84, 0x553c0000, 0x0f5fd5e9, 0x0300f53c, 0x00830008, |
| 8796 | | 0x7767b722, 0x002b3f82, 0xa692bd00, 0xfe0000d7, 0x83800380, 0x21f1826f, 0x00850002, 0x41820120, 0x40fec026, 0x80030000, 0x05821083, 0x07830120, |
| 8797 | | 0x0221038a, 0x24118200, 0x90000101, 0x82798200, 0x00022617, 0x00400008, 0x2009820a, 0x82098276, 0x82002006, 0x9001213b, 0x0223c883, 0x828a02bc, |
| 8798 | | 0x858f2010, 0xc5012507, 0x00023200, 0x04210083, 0x91058309, 0x6c412b03, 0x40007374, 0xac200000, 0x00830008, 0x01000523, 0x834d8380, 0x80032103, |
| 8799 | | 0x012101bf, 0x23b88280, 0x00800000, 0x0b830382, 0x07820120, 0x83800021, 0x88012001, 0x84002009, 0x2005870f, 0x870d8301, 0x2023901b, 0x83199501, |
| 8800 | | 0x82002015, 0x84802000, 0x84238267, 0x88002027, 0x8561882d, 0x21058211, 0x13880000, 0x01800022, 0x05850d85, 0x0f828020, 0x03208384, 0x03200582, |
| 8801 | | 0x47901b84, 0x1b850020, 0x1f821d82, 0x3f831d88, 0x3f410383, 0x84058405, 0x210982cd, 0x09830000, 0x03207789, 0xf38a1384, 0x01203782, 0x13872384, |
| 8802 | | 0x0b88c983, 0x0d898f84, 0x00202982, 0x23900383, 0x87008021, 0x83df8301, 0x86118d03, 0x863f880d, 0x8f35880f, 0x2160820f, 0x04830300, 0x1c220382, |
| 8803 | | 0x05820100, 0x4c000022, 0x09831182, 0x04001c24, 0x11823000, 0x0800082e, 0x00000200, 0xff007f00, 0xffffac20, 0x00220982, 0x09848100, 0xdf216682, |
| 8804 | | 0x843586d5, 0x06012116, 0x04400684, 0xa58120d7, 0x00b127d8, 0x01b88d01, 0x2d8685ff, 0xc100c621, 0xf4be0801, 0x9e011c01, 0x88021402, 0x1403fc02, |
| 8805 | | 0x9c035803, 0x1404de03, 0x50043204, 0xa2046204, 0x66051605, 0x1206bc05, 0xd6067406, 0x7e073807, 0x4e08ec07, 0x96086c08, 0x1009d008, 0x88094a09, |
| 8806 | | 0x800a160a, 0x560b040b, 0x2e0cc80b, 0xea0c820c, 0xa40d5e0d, 0x500eea0d, 0x280f960e, 0x1210b00f, 0xe0107410, 0xb6115211, 0x6e120412, 0x4c13c412, |
| 8807 | | 0xf613ac13, 0xae145814, 0x4015ea14, 0xa6158015, 0x1216b815, 0xc6167e16, 0x8e173417, 0x5618e017, 0xee18ba18, 0x96193619, 0x481ad419, 0xf01a9c1a, |
| 8808 | | 0xc81b5c1b, 0x4c1c041c, 0xea1c961c, 0x921d2a1d, 0x401ed21d, 0xe01e8e1e, 0x761f241f, 0xa61fa61f, 0x01821020, 0x8a202e34, 0xc820b220, 0x74211421, |
| 8809 | | 0xee219821, 0x86226222, 0x01820c23, 0x83238021, 0x23983c01, 0x24d823b0, 0x244a2400, 0x24902468, 0x250625ae, 0x25822560, 0x26f825f8, 0x82aa2658, |
| 8810 | | 0xd8be0801, 0x9a274027, 0x68280a28, 0x0e29a828, 0xb8292029, 0x362af829, 0x602a602a, 0x2a2b022b, 0xac2b5e2b, 0x202ce62b, 0x9a2c342c, 0x5c2d282d, |
| 8811 | | 0xaa2d782d, 0x262ee82d, 0x262fa62e, 0xf42fb62f, 0xc8305e30, 0xb4313e31, 0x9e321e32, 0x82331e33, 0x5c34ee33, 0x3a35ce34, 0xd4358635, 0x72362636, |
| 8812 | | 0x7637e636, 0x3a38d837, 0x1239a638, 0xae397439, 0x9a3a2e3a, 0x7c3b063b, 0x3a3ce83b, 0x223d963c, 0xec3d863d, 0xc63e563e, 0x9a3f2a3f, 0x6a401240, |
| 8813 | | 0x3641d040, 0x0842a241, 0x7a424042, 0xf042b842, 0xcc436243, 0x8a442a44, 0x5845ee44, 0xe245b645, 0xb4465446, 0x7a471447, 0x5448da47, 0x4049c648, |
| 8814 | | 0x15462400, 0x034d0808, 0x0b000700, 0x13000f00, 0x1b001700, 0x23001f00, 0x2b002700, 0x33002f00, 0x3b003700, 0x43003f00, 0x4b004700, 0x53004f00, |
| 8815 | | 0x5b005700, 0x63005f00, 0x6b006700, 0x73006f00, 0x7b007700, 0x83007f00, 0x8b008700, 0x00008f00, 0x15333511, 0x20039631, 0x20178205, 0xd3038221, |
| 8816 | | 0x20739707, 0x25008580, 0x028080fc, 0x05be8080, 0x04204a85, 0x05ce0685, 0x0107002a, 0x02000080, 0x00000400, 0x250d8b41, 0x33350100, 0x03920715, |
| 8817 | | 0x13820320, 0x858d0120, 0x0e8d0320, 0xff260d83, 0x00808000, 0x54820106, 0x04800223, 0x845b8c80, 0x41332059, 0x078b068f, 0x82000121, 0x82fe2039, |
| 8818 | | 0x84802003, 0x83042004, 0x23598a0e, 0x00180000, 0x03210082, 0x42ab9080, 0x73942137, 0x2013bb41, 0x8f978205, 0x2027a39b, 0x20b68801, 0x84b286fd, |
| 8819 | | 0x91c88407, 0x41032011, 0x11a51130, 0x15000027, 0x80ff8000, 0x11af4103, 0x841b0341, 0x8bd983fd, 0x9be99bc9, 0x8343831b, 0x21f1821f, 0xb58300ff, |
| 8820 | | 0x0f84e889, 0xf78a0484, 0x8000ff22, 0x0020eeb3, 0x14200082, 0x2130ef41, 0xeb431300, 0x4133200a, 0xd7410ecb, 0x9a07200b, 0x2027871b, 0x21238221, |
| 8821 | | 0xe7828080, 0xe784fd20, 0xe8848020, 0xfe808022, 0x08880d85, 0xba41fd20, 0x82248205, 0x85eab02a, 0x008022e7, 0x2cd74200, 0x44010021, 0xd34406eb, |
| 8822 | | 0x44312013, 0xcf8b0eef, 0x0d422f8b, 0x82332007, 0x0001212f, 0x8023cf82, 0x83000180, 0x820583de, 0x830682d4, 0x820020d4, 0x82dc850a, 0x20e282e9, |
| 8823 | | 0xb2ff85fe, 0x010327e9, 0x02000380, 0x0f440400, 0x0c634407, 0x68825982, 0x85048021, 0x260a825d, 0x010b0000, 0x4400ff00, 0x2746103f, 0x08d74209, |
| 8824 | | 0x4d440720, 0x0eaf4406, 0xc3441d20, 0x23078406, 0xff800002, 0x04845b83, 0x8d05b241, 0x1781436f, 0x6b8c87a5, 0x1521878e, 0x06474505, 0x01210783, |
| 8825 | | 0x84688c00, 0x8904828e, 0x441e8cf7, 0x0b270cff, 0x80008000, 0x45030003, 0xfb430fab, 0x080f4107, 0x410bf942, 0xd34307e5, 0x070d4207, 0x80800123, |
| 8826 | | 0x205d85fe, 0x849183fe, 0x20128404, 0x82809702, 0x00002217, 0x41839a09, 0x6b4408cf, 0x0733440f, 0x3b460720, 0x82798707, 0x97802052, 0x0000296f, |
| 8827 | | 0xff800004, 0x01800100, 0x0021ef89, 0x0a914625, 0x410a4d41, 0x00250ed4, 0x00050000, 0x056d4280, 0x210a7b46, 0x21481300, 0x46ed8512, 0x00210bd1, |
| 8828 | | 0x89718202, 0x21738877, 0x2b850001, 0x00220582, 0x87450a00, 0x0ddb4606, 0x41079b42, 0x9d420c09, 0x0b09420b, 0x8d820720, 0x9742fc84, 0x42098909, |
| 8829 | | 0x00241e0f, 0x00800014, 0x0b47da82, 0x0833442a, 0x49078d41, 0x2f450f13, 0x42278f17, 0x01200751, 0x22063742, 0x44808001, 0x20450519, 0x88068906, |
| 8830 | | 0x83fe2019, 0x4203202a, 0x1a941a58, 0x00820020, 0xe7a40e20, 0x420ce146, 0x854307e9, 0x0fcb4713, 0xff20a182, 0xfe209b82, 0x0c867f8b, 0x0021aea4, |
| 8831 | | 0x219fa40f, 0x7d41003b, 0x07194214, 0xbf440520, 0x071d4206, 0x6941a590, 0x80802309, 0x028900ff, 0xa9a4b685, 0xc5808021, 0x449b82ab, 0x152007eb, |
| 8832 | | 0x42134d46, 0x61440a15, 0x051e4208, 0x222b0442, 0x47001100, 0xfd412913, 0x17194714, 0x410f5b41, 0x02220773, 0x09428080, 0x21a98208, 0xd4420001, |
| 8833 | | 0x481c840d, 0x00232bc9, 0x42120000, 0xe74c261b, 0x149d4405, 0x07209d87, 0x410db944, 0x14421c81, 0x42fd2005, 0x80410bd2, 0x203d8531, 0x06874100, |
| 8834 | | 0x48256f4a, 0xcb420c95, 0x13934113, 0x44075d44, 0x044c0855, 0x00ff2105, 0xfe228185, 0x45448000, 0x22c5b508, 0x410c0000, 0x7b412087, 0x1bb74514, |
| 8835 | | 0x32429c85, 0x0a574805, 0x21208943, 0x8ba01300, 0x440dfb4e, 0x77431437, 0x245b4113, 0x200fb145, 0x41108ffe, 0x80203562, 0x00200082, 0x46362b42, |
| 8836 | | 0x1742178d, 0x4527830f, 0x0f830b2f, 0x4a138146, 0x802409a1, 0xfe8000ff, 0x94419982, 0x09294320, 0x04000022, 0x49050f4f, 0xcb470a63, 0x48032008, |
| 8837 | | 0x2b48067b, 0x85022008, 0x82638338, 0x00002209, 0x05af4806, 0x900e9f49, 0x84c5873f, 0x214285bd, 0x064900ff, 0x0c894607, 0x00000023, 0x4903820a, |
| 8838 | | 0x714319f3, 0x0749410c, 0x8a07a145, 0x02152507, 0xfe808000, 0x74490386, 0x8080211b, 0x0c276f82, 0x00018000, 0x48028003, 0x2b2315db, 0x43002f00, |
| 8839 | | 0x6f82142f, 0x44011521, 0x93510da7, 0x20e68508, 0x06494d80, 0x8e838020, 0x06821286, 0x124bff20, 0x25f3830c, 0x03800080, 0xe74a0380, 0x207b8715, |
| 8840 | | 0x876b861d, 0x4a152007, 0x07870775, 0xf6876086, 0x8417674a, 0x0a0021f2, 0x431c9743, 0x8d421485, 0x200b830b, 0x06474d03, 0x71828020, 0x04510120, |
| 8841 | | 0x42da8606, 0x1f831882, 0x001a0022, 0xff4d0082, 0x0b0f532c, 0x0d449b94, 0x4e312007, 0x074f12e7, 0x0bf3490b, 0xbb412120, 0x413f820a, 0xef490857, |
| 8842 | | 0x80002313, 0xe2830001, 0x6441fc20, 0x8b802006, 0x00012108, 0xfd201582, 0x492c9b48, 0x802014ff, 0x51084347, 0x0f4327f3, 0x17bf4a14, 0x201b7944, |
| 8843 | | 0x06964201, 0x134ffe20, 0x20d6830b, 0x25d78280, 0xfd800002, 0x05888000, 0x9318dc41, 0x21d282d4, 0xdb481800, 0x0dff542a, 0x45107743, 0xe14813f5, |
| 8844 | | 0x0f034113, 0x83135d45, 0x47b28437, 0xe4510e73, 0x21f58e06, 0x2b8400fd, 0x1041fcac, 0x08db4b0b, 0x421fdb41, 0xdf4b18df, 0x011d210a, 0x420af350, |
| 8845 | | 0x6e8308af, 0xac85cb86, 0x1e461082, 0x82b7a407, 0x411420a3, 0xa34130ab, 0x178f4124, 0x41139741, 0x86410d93, 0x82118511, 0x057243d8, 0x8941d9a4, |
| 8846 | | 0x3093480c, 0x4a13474f, 0xfb5016a9, 0x07ad4108, 0x4a0f9d42, 0xfe200fad, 0x4708aa41, 0x83482dba, 0x288f4d06, 0xb398c3bb, 0x44267b41, 0xb34439d7, |
| 8847 | | 0x0755410f, 0x200ebb45, 0x0f5f4215, 0x20191343, 0x06df5301, 0xf04c0220, 0x2ba64d07, 0x82050841, 0x430020ce, 0xa78f3627, 0x5213ff42, 0x2f970bc1, |
| 8848 | | 0x4305ab55, 0xa084111b, 0x450bac45, 0x5f4238b8, 0x010c2106, 0x0220ed82, 0x441bb344, 0x875010af, 0x0737480f, 0x490c5747, 0x0c840c03, 0x4c204b42, |
| 8849 | | 0x8ba905d7, 0x8b948793, 0x510c0c51, 0xfb4b24b9, 0x1b174107, 0x5709d74c, 0xd1410ca5, 0x079d480f, 0x201ff541, 0x06804780, 0x7d520120, 0x80002205, |
| 8850 | | 0x20a983fe, 0x47bb83fe, 0x1b8409b4, 0x81580220, 0x4e00202c, 0x4f41282f, 0x0eab4f17, 0x57471520, 0x0e0f4808, 0x8221e041, 0x3e1b4a8b, 0x4407175d, |
| 8851 | | 0x1b4b071f, 0x4a0f8b07, 0x174a0703, 0x0ba5411b, 0x430fb141, 0x0120057b, 0xfc20dd82, 0x4a056047, 0xf4850c0c, 0x01221982, 0x02828000, 0x1a5d088b, |
| 8852 | | 0x20094108, 0x8c0e3941, 0x4900200e, 0x7744434f, 0x200b870b, 0x0e4b5a33, 0x2b41f78b, 0x8b138307, 0x0b9f450b, 0x2406f741, 0xfd808001, 0x09475a00, |
| 8853 | | 0x84000121, 0x5980200e, 0x85450e5d, 0x832c8206, 0x4106831e, 0x00213814, 0x28b34810, 0x410c2f4b, 0x5f4a13d7, 0x0b2b4113, 0x6e43a883, 0x11174b05, |
| 8854 | | 0x4b066a45, 0xcc470541, 0x5000202b, 0xcb472f4b, 0x44b59f0f, 0xc5430b5b, 0x0d654907, 0x21065544, 0xd6828080, 0xfe201982, 0x8230ec4a, 0x120025c2, |
| 8855 | | 0x80ff8000, 0x4128d74d, 0x3320408b, 0x410a9f50, 0xdb822793, 0x822bd454, 0x61134b2e, 0x410b214a, 0xad4117c9, 0x0001211f, 0x4206854f, 0x4b430596, |
| 8856 | | 0x06bb5530, 0x2025cf46, 0x0ddd5747, 0x500ea349, 0x0f840fa7, 0x5213c153, 0x634e08d1, 0x0bbe4809, 0x59316e4d, 0x5b50053f, 0x203f6323, 0x5117eb46, |
| 8857 | | 0x94450a63, 0x246e410a, 0x63410020, 0x0bdb5f2f, 0x4233ab44, 0x39480757, 0x112d4a07, 0x7241118f, 0x000e2132, 0x9f286f41, 0x0f8762c3, 0x33350723, |
| 8858 | | 0x094e6415, 0x2010925f, 0x067252fe, 0xd0438020, 0x63a68225, 0x11203a4f, 0x480e6360, 0x5748131f, 0x079b521f, 0x200e2f43, 0x864b8315, 0x113348e7, |
| 8859 | | 0x85084e48, 0x06855008, 0x5880fd21, 0x7c420925, 0x0c414824, 0x37470c86, 0x1b8b422b, 0x5b0a8755, 0x23410c21, 0x0b83420b, 0x5a082047, 0xf482067f, |
| 8860 | | 0xa80b4c47, 0x0c0021cf, 0x20207b42, 0x0fb74100, 0x420b8744, 0xeb43076f, 0x0f6f420b, 0x4261fe20, 0x439aa00c, 0x215034e3, 0x0ff9570f, 0x4b1f2d5d, |
| 8861 | | 0x2d5d0c6f, 0x09634d0b, 0x1f51b8a0, 0x620f200c, 0xaf681e87, 0x24f94d07, 0x4e0f4945, 0xfe200c05, 0x22139742, 0x57048080, 0x23950c20, 0x97601585, |
| 8862 | | 0x4813201f, 0xad620523, 0x200f8f0f, 0x9e638f15, 0x00002181, 0x41342341, 0x0f930f0b, 0x210b4b62, 0x978f0001, 0xfe200f84, 0x8425c863, 0x2704822b, |
| 8863 | | 0x80000a00, 0x00038001, 0x610e9768, 0x834514bb, 0x0bc3430f, 0x2107e357, 0x80848080, 0x4400fe21, 0x2e410983, 0x00002a1a, 0x00000700, 0x800380ff, |
| 8864 | | 0x0fdf5800, 0x59150021, 0xd142163d, 0x0c02410c, 0x01020025, 0x65800300, 0x00240853, 0x1d333501, 0x15220382, 0x35420001, 0x44002008, 0x376406d7, |
| 8865 | | 0x096f6b19, 0x480bc142, 0x8f4908a7, 0x211f8b1f, 0x9e830001, 0x0584fe20, 0x4180fd21, 0x11850910, 0x8d198259, 0x000021d4, 0x5a08275d, 0x275d1983, |
| 8866 | | 0x06d9420e, 0x9f08b36a, 0x0f7d47b5, 0x8d8a2f8b, 0x4c0e0b57, 0xe7410e17, 0x42d18c1a, 0xb351087a, 0x1ac36505, 0x4b4a2f20, 0x0b9f450d, 0x430beb53, |
| 8867 | | 0xa7881015, 0xa5826a83, 0x80200f82, 0x86185a65, 0x4100208e, 0x176c3367, 0x0fe7650b, 0x4a17ad4b, 0x0f4217ed, 0x112e4206, 0x41113a42, 0xf7423169, |
| 8868 | | 0x0cb34737, 0x560f8b46, 0xa75407e5, 0x5f01200f, 0x31590c48, 0x80802106, 0x42268841, 0x0020091e, 0x4207ef64, 0x69461df7, 0x138d4114, 0x820f5145, |
| 8869 | | 0x53802090, 0xff200529, 0xb944b183, 0x417e8505, 0x00202561, 0x15210082, 0x42378200, 0x9b431cc3, 0x004f220d, 0x0dd54253, 0x4213f149, 0x7d41133b, |
| 8870 | | 0x42c9870b, 0x802010f9, 0x420b2c42, 0x8f441138, 0x267c4408, 0x600cb743, 0x8f4109d3, 0x05ab701d, 0x83440020, 0x3521223f, 0x0b794733, 0xfb62fe20, |
| 8871 | | 0x4afd2010, 0xaf410ae7, 0x25ce8525, 0x01080000, 0x7b6b0000, 0x0973710b, 0x82010021, 0x49038375, 0x33420767, 0x052c4212, 0x58464b85, 0x41fe2005, |
| 8872 | | 0x50440c27, 0x000c2209, 0x1cb36b80, 0x9b06df44, 0x0f93566f, 0x52830220, 0xfe216e8d, 0x200f8200, 0x0fb86704, 0xb057238d, 0x050b5305, 0x7217eb47, |
| 8873 | | 0xbd410b6b, 0x0f214610, 0x871f9956, 0x1e91567e, 0x2029b741, 0x20008200, 0x18b7410a, 0x27002322, 0x41095543, 0x0f8f0fb3, 0x41000121, 0x889d111c, |
| 8874 | | 0x14207b82, 0x00200382, 0x73188761, 0x475013a7, 0x6e33200c, 0x234e0ea3, 0x9b138313, 0x08e54d17, 0x9711094e, 0x2ee74311, 0x4908875e, 0xd75d1f1f, |
| 8875 | | 0x19ab5238, 0xa2084d48, 0x63a7a9b3, 0x55450b83, 0x0fd74213, 0x440d814c, 0x4f481673, 0x05714323, 0x13000022, 0x412e1f46, 0xdf493459, 0x21c7550f, |
| 8876 | | 0x8408215f, 0x201d49cb, 0xb1103043, 0x0f0d65d7, 0x452b8d41, 0x594b0f8d, 0x0b004605, 0xb215eb46, 0x000a24d7, 0x47000080, 0x002118cf, 0x06436413, |
| 8877 | | 0x420bd750, 0x2b500743, 0x076a470c, 0x4105c050, 0xd942053f, 0x0d00211a, 0x5f44779c, 0x0ce94805, 0x51558186, 0x14a54c0b, 0x49082b41, 0x0a4b0888, |
| 8878 | | 0x8080261f, 0x0d000000, 0x20048201, 0x1deb6a03, 0x420cb372, 0x07201783, 0x4306854d, 0x8b830c59, 0x59093c74, 0x0020250f, 0x67070f4a, 0x2341160b, |
| 8879 | | 0x00372105, 0x431c515d, 0x554e17ef, 0x0e5d6b05, 0x41115442, 0xb74a1ac1, 0x2243420a, 0x5b4f878f, 0x7507200f, 0x384b086f, 0x09d45409, 0x0020869a, |
| 8880 | | 0x12200082, 0xab460382, 0x10075329, 0x54138346, 0xaf540fbf, 0x1ea75413, 0x9a0c9e54, 0x0f6b44c1, 0x41000021, 0x47412a4f, 0x07374907, 0x5310bf76, |
| 8881 | | 0xff2009b4, 0x9a09a64c, 0x8200208d, 0x34c34500, 0x970fe141, 0x1fd74b0f, 0x440a3850, 0x206411f0, 0x27934609, 0x470c5d41, 0x555c2947, 0x1787540f, |
| 8882 | | 0x6e0f234e, 0x7d540a1b, 0x1d736b08, 0x0026a088, 0x80000e00, 0x9b5200ff, 0x08ef4318, 0x450bff77, 0x1d4d0b83, 0x081f7006, 0xcb691b86, 0x4b022008, |
| 8883 | | 0xc34b0b33, 0x1d0d4a0c, 0x8025a188, 0x0b000000, 0x52a38201, 0xbf7d0873, 0x0c234511, 0x8f0f894a, 0x4101200f, 0x0c880c9d, 0x2b418ea1, 0x06c74128, |
| 8884 | | 0x66181341, 0x7b4c0bb9, 0x0c06630b, 0xfe200c87, 0x9ba10882, 0x27091765, 0x01000008, 0x02800380, 0x48113f4e, 0x29430cf5, 0x09a75a0b, 0x31618020, |
| 8885 | | 0x6d802009, 0x61840e33, 0x8208bf51, 0x0c637d61, 0x7f092379, 0x4f470f4b, 0x1797510c, 0x46076157, 0xf5500fdf, 0x0f616910, 0x1171fe20, 0x82802006, |
| 8886 | | 0x08696908, 0x41127a4c, 0x3f4a15f3, 0x01042607, 0x0200ff00, 0x1cf77700, 0xff204185, 0x00235b8d, 0x43100000, 0x3b22243f, 0x3b4d3f00, 0x0b937709, |
| 8887 | | 0xad42f18f, 0x0b1f420f, 0x51084b43, 0x8020104a, 0xb557ff83, 0x052b7f2a, 0x0280ff22, 0x250beb78, 0x00170013, 0xbf6d2500, 0x07db760e, 0x410e2b7f, |
| 8888 | | 0x00230e4f, 0x49030000, 0x0582055b, 0x07000326, 0x00000b00, 0x580bcd46, 0x00200cdd, 0x57078749, 0x8749160f, 0x0f994f0a, 0x41134761, 0x01200b31, |
| 8889 | | 0xeb796883, 0x0b41500b, 0x0e90b38e, 0x202e7b51, 0x05d95801, 0x41080570, 0x1d530fc9, 0x0b937a0f, 0xaf8eb387, 0xf743b98f, 0x07c74227, 0x80000523, |
| 8890 | | 0x0fcb4503, 0x430ca37b, 0x7782077f, 0x8d0a9947, 0x08af4666, 0xeb798020, 0x6459881e, 0xc3740bbf, 0x0feb6f0b, 0x20072748, 0x052b6102, 0x435e0584, |
| 8891 | | 0x7d088308, 0x03200afd, 0x92109e41, 0x28aa8210, 0x80001500, 0x80030000, 0x0fdb5805, 0x209f4018, 0xa7418d87, 0x0aa3440f, 0x20314961, 0x073a52ff, |
| 8892 | | 0x6108505d, 0x43181051, 0x00223457, 0xe7820500, 0x50028021, 0x81410d33, 0x063d7108, 0xdb41af84, 0x4d888205, 0x00201198, 0x463d835f, 0x152106d7, |
| 8893 | | 0x0a355a33, 0x6917614e, 0x75411f4d, 0x184b8b07, 0x1809c344, 0x21091640, 0x0b828000, 0x42808021, 0x26790519, 0x86058605, 0x2428422d, 0x22123b42, |
| 8894 | | 0x42000080, 0xf587513b, 0x7813677b, 0xaf4d139f, 0x00ff210c, 0x5e0a1d57, 0x3b421546, 0x01032736, 0x02000380, 0x41180480, 0x2f420f07, 0x0c624807, |
| 8895 | | 0x00000025, 0x18000103, 0x83153741, 0x430120c3, 0x042106b2, 0x088d4d00, 0x2f830620, 0x1810434a, 0x18140345, 0x8507fb41, 0x5ee582ea, 0x0023116c, |
| 8896 | | 0x8d000600, 0x053b56af, 0xa6554fa2, 0x0d704608, 0x40180d20, 0x47181a43, 0xd37b07ff, 0x0b79500c, 0x420fd745, 0x47450bd9, 0x8471830a, 0x095a777e, |
| 8897 | | 0x84137542, 0x82002013, 0x2f401800, 0x0007213b, 0x4405e349, 0x0d550ff3, 0x16254c0c, 0x820ffe4a, 0x0400218a, 0x89066f41, 0x106b414f, 0xc84d0120, |
| 8898 | | 0x80802206, 0x0c9a4b03, 0x00100025, 0x68000200, 0x9d8c2473, 0x44134344, 0xf36a0f33, 0x4678860f, 0x1b440a25, 0x41988c0a, 0x80201879, 0x43079b5e, |
| 8899 | | 0x4a18080b, 0x0341190b, 0x1259530c, 0x43251552, 0x908205c8, 0x0cac4018, 0x86000421, 0x0e504aa2, 0x0020b891, 0xfb450082, 0x51132014, 0x8f5205f3, |
| 8900 | | 0x35052108, 0x8505cb59, 0x0f6d4f70, 0x82150021, 0x29af5047, 0x4f004b24, 0x75795300, 0x1b595709, 0x460b6742, 0xbf4b0f0d, 0x5743870b, 0xcb6d1461, |
| 8901 | | 0x08f64505, 0x4e05ab6c, 0x334126c3, 0x0bcb6b0d, 0x1811034d, 0x4111ef4b, 0x814f1ce5, 0x20af8227, 0x07fd7b80, 0x41188e84, 0xef410f33, 0x80802429, |
| 8902 | | 0x410d0000, 0xa34205ab, 0x76b7881c, 0xff500b89, 0x0741430f, 0x20086f4a, 0x209d8200, 0x234c18fd, 0x05d4670a, 0x4509af51, 0x9642078d, 0x189e831d, |
| 8903 | | 0x7c1cc74b, 0xcd4c07b9, 0x0e7c440f, 0x8b7b0320, 0x21108210, 0xc76c8080, 0x03002106, 0x6b23bf41, 0xc549060b, 0x7946180b, 0x0ff7530f, 0x17ad4618, |
| 8904 | | 0x200ecd45, 0x208c83fd, 0x5e0488fe, 0x032009c6, 0x420d044e, 0x0d8f0d7f, 0x00820020, 0x18001021, 0x6d273b45, 0xfd4c0c93, 0xcf451813, 0x0fe5450f, |
| 8905 | | 0x5a47c382, 0x820a8b0a, 0x282b4998, 0x410a8b5b, 0x4b232583, 0x54004f00, 0x978f0ce3, 0x500f1944, 0xa95f1709, 0x0280220b, 0x05ba7080, 0xa1530682, |
| 8906 | | 0x06324c13, 0x91412582, 0x05536e2c, 0x63431020, 0x0f434706, 0x8c11374c, 0x176143d7, 0x4d0f454c, 0xd3680bed, 0x0bee4d17, 0x212b9a41, 0x0f530a00, |
| 8907 | | 0x140d531c, 0x43139143, 0x95610e8d, 0x0f094415, 0x4205fb56, 0x1b4205cf, 0x17015225, 0x5e0c477f, 0xaf6e0aeb, 0x0ff36218, 0x04849a84, 0x0a454218, |
| 8908 | | 0x9c430420, 0x23c6822b, 0x04000102, 0x45091b4b, 0xf05f0955, 0x82802007, 0x421c2023, 0x5218282b, 0x7b53173f, 0x0fe7480c, 0x74173b7f, 0x47751317, |
| 8909 | | 0x634d1807, 0x0f6f430f, 0x24086547, 0xfc808002, 0x0b3c7f80, 0x10840120, 0x188d1282, 0x20096b43, 0x0fc24403, 0x00260faf, 0x0180000b, 0x3f500280, |
| 8910 | | 0x18002019, 0x450b4941, 0xf3530fb9, 0x18002010, 0x8208a551, 0x06234d56, 0xcb58a39b, 0xc3421805, 0x1313461e, 0x0f855018, 0xd34b0120, 0x6cfe2008, |
| 8911 | | 0x574f0885, 0x09204114, 0x07000029, 0x00008000, 0x44028002, 0x01420f57, 0x10c95c10, 0x11184c18, 0x80221185, 0x7f421e00, 0x00732240, 0x09cd4977, |
| 8912 | | 0x6d0b2b42, 0x4f180f8f, 0x8f5a0bcb, 0x9b0f830f, 0x0fb9411f, 0x230b5756, 0x00fd8080, 0x82060745, 0x000121d5, 0x8e0fb277, 0x4a8d4211, 0x24061c53, |
| 8913 | | 0x04000007, 0x12275280, 0x430c954c, 0x80201545, 0x200f764f, 0x20008200, 0x20ce8308, 0x09534f02, 0x660edf64, 0x73731771, 0xe7411807, 0x20a2820c, |
| 8914 | | 0x13b64404, 0x8f5d6682, 0x1d6b4508, 0x0cff4d18, 0x3348c58f, 0x0fc34c07, 0x31558b84, 0x8398820f, 0x17514712, 0x240b0e46, 0x80000a00, 0x093b4502, |
| 8915 | | 0x420f9759, 0xa54c0bf1, 0x0f2b470c, 0x410d314b, 0x2584170c, 0x73b30020, 0xb55fe782, 0x204d8410, 0x08e043fe, 0x4f147e41, 0x022008ab, 0x4b055159, |
| 8916 | | 0x2950068f, 0x00022208, 0x48511880, 0x82002009, 0x00112300, 0x634dff00, 0x24415f27, 0x180f6d43, 0x4d0b5d45, 0x4d5f05ef, 0x01802317, 0x56188000, |
| 8917 | | 0xa7840807, 0xc6450220, 0x21ca8229, 0x4b781a00, 0x3359182c, 0x0cf3470f, 0x180bef46, 0x420b0354, 0xff470b07, 0x4515200a, 0x9758239b, 0x4a80200c, |
| 8918 | | 0xd2410a26, 0x05fb4a08, 0x4b05e241, 0x03200dc9, 0x92290941, 0x00002829, 0x00010900, 0x5b020001, 0x23201363, 0x460d776a, 0xef530fdb, 0x209a890c, |
| 8919 | | 0x13fc4302, 0x00008024, 0xc4820104, 0x08820220, 0x20086b5b, 0x18518700, 0x8408d349, 0x0da449a1, 0x00080024, 0x7b690280, 0x4c438b1a, 0x01220f63, |
| 8920 | | 0x4c878000, 0x5c149c53, 0xfb430868, 0x2f56181e, 0x0ccf7b1b, 0x0f075618, 0x2008e347, 0x14144104, 0x00207f83, 0x00207b82, 0x201adf47, 0x16c35a13, |
| 8921 | | 0x540fdf47, 0x802006c8, 0x5418f185, 0x29430995, 0x00002419, 0x58001600, 0x5720316f, 0x4d051542, 0x4b7b1b03, 0x138f4707, 0xb747b787, 0x4aab8213, |
| 8922 | | 0x058305fc, 0x20115759, 0x82128401, 0x0a0b44e8, 0x46800121, 0xe64210d0, 0x82129312, 0x4bffdffe, 0x3b41171b, 0x9b27870f, 0x808022ff, 0x085c68fe, |
| 8923 | | 0x41800021, 0x01410b20, 0x001a213a, 0x47480082, 0x11374e12, 0x56130b4c, 0xdf4b0c65, 0x0b0f590b, 0x0f574c18, 0x830feb4b, 0x075f480f, 0x480b4755, |
| 8924 | | 0x40490b73, 0x80012206, 0x09d74280, 0x80fe8022, 0x80210e86, 0x056643ff, 0x10820020, 0x420b2646, 0x0b58391a, 0xd74c1808, 0x078b4e22, 0x2007f55f, |
| 8925 | | 0x4b491807, 0x83802017, 0x65aa82a7, 0x3152099e, 0x068b7616, 0x9b431220, 0x09bb742c, 0x500e376c, 0x8342179b, 0x0a4d5d0f, 0x8020a883, 0x180cd349, |
| 8926 | | 0x2016bb4b, 0x14476004, 0x84136c43, 0x08cf7813, 0x4f4c0520, 0x156f420f, 0x20085f42, 0x6fd3be03, 0xd4d30803, 0xa7411420, 0x004b222c, 0x0d3b614f, |
| 8927 | | 0x3f702120, 0x1393410a, 0x8f132745, 0x47421827, 0x41e08209, 0xb05e2bb9, 0x18b7410c, 0x18082647, 0x4107a748, 0xeb8826bf, 0x0ca76018, 0x733ecb41, |
| 8928 | | 0xd0410d83, 0x43ebaf2a, 0x0420067f, 0x721dab4c, 0x472005bb, 0x4105d341, 0x334844cb, 0x20dba408, 0x47d6ac00, 0x034e3aef, 0x0f8f421b, 0x930f134d, |
| 8929 | | 0x3521231f, 0xb7421533, 0x42f5ad0a, 0x1e961eaa, 0x17000022, 0x4c367b50, 0x7d491001, 0x0bf5520f, 0x4c18fda7, 0xb8460c55, 0x83fe2005, 0x00fe25b9, |
| 8930 | | 0x80000180, 0x9e751085, 0x261b5c12, 0x82110341, 0x001123fb, 0x4518fe80, 0xf38c2753, 0x6d134979, 0x295107a7, 0xaf5f180f, 0x0fe3660c, 0x180b6079, |
| 8931 | | 0x2007bd5f, 0x9aab9103, 0x2f4d1811, 0x05002109, 0x44254746, 0x1d200787, 0x450bab75, 0x4f180f57, 0x4f181361, 0x3b831795, 0xeb4b0120, 0x0b734805, |
| 8932 | | 0x84078f48, 0x2e1b47bc, 0x00203383, 0xaf065f45, 0x831520d7, 0x130f51a7, 0x1797bf97, 0x2b47d783, 0x18fe2005, 0x4a18a44f, 0xa64d086d, 0x1ab0410d, |
| 8933 | | 0x6205a258, 0xdbab069f, 0x4f06f778, 0xa963081d, 0x133b670a, 0x8323d141, 0x13195b23, 0x530f5e70, 0xe5ad0824, 0x58001421, 0x1f472b4b, 0x47bf410c, |
| 8934 | | 0x82000121, 0x83fe20cb, 0x07424404, 0x68068243, 0xd7ad0d3d, 0x00010d26, 0x80020000, 0x4a1c6f43, 0x23681081, 0x10a14f13, 0x8a070e57, 0x430a848f, |
| 8935 | | 0x7372243e, 0x4397a205, 0xb56c1021, 0x43978f0f, 0x64180505, 0x99aa0ff2, 0x0e000022, 0x20223341, 0x094b4f37, 0x074a3320, 0x2639410a, 0xfe208e84, |
| 8936 | | 0x8b0e0048, 0x508020a3, 0x9e4308fe, 0x073f4115, 0xe3480420, 0x0c9b5f1b, 0x7c137743, 0x9a95185b, 0x6122b148, 0x979b08df, 0x0fe36c18, 0x48109358, |
| 8937 | | 0x23441375, 0x0ffd5c0b, 0x180fc746, 0x2011d157, 0x07e95702, 0x58180120, 0x18770ac3, 0x51032008, 0x7d4118e3, 0x80802315, 0x3b4c1900, 0xbb5a1830, |
| 8938 | | 0x0ceb6109, 0x5b0b3d42, 0x4f181369, 0x4f180b8d, 0x4f180f75, 0x355a1b81, 0x200d820d, 0x18e483fd, 0x4528854f, 0x89420846, 0x1321411f, 0x44086b60, |
| 8939 | | 0x07421d77, 0x107d4405, 0x4113fd41, 0x5a181bf1, 0x4f180db3, 0x8021128f, 0x20f68280, 0x44a882fe, 0x334d249a, 0x052f6109, 0x1520c3a7, 0xef4eb783, |
| 8940 | | 0x4ec39b1b, 0xc4c90ee7, 0x20060b4d, 0x256f4905, 0x4d0cf761, 0xcf9b1f13, 0xa213d74e, 0x0e1145d4, 0x50135b42, 0xcb4e398f, 0x20d79f27, 0x08865d80, |
| 8941 | | 0x186d5018, 0xa90f7142, 0x067342d7, 0x3f450420, 0x65002021, 0xe3560771, 0x24d38f23, 0x15333531, 0x0eb94d01, 0x451c9f41, 0x384322fb, 0x00092108, |
| 8942 | | 0x19af6b18, 0x6e0c6f5a, 0xbd770bfb, 0x22bb7718, 0x20090f57, 0x25e74204, 0x4207275a, 0xdb5408ef, 0x1769450f, 0x1b1b5518, 0x210b1f57, 0x5e4c8001, |
| 8943 | | 0x55012006, 0x802107f1, 0x0a306a80, 0x45808021, 0x0d850b88, 0x31744f18, 0x1808ec54, 0x2009575b, 0x45ffa505, 0x1b420c73, 0x180f9f0f, 0x4a0cf748, |
| 8944 | | 0x501805b2, 0x00210f40, 0x4d118f80, 0xd6823359, 0x072b5118, 0x314ad7aa, 0x8fc79f08, 0x45d78b1f, 0xfe20058f, 0x23325118, 0x7b54d9b5, 0x9fc38f46, |
| 8945 | | 0x10bb410f, 0x41077b42, 0xc1410faf, 0x27cf441d, 0x46051b4f, 0x04200683, 0x2121d344, 0x8f530043, 0x8fcf9f0e, 0x21df8c1f, 0x50188000, 0x5d180e52, |
| 8946 | | 0xfd201710, 0x4405c341, 0xd68528e3, 0x20071f6b, 0x1b734305, 0x6b080957, 0x7d422b1f, 0x67002006, 0x7f8317b1, 0x2024cb48, 0x08676e00, 0x8749a39b, |
| 8947 | | 0x18132006, 0x410a6370, 0x8f490b47, 0x7e1f8f13, 0x551805c3, 0x4c180915, 0xfe200e2f, 0x244d5d18, 0x270bcf44, 0xff000019, 0x04800380, 0x5f253342, |
| 8948 | | 0xff520df7, 0x13274c18, 0x5542dd93, 0x0776181b, 0xf94a1808, 0x084a4c0c, 0x4308ea5b, 0xde831150, 0x7900fd21, 0x00492c1e, 0x060f4510, 0x17410020, |
| 8949 | | 0x0ce74526, 0x6206b341, 0x1f561083, 0x9d6c181b, 0x08a0500e, 0x112e4118, 0x60000421, 0xbf901202, 0x4408e241, 0xc7ab0513, 0xb40f0950, 0x055943c7, |
| 8950 | | 0x4f18ff20, 0xc9ae1cad, 0x32b34f18, 0x7a180120, 0x3d520a05, 0x53d1b40a, 0x80200813, 0x1b815018, 0x832bf86f, 0x67731847, 0x297f4308, 0x6418d54e, |
| 8951 | | 0x734213f7, 0x056b4b27, 0xdba5fe20, 0x1828aa4e, 0x2031a370, 0x06cb6101, 0x2040ad41, 0x07365300, 0x2558d985, 0x83fe200c, 0x0380211c, 0x542c4743, |
| 8952 | | 0x052006b7, 0x6021df45, 0x897b0707, 0x18d3c010, 0x20090e70, 0x1d5843ff, 0x540a0e44, 0x002126c5, 0x322f7416, 0x636a5720, 0x0f317409, 0x610fe159, |
| 8953 | | 0x294617e7, 0x08555213, 0x2006a75d, 0x6cec84fd, 0xfb5907be, 0x3a317405, 0x83808021, 0x180f20ea, 0x4626434a, 0x531818e3, 0xdb59172d, 0x0cbb460c, |
| 8954 | | 0x2013d859, 0x18b94502, 0x8f46188d, 0x77521842, 0x0a184e38, 0x9585fd20, 0x6a180684, 0xc64507e9, 0x51cbb230, 0xd3440cf3, 0x17ff6a0f, 0x450f5b42, |
| 8955 | | 0x276407c1, 0x4853180a, 0x21ccb010, 0xcf580013, 0x0c15442d, 0x410a1144, 0x1144359d, 0x5cfe2006, 0xa1410a43, 0x2bb64519, 0x2f5b7618, 0xb512b745, |
| 8956 | | 0x0cfd6fd1, 0x42089f59, 0xb8450c70, 0x0000232d, 0x50180900, 0xb9491ae3, 0x0fc37610, 0x01210f83, 0x0f3b4100, 0xa01b2742, 0x0ccd426f, 0x6e8f6f94, |
| 8957 | | 0x9c808021, 0xc7511870, 0x17c74b08, 0x9b147542, 0x44fe2079, 0xd5480c7e, 0x95ef861d, 0x101b597b, 0xf5417594, 0x9f471808, 0x86868d0e, 0x3733491c, |
| 8958 | | 0x690f4d6d, 0x43440b83, 0x1ba94c0b, 0x660cd16b, 0x802008ae, 0x74126448, 0xcb4f38a3, 0x2cb74b0b, 0x47137755, 0xe3971777, 0x1b5d0120, 0x057a4108, |
| 8959 | | 0x6e08664d, 0x17421478, 0x11af4208, 0x850c3f42, 0x08234f0c, 0x4321eb4a, 0xf3451095, 0x0f394e0f, 0x4310eb45, 0xc09707b1, 0x54431782, 0xaec08d1d, |
| 8960 | | 0x0f434dbb, 0x9f0c0b45, 0x0a3b4dbb, 0x4618bdc7, 0x536032eb, 0x17354213, 0x4d134169, 0xc7a30c2f, 0x4e254342, 0x174332cf, 0x43cdae17, 0x6b4706e4, |
| 8961 | | 0x0e16430d, 0x530b5542, 0x2f7c26bb, 0x13075f31, 0x43175342, 0x60181317, 0x6550114e, 0x28624710, 0x58070021, 0x59181683, 0x2d540cf5, 0x05d5660c, |
| 8962 | | 0x20090c7b, 0x0e157e02, 0x8000ff2b, 0x14000080, 0x80ff8000, 0x27137e03, 0x336a4b20, 0x0f817107, 0x13876e18, 0x730f2f7e, 0x2f450b75, 0x6d02200b, |
| 8963 | | 0x6d66094c, 0x4b802009, 0x15820a02, 0x2f45fe20, 0x5e032006, 0x00202fd9, 0x450af741, 0xeb412e0f, 0x0ff3411f, 0x420a8b65, 0xf7410eae, 0x1c664810, |
| 8964 | | 0x540e1145, 0xbfa509f3, 0x42302f58, 0x80200c35, 0xcb066c47, 0x4b1120c1, 0x41492abb, 0x34854110, 0xa7097b72, 0x251545c7, 0x4b2c7f56, 0xc5b40bab, |
| 8965 | | 0x940cd54e, 0x2e6151c8, 0x09f35f18, 0x4b420420, 0x09677121, 0x8f24f357, 0x1b5418e1, 0x08915a1f, 0x3143d894, 0x22541805, 0x1b9b4b0e, 0x8c0d3443, |
| 8966 | | 0x1400240d, 0x18ff8000, 0x582e6387, 0xf99b2b3b, 0x8807a550, 0x17a14790, 0x2184fd20, 0x5758fe20, 0x2354882c, 0x15000080, 0x5e056751, 0x334c2c2f, |
| 8967 | | 0x97c58f0c, 0x1fd7410f, 0x0d4d4018, 0x4114dc41, 0x04470ed6, 0x0dd54128, 0x00820020, 0x02011523, 0x22008700, 0x86480024, 0x0001240a, 0x8682001a, |
| 8968 | | 0x0002240b, 0x866c000e, 0x8a03200b, 0x8a042017, 0x0005220b, 0x22218614, 0x84060000, 0x86012017, 0x8212200f, 0x250b8519, 0x000d0001, 0x0b850031, |
| 8969 | | 0x07000224, 0x0b862600, 0x11000324, 0x0b862d00, 0x238a0420, 0x0a000524, 0x17863e00, 0x17840620, 0x01000324, 0x57820904, 0x0b85a783, 0x0b85a785, |
| 8970 | | 0x0b85a785, 0x22000325, 0x85007a00, 0x85a7850b, 0x85a7850b, 0x22a7850b, 0x82300032, 0x00342201, 0x0805862f, 0x35003131, 0x54207962, 0x74736972, |
| 8971 | | 0x47206e61, 0x6d6d6972, 0x65527265, 0x616c7567, 0x58545472, 0x6f725020, 0x43796767, 0x6e61656c, 0x30325454, 0x822f3430, 0x35313502, 0x79006200, |
| 8972 | | 0x54002000, 0x69007200, 0x74007300, 0x6e006100, 0x47200f82, 0x6d240f84, 0x65006d00, 0x52200982, 0x67240582, 0x6c007500, 0x72201d82, 0x54222b82, |
| 8973 | | 0x23825800, 0x19825020, 0x67006f22, 0x79220182, 0x1b824300, 0x3b846520, 0x1f825420, 0x41000021, 0x1422099b, 0x0b410000, 0x87088206, 0x01012102, |
| 8974 | | 0x78080982, 0x01020101, 0x01040103, 0x01060105, 0x01080107, 0x010a0109, 0x010c010b, 0x010e010d, 0x0110010f, 0x01120111, 0x01140113, 0x01160115, |
| 8975 | | 0x01180117, 0x011a0119, 0x011c011b, 0x011e011d, 0x0020011f, 0x00040003, 0x00060005, 0x00080007, 0x000a0009, 0x000c000b, 0x000e000d, 0x0010000f, |
| 8976 | | 0x00120011, 0x00140013, 0x00160015, 0x00180017, 0x001a0019, 0x001c001b, 0x001e001d, 0x08bb821f, 0x22002142, 0x24002300, 0x26002500, 0x28002700, |
| 8977 | | 0x2a002900, 0x2c002b00, 0x2e002d00, 0x30002f00, 0x32003100, 0x34003300, 0x36003500, 0x38003700, 0x3a003900, 0x3c003b00, 0x3e003d00, 0x40003f00, |
| 8978 | | 0x42004100, 0x4b09f382, 0x00450044, 0x00470046, 0x00490048, 0x004b004a, 0x004d004c, 0x004f004e, 0x00510050, 0x00530052, 0x00550054, 0x00570056, |
| 8979 | | 0x00590058, 0x005b005a, 0x005d005c, 0x005f005e, 0x01610060, 0x01220121, 0x01240123, 0x01260125, 0x01280127, 0x012a0129, 0x012c012b, 0x012e012d, |
| 8980 | | 0x0130012f, 0x01320131, 0x01340133, 0x01360135, 0x01380137, 0x013a0139, 0x013c013b, 0x013e013d, 0x0140013f, 0x00ac0041, 0x008400a3, 0x00bd0085, |
| 8981 | | 0x00e80096, 0x008e0086, 0x009d008b, 0x00a400a9, 0x008a00ef, 0x008300da, 0x00f20093, 0x008d00f3, 0x00880097, 0x00de00c3, 0x009e00f1, 0x00f500aa, |
| 8982 | | 0x00f600f4, 0x00ad00a2, 0x00c700c9, 0x006200ae, 0x00900063, 0x00cb0064, 0x00c80065, 0x00cf00ca, 0x00cd00cc, 0x00e900ce, 0x00d30066, 0x00d100d0, |
| 8983 | | 0x006700af, 0x009100f0, 0x00d400d6, 0x006800d5, 0x00ed00eb, 0x006a0089, 0x006b0069, 0x006c006d, 0x00a0006e, 0x0071006f, 0x00720070, 0x00750073, |
| 8984 | | 0x00760074, 0x00ea0077, 0x007a0078, 0x007b0079, 0x007c007d, 0x00a100b8, 0x007e007f, 0x00810080, 0x00ee00ec, 0x6e750eba, 0x646f6369, 0x78302365, |
| 8985 | | 0x31303030, 0x32200e8d, 0x33200e8d, 0x34200e8d, 0x35200e8d, 0x36200e8d, 0x37200e8d, 0x38200e8d, 0x39200e8d, 0x61200e8d, 0x62200e8d, 0x63200e8d, |
| 8986 | | 0x64200e8d, 0x65200e8d, 0x66200e8d, 0x31210e8c, 0x8d0e8d30, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, |
| 8987 | | 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x66312def, 0x6c656406, 0x04657465, 0x6f727545, 0x3820ec8c, 0x3820ec8d, |
| 8988 | | 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, |
| 8989 | | 0x3820ec8d, 0x200ddc41, 0x0ddc4139, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, |
| 8990 | | 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0x00663923, 0x48fa0500, 0x00f762f9, |
| 9245 | 0x0000bc57, 0x00000000, 0xf8a00000, 0x00000400, 0x00010037, 0x000c0000, 0x00030080, 0x2f534f40, 0x74eb8832, 0x01000090, 0x2c158248, 0x616d634e, |
| 9246 | 0x23120270, 0x03000075, 0x241382a0, 0x74766352, 0x82178220, 0xfc042102, 0x02380482, 0x66796c67, 0x5689af12, 0x04070000, 0x80920000, 0x64616568, |
| 9247 | 0xd36691d7, 0xcc201b82, 0x36210382, 0x27108268, 0xc3014208, 0x04010000, 0x243b0f82, 0x78746d68, 0x807e008a, 0x98010000, 0x06020000, 0x61636f6c, |
| 9248 | 0xd8b0738c, 0x82050000, 0x0402291e, 0x7078616d, 0xda00ae01, 0x28201f82, 0x202c1082, 0x656d616e, 0x96bb5925, 0x84990000, 0x9e2c1382, 0x74736f70, |
| 9249 | 0xef83aca6, 0x249b0000, 0xd22c3382, 0x70657270, 0x12010269, 0xf4040000, 0x08202f82, 0x012ecb84, 0x553c0000, 0x0f5fd5e9, 0x0300f53c, 0x00830008, |
| 9250 | 0x7767b722, 0x002b3f82, 0xa692bd00, 0xfe0000d7, 0x83800380, 0x21f1826f, 0x00850002, 0x41820120, 0x40fec026, 0x80030000, 0x05821083, 0x07830120, |
| 9251 | 0x0221038a, 0x24118200, 0x90000101, 0x82798200, 0x00022617, 0x00400008, 0x2009820a, 0x82098276, 0x82002006, 0x9001213b, 0x0223c883, 0x828a02bc, |
| 9252 | 0x858f2010, 0xc5012507, 0x00023200, 0x04210083, 0x91058309, 0x6c412b03, 0x40007374, 0xac200000, 0x00830008, 0x01000523, 0x834d8380, 0x80032103, |
| 9253 | 0x012101bf, 0x23b88280, 0x00800000, 0x0b830382, 0x07820120, 0x83800021, 0x88012001, 0x84002009, 0x2005870f, 0x870d8301, 0x2023901b, 0x83199501, |
| 9254 | 0x82002015, 0x84802000, 0x84238267, 0x88002027, 0x8561882d, 0x21058211, 0x13880000, 0x01800022, 0x05850d85, 0x0f828020, 0x03208384, 0x03200582, |
| 9255 | 0x47901b84, 0x1b850020, 0x1f821d82, 0x3f831d88, 0x3f410383, 0x84058405, 0x210982cd, 0x09830000, 0x03207789, 0xf38a1384, 0x01203782, 0x13872384, |
| 9256 | 0x0b88c983, 0x0d898f84, 0x00202982, 0x23900383, 0x87008021, 0x83df8301, 0x86118d03, 0x863f880d, 0x8f35880f, 0x2160820f, 0x04830300, 0x1c220382, |
| 9257 | 0x05820100, 0x4c000022, 0x09831182, 0x04001c24, 0x11823000, 0x0800082e, 0x00000200, 0xff007f00, 0xffffac20, 0x00220982, 0x09848100, 0xdf216682, |
| 9258 | 0x843586d5, 0x06012116, 0x04400684, 0xa58120d7, 0x00b127d8, 0x01b88d01, 0x2d8685ff, 0xc100c621, 0xf4be0801, 0x9e011c01, 0x88021402, 0x1403fc02, |
| 9259 | 0x9c035803, 0x1404de03, 0x50043204, 0xa2046204, 0x66051605, 0x1206bc05, 0xd6067406, 0x7e073807, 0x4e08ec07, 0x96086c08, 0x1009d008, 0x88094a09, |
| 9260 | 0x800a160a, 0x560b040b, 0x2e0cc80b, 0xea0c820c, 0xa40d5e0d, 0x500eea0d, 0x280f960e, 0x1210b00f, 0xe0107410, 0xb6115211, 0x6e120412, 0x4c13c412, |
| 9261 | 0xf613ac13, 0xae145814, 0x4015ea14, 0xa6158015, 0x1216b815, 0xc6167e16, 0x8e173417, 0x5618e017, 0xee18ba18, 0x96193619, 0x481ad419, 0xf01a9c1a, |
| 9262 | 0xc81b5c1b, 0x4c1c041c, 0xea1c961c, 0x921d2a1d, 0x401ed21d, 0xe01e8e1e, 0x761f241f, 0xa61fa61f, 0x01821020, 0x8a202e34, 0xc820b220, 0x74211421, |
| 9263 | 0xee219821, 0x86226222, 0x01820c23, 0x83238021, 0x23983c01, 0x24d823b0, 0x244a2400, 0x24902468, 0x250625ae, 0x25822560, 0x26f825f8, 0x82aa2658, |
| 9264 | 0xd8be0801, 0x9a274027, 0x68280a28, 0x0e29a828, 0xb8292029, 0x362af829, 0x602a602a, 0x2a2b022b, 0xac2b5e2b, 0x202ce62b, 0x9a2c342c, 0x5c2d282d, |
| 9265 | 0xaa2d782d, 0x262ee82d, 0x262fa62e, 0xf42fb62f, 0xc8305e30, 0xb4313e31, 0x9e321e32, 0x82331e33, 0x5c34ee33, 0x3a35ce34, 0xd4358635, 0x72362636, |
| 9266 | 0x7637e636, 0x3a38d837, 0x1239a638, 0xae397439, 0x9a3a2e3a, 0x7c3b063b, 0x3a3ce83b, 0x223d963c, 0xec3d863d, 0xc63e563e, 0x9a3f2a3f, 0x6a401240, |
| 9267 | 0x3641d040, 0x0842a241, 0x7a424042, 0xf042b842, 0xcc436243, 0x8a442a44, 0x5845ee44, 0xe245b645, 0xb4465446, 0x7a471447, 0x5448da47, 0x4049c648, |
| 9268 | 0x15462400, 0x034d0808, 0x0b000700, 0x13000f00, 0x1b001700, 0x23001f00, 0x2b002700, 0x33002f00, 0x3b003700, 0x43003f00, 0x4b004700, 0x53004f00, |
| 9269 | 0x5b005700, 0x63005f00, 0x6b006700, 0x73006f00, 0x7b007700, 0x83007f00, 0x8b008700, 0x00008f00, 0x15333511, 0x20039631, 0x20178205, 0xd3038221, |
| 9270 | 0x20739707, 0x25008580, 0x028080fc, 0x05be8080, 0x04204a85, 0x05ce0685, 0x0107002a, 0x02000080, 0x00000400, 0x250d8b41, 0x33350100, 0x03920715, |
| 9271 | 0x13820320, 0x858d0120, 0x0e8d0320, 0xff260d83, 0x00808000, 0x54820106, 0x04800223, 0x845b8c80, 0x41332059, 0x078b068f, 0x82000121, 0x82fe2039, |
| 9272 | 0x84802003, 0x83042004, 0x23598a0e, 0x00180000, 0x03210082, 0x42ab9080, 0x73942137, 0x2013bb41, 0x8f978205, 0x2027a39b, 0x20b68801, 0x84b286fd, |
| 9273 | 0x91c88407, 0x41032011, 0x11a51130, 0x15000027, 0x80ff8000, 0x11af4103, 0x841b0341, 0x8bd983fd, 0x9be99bc9, 0x8343831b, 0x21f1821f, 0xb58300ff, |
| 9274 | 0x0f84e889, 0xf78a0484, 0x8000ff22, 0x0020eeb3, 0x14200082, 0x2130ef41, 0xeb431300, 0x4133200a, 0xd7410ecb, 0x9a07200b, 0x2027871b, 0x21238221, |
| 9275 | 0xe7828080, 0xe784fd20, 0xe8848020, 0xfe808022, 0x08880d85, 0xba41fd20, 0x82248205, 0x85eab02a, 0x008022e7, 0x2cd74200, 0x44010021, 0xd34406eb, |
| 9276 | 0x44312013, 0xcf8b0eef, 0x0d422f8b, 0x82332007, 0x0001212f, 0x8023cf82, 0x83000180, 0x820583de, 0x830682d4, 0x820020d4, 0x82dc850a, 0x20e282e9, |
| 9277 | 0xb2ff85fe, 0x010327e9, 0x02000380, 0x0f440400, 0x0c634407, 0x68825982, 0x85048021, 0x260a825d, 0x010b0000, 0x4400ff00, 0x2746103f, 0x08d74209, |
| 9278 | 0x4d440720, 0x0eaf4406, 0xc3441d20, 0x23078406, 0xff800002, 0x04845b83, 0x8d05b241, 0x1781436f, 0x6b8c87a5, 0x1521878e, 0x06474505, 0x01210783, |
| 9279 | 0x84688c00, 0x8904828e, 0x441e8cf7, 0x0b270cff, 0x80008000, 0x45030003, 0xfb430fab, 0x080f4107, 0x410bf942, 0xd34307e5, 0x070d4207, 0x80800123, |
| 9280 | 0x205d85fe, 0x849183fe, 0x20128404, 0x82809702, 0x00002217, 0x41839a09, 0x6b4408cf, 0x0733440f, 0x3b460720, 0x82798707, 0x97802052, 0x0000296f, |
| 9281 | 0xff800004, 0x01800100, 0x0021ef89, 0x0a914625, 0x410a4d41, 0x00250ed4, 0x00050000, 0x056d4280, 0x210a7b46, 0x21481300, 0x46ed8512, 0x00210bd1, |
| 9282 | 0x89718202, 0x21738877, 0x2b850001, 0x00220582, 0x87450a00, 0x0ddb4606, 0x41079b42, 0x9d420c09, 0x0b09420b, 0x8d820720, 0x9742fc84, 0x42098909, |
| 9283 | 0x00241e0f, 0x00800014, 0x0b47da82, 0x0833442a, 0x49078d41, 0x2f450f13, 0x42278f17, 0x01200751, 0x22063742, 0x44808001, 0x20450519, 0x88068906, |
| 9284 | 0x83fe2019, 0x4203202a, 0x1a941a58, 0x00820020, 0xe7a40e20, 0x420ce146, 0x854307e9, 0x0fcb4713, 0xff20a182, 0xfe209b82, 0x0c867f8b, 0x0021aea4, |
| 9285 | 0x219fa40f, 0x7d41003b, 0x07194214, 0xbf440520, 0x071d4206, 0x6941a590, 0x80802309, 0x028900ff, 0xa9a4b685, 0xc5808021, 0x449b82ab, 0x152007eb, |
| 9286 | 0x42134d46, 0x61440a15, 0x051e4208, 0x222b0442, 0x47001100, 0xfd412913, 0x17194714, 0x410f5b41, 0x02220773, 0x09428080, 0x21a98208, 0xd4420001, |
| 9287 | 0x481c840d, 0x00232bc9, 0x42120000, 0xe74c261b, 0x149d4405, 0x07209d87, 0x410db944, 0x14421c81, 0x42fd2005, 0x80410bd2, 0x203d8531, 0x06874100, |
| 9288 | 0x48256f4a, 0xcb420c95, 0x13934113, 0x44075d44, 0x044c0855, 0x00ff2105, 0xfe228185, 0x45448000, 0x22c5b508, 0x410c0000, 0x7b412087, 0x1bb74514, |
| 9289 | 0x32429c85, 0x0a574805, 0x21208943, 0x8ba01300, 0x440dfb4e, 0x77431437, 0x245b4113, 0x200fb145, 0x41108ffe, 0x80203562, 0x00200082, 0x46362b42, |
| 9290 | 0x1742178d, 0x4527830f, 0x0f830b2f, 0x4a138146, 0x802409a1, 0xfe8000ff, 0x94419982, 0x09294320, 0x04000022, 0x49050f4f, 0xcb470a63, 0x48032008, |
| 9291 | 0x2b48067b, 0x85022008, 0x82638338, 0x00002209, 0x05af4806, 0x900e9f49, 0x84c5873f, 0x214285bd, 0x064900ff, 0x0c894607, 0x00000023, 0x4903820a, |
| 9292 | 0x714319f3, 0x0749410c, 0x8a07a145, 0x02152507, 0xfe808000, 0x74490386, 0x8080211b, 0x0c276f82, 0x00018000, 0x48028003, 0x2b2315db, 0x43002f00, |
| 9293 | 0x6f82142f, 0x44011521, 0x93510da7, 0x20e68508, 0x06494d80, 0x8e838020, 0x06821286, 0x124bff20, 0x25f3830c, 0x03800080, 0xe74a0380, 0x207b8715, |
| 9294 | 0x876b861d, 0x4a152007, 0x07870775, 0xf6876086, 0x8417674a, 0x0a0021f2, 0x431c9743, 0x8d421485, 0x200b830b, 0x06474d03, 0x71828020, 0x04510120, |
| 9295 | 0x42da8606, 0x1f831882, 0x001a0022, 0xff4d0082, 0x0b0f532c, 0x0d449b94, 0x4e312007, 0x074f12e7, 0x0bf3490b, 0xbb412120, 0x413f820a, 0xef490857, |
| 9296 | 0x80002313, 0xe2830001, 0x6441fc20, 0x8b802006, 0x00012108, 0xfd201582, 0x492c9b48, 0x802014ff, 0x51084347, 0x0f4327f3, 0x17bf4a14, 0x201b7944, |
| 9297 | 0x06964201, 0x134ffe20, 0x20d6830b, 0x25d78280, 0xfd800002, 0x05888000, 0x9318dc41, 0x21d282d4, 0xdb481800, 0x0dff542a, 0x45107743, 0xe14813f5, |
| 9298 | 0x0f034113, 0x83135d45, 0x47b28437, 0xe4510e73, 0x21f58e06, 0x2b8400fd, 0x1041fcac, 0x08db4b0b, 0x421fdb41, 0xdf4b18df, 0x011d210a, 0x420af350, |
| 9299 | 0x6e8308af, 0xac85cb86, 0x1e461082, 0x82b7a407, 0x411420a3, 0xa34130ab, 0x178f4124, 0x41139741, 0x86410d93, 0x82118511, 0x057243d8, 0x8941d9a4, |
| 9300 | 0x3093480c, 0x4a13474f, 0xfb5016a9, 0x07ad4108, 0x4a0f9d42, 0xfe200fad, 0x4708aa41, 0x83482dba, 0x288f4d06, 0xb398c3bb, 0x44267b41, 0xb34439d7, |
| 9301 | 0x0755410f, 0x200ebb45, 0x0f5f4215, 0x20191343, 0x06df5301, 0xf04c0220, 0x2ba64d07, 0x82050841, 0x430020ce, 0xa78f3627, 0x5213ff42, 0x2f970bc1, |
| 9302 | 0x4305ab55, 0xa084111b, 0x450bac45, 0x5f4238b8, 0x010c2106, 0x0220ed82, 0x441bb344, 0x875010af, 0x0737480f, 0x490c5747, 0x0c840c03, 0x4c204b42, |
| 9303 | 0x8ba905d7, 0x8b948793, 0x510c0c51, 0xfb4b24b9, 0x1b174107, 0x5709d74c, 0xd1410ca5, 0x079d480f, 0x201ff541, 0x06804780, 0x7d520120, 0x80002205, |
| 9304 | 0x20a983fe, 0x47bb83fe, 0x1b8409b4, 0x81580220, 0x4e00202c, 0x4f41282f, 0x0eab4f17, 0x57471520, 0x0e0f4808, 0x8221e041, 0x3e1b4a8b, 0x4407175d, |
| 9305 | 0x1b4b071f, 0x4a0f8b07, 0x174a0703, 0x0ba5411b, 0x430fb141, 0x0120057b, 0xfc20dd82, 0x4a056047, 0xf4850c0c, 0x01221982, 0x02828000, 0x1a5d088b, |
| 9306 | 0x20094108, 0x8c0e3941, 0x4900200e, 0x7744434f, 0x200b870b, 0x0e4b5a33, 0x2b41f78b, 0x8b138307, 0x0b9f450b, 0x2406f741, 0xfd808001, 0x09475a00, |
| 9307 | 0x84000121, 0x5980200e, 0x85450e5d, 0x832c8206, 0x4106831e, 0x00213814, 0x28b34810, 0x410c2f4b, 0x5f4a13d7, 0x0b2b4113, 0x6e43a883, 0x11174b05, |
| 9308 | 0x4b066a45, 0xcc470541, 0x5000202b, 0xcb472f4b, 0x44b59f0f, 0xc5430b5b, 0x0d654907, 0x21065544, 0xd6828080, 0xfe201982, 0x8230ec4a, 0x120025c2, |
| 9309 | 0x80ff8000, 0x4128d74d, 0x3320408b, 0x410a9f50, 0xdb822793, 0x822bd454, 0x61134b2e, 0x410b214a, 0xad4117c9, 0x0001211f, 0x4206854f, 0x4b430596, |
| 9310 | 0x06bb5530, 0x2025cf46, 0x0ddd5747, 0x500ea349, 0x0f840fa7, 0x5213c153, 0x634e08d1, 0x0bbe4809, 0x59316e4d, 0x5b50053f, 0x203f6323, 0x5117eb46, |
| 9311 | 0x94450a63, 0x246e410a, 0x63410020, 0x0bdb5f2f, 0x4233ab44, 0x39480757, 0x112d4a07, 0x7241118f, 0x000e2132, 0x9f286f41, 0x0f8762c3, 0x33350723, |
| 9312 | 0x094e6415, 0x2010925f, 0x067252fe, 0xd0438020, 0x63a68225, 0x11203a4f, 0x480e6360, 0x5748131f, 0x079b521f, 0x200e2f43, 0x864b8315, 0x113348e7, |
| 9313 | 0x85084e48, 0x06855008, 0x5880fd21, 0x7c420925, 0x0c414824, 0x37470c86, 0x1b8b422b, 0x5b0a8755, 0x23410c21, 0x0b83420b, 0x5a082047, 0xf482067f, |
| 9314 | 0xa80b4c47, 0x0c0021cf, 0x20207b42, 0x0fb74100, 0x420b8744, 0xeb43076f, 0x0f6f420b, 0x4261fe20, 0x439aa00c, 0x215034e3, 0x0ff9570f, 0x4b1f2d5d, |
| 9315 | 0x2d5d0c6f, 0x09634d0b, 0x1f51b8a0, 0x620f200c, 0xaf681e87, 0x24f94d07, 0x4e0f4945, 0xfe200c05, 0x22139742, 0x57048080, 0x23950c20, 0x97601585, |
| 9316 | 0x4813201f, 0xad620523, 0x200f8f0f, 0x9e638f15, 0x00002181, 0x41342341, 0x0f930f0b, 0x210b4b62, 0x978f0001, 0xfe200f84, 0x8425c863, 0x2704822b, |
| 9317 | 0x80000a00, 0x00038001, 0x610e9768, 0x834514bb, 0x0bc3430f, 0x2107e357, 0x80848080, 0x4400fe21, 0x2e410983, 0x00002a1a, 0x00000700, 0x800380ff, |
| 9318 | 0x0fdf5800, 0x59150021, 0xd142163d, 0x0c02410c, 0x01020025, 0x65800300, 0x00240853, 0x1d333501, 0x15220382, 0x35420001, 0x44002008, 0x376406d7, |
| 9319 | 0x096f6b19, 0x480bc142, 0x8f4908a7, 0x211f8b1f, 0x9e830001, 0x0584fe20, 0x4180fd21, 0x11850910, 0x8d198259, 0x000021d4, 0x5a08275d, 0x275d1983, |
| 9320 | 0x06d9420e, 0x9f08b36a, 0x0f7d47b5, 0x8d8a2f8b, 0x4c0e0b57, 0xe7410e17, 0x42d18c1a, 0xb351087a, 0x1ac36505, 0x4b4a2f20, 0x0b9f450d, 0x430beb53, |
| 9321 | 0xa7881015, 0xa5826a83, 0x80200f82, 0x86185a65, 0x4100208e, 0x176c3367, 0x0fe7650b, 0x4a17ad4b, 0x0f4217ed, 0x112e4206, 0x41113a42, 0xf7423169, |
| 9322 | 0x0cb34737, 0x560f8b46, 0xa75407e5, 0x5f01200f, 0x31590c48, 0x80802106, 0x42268841, 0x0020091e, 0x4207ef64, 0x69461df7, 0x138d4114, 0x820f5145, |
| 9323 | 0x53802090, 0xff200529, 0xb944b183, 0x417e8505, 0x00202561, 0x15210082, 0x42378200, 0x9b431cc3, 0x004f220d, 0x0dd54253, 0x4213f149, 0x7d41133b, |
| 9324 | 0x42c9870b, 0x802010f9, 0x420b2c42, 0x8f441138, 0x267c4408, 0x600cb743, 0x8f4109d3, 0x05ab701d, 0x83440020, 0x3521223f, 0x0b794733, 0xfb62fe20, |
| 9325 | 0x4afd2010, 0xaf410ae7, 0x25ce8525, 0x01080000, 0x7b6b0000, 0x0973710b, 0x82010021, 0x49038375, 0x33420767, 0x052c4212, 0x58464b85, 0x41fe2005, |
| 9326 | 0x50440c27, 0x000c2209, 0x1cb36b80, 0x9b06df44, 0x0f93566f, 0x52830220, 0xfe216e8d, 0x200f8200, 0x0fb86704, 0xb057238d, 0x050b5305, 0x7217eb47, |
| 9327 | 0xbd410b6b, 0x0f214610, 0x871f9956, 0x1e91567e, 0x2029b741, 0x20008200, 0x18b7410a, 0x27002322, 0x41095543, 0x0f8f0fb3, 0x41000121, 0x889d111c, |
| 9328 | 0x14207b82, 0x00200382, 0x73188761, 0x475013a7, 0x6e33200c, 0x234e0ea3, 0x9b138313, 0x08e54d17, 0x9711094e, 0x2ee74311, 0x4908875e, 0xd75d1f1f, |
| 9329 | 0x19ab5238, 0xa2084d48, 0x63a7a9b3, 0x55450b83, 0x0fd74213, 0x440d814c, 0x4f481673, 0x05714323, 0x13000022, 0x412e1f46, 0xdf493459, 0x21c7550f, |
| 9330 | 0x8408215f, 0x201d49cb, 0xb1103043, 0x0f0d65d7, 0x452b8d41, 0x594b0f8d, 0x0b004605, 0xb215eb46, 0x000a24d7, 0x47000080, 0x002118cf, 0x06436413, |
| 9331 | 0x420bd750, 0x2b500743, 0x076a470c, 0x4105c050, 0xd942053f, 0x0d00211a, 0x5f44779c, 0x0ce94805, 0x51558186, 0x14a54c0b, 0x49082b41, 0x0a4b0888, |
| 9332 | 0x8080261f, 0x0d000000, 0x20048201, 0x1deb6a03, 0x420cb372, 0x07201783, 0x4306854d, 0x8b830c59, 0x59093c74, 0x0020250f, 0x67070f4a, 0x2341160b, |
| 9333 | 0x00372105, 0x431c515d, 0x554e17ef, 0x0e5d6b05, 0x41115442, 0xb74a1ac1, 0x2243420a, 0x5b4f878f, 0x7507200f, 0x384b086f, 0x09d45409, 0x0020869a, |
| 9334 | 0x12200082, 0xab460382, 0x10075329, 0x54138346, 0xaf540fbf, 0x1ea75413, 0x9a0c9e54, 0x0f6b44c1, 0x41000021, 0x47412a4f, 0x07374907, 0x5310bf76, |
| 9335 | 0xff2009b4, 0x9a09a64c, 0x8200208d, 0x34c34500, 0x970fe141, 0x1fd74b0f, 0x440a3850, 0x206411f0, 0x27934609, 0x470c5d41, 0x555c2947, 0x1787540f, |
| 9336 | 0x6e0f234e, 0x7d540a1b, 0x1d736b08, 0x0026a088, 0x80000e00, 0x9b5200ff, 0x08ef4318, 0x450bff77, 0x1d4d0b83, 0x081f7006, 0xcb691b86, 0x4b022008, |
| 9337 | 0xc34b0b33, 0x1d0d4a0c, 0x8025a188, 0x0b000000, 0x52a38201, 0xbf7d0873, 0x0c234511, 0x8f0f894a, 0x4101200f, 0x0c880c9d, 0x2b418ea1, 0x06c74128, |
| 9338 | 0x66181341, 0x7b4c0bb9, 0x0c06630b, 0xfe200c87, 0x9ba10882, 0x27091765, 0x01000008, 0x02800380, 0x48113f4e, 0x29430cf5, 0x09a75a0b, 0x31618020, |
| 9339 | 0x6d802009, 0x61840e33, 0x8208bf51, 0x0c637d61, 0x7f092379, 0x4f470f4b, 0x1797510c, 0x46076157, 0xf5500fdf, 0x0f616910, 0x1171fe20, 0x82802006, |
| 9340 | 0x08696908, 0x41127a4c, 0x3f4a15f3, 0x01042607, 0x0200ff00, 0x1cf77700, 0xff204185, 0x00235b8d, 0x43100000, 0x3b22243f, 0x3b4d3f00, 0x0b937709, |
| 9341 | 0xad42f18f, 0x0b1f420f, 0x51084b43, 0x8020104a, 0xb557ff83, 0x052b7f2a, 0x0280ff22, 0x250beb78, 0x00170013, 0xbf6d2500, 0x07db760e, 0x410e2b7f, |
| 9342 | 0x00230e4f, 0x49030000, 0x0582055b, 0x07000326, 0x00000b00, 0x580bcd46, 0x00200cdd, 0x57078749, 0x8749160f, 0x0f994f0a, 0x41134761, 0x01200b31, |
| 9343 | 0xeb796883, 0x0b41500b, 0x0e90b38e, 0x202e7b51, 0x05d95801, 0x41080570, 0x1d530fc9, 0x0b937a0f, 0xaf8eb387, 0xf743b98f, 0x07c74227, 0x80000523, |
| 9344 | 0x0fcb4503, 0x430ca37b, 0x7782077f, 0x8d0a9947, 0x08af4666, 0xeb798020, 0x6459881e, 0xc3740bbf, 0x0feb6f0b, 0x20072748, 0x052b6102, 0x435e0584, |
| 9345 | 0x7d088308, 0x03200afd, 0x92109e41, 0x28aa8210, 0x80001500, 0x80030000, 0x0fdb5805, 0x209f4018, 0xa7418d87, 0x0aa3440f, 0x20314961, 0x073a52ff, |
| 9346 | 0x6108505d, 0x43181051, 0x00223457, 0xe7820500, 0x50028021, 0x81410d33, 0x063d7108, 0xdb41af84, 0x4d888205, 0x00201198, 0x463d835f, 0x152106d7, |
| 9347 | 0x0a355a33, 0x6917614e, 0x75411f4d, 0x184b8b07, 0x1809c344, 0x21091640, 0x0b828000, 0x42808021, 0x26790519, 0x86058605, 0x2428422d, 0x22123b42, |
| 9348 | 0x42000080, 0xf587513b, 0x7813677b, 0xaf4d139f, 0x00ff210c, 0x5e0a1d57, 0x3b421546, 0x01032736, 0x02000380, 0x41180480, 0x2f420f07, 0x0c624807, |
| 9349 | 0x00000025, 0x18000103, 0x83153741, 0x430120c3, 0x042106b2, 0x088d4d00, 0x2f830620, 0x1810434a, 0x18140345, 0x8507fb41, 0x5ee582ea, 0x0023116c, |
| 9350 | 0x8d000600, 0x053b56af, 0xa6554fa2, 0x0d704608, 0x40180d20, 0x47181a43, 0xd37b07ff, 0x0b79500c, 0x420fd745, 0x47450bd9, 0x8471830a, 0x095a777e, |
| 9351 | 0x84137542, 0x82002013, 0x2f401800, 0x0007213b, 0x4405e349, 0x0d550ff3, 0x16254c0c, 0x820ffe4a, 0x0400218a, 0x89066f41, 0x106b414f, 0xc84d0120, |
| 9352 | 0x80802206, 0x0c9a4b03, 0x00100025, 0x68000200, 0x9d8c2473, 0x44134344, 0xf36a0f33, 0x4678860f, 0x1b440a25, 0x41988c0a, 0x80201879, 0x43079b5e, |
| 9353 | 0x4a18080b, 0x0341190b, 0x1259530c, 0x43251552, 0x908205c8, 0x0cac4018, 0x86000421, 0x0e504aa2, 0x0020b891, 0xfb450082, 0x51132014, 0x8f5205f3, |
| 9354 | 0x35052108, 0x8505cb59, 0x0f6d4f70, 0x82150021, 0x29af5047, 0x4f004b24, 0x75795300, 0x1b595709, 0x460b6742, 0xbf4b0f0d, 0x5743870b, 0xcb6d1461, |
| 9355 | 0x08f64505, 0x4e05ab6c, 0x334126c3, 0x0bcb6b0d, 0x1811034d, 0x4111ef4b, 0x814f1ce5, 0x20af8227, 0x07fd7b80, 0x41188e84, 0xef410f33, 0x80802429, |
| 9356 | 0x410d0000, 0xa34205ab, 0x76b7881c, 0xff500b89, 0x0741430f, 0x20086f4a, 0x209d8200, 0x234c18fd, 0x05d4670a, 0x4509af51, 0x9642078d, 0x189e831d, |
| 9357 | 0x7c1cc74b, 0xcd4c07b9, 0x0e7c440f, 0x8b7b0320, 0x21108210, 0xc76c8080, 0x03002106, 0x6b23bf41, 0xc549060b, 0x7946180b, 0x0ff7530f, 0x17ad4618, |
| 9358 | 0x200ecd45, 0x208c83fd, 0x5e0488fe, 0x032009c6, 0x420d044e, 0x0d8f0d7f, 0x00820020, 0x18001021, 0x6d273b45, 0xfd4c0c93, 0xcf451813, 0x0fe5450f, |
| 9359 | 0x5a47c382, 0x820a8b0a, 0x282b4998, 0x410a8b5b, 0x4b232583, 0x54004f00, 0x978f0ce3, 0x500f1944, 0xa95f1709, 0x0280220b, 0x05ba7080, 0xa1530682, |
| 9360 | 0x06324c13, 0x91412582, 0x05536e2c, 0x63431020, 0x0f434706, 0x8c11374c, 0x176143d7, 0x4d0f454c, 0xd3680bed, 0x0bee4d17, 0x212b9a41, 0x0f530a00, |
| 9361 | 0x140d531c, 0x43139143, 0x95610e8d, 0x0f094415, 0x4205fb56, 0x1b4205cf, 0x17015225, 0x5e0c477f, 0xaf6e0aeb, 0x0ff36218, 0x04849a84, 0x0a454218, |
| 9362 | 0x9c430420, 0x23c6822b, 0x04000102, 0x45091b4b, 0xf05f0955, 0x82802007, 0x421c2023, 0x5218282b, 0x7b53173f, 0x0fe7480c, 0x74173b7f, 0x47751317, |
| 9363 | 0x634d1807, 0x0f6f430f, 0x24086547, 0xfc808002, 0x0b3c7f80, 0x10840120, 0x188d1282, 0x20096b43, 0x0fc24403, 0x00260faf, 0x0180000b, 0x3f500280, |
| 9364 | 0x18002019, 0x450b4941, 0xf3530fb9, 0x18002010, 0x8208a551, 0x06234d56, 0xcb58a39b, 0xc3421805, 0x1313461e, 0x0f855018, 0xd34b0120, 0x6cfe2008, |
| 9365 | 0x574f0885, 0x09204114, 0x07000029, 0x00008000, 0x44028002, 0x01420f57, 0x10c95c10, 0x11184c18, 0x80221185, 0x7f421e00, 0x00732240, 0x09cd4977, |
| 9366 | 0x6d0b2b42, 0x4f180f8f, 0x8f5a0bcb, 0x9b0f830f, 0x0fb9411f, 0x230b5756, 0x00fd8080, 0x82060745, 0x000121d5, 0x8e0fb277, 0x4a8d4211, 0x24061c53, |
| 9367 | 0x04000007, 0x12275280, 0x430c954c, 0x80201545, 0x200f764f, 0x20008200, 0x20ce8308, 0x09534f02, 0x660edf64, 0x73731771, 0xe7411807, 0x20a2820c, |
| 9368 | 0x13b64404, 0x8f5d6682, 0x1d6b4508, 0x0cff4d18, 0x3348c58f, 0x0fc34c07, 0x31558b84, 0x8398820f, 0x17514712, 0x240b0e46, 0x80000a00, 0x093b4502, |
| 9369 | 0x420f9759, 0xa54c0bf1, 0x0f2b470c, 0x410d314b, 0x2584170c, 0x73b30020, 0xb55fe782, 0x204d8410, 0x08e043fe, 0x4f147e41, 0x022008ab, 0x4b055159, |
| 9370 | 0x2950068f, 0x00022208, 0x48511880, 0x82002009, 0x00112300, 0x634dff00, 0x24415f27, 0x180f6d43, 0x4d0b5d45, 0x4d5f05ef, 0x01802317, 0x56188000, |
| 9371 | 0xa7840807, 0xc6450220, 0x21ca8229, 0x4b781a00, 0x3359182c, 0x0cf3470f, 0x180bef46, 0x420b0354, 0xff470b07, 0x4515200a, 0x9758239b, 0x4a80200c, |
| 9372 | 0xd2410a26, 0x05fb4a08, 0x4b05e241, 0x03200dc9, 0x92290941, 0x00002829, 0x00010900, 0x5b020001, 0x23201363, 0x460d776a, 0xef530fdb, 0x209a890c, |
| 9373 | 0x13fc4302, 0x00008024, 0xc4820104, 0x08820220, 0x20086b5b, 0x18518700, 0x8408d349, 0x0da449a1, 0x00080024, 0x7b690280, 0x4c438b1a, 0x01220f63, |
| 9374 | 0x4c878000, 0x5c149c53, 0xfb430868, 0x2f56181e, 0x0ccf7b1b, 0x0f075618, 0x2008e347, 0x14144104, 0x00207f83, 0x00207b82, 0x201adf47, 0x16c35a13, |
| 9375 | 0x540fdf47, 0x802006c8, 0x5418f185, 0x29430995, 0x00002419, 0x58001600, 0x5720316f, 0x4d051542, 0x4b7b1b03, 0x138f4707, 0xb747b787, 0x4aab8213, |
| 9376 | 0x058305fc, 0x20115759, 0x82128401, 0x0a0b44e8, 0x46800121, 0xe64210d0, 0x82129312, 0x4bffdffe, 0x3b41171b, 0x9b27870f, 0x808022ff, 0x085c68fe, |
| 9377 | 0x41800021, 0x01410b20, 0x001a213a, 0x47480082, 0x11374e12, 0x56130b4c, 0xdf4b0c65, 0x0b0f590b, 0x0f574c18, 0x830feb4b, 0x075f480f, 0x480b4755, |
| 9378 | 0x40490b73, 0x80012206, 0x09d74280, 0x80fe8022, 0x80210e86, 0x056643ff, 0x10820020, 0x420b2646, 0x0b58391a, 0xd74c1808, 0x078b4e22, 0x2007f55f, |
| 9379 | 0x4b491807, 0x83802017, 0x65aa82a7, 0x3152099e, 0x068b7616, 0x9b431220, 0x09bb742c, 0x500e376c, 0x8342179b, 0x0a4d5d0f, 0x8020a883, 0x180cd349, |
| 9380 | 0x2016bb4b, 0x14476004, 0x84136c43, 0x08cf7813, 0x4f4c0520, 0x156f420f, 0x20085f42, 0x6fd3be03, 0xd4d30803, 0xa7411420, 0x004b222c, 0x0d3b614f, |
| 9381 | 0x3f702120, 0x1393410a, 0x8f132745, 0x47421827, 0x41e08209, 0xb05e2bb9, 0x18b7410c, 0x18082647, 0x4107a748, 0xeb8826bf, 0x0ca76018, 0x733ecb41, |
| 9382 | 0xd0410d83, 0x43ebaf2a, 0x0420067f, 0x721dab4c, 0x472005bb, 0x4105d341, 0x334844cb, 0x20dba408, 0x47d6ac00, 0x034e3aef, 0x0f8f421b, 0x930f134d, |
| 9383 | 0x3521231f, 0xb7421533, 0x42f5ad0a, 0x1e961eaa, 0x17000022, 0x4c367b50, 0x7d491001, 0x0bf5520f, 0x4c18fda7, 0xb8460c55, 0x83fe2005, 0x00fe25b9, |
| 9384 | 0x80000180, 0x9e751085, 0x261b5c12, 0x82110341, 0x001123fb, 0x4518fe80, 0xf38c2753, 0x6d134979, 0x295107a7, 0xaf5f180f, 0x0fe3660c, 0x180b6079, |
| 9385 | 0x2007bd5f, 0x9aab9103, 0x2f4d1811, 0x05002109, 0x44254746, 0x1d200787, 0x450bab75, 0x4f180f57, 0x4f181361, 0x3b831795, 0xeb4b0120, 0x0b734805, |
| 9386 | 0x84078f48, 0x2e1b47bc, 0x00203383, 0xaf065f45, 0x831520d7, 0x130f51a7, 0x1797bf97, 0x2b47d783, 0x18fe2005, 0x4a18a44f, 0xa64d086d, 0x1ab0410d, |
| 9387 | 0x6205a258, 0xdbab069f, 0x4f06f778, 0xa963081d, 0x133b670a, 0x8323d141, 0x13195b23, 0x530f5e70, 0xe5ad0824, 0x58001421, 0x1f472b4b, 0x47bf410c, |
| 9388 | 0x82000121, 0x83fe20cb, 0x07424404, 0x68068243, 0xd7ad0d3d, 0x00010d26, 0x80020000, 0x4a1c6f43, 0x23681081, 0x10a14f13, 0x8a070e57, 0x430a848f, |
| 9389 | 0x7372243e, 0x4397a205, 0xb56c1021, 0x43978f0f, 0x64180505, 0x99aa0ff2, 0x0e000022, 0x20223341, 0x094b4f37, 0x074a3320, 0x2639410a, 0xfe208e84, |
| 9390 | 0x8b0e0048, 0x508020a3, 0x9e4308fe, 0x073f4115, 0xe3480420, 0x0c9b5f1b, 0x7c137743, 0x9a95185b, 0x6122b148, 0x979b08df, 0x0fe36c18, 0x48109358, |
| 9391 | 0x23441375, 0x0ffd5c0b, 0x180fc746, 0x2011d157, 0x07e95702, 0x58180120, 0x18770ac3, 0x51032008, 0x7d4118e3, 0x80802315, 0x3b4c1900, 0xbb5a1830, |
| 9392 | 0x0ceb6109, 0x5b0b3d42, 0x4f181369, 0x4f180b8d, 0x4f180f75, 0x355a1b81, 0x200d820d, 0x18e483fd, 0x4528854f, 0x89420846, 0x1321411f, 0x44086b60, |
| 9393 | 0x07421d77, 0x107d4405, 0x4113fd41, 0x5a181bf1, 0x4f180db3, 0x8021128f, 0x20f68280, 0x44a882fe, 0x334d249a, 0x052f6109, 0x1520c3a7, 0xef4eb783, |
| 9394 | 0x4ec39b1b, 0xc4c90ee7, 0x20060b4d, 0x256f4905, 0x4d0cf761, 0xcf9b1f13, 0xa213d74e, 0x0e1145d4, 0x50135b42, 0xcb4e398f, 0x20d79f27, 0x08865d80, |
| 9395 | 0x186d5018, 0xa90f7142, 0x067342d7, 0x3f450420, 0x65002021, 0xe3560771, 0x24d38f23, 0x15333531, 0x0eb94d01, 0x451c9f41, 0x384322fb, 0x00092108, |
| 9396 | 0x19af6b18, 0x6e0c6f5a, 0xbd770bfb, 0x22bb7718, 0x20090f57, 0x25e74204, 0x4207275a, 0xdb5408ef, 0x1769450f, 0x1b1b5518, 0x210b1f57, 0x5e4c8001, |
| 9397 | 0x55012006, 0x802107f1, 0x0a306a80, 0x45808021, 0x0d850b88, 0x31744f18, 0x1808ec54, 0x2009575b, 0x45ffa505, 0x1b420c73, 0x180f9f0f, 0x4a0cf748, |
| 9398 | 0x501805b2, 0x00210f40, 0x4d118f80, 0xd6823359, 0x072b5118, 0x314ad7aa, 0x8fc79f08, 0x45d78b1f, 0xfe20058f, 0x23325118, 0x7b54d9b5, 0x9fc38f46, |
| 9399 | 0x10bb410f, 0x41077b42, 0xc1410faf, 0x27cf441d, 0x46051b4f, 0x04200683, 0x2121d344, 0x8f530043, 0x8fcf9f0e, 0x21df8c1f, 0x50188000, 0x5d180e52, |
| 9400 | 0xfd201710, 0x4405c341, 0xd68528e3, 0x20071f6b, 0x1b734305, 0x6b080957, 0x7d422b1f, 0x67002006, 0x7f8317b1, 0x2024cb48, 0x08676e00, 0x8749a39b, |
| 9401 | 0x18132006, 0x410a6370, 0x8f490b47, 0x7e1f8f13, 0x551805c3, 0x4c180915, 0xfe200e2f, 0x244d5d18, 0x270bcf44, 0xff000019, 0x04800380, 0x5f253342, |
| 9402 | 0xff520df7, 0x13274c18, 0x5542dd93, 0x0776181b, 0xf94a1808, 0x084a4c0c, 0x4308ea5b, 0xde831150, 0x7900fd21, 0x00492c1e, 0x060f4510, 0x17410020, |
| 9403 | 0x0ce74526, 0x6206b341, 0x1f561083, 0x9d6c181b, 0x08a0500e, 0x112e4118, 0x60000421, 0xbf901202, 0x4408e241, 0xc7ab0513, 0xb40f0950, 0x055943c7, |
| 9404 | 0x4f18ff20, 0xc9ae1cad, 0x32b34f18, 0x7a180120, 0x3d520a05, 0x53d1b40a, 0x80200813, 0x1b815018, 0x832bf86f, 0x67731847, 0x297f4308, 0x6418d54e, |
| 9405 | 0x734213f7, 0x056b4b27, 0xdba5fe20, 0x1828aa4e, 0x2031a370, 0x06cb6101, 0x2040ad41, 0x07365300, 0x2558d985, 0x83fe200c, 0x0380211c, 0x542c4743, |
| 9406 | 0x052006b7, 0x6021df45, 0x897b0707, 0x18d3c010, 0x20090e70, 0x1d5843ff, 0x540a0e44, 0x002126c5, 0x322f7416, 0x636a5720, 0x0f317409, 0x610fe159, |
| 9407 | 0x294617e7, 0x08555213, 0x2006a75d, 0x6cec84fd, 0xfb5907be, 0x3a317405, 0x83808021, 0x180f20ea, 0x4626434a, 0x531818e3, 0xdb59172d, 0x0cbb460c, |
| 9408 | 0x2013d859, 0x18b94502, 0x8f46188d, 0x77521842, 0x0a184e38, 0x9585fd20, 0x6a180684, 0xc64507e9, 0x51cbb230, 0xd3440cf3, 0x17ff6a0f, 0x450f5b42, |
| 9409 | 0x276407c1, 0x4853180a, 0x21ccb010, 0xcf580013, 0x0c15442d, 0x410a1144, 0x1144359d, 0x5cfe2006, 0xa1410a43, 0x2bb64519, 0x2f5b7618, 0xb512b745, |
| 9410 | 0x0cfd6fd1, 0x42089f59, 0xb8450c70, 0x0000232d, 0x50180900, 0xb9491ae3, 0x0fc37610, 0x01210f83, 0x0f3b4100, 0xa01b2742, 0x0ccd426f, 0x6e8f6f94, |
| 9411 | 0x9c808021, 0xc7511870, 0x17c74b08, 0x9b147542, 0x44fe2079, 0xd5480c7e, 0x95ef861d, 0x101b597b, 0xf5417594, 0x9f471808, 0x86868d0e, 0x3733491c, |
| 9412 | 0x690f4d6d, 0x43440b83, 0x1ba94c0b, 0x660cd16b, 0x802008ae, 0x74126448, 0xcb4f38a3, 0x2cb74b0b, 0x47137755, 0xe3971777, 0x1b5d0120, 0x057a4108, |
| 9413 | 0x6e08664d, 0x17421478, 0x11af4208, 0x850c3f42, 0x08234f0c, 0x4321eb4a, 0xf3451095, 0x0f394e0f, 0x4310eb45, 0xc09707b1, 0x54431782, 0xaec08d1d, |
| 9414 | 0x0f434dbb, 0x9f0c0b45, 0x0a3b4dbb, 0x4618bdc7, 0x536032eb, 0x17354213, 0x4d134169, 0xc7a30c2f, 0x4e254342, 0x174332cf, 0x43cdae17, 0x6b4706e4, |
| 9415 | 0x0e16430d, 0x530b5542, 0x2f7c26bb, 0x13075f31, 0x43175342, 0x60181317, 0x6550114e, 0x28624710, 0x58070021, 0x59181683, 0x2d540cf5, 0x05d5660c, |
| 9416 | 0x20090c7b, 0x0e157e02, 0x8000ff2b, 0x14000080, 0x80ff8000, 0x27137e03, 0x336a4b20, 0x0f817107, 0x13876e18, 0x730f2f7e, 0x2f450b75, 0x6d02200b, |
| 9417 | 0x6d66094c, 0x4b802009, 0x15820a02, 0x2f45fe20, 0x5e032006, 0x00202fd9, 0x450af741, 0xeb412e0f, 0x0ff3411f, 0x420a8b65, 0xf7410eae, 0x1c664810, |
| 9418 | 0x540e1145, 0xbfa509f3, 0x42302f58, 0x80200c35, 0xcb066c47, 0x4b1120c1, 0x41492abb, 0x34854110, 0xa7097b72, 0x251545c7, 0x4b2c7f56, 0xc5b40bab, |
| 9419 | 0x940cd54e, 0x2e6151c8, 0x09f35f18, 0x4b420420, 0x09677121, 0x8f24f357, 0x1b5418e1, 0x08915a1f, 0x3143d894, 0x22541805, 0x1b9b4b0e, 0x8c0d3443, |
| 9420 | 0x1400240d, 0x18ff8000, 0x582e6387, 0xf99b2b3b, 0x8807a550, 0x17a14790, 0x2184fd20, 0x5758fe20, 0x2354882c, 0x15000080, 0x5e056751, 0x334c2c2f, |
| 9421 | 0x97c58f0c, 0x1fd7410f, 0x0d4d4018, 0x4114dc41, 0x04470ed6, 0x0dd54128, 0x00820020, 0x02011523, 0x22008700, 0x86480024, 0x0001240a, 0x8682001a, |
| 9422 | 0x0002240b, 0x866c000e, 0x8a03200b, 0x8a042017, 0x0005220b, 0x22218614, 0x84060000, 0x86012017, 0x8212200f, 0x250b8519, 0x000d0001, 0x0b850031, |
| 9423 | 0x07000224, 0x0b862600, 0x11000324, 0x0b862d00, 0x238a0420, 0x0a000524, 0x17863e00, 0x17840620, 0x01000324, 0x57820904, 0x0b85a783, 0x0b85a785, |
| 9424 | 0x0b85a785, 0x22000325, 0x85007a00, 0x85a7850b, 0x85a7850b, 0x22a7850b, 0x82300032, 0x00342201, 0x0805862f, 0x35003131, 0x54207962, 0x74736972, |
| 9425 | 0x47206e61, 0x6d6d6972, 0x65527265, 0x616c7567, 0x58545472, 0x6f725020, 0x43796767, 0x6e61656c, 0x30325454, 0x822f3430, 0x35313502, 0x79006200, |
| 9426 | 0x54002000, 0x69007200, 0x74007300, 0x6e006100, 0x47200f82, 0x6d240f84, 0x65006d00, 0x52200982, 0x67240582, 0x6c007500, 0x72201d82, 0x54222b82, |
| 9427 | 0x23825800, 0x19825020, 0x67006f22, 0x79220182, 0x1b824300, 0x3b846520, 0x1f825420, 0x41000021, 0x1422099b, 0x0b410000, 0x87088206, 0x01012102, |
| 9428 | 0x78080982, 0x01020101, 0x01040103, 0x01060105, 0x01080107, 0x010a0109, 0x010c010b, 0x010e010d, 0x0110010f, 0x01120111, 0x01140113, 0x01160115, |
| 9429 | 0x01180117, 0x011a0119, 0x011c011b, 0x011e011d, 0x0020011f, 0x00040003, 0x00060005, 0x00080007, 0x000a0009, 0x000c000b, 0x000e000d, 0x0010000f, |
| 9430 | 0x00120011, 0x00140013, 0x00160015, 0x00180017, 0x001a0019, 0x001c001b, 0x001e001d, 0x08bb821f, 0x22002142, 0x24002300, 0x26002500, 0x28002700, |
| 9431 | 0x2a002900, 0x2c002b00, 0x2e002d00, 0x30002f00, 0x32003100, 0x34003300, 0x36003500, 0x38003700, 0x3a003900, 0x3c003b00, 0x3e003d00, 0x40003f00, |
| 9432 | 0x42004100, 0x4b09f382, 0x00450044, 0x00470046, 0x00490048, 0x004b004a, 0x004d004c, 0x004f004e, 0x00510050, 0x00530052, 0x00550054, 0x00570056, |
| 9433 | 0x00590058, 0x005b005a, 0x005d005c, 0x005f005e, 0x01610060, 0x01220121, 0x01240123, 0x01260125, 0x01280127, 0x012a0129, 0x012c012b, 0x012e012d, |
| 9434 | 0x0130012f, 0x01320131, 0x01340133, 0x01360135, 0x01380137, 0x013a0139, 0x013c013b, 0x013e013d, 0x0140013f, 0x00ac0041, 0x008400a3, 0x00bd0085, |
| 9435 | 0x00e80096, 0x008e0086, 0x009d008b, 0x00a400a9, 0x008a00ef, 0x008300da, 0x00f20093, 0x008d00f3, 0x00880097, 0x00de00c3, 0x009e00f1, 0x00f500aa, |
| 9436 | 0x00f600f4, 0x00ad00a2, 0x00c700c9, 0x006200ae, 0x00900063, 0x00cb0064, 0x00c80065, 0x00cf00ca, 0x00cd00cc, 0x00e900ce, 0x00d30066, 0x00d100d0, |
| 9437 | 0x006700af, 0x009100f0, 0x00d400d6, 0x006800d5, 0x00ed00eb, 0x006a0089, 0x006b0069, 0x006c006d, 0x00a0006e, 0x0071006f, 0x00720070, 0x00750073, |
| 9438 | 0x00760074, 0x00ea0077, 0x007a0078, 0x007b0079, 0x007c007d, 0x00a100b8, 0x007e007f, 0x00810080, 0x00ee00ec, 0x6e750eba, 0x646f6369, 0x78302365, |
| 9439 | 0x31303030, 0x32200e8d, 0x33200e8d, 0x34200e8d, 0x35200e8d, 0x36200e8d, 0x37200e8d, 0x38200e8d, 0x39200e8d, 0x61200e8d, 0x62200e8d, 0x63200e8d, |
| 9440 | 0x64200e8d, 0x65200e8d, 0x66200e8d, 0x31210e8c, 0x8d0e8d30, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, |
| 9441 | 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x8d3120ef, 0x66312def, 0x6c656406, 0x04657465, 0x6f727545, 0x3820ec8c, 0x3820ec8d, |
| 9442 | 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, 0x3820ec8d, |
| 9443 | 0x3820ec8d, 0x200ddc41, 0x0ddc4139, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, |
| 9444 | 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0xef8d3920, 0x00663923, 0x48fa0500, 0x00f762f9, |
| 8991 | 9445 | }; |
| 8992 | 9446 | |
| 8993 | 9447 | static void GetDefaultCompressedFontDataTTF(const void** ttf_compressed_data, unsigned int* ttf_compressed_size) |