framework2

1
//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
2
//based on imgui.h file version "1.89.9" 18990 from Dear ImGui https://github.com/ocornut/imgui
3
//with imgui_internal.h api
4
//docking branch
5
#ifdef IMGUI_ENABLE_FREETYPE
6
#ifndef CIMGUI_FREETYPE
7
#error "IMGUI_FREETYPE should be defined for Freetype linking"
8
#endif
9
#else
10
#ifdef CIMGUI_FREETYPE
11
#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
12
#endif
13
#endif
14
#include <imgui.h>
15
#ifdef IMGUI_ENABLE_FREETYPE
16
#include "./imgui/misc/freetype/imgui_freetype.h"
17
#endif
18
#include <imgui_internal.h>
19
#include "cimgui.h"
20

21

22

23
CIMGUI_API ImVec2* ImVec2_ImVec2_Nil(void)
24
{
25
    return IM_NEW(ImVec2)();
26
}
27
CIMGUI_API void ImVec2_destroy(ImVec2* self)
28
{
29
    IM_DELETE(self);
30
}
31
CIMGUI_API ImVec2* ImVec2_ImVec2_Float(float _x,float _y)
32
{
33
    return IM_NEW(ImVec2)(_x,_y);
34
}
35
CIMGUI_API ImVec4* ImVec4_ImVec4_Nil(void)
36
{
37
    return IM_NEW(ImVec4)();
38
}
39
CIMGUI_API void ImVec4_destroy(ImVec4* self)
40
{
41
    IM_DELETE(self);
42
}
43
CIMGUI_API ImVec4* ImVec4_ImVec4_Float(float _x,float _y,float _z,float _w)
44
{
45
    return IM_NEW(ImVec4)(_x,_y,_z,_w);
46
}
47
CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas)
48
{
49
    return ImGui::CreateContext(shared_font_atlas);
50
}
51
CIMGUI_API void igDestroyContext(ImGuiContext* ctx)
52
{
53
    return ImGui::DestroyContext(ctx);
54
}
55
CIMGUI_API ImGuiContext* igGetCurrentContext()
56
{
57
    return ImGui::GetCurrentContext();
58
}
59
CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
60
{
61
    return ImGui::SetCurrentContext(ctx);
62
}
63
CIMGUI_API ImGuiIO* igGetIO()
64
{
65
    return &ImGui::GetIO();
66
}
67
CIMGUI_API ImGuiStyle* igGetStyle()
68
{
69
    return &ImGui::GetStyle();
70
}
71
CIMGUI_API void igNewFrame()
72
{
73
    return ImGui::NewFrame();
74
}
75
CIMGUI_API void igEndFrame()
76
{
77
    return ImGui::EndFrame();
78
}
79
CIMGUI_API void igRender()
80
{
81
    return ImGui::Render();
82
}
83
CIMGUI_API ImDrawData* igGetDrawData()
84
{
85
    return ImGui::GetDrawData();
86
}
87
CIMGUI_API void igShowDemoWindow(bool* p_open)
88
{
89
    return ImGui::ShowDemoWindow(p_open);
90
}
91
CIMGUI_API void igShowMetricsWindow(bool* p_open)
92
{
93
    return ImGui::ShowMetricsWindow(p_open);
94
}
95
CIMGUI_API void igShowDebugLogWindow(bool* p_open)
96
{
97
    return ImGui::ShowDebugLogWindow(p_open);
98
}
99
CIMGUI_API void igShowStackToolWindow(bool* p_open)
100
{
101
    return ImGui::ShowStackToolWindow(p_open);
102
}
103
CIMGUI_API void igShowAboutWindow(bool* p_open)
104
{
105
    return ImGui::ShowAboutWindow(p_open);
106
}
107
CIMGUI_API void igShowStyleEditor(ImGuiStyle* ref)
108
{
109
    return ImGui::ShowStyleEditor(ref);
110
}
111
CIMGUI_API bool igShowStyleSelector(const char* label)
112
{
113
    return ImGui::ShowStyleSelector(label);
114
}
115
CIMGUI_API void igShowFontSelector(const char* label)
116
{
117
    return ImGui::ShowFontSelector(label);
118
}
119
CIMGUI_API void igShowUserGuide()
120
{
121
    return ImGui::ShowUserGuide();
122
}
123
CIMGUI_API const char* igGetVersion()
124
{
125
    return ImGui::GetVersion();
126
}
127
CIMGUI_API void igStyleColorsDark(ImGuiStyle* dst)
128
{
129
    return ImGui::StyleColorsDark(dst);
130
}
131
CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst)
132
{
133
    return ImGui::StyleColorsLight(dst);
134
}
135
CIMGUI_API void igStyleColorsClassic(ImGuiStyle* dst)
136
{
137
    return ImGui::StyleColorsClassic(dst);
138
}
139
CIMGUI_API bool igBegin(const char* name,bool* p_open,ImGuiWindowFlags flags)
140
{
141
    return ImGui::Begin(name,p_open,flags);
142
}
143
CIMGUI_API void igEnd()
144
{
145
    return ImGui::End();
146
}
147
CIMGUI_API bool igBeginChild_Str(const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags)
148
{
149
    return ImGui::BeginChild(str_id,size,border,flags);
150
}
151
CIMGUI_API bool igBeginChild_ID(ImGuiID id,const ImVec2 size,bool border,ImGuiWindowFlags flags)
152
{
153
    return ImGui::BeginChild(id,size,border,flags);
154
}
155
CIMGUI_API void igEndChild()
156
{
157
    return ImGui::EndChild();
158
}
159
CIMGUI_API bool igIsWindowAppearing()
160
{
161
    return ImGui::IsWindowAppearing();
162
}
163
CIMGUI_API bool igIsWindowCollapsed()
164
{
165
    return ImGui::IsWindowCollapsed();
166
}
167
CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags)
168
{
169
    return ImGui::IsWindowFocused(flags);
170
}
171
CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags)
172
{
173
    return ImGui::IsWindowHovered(flags);
174
}
175
CIMGUI_API ImDrawList* igGetWindowDrawList()
176
{
177
    return ImGui::GetWindowDrawList();
178
}
179
CIMGUI_API float igGetWindowDpiScale()
180
{
181
    return ImGui::GetWindowDpiScale();
182
}
183
CIMGUI_API void igGetWindowPos(ImVec2 *pOut)
184
{
185
    *pOut = ImGui::GetWindowPos();
186
}
187
CIMGUI_API void igGetWindowSize(ImVec2 *pOut)
188
{
189
    *pOut = ImGui::GetWindowSize();
190
}
191
CIMGUI_API float igGetWindowWidth()
192
{
193
    return ImGui::GetWindowWidth();
194
}
195
CIMGUI_API float igGetWindowHeight()
196
{
197
    return ImGui::GetWindowHeight();
198
}
199
CIMGUI_API ImGuiViewport* igGetWindowViewport()
200
{
201
    return ImGui::GetWindowViewport();
202
}
203
CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
204
{
205
    return ImGui::SetNextWindowPos(pos,cond,pivot);
206
}
207
CIMGUI_API void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond)
208
{
209
    return ImGui::SetNextWindowSize(size,cond);
210
}
211
CIMGUI_API void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data)
212
{
213
    return ImGui::SetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data);
214
}
215
CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size)
216
{
217
    return ImGui::SetNextWindowContentSize(size);
218
}
219
CIMGUI_API void igSetNextWindowCollapsed(bool collapsed,ImGuiCond cond)
220
{
221
    return ImGui::SetNextWindowCollapsed(collapsed,cond);
222
}
223
CIMGUI_API void igSetNextWindowFocus()
224
{
225
    return ImGui::SetNextWindowFocus();
226
}
227
CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll)
228
{
229
    return ImGui::SetNextWindowScroll(scroll);
230
}
231
CIMGUI_API void igSetNextWindowBgAlpha(float alpha)
232
{
233
    return ImGui::SetNextWindowBgAlpha(alpha);
234
}
235
CIMGUI_API void igSetNextWindowViewport(ImGuiID viewport_id)
236
{
237
    return ImGui::SetNextWindowViewport(viewport_id);
238
}
239
CIMGUI_API void igSetWindowPos_Vec2(const ImVec2 pos,ImGuiCond cond)
240
{
241
    return ImGui::SetWindowPos(pos,cond);
242
}
243
CIMGUI_API void igSetWindowSize_Vec2(const ImVec2 size,ImGuiCond cond)
244
{
245
    return ImGui::SetWindowSize(size,cond);
246
}
247
CIMGUI_API void igSetWindowCollapsed_Bool(bool collapsed,ImGuiCond cond)
248
{
249
    return ImGui::SetWindowCollapsed(collapsed,cond);
250
}
251
CIMGUI_API void igSetWindowFocus_Nil()
252
{
253
    return ImGui::SetWindowFocus();
254
}
255
CIMGUI_API void igSetWindowFontScale(float scale)
256
{
257
    return ImGui::SetWindowFontScale(scale);
258
}
259
CIMGUI_API void igSetWindowPos_Str(const char* name,const ImVec2 pos,ImGuiCond cond)
260
{
261
    return ImGui::SetWindowPos(name,pos,cond);
262
}
263
CIMGUI_API void igSetWindowSize_Str(const char* name,const ImVec2 size,ImGuiCond cond)
264
{
265
    return ImGui::SetWindowSize(name,size,cond);
266
}
267
CIMGUI_API void igSetWindowCollapsed_Str(const char* name,bool collapsed,ImGuiCond cond)
268
{
269
    return ImGui::SetWindowCollapsed(name,collapsed,cond);
270
}
271
CIMGUI_API void igSetWindowFocus_Str(const char* name)
272
{
273
    return ImGui::SetWindowFocus(name);
274
}
275
CIMGUI_API void igGetContentRegionAvail(ImVec2 *pOut)
276
{
277
    *pOut = ImGui::GetContentRegionAvail();
278
}
279
CIMGUI_API void igGetContentRegionMax(ImVec2 *pOut)
280
{
281
    *pOut = ImGui::GetContentRegionMax();
282
}
283
CIMGUI_API void igGetWindowContentRegionMin(ImVec2 *pOut)
284
{
285
    *pOut = ImGui::GetWindowContentRegionMin();
286
}
287
CIMGUI_API void igGetWindowContentRegionMax(ImVec2 *pOut)
288
{
289
    *pOut = ImGui::GetWindowContentRegionMax();
290
}
291
CIMGUI_API float igGetScrollX()
292
{
293
    return ImGui::GetScrollX();
294
}
295
CIMGUI_API float igGetScrollY()
296
{
297
    return ImGui::GetScrollY();
298
}
299
CIMGUI_API void igSetScrollX_Float(float scroll_x)
300
{
301
    return ImGui::SetScrollX(scroll_x);
302
}
303
CIMGUI_API void igSetScrollY_Float(float scroll_y)
304
{
305
    return ImGui::SetScrollY(scroll_y);
306
}
307
CIMGUI_API float igGetScrollMaxX()
308
{
309
    return ImGui::GetScrollMaxX();
310
}
311
CIMGUI_API float igGetScrollMaxY()
312
{
313
    return ImGui::GetScrollMaxY();
314
}
315
CIMGUI_API void igSetScrollHereX(float center_x_ratio)
316
{
317
    return ImGui::SetScrollHereX(center_x_ratio);
318
}
319
CIMGUI_API void igSetScrollHereY(float center_y_ratio)
320
{
321
    return ImGui::SetScrollHereY(center_y_ratio);
322
}
323
CIMGUI_API void igSetScrollFromPosX_Float(float local_x,float center_x_ratio)
324
{
325
    return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
326
}
327
CIMGUI_API void igSetScrollFromPosY_Float(float local_y,float center_y_ratio)
328
{
329
    return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
330
}
331
CIMGUI_API void igPushFont(ImFont* font)
332
{
333
    return ImGui::PushFont(font);
334
}
335
CIMGUI_API void igPopFont()
336
{
337
    return ImGui::PopFont();
338
}
339
CIMGUI_API void igPushStyleColor_U32(ImGuiCol idx,ImU32 col)
340
{
341
    return ImGui::PushStyleColor(idx,col);
342
}
343
CIMGUI_API void igPushStyleColor_Vec4(ImGuiCol idx,const ImVec4 col)
344
{
345
    return ImGui::PushStyleColor(idx,col);
346
}
347
CIMGUI_API void igPopStyleColor(int count)
348
{
349
    return ImGui::PopStyleColor(count);
350
}
351
CIMGUI_API void igPushStyleVar_Float(ImGuiStyleVar idx,float val)
352
{
353
    return ImGui::PushStyleVar(idx,val);
354
}
355
CIMGUI_API void igPushStyleVar_Vec2(ImGuiStyleVar idx,const ImVec2 val)
356
{
357
    return ImGui::PushStyleVar(idx,val);
358
}
359
CIMGUI_API void igPopStyleVar(int count)
360
{
361
    return ImGui::PopStyleVar(count);
362
}
363
CIMGUI_API void igPushTabStop(bool tab_stop)
364
{
365
    return ImGui::PushTabStop(tab_stop);
366
}
367
CIMGUI_API void igPopTabStop()
368
{
369
    return ImGui::PopTabStop();
370
}
371
CIMGUI_API void igPushButtonRepeat(bool repeat)
372
{
373
    return ImGui::PushButtonRepeat(repeat);
374
}
375
CIMGUI_API void igPopButtonRepeat()
376
{
377
    return ImGui::PopButtonRepeat();
378
}
379
CIMGUI_API void igPushItemWidth(float item_width)
380
{
381
    return ImGui::PushItemWidth(item_width);
382
}
383
CIMGUI_API void igPopItemWidth()
384
{
385
    return ImGui::PopItemWidth();
386
}
387
CIMGUI_API void igSetNextItemWidth(float item_width)
388
{
389
    return ImGui::SetNextItemWidth(item_width);
390
}
391
CIMGUI_API float igCalcItemWidth()
392
{
393
    return ImGui::CalcItemWidth();
394
}
395
CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x)
396
{
397
    return ImGui::PushTextWrapPos(wrap_local_pos_x);
398
}
399
CIMGUI_API void igPopTextWrapPos()
400
{
401
    return ImGui::PopTextWrapPos();
402
}
403
CIMGUI_API ImFont* igGetFont()
404
{
405
    return ImGui::GetFont();
406
}
407
CIMGUI_API float igGetFontSize()
408
{
409
    return ImGui::GetFontSize();
410
}
411
CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2 *pOut)
412
{
413
    *pOut = ImGui::GetFontTexUvWhitePixel();
414
}
415
CIMGUI_API ImU32 igGetColorU32_Col(ImGuiCol idx,float alpha_mul)
416
{
417
    return ImGui::GetColorU32(idx,alpha_mul);
418
}
419
CIMGUI_API ImU32 igGetColorU32_Vec4(const ImVec4 col)
420
{
421
    return ImGui::GetColorU32(col);
422
}
423
CIMGUI_API ImU32 igGetColorU32_U32(ImU32 col)
424
{
425
    return ImGui::GetColorU32(col);
426
}
427
CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx)
428
{
429
    return &ImGui::GetStyleColorVec4(idx);
430
}
431
CIMGUI_API void igSeparator()
432
{
433
    return ImGui::Separator();
434
}
435
CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
436
{
437
    return ImGui::SameLine(offset_from_start_x,spacing);
438
}
439
CIMGUI_API void igNewLine()
440
{
441
    return ImGui::NewLine();
442
}
443
CIMGUI_API void igSpacing()
444
{
445
    return ImGui::Spacing();
446
}
447
CIMGUI_API void igDummy(const ImVec2 size)
448
{
449
    return ImGui::Dummy(size);
450
}
451
CIMGUI_API void igIndent(float indent_w)
452
{
453
    return ImGui::Indent(indent_w);
454
}
455
CIMGUI_API void igUnindent(float indent_w)
456
{
457
    return ImGui::Unindent(indent_w);
458
}
459
CIMGUI_API void igBeginGroup()
460
{
461
    return ImGui::BeginGroup();
462
}
463
CIMGUI_API void igEndGroup()
464
{
465
    return ImGui::EndGroup();
466
}
467
CIMGUI_API void igGetCursorPos(ImVec2 *pOut)
468
{
469
    *pOut = ImGui::GetCursorPos();
470
}
471
CIMGUI_API float igGetCursorPosX()
472
{
473
    return ImGui::GetCursorPosX();
474
}
475
CIMGUI_API float igGetCursorPosY()
476
{
477
    return ImGui::GetCursorPosY();
478
}
479
CIMGUI_API void igSetCursorPos(const ImVec2 local_pos)
480
{
481
    return ImGui::SetCursorPos(local_pos);
482
}
483
CIMGUI_API void igSetCursorPosX(float local_x)
484
{
485
    return ImGui::SetCursorPosX(local_x);
486
}
487
CIMGUI_API void igSetCursorPosY(float local_y)
488
{
489
    return ImGui::SetCursorPosY(local_y);
490
}
491
CIMGUI_API void igGetCursorStartPos(ImVec2 *pOut)
492
{
493
    *pOut = ImGui::GetCursorStartPos();
494
}
495
CIMGUI_API void igGetCursorScreenPos(ImVec2 *pOut)
496
{
497
    *pOut = ImGui::GetCursorScreenPos();
498
}
499
CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos)
500
{
501
    return ImGui::SetCursorScreenPos(pos);
502
}
503
CIMGUI_API void igAlignTextToFramePadding()
504
{
505
    return ImGui::AlignTextToFramePadding();
506
}
507
CIMGUI_API float igGetTextLineHeight()
508
{
509
    return ImGui::GetTextLineHeight();
510
}
511
CIMGUI_API float igGetTextLineHeightWithSpacing()
512
{
513
    return ImGui::GetTextLineHeightWithSpacing();
514
}
515
CIMGUI_API float igGetFrameHeight()
516
{
517
    return ImGui::GetFrameHeight();
518
}
519
CIMGUI_API float igGetFrameHeightWithSpacing()
520
{
521
    return ImGui::GetFrameHeightWithSpacing();
522
}
523
CIMGUI_API void igPushID_Str(const char* str_id)
524
{
525
    return ImGui::PushID(str_id);
526
}
527
CIMGUI_API void igPushID_StrStr(const char* str_id_begin,const char* str_id_end)
528
{
529
    return ImGui::PushID(str_id_begin,str_id_end);
530
}
531
CIMGUI_API void igPushID_Ptr(const void* ptr_id)
532
{
533
    return ImGui::PushID(ptr_id);
534
}
535
CIMGUI_API void igPushID_Int(int int_id)
536
{
537
    return ImGui::PushID(int_id);
538
}
539
CIMGUI_API void igPopID()
540
{
541
    return ImGui::PopID();
542
}
543
CIMGUI_API ImGuiID igGetID_Str(const char* str_id)
544
{
545
    return ImGui::GetID(str_id);
546
}
547
CIMGUI_API ImGuiID igGetID_StrStr(const char* str_id_begin,const char* str_id_end)
548
{
549
    return ImGui::GetID(str_id_begin,str_id_end);
550
}
551
CIMGUI_API ImGuiID igGetID_Ptr(const void* ptr_id)
552
{
553
    return ImGui::GetID(ptr_id);
554
}
555
CIMGUI_API void igTextUnformatted(const char* text,const char* text_end)
556
{
557
    return ImGui::TextUnformatted(text,text_end);
558
}
559
CIMGUI_API void igText(const char* fmt,...)
560
{
561
    va_list args;
562
    va_start(args, fmt);
563
    ImGui::TextV(fmt,args);
564
    va_end(args);
565
}
566
CIMGUI_API void igTextV(const char* fmt,va_list args)
567
{
568
    return ImGui::TextV(fmt,args);
569
}
570
CIMGUI_API void igTextColored(const ImVec4 col,const char* fmt,...)
571
{
572
    va_list args;
573
    va_start(args, fmt);
574
    ImGui::TextColoredV(col,fmt,args);
575
    va_end(args);
576
}
577
CIMGUI_API void igTextColoredV(const ImVec4 col,const char* fmt,va_list args)
578
{
579
    return ImGui::TextColoredV(col,fmt,args);
580
}
581
CIMGUI_API void igTextDisabled(const char* fmt,...)
582
{
583
    va_list args;
584
    va_start(args, fmt);
585
    ImGui::TextDisabledV(fmt,args);
586
    va_end(args);
587
}
588
CIMGUI_API void igTextDisabledV(const char* fmt,va_list args)
589
{
590
    return ImGui::TextDisabledV(fmt,args);
591
}
592
CIMGUI_API void igTextWrapped(const char* fmt,...)
593
{
594
    va_list args;
595
    va_start(args, fmt);
596
    ImGui::TextWrappedV(fmt,args);
597
    va_end(args);
598
}
599
CIMGUI_API void igTextWrappedV(const char* fmt,va_list args)
600
{
601
    return ImGui::TextWrappedV(fmt,args);
602
}
603
CIMGUI_API void igLabelText(const char* label,const char* fmt,...)
604
{
605
    va_list args;
606
    va_start(args, fmt);
607
    ImGui::LabelTextV(label,fmt,args);
608
    va_end(args);
609
}
610
CIMGUI_API void igLabelTextV(const char* label,const char* fmt,va_list args)
611
{
612
    return ImGui::LabelTextV(label,fmt,args);
613
}
614
CIMGUI_API void igBulletText(const char* fmt,...)
615
{
616
    va_list args;
617
    va_start(args, fmt);
618
    ImGui::BulletTextV(fmt,args);
619
    va_end(args);
620
}
621
CIMGUI_API void igBulletTextV(const char* fmt,va_list args)
622
{
623
    return ImGui::BulletTextV(fmt,args);
624
}
625
CIMGUI_API void igSeparatorText(const char* label)
626
{
627
    return ImGui::SeparatorText(label);
628
}
629
CIMGUI_API bool igButton(const char* label,const ImVec2 size)
630
{
631
    return ImGui::Button(label,size);
632
}
633
CIMGUI_API bool igSmallButton(const char* label)
634
{
635
    return ImGui::SmallButton(label);
636
}
637
CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size,ImGuiButtonFlags flags)
638
{
639
    return ImGui::InvisibleButton(str_id,size,flags);
640
}
641
CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir)
642
{
643
    return ImGui::ArrowButton(str_id,dir);
644
}
645
CIMGUI_API bool igCheckbox(const char* label,bool* v)
646
{
647
    return ImGui::Checkbox(label,v);
648
}
649
CIMGUI_API bool igCheckboxFlags_IntPtr(const char* label,int* flags,int flags_value)
650
{
651
    return ImGui::CheckboxFlags(label,flags,flags_value);
652
}
653
CIMGUI_API bool igCheckboxFlags_UintPtr(const char* label,unsigned int* flags,unsigned int flags_value)
654
{
655
    return ImGui::CheckboxFlags(label,flags,flags_value);
656
}
657
CIMGUI_API bool igRadioButton_Bool(const char* label,bool active)
658
{
659
    return ImGui::RadioButton(label,active);
660
}
661
CIMGUI_API bool igRadioButton_IntPtr(const char* label,int* v,int v_button)
662
{
663
    return ImGui::RadioButton(label,v,v_button);
664
}
665
CIMGUI_API void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay)
666
{
667
    return ImGui::ProgressBar(fraction,size_arg,overlay);
668
}
669
CIMGUI_API void igBullet()
670
{
671
    return ImGui::Bullet();
672
}
673
CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)
674
{
675
    return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col);
676
}
677
CIMGUI_API bool igImageButton(const char* str_id,ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col)
678
{
679
    return ImGui::ImageButton(str_id,user_texture_id,size,uv0,uv1,bg_col,tint_col);
680
}
681
CIMGUI_API bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags)
682
{
683
    return ImGui::BeginCombo(label,preview_value,flags);
684
}
685
CIMGUI_API void igEndCombo()
686
{
687
    return ImGui::EndCombo();
688
}
689
CIMGUI_API bool igCombo_Str_arr(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items)
690
{
691
    return ImGui::Combo(label,current_item,items,items_count,popup_max_height_in_items);
692
}
693
CIMGUI_API bool igCombo_Str(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items)
694
{
695
    return ImGui::Combo(label,current_item,items_separated_by_zeros,popup_max_height_in_items);
696
}
697
CIMGUI_API bool igCombo_FnBoolPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items)
698
{
699
    return ImGui::Combo(label,current_item,items_getter,data,items_count,popup_max_height_in_items);
700
}
701
CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
702
{
703
    return ImGui::DragFloat(label,v,v_speed,v_min,v_max,format,flags);
704
}
705
CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
706
{
707
    return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,format,flags);
708
}
709
CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
710
{
711
    return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,format,flags);
712
}
713
CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
714
{
715
    return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,format,flags);
716
}
717
CIMGUI_API bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)
718
{
719
    return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags);
720
}
721
CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
722
{
723
    return ImGui::DragInt(label,v,v_speed,v_min,v_max,format,flags);
724
}
725
CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
726
{
727
    return ImGui::DragInt2(label,v,v_speed,v_min,v_max,format,flags);
728
}
729
CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
730
{
731
    return ImGui::DragInt3(label,v,v_speed,v_min,v_max,format,flags);
732
}
733
CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
734
{
735
    return ImGui::DragInt4(label,v,v_speed,v_min,v_max,format,flags);
736
}
737
CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)
738
{
739
    return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags);
740
}
741
CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* p_data,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
742
{
743
    return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,flags);
744
}
745
CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
746
{
747
    return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,flags);
748
}
749
CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
750
{
751
    return ImGui::SliderFloat(label,v,v_min,v_max,format,flags);
752
}
753
CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
754
{
755
    return ImGui::SliderFloat2(label,v,v_min,v_max,format,flags);
756
}
757
CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
758
{
759
    return ImGui::SliderFloat3(label,v,v_min,v_max,format,flags);
760
}
761
CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
762
{
763
    return ImGui::SliderFloat4(label,v,v_min,v_max,format,flags);
764
}
765
CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format,ImGuiSliderFlags flags)
766
{
767
    return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format,flags);
768
}
769
CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
770
{
771
    return ImGui::SliderInt(label,v,v_min,v_max,format,flags);
772
}
773
CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
774
{
775
    return ImGui::SliderInt2(label,v,v_min,v_max,format,flags);
776
}
777
CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
778
{
779
    return ImGui::SliderInt3(label,v,v_min,v_max,format,flags);
780
}
781
CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
782
{
783
    return ImGui::SliderInt4(label,v,v_min,v_max,format,flags);
784
}
785
CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
786
{
787
    return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,flags);
788
}
789
CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
790
{
791
    return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,flags);
792
}
793
CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
794
{
795
    return ImGui::VSliderFloat(label,size,v,v_min,v_max,format,flags);
796
}
797
CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
798
{
799
    return ImGui::VSliderInt(label,size,v,v_min,v_max,format,flags);
800
}
801
CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
802
{
803
    return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,flags);
804
}
805
CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
806
{
807
    return ImGui::InputText(label,buf,buf_size,flags,callback,user_data);
808
}
809
CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
810
{
811
    return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
812
}
813
CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
814
{
815
    return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
816
}
817
CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
818
{
819
    return ImGui::InputFloat(label,v,step,step_fast,format,flags);
820
}
821
CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)
822
{
823
    return ImGui::InputFloat2(label,v,format,flags);
824
}
825
CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)
826
{
827
    return ImGui::InputFloat3(label,v,format,flags);
828
}
829
CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)
830
{
831
    return ImGui::InputFloat4(label,v,format,flags);
832
}
833
CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)
834
{
835
    return ImGui::InputInt(label,v,step,step_fast,flags);
836
}
837
CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags)
838
{
839
    return ImGui::InputInt2(label,v,flags);
840
}
841
CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags)
842
{
843
    return ImGui::InputInt3(label,v,flags);
844
}
845
CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags)
846
{
847
    return ImGui::InputInt4(label,v,flags);
848
}
849
CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)
850
{
851
    return ImGui::InputDouble(label,v,step,step_fast,format,flags);
852
}
853
CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
854
{
855
    return ImGui::InputScalar(label,data_type,p_data,p_step,p_step_fast,format,flags);
856
}
857
CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
858
{
859
    return ImGui::InputScalarN(label,data_type,p_data,components,p_step,p_step_fast,format,flags);
860
}
861
CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
862
{
863
    return ImGui::ColorEdit3(label,col,flags);
864
}
865
CIMGUI_API bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags)
866
{
867
    return ImGui::ColorEdit4(label,col,flags);
868
}
869
CIMGUI_API bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags)
870
{
871
    return ImGui::ColorPicker3(label,col,flags);
872
}
873
CIMGUI_API bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col)
874
{
875
    return ImGui::ColorPicker4(label,col,flags,ref_col);
876
}
877
CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,const ImVec2 size)
878
{
879
    return ImGui::ColorButton(desc_id,col,flags,size);
880
}
881
CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags)
882
{
883
    return ImGui::SetColorEditOptions(flags);
884
}
885
CIMGUI_API bool igTreeNode_Str(const char* label)
886
{
887
    return ImGui::TreeNode(label);
888
}
889
CIMGUI_API bool igTreeNode_StrStr(const char* str_id,const char* fmt,...)
890
{
891
    va_list args;
892
    va_start(args, fmt);
893
    bool ret = ImGui::TreeNodeV(str_id,fmt,args);
894
    va_end(args);
895
    return ret;
896
}
897
CIMGUI_API bool igTreeNode_Ptr(const void* ptr_id,const char* fmt,...)
898
{
899
    va_list args;
900
    va_start(args, fmt);
901
    bool ret = ImGui::TreeNodeV(ptr_id,fmt,args);
902
    va_end(args);
903
    return ret;
904
}
905
CIMGUI_API bool igTreeNodeV_Str(const char* str_id,const char* fmt,va_list args)
906
{
907
    return ImGui::TreeNodeV(str_id,fmt,args);
908
}
909
CIMGUI_API bool igTreeNodeV_Ptr(const void* ptr_id,const char* fmt,va_list args)
910
{
911
    return ImGui::TreeNodeV(ptr_id,fmt,args);
912
}
913
CIMGUI_API bool igTreeNodeEx_Str(const char* label,ImGuiTreeNodeFlags flags)
914
{
915
    return ImGui::TreeNodeEx(label,flags);
916
}
917
CIMGUI_API bool igTreeNodeEx_StrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)
918
{
919
    va_list args;
920
    va_start(args, fmt);
921
    bool ret = ImGui::TreeNodeExV(str_id,flags,fmt,args);
922
    va_end(args);
923
    return ret;
924
}
925
CIMGUI_API bool igTreeNodeEx_Ptr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)
926
{
927
    va_list args;
928
    va_start(args, fmt);
929
    bool ret = ImGui::TreeNodeExV(ptr_id,flags,fmt,args);
930
    va_end(args);
931
    return ret;
932
}
933
CIMGUI_API bool igTreeNodeExV_Str(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)
934
{
935
    return ImGui::TreeNodeExV(str_id,flags,fmt,args);
936
}
937
CIMGUI_API bool igTreeNodeExV_Ptr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)
938
{
939
    return ImGui::TreeNodeExV(ptr_id,flags,fmt,args);
940
}
941
CIMGUI_API void igTreePush_Str(const char* str_id)
942
{
943
    return ImGui::TreePush(str_id);
944
}
945
CIMGUI_API void igTreePush_Ptr(const void* ptr_id)
946
{
947
    return ImGui::TreePush(ptr_id);
948
}
949
CIMGUI_API void igTreePop()
950
{
951
    return ImGui::TreePop();
952
}
953
CIMGUI_API float igGetTreeNodeToLabelSpacing()
954
{
955
    return ImGui::GetTreeNodeToLabelSpacing();
956
}
957
CIMGUI_API bool igCollapsingHeader_TreeNodeFlags(const char* label,ImGuiTreeNodeFlags flags)
958
{
959
    return ImGui::CollapsingHeader(label,flags);
960
}
961
CIMGUI_API bool igCollapsingHeader_BoolPtr(const char* label,bool* p_visible,ImGuiTreeNodeFlags flags)
962
{
963
    return ImGui::CollapsingHeader(label,p_visible,flags);
964
}
965
CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
966
{
967
    return ImGui::SetNextItemOpen(is_open,cond);
968
}
969
CIMGUI_API bool igSelectable_Bool(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
970
{
971
    return ImGui::Selectable(label,selected,flags,size);
972
}
973
CIMGUI_API bool igSelectable_BoolPtr(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size)
974
{
975
    return ImGui::Selectable(label,p_selected,flags,size);
976
}
977
CIMGUI_API bool igBeginListBox(const char* label,const ImVec2 size)
978
{
979
    return ImGui::BeginListBox(label,size);
980
}
981
CIMGUI_API void igEndListBox()
982
{
983
    return ImGui::EndListBox();
984
}
985
CIMGUI_API bool igListBox_Str_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items)
986
{
987
    return ImGui::ListBox(label,current_item,items,items_count,height_in_items);
988
}
989
CIMGUI_API bool igListBox_FnBoolPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items)
990
{
991
    return ImGui::ListBox(label,current_item,items_getter,data,items_count,height_in_items);
992
}
993
CIMGUI_API void igPlotLines_FloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)
994
{
995
    return ImGui::PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
996
}
997
CIMGUI_API void igPlotLines_FnFloatPtr(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)
998
{
999
    return ImGui::PlotLines(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
1000
}
1001
CIMGUI_API void igPlotHistogram_FloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)
1002
{
1003
    return ImGui::PlotHistogram(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
1004
}
1005
CIMGUI_API void igPlotHistogram_FnFloatPtr(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)
1006
{
1007
    return ImGui::PlotHistogram(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
1008
}
1009
CIMGUI_API void igValue_Bool(const char* prefix,bool b)
1010
{
1011
    return ImGui::Value(prefix,b);
1012
}
1013
CIMGUI_API void igValue_Int(const char* prefix,int v)
1014
{
1015
    return ImGui::Value(prefix,v);
1016
}
1017
CIMGUI_API void igValue_Uint(const char* prefix,unsigned int v)
1018
{
1019
    return ImGui::Value(prefix,v);
1020
}
1021
CIMGUI_API void igValue_Float(const char* prefix,float v,const char* float_format)
1022
{
1023
    return ImGui::Value(prefix,v,float_format);
1024
}
1025
CIMGUI_API bool igBeginMenuBar()
1026
{
1027
    return ImGui::BeginMenuBar();
1028
}
1029
CIMGUI_API void igEndMenuBar()
1030
{
1031
    return ImGui::EndMenuBar();
1032
}
1033
CIMGUI_API bool igBeginMainMenuBar()
1034
{
1035
    return ImGui::BeginMainMenuBar();
1036
}
1037
CIMGUI_API void igEndMainMenuBar()
1038
{
1039
    return ImGui::EndMainMenuBar();
1040
}
1041
CIMGUI_API bool igBeginMenu(const char* label,bool enabled)
1042
{
1043
    return ImGui::BeginMenu(label,enabled);
1044
}
1045
CIMGUI_API void igEndMenu()
1046
{
1047
    return ImGui::EndMenu();
1048
}
1049
CIMGUI_API bool igMenuItem_Bool(const char* label,const char* shortcut,bool selected,bool enabled)
1050
{
1051
    return ImGui::MenuItem(label,shortcut,selected,enabled);
1052
}
1053
CIMGUI_API bool igMenuItem_BoolPtr(const char* label,const char* shortcut,bool* p_selected,bool enabled)
1054
{
1055
    return ImGui::MenuItem(label,shortcut,p_selected,enabled);
1056
}
1057
CIMGUI_API bool igBeginTooltip()
1058
{
1059
    return ImGui::BeginTooltip();
1060
}
1061
CIMGUI_API void igEndTooltip()
1062
{
1063
    return ImGui::EndTooltip();
1064
}
1065
CIMGUI_API void igSetTooltip(const char* fmt,...)
1066
{
1067
    va_list args;
1068
    va_start(args, fmt);
1069
    ImGui::SetTooltipV(fmt,args);
1070
    va_end(args);
1071
}
1072
CIMGUI_API void igSetTooltipV(const char* fmt,va_list args)
1073
{
1074
    return ImGui::SetTooltipV(fmt,args);
1075
}
1076
CIMGUI_API bool igBeginItemTooltip()
1077
{
1078
    return ImGui::BeginItemTooltip();
1079
}
1080
CIMGUI_API void igSetItemTooltip(const char* fmt,...)
1081
{
1082
    va_list args;
1083
    va_start(args, fmt);
1084
    ImGui::SetItemTooltipV(fmt,args);
1085
    va_end(args);
1086
}
1087
CIMGUI_API void igSetItemTooltipV(const char* fmt,va_list args)
1088
{
1089
    return ImGui::SetItemTooltipV(fmt,args);
1090
}
1091
CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags)
1092
{
1093
    return ImGui::BeginPopup(str_id,flags);
1094
}
1095
CIMGUI_API bool igBeginPopupModal(const char* name,bool* p_open,ImGuiWindowFlags flags)
1096
{
1097
    return ImGui::BeginPopupModal(name,p_open,flags);
1098
}
1099
CIMGUI_API void igEndPopup()
1100
{
1101
    return ImGui::EndPopup();
1102
}
1103
CIMGUI_API void igOpenPopup_Str(const char* str_id,ImGuiPopupFlags popup_flags)
1104
{
1105
    return ImGui::OpenPopup(str_id,popup_flags);
1106
}
1107
CIMGUI_API void igOpenPopup_ID(ImGuiID id,ImGuiPopupFlags popup_flags)
1108
{
1109
    return ImGui::OpenPopup(id,popup_flags);
1110
}
1111
CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,ImGuiPopupFlags popup_flags)
1112
{
1113
    return ImGui::OpenPopupOnItemClick(str_id,popup_flags);
1114
}
1115
CIMGUI_API void igCloseCurrentPopup()
1116
{
1117
    return ImGui::CloseCurrentPopup();
1118
}
1119
CIMGUI_API bool igBeginPopupContextItem(const char* str_id,ImGuiPopupFlags popup_flags)
1120
{
1121
    return ImGui::BeginPopupContextItem(str_id,popup_flags);
1122
}
1123
CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,ImGuiPopupFlags popup_flags)
1124
{
1125
    return ImGui::BeginPopupContextWindow(str_id,popup_flags);
1126
}
1127
CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiPopupFlags popup_flags)
1128
{
1129
    return ImGui::BeginPopupContextVoid(str_id,popup_flags);
1130
}
1131
CIMGUI_API bool igIsPopupOpen_Str(const char* str_id,ImGuiPopupFlags flags)
1132
{
1133
    return ImGui::IsPopupOpen(str_id,flags);
1134
}
1135
CIMGUI_API bool igBeginTable(const char* str_id,int column,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width)
1136
{
1137
    return ImGui::BeginTable(str_id,column,flags,outer_size,inner_width);
1138
}
1139
CIMGUI_API void igEndTable()
1140
{
1141
    return ImGui::EndTable();
1142
}
1143
CIMGUI_API void igTableNextRow(ImGuiTableRowFlags row_flags,float min_row_height)
1144
{
1145
    return ImGui::TableNextRow(row_flags,min_row_height);
1146
}
1147
CIMGUI_API bool igTableNextColumn()
1148
{
1149
    return ImGui::TableNextColumn();
1150
}
1151
CIMGUI_API bool igTableSetColumnIndex(int column_n)
1152
{
1153
    return ImGui::TableSetColumnIndex(column_n);
1154
}
1155
CIMGUI_API void igTableSetupColumn(const char* label,ImGuiTableColumnFlags flags,float init_width_or_weight,ImGuiID user_id)
1156
{
1157
    return ImGui::TableSetupColumn(label,flags,init_width_or_weight,user_id);
1158
}
1159
CIMGUI_API void igTableSetupScrollFreeze(int cols,int rows)
1160
{
1161
    return ImGui::TableSetupScrollFreeze(cols,rows);
1162
}
1163
CIMGUI_API void igTableHeadersRow()
1164
{
1165
    return ImGui::TableHeadersRow();
1166
}
1167
CIMGUI_API void igTableHeader(const char* label)
1168
{
1169
    return ImGui::TableHeader(label);
1170
}
1171
CIMGUI_API ImGuiTableSortSpecs* igTableGetSortSpecs()
1172
{
1173
    return ImGui::TableGetSortSpecs();
1174
}
1175
CIMGUI_API int igTableGetColumnCount()
1176
{
1177
    return ImGui::TableGetColumnCount();
1178
}
1179
CIMGUI_API int igTableGetColumnIndex()
1180
{
1181
    return ImGui::TableGetColumnIndex();
1182
}
1183
CIMGUI_API int igTableGetRowIndex()
1184
{
1185
    return ImGui::TableGetRowIndex();
1186
}
1187
CIMGUI_API const char* igTableGetColumnName_Int(int column_n)
1188
{
1189
    return ImGui::TableGetColumnName(column_n);
1190
}
1191
CIMGUI_API ImGuiTableColumnFlags igTableGetColumnFlags(int column_n)
1192
{
1193
    return ImGui::TableGetColumnFlags(column_n);
1194
}
1195
CIMGUI_API void igTableSetColumnEnabled(int column_n,bool v)
1196
{
1197
    return ImGui::TableSetColumnEnabled(column_n,v);
1198
}
1199
CIMGUI_API void igTableSetBgColor(ImGuiTableBgTarget target,ImU32 color,int column_n)
1200
{
1201
    return ImGui::TableSetBgColor(target,color,column_n);
1202
}
1203
CIMGUI_API void igColumns(int count,const char* id,bool border)
1204
{
1205
    return ImGui::Columns(count,id,border);
1206
}
1207
CIMGUI_API void igNextColumn()
1208
{
1209
    return ImGui::NextColumn();
1210
}
1211
CIMGUI_API int igGetColumnIndex()
1212
{
1213
    return ImGui::GetColumnIndex();
1214
}
1215
CIMGUI_API float igGetColumnWidth(int column_index)
1216
{
1217
    return ImGui::GetColumnWidth(column_index);
1218
}
1219
CIMGUI_API void igSetColumnWidth(int column_index,float width)
1220
{
1221
    return ImGui::SetColumnWidth(column_index,width);
1222
}
1223
CIMGUI_API float igGetColumnOffset(int column_index)
1224
{
1225
    return ImGui::GetColumnOffset(column_index);
1226
}
1227
CIMGUI_API void igSetColumnOffset(int column_index,float offset_x)
1228
{
1229
    return ImGui::SetColumnOffset(column_index,offset_x);
1230
}
1231
CIMGUI_API int igGetColumnsCount()
1232
{
1233
    return ImGui::GetColumnsCount();
1234
}
1235
CIMGUI_API bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags)
1236
{
1237
    return ImGui::BeginTabBar(str_id,flags);
1238
}
1239
CIMGUI_API void igEndTabBar()
1240
{
1241
    return ImGui::EndTabBar();
1242
}
1243
CIMGUI_API bool igBeginTabItem(const char* label,bool* p_open,ImGuiTabItemFlags flags)
1244
{
1245
    return ImGui::BeginTabItem(label,p_open,flags);
1246
}
1247
CIMGUI_API void igEndTabItem()
1248
{
1249
    return ImGui::EndTabItem();
1250
}
1251
CIMGUI_API bool igTabItemButton(const char* label,ImGuiTabItemFlags flags)
1252
{
1253
    return ImGui::TabItemButton(label,flags);
1254
}
1255
CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
1256
{
1257
    return ImGui::SetTabItemClosed(tab_or_docked_window_label);
1258
}
1259
CIMGUI_API ImGuiID igDockSpace(ImGuiID id,const ImVec2 size,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)
1260
{
1261
    return ImGui::DockSpace(id,size,flags,window_class);
1262
}
1263
CIMGUI_API ImGuiID igDockSpaceOverViewport(const ImGuiViewport* viewport,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)
1264
{
1265
    return ImGui::DockSpaceOverViewport(viewport,flags,window_class);
1266
}
1267
CIMGUI_API void igSetNextWindowDockID(ImGuiID dock_id,ImGuiCond cond)
1268
{
1269
    return ImGui::SetNextWindowDockID(dock_id,cond);
1270
}
1271
CIMGUI_API void igSetNextWindowClass(const ImGuiWindowClass* window_class)
1272
{
1273
    return ImGui::SetNextWindowClass(window_class);
1274
}
1275
CIMGUI_API ImGuiID igGetWindowDockID()
1276
{
1277
    return ImGui::GetWindowDockID();
1278
}
1279
CIMGUI_API bool igIsWindowDocked()
1280
{
1281
    return ImGui::IsWindowDocked();
1282
}
1283
CIMGUI_API void igLogToTTY(int auto_open_depth)
1284
{
1285
    return ImGui::LogToTTY(auto_open_depth);
1286
}
1287
CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
1288
{
1289
    return ImGui::LogToFile(auto_open_depth,filename);
1290
}
1291
CIMGUI_API void igLogToClipboard(int auto_open_depth)
1292
{
1293
    return ImGui::LogToClipboard(auto_open_depth);
1294
}
1295
CIMGUI_API void igLogFinish()
1296
{
1297
    return ImGui::LogFinish();
1298
}
1299
CIMGUI_API void igLogButtons()
1300
{
1301
    return ImGui::LogButtons();
1302
}
1303
CIMGUI_API void igLogTextV(const char* fmt,va_list args)
1304
{
1305
    return ImGui::LogTextV(fmt,args);
1306
}
1307
CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
1308
{
1309
    return ImGui::BeginDragDropSource(flags);
1310
}
1311
CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
1312
{
1313
    return ImGui::SetDragDropPayload(type,data,sz,cond);
1314
}
1315
CIMGUI_API void igEndDragDropSource()
1316
{
1317
    return ImGui::EndDragDropSource();
1318
}
1319
CIMGUI_API bool igBeginDragDropTarget()
1320
{
1321
    return ImGui::BeginDragDropTarget();
1322
}
1323
CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags)
1324
{
1325
    return ImGui::AcceptDragDropPayload(type,flags);
1326
}
1327
CIMGUI_API void igEndDragDropTarget()
1328
{
1329
    return ImGui::EndDragDropTarget();
1330
}
1331
CIMGUI_API const ImGuiPayload* igGetDragDropPayload()
1332
{
1333
    return ImGui::GetDragDropPayload();
1334
}
1335
CIMGUI_API void igBeginDisabled(bool disabled)
1336
{
1337
    return ImGui::BeginDisabled(disabled);
1338
}
1339
CIMGUI_API void igEndDisabled()
1340
{
1341
    return ImGui::EndDisabled();
1342
}
1343
CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
1344
{
1345
    return ImGui::PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
1346
}
1347
CIMGUI_API void igPopClipRect()
1348
{
1349
    return ImGui::PopClipRect();
1350
}
1351
CIMGUI_API void igSetItemDefaultFocus()
1352
{
1353
    return ImGui::SetItemDefaultFocus();
1354
}
1355
CIMGUI_API void igSetKeyboardFocusHere(int offset)
1356
{
1357
    return ImGui::SetKeyboardFocusHere(offset);
1358
}
1359
CIMGUI_API void igSetNextItemAllowOverlap()
1360
{
1361
    return ImGui::SetNextItemAllowOverlap();
1362
}
1363
CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags)
1364
{
1365
    return ImGui::IsItemHovered(flags);
1366
}
1367
CIMGUI_API bool igIsItemActive()
1368
{
1369
    return ImGui::IsItemActive();
1370
}
1371
CIMGUI_API bool igIsItemFocused()
1372
{
1373
    return ImGui::IsItemFocused();
1374
}
1375
CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button)
1376
{
1377
    return ImGui::IsItemClicked(mouse_button);
1378
}
1379
CIMGUI_API bool igIsItemVisible()
1380
{
1381
    return ImGui::IsItemVisible();
1382
}
1383
CIMGUI_API bool igIsItemEdited()
1384
{
1385
    return ImGui::IsItemEdited();
1386
}
1387
CIMGUI_API bool igIsItemActivated()
1388
{
1389
    return ImGui::IsItemActivated();
1390
}
1391
CIMGUI_API bool igIsItemDeactivated()
1392
{
1393
    return ImGui::IsItemDeactivated();
1394
}
1395
CIMGUI_API bool igIsItemDeactivatedAfterEdit()
1396
{
1397
    return ImGui::IsItemDeactivatedAfterEdit();
1398
}
1399
CIMGUI_API bool igIsItemToggledOpen()
1400
{
1401
    return ImGui::IsItemToggledOpen();
1402
}
1403
CIMGUI_API bool igIsAnyItemHovered()
1404
{
1405
    return ImGui::IsAnyItemHovered();
1406
}
1407
CIMGUI_API bool igIsAnyItemActive()
1408
{
1409
    return ImGui::IsAnyItemActive();
1410
}
1411
CIMGUI_API bool igIsAnyItemFocused()
1412
{
1413
    return ImGui::IsAnyItemFocused();
1414
}
1415
CIMGUI_API ImGuiID igGetItemID()
1416
{
1417
    return ImGui::GetItemID();
1418
}
1419
CIMGUI_API void igGetItemRectMin(ImVec2 *pOut)
1420
{
1421
    *pOut = ImGui::GetItemRectMin();
1422
}
1423
CIMGUI_API void igGetItemRectMax(ImVec2 *pOut)
1424
{
1425
    *pOut = ImGui::GetItemRectMax();
1426
}
1427
CIMGUI_API void igGetItemRectSize(ImVec2 *pOut)
1428
{
1429
    *pOut = ImGui::GetItemRectSize();
1430
}
1431
CIMGUI_API ImGuiViewport* igGetMainViewport()
1432
{
1433
    return ImGui::GetMainViewport();
1434
}
1435
CIMGUI_API ImDrawList* igGetBackgroundDrawList_Nil()
1436
{
1437
    return ImGui::GetBackgroundDrawList();
1438
}
1439
CIMGUI_API ImDrawList* igGetForegroundDrawList_Nil()
1440
{
1441
    return ImGui::GetForegroundDrawList();
1442
}
1443
CIMGUI_API ImDrawList* igGetBackgroundDrawList_ViewportPtr(ImGuiViewport* viewport)
1444
{
1445
    return ImGui::GetBackgroundDrawList(viewport);
1446
}
1447
CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport)
1448
{
1449
    return ImGui::GetForegroundDrawList(viewport);
1450
}
1451
CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size)
1452
{
1453
    return ImGui::IsRectVisible(size);
1454
}
1455
CIMGUI_API bool igIsRectVisible_Vec2(const ImVec2 rect_min,const ImVec2 rect_max)
1456
{
1457
    return ImGui::IsRectVisible(rect_min,rect_max);
1458
}
1459
CIMGUI_API double igGetTime()
1460
{
1461
    return ImGui::GetTime();
1462
}
1463
CIMGUI_API int igGetFrameCount()
1464
{
1465
    return ImGui::GetFrameCount();
1466
}
1467
CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
1468
{
1469
    return ImGui::GetDrawListSharedData();
1470
}
1471
CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx)
1472
{
1473
    return ImGui::GetStyleColorName(idx);
1474
}
1475
CIMGUI_API void igSetStateStorage(ImGuiStorage* storage)
1476
{
1477
    return ImGui::SetStateStorage(storage);
1478
}
1479
CIMGUI_API ImGuiStorage* igGetStateStorage()
1480
{
1481
    return ImGui::GetStateStorage();
1482
}
1483
CIMGUI_API bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags)
1484
{
1485
    return ImGui::BeginChildFrame(id,size,flags);
1486
}
1487
CIMGUI_API void igEndChildFrame()
1488
{
1489
    return ImGui::EndChildFrame();
1490
}
1491
CIMGUI_API void igCalcTextSize(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
1492
{
1493
    *pOut = ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width);
1494
}
1495
CIMGUI_API void igColorConvertU32ToFloat4(ImVec4 *pOut,ImU32 in)
1496
{
1497
    *pOut = ImGui::ColorConvertU32ToFloat4(in);
1498
}
1499
CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in)
1500
{
1501
    return ImGui::ColorConvertFloat4ToU32(in);
1502
}
1503
CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float* out_h,float* out_s,float* out_v)
1504
{
1505
    return ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v);
1506
}
1507
CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float* out_r,float* out_g,float* out_b)
1508
{
1509
    return ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
1510
}
1511
CIMGUI_API bool igIsKeyDown_Nil(ImGuiKey key)
1512
{
1513
    return ImGui::IsKeyDown(key);
1514
}
1515
CIMGUI_API bool igIsKeyPressed_Bool(ImGuiKey key,bool repeat)
1516
{
1517
    return ImGui::IsKeyPressed(key,repeat);
1518
}
1519
CIMGUI_API bool igIsKeyReleased_Nil(ImGuiKey key)
1520
{
1521
    return ImGui::IsKeyReleased(key);
1522
}
1523
CIMGUI_API int igGetKeyPressedAmount(ImGuiKey key,float repeat_delay,float rate)
1524
{
1525
    return ImGui::GetKeyPressedAmount(key,repeat_delay,rate);
1526
}
1527
CIMGUI_API const char* igGetKeyName(ImGuiKey key)
1528
{
1529
    return ImGui::GetKeyName(key);
1530
}
1531
CIMGUI_API void igSetNextFrameWantCaptureKeyboard(bool want_capture_keyboard)
1532
{
1533
    return ImGui::SetNextFrameWantCaptureKeyboard(want_capture_keyboard);
1534
}
1535
CIMGUI_API bool igIsMouseDown_Nil(ImGuiMouseButton button)
1536
{
1537
    return ImGui::IsMouseDown(button);
1538
}
1539
CIMGUI_API bool igIsMouseClicked_Bool(ImGuiMouseButton button,bool repeat)
1540
{
1541
    return ImGui::IsMouseClicked(button,repeat);
1542
}
1543
CIMGUI_API bool igIsMouseReleased_Nil(ImGuiMouseButton button)
1544
{
1545
    return ImGui::IsMouseReleased(button);
1546
}
1547
CIMGUI_API bool igIsMouseDoubleClicked(ImGuiMouseButton button)
1548
{
1549
    return ImGui::IsMouseDoubleClicked(button);
1550
}
1551
CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button)
1552
{
1553
    return ImGui::GetMouseClickedCount(button);
1554
}
1555
CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip)
1556
{
1557
    return ImGui::IsMouseHoveringRect(r_min,r_max,clip);
1558
}
1559
CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos)
1560
{
1561
    return ImGui::IsMousePosValid(mouse_pos);
1562
}
1563
CIMGUI_API bool igIsAnyMouseDown()
1564
{
1565
    return ImGui::IsAnyMouseDown();
1566
}
1567
CIMGUI_API void igGetMousePos(ImVec2 *pOut)
1568
{
1569
    *pOut = ImGui::GetMousePos();
1570
}
1571
CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2 *pOut)
1572
{
1573
    *pOut = ImGui::GetMousePosOnOpeningCurrentPopup();
1574
}
1575
CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold)
1576
{
1577
    return ImGui::IsMouseDragging(button,lock_threshold);
1578
}
1579
CIMGUI_API void igGetMouseDragDelta(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold)
1580
{
1581
    *pOut = ImGui::GetMouseDragDelta(button,lock_threshold);
1582
}
1583
CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button)
1584
{
1585
    return ImGui::ResetMouseDragDelta(button);
1586
}
1587
CIMGUI_API ImGuiMouseCursor igGetMouseCursor()
1588
{
1589
    return ImGui::GetMouseCursor();
1590
}
1591
CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type)
1592
{
1593
    return ImGui::SetMouseCursor(cursor_type);
1594
}
1595
CIMGUI_API void igSetNextFrameWantCaptureMouse(bool want_capture_mouse)
1596
{
1597
    return ImGui::SetNextFrameWantCaptureMouse(want_capture_mouse);
1598
}
1599
CIMGUI_API const char* igGetClipboardText()
1600
{
1601
    return ImGui::GetClipboardText();
1602
}
1603
CIMGUI_API void igSetClipboardText(const char* text)
1604
{
1605
    return ImGui::SetClipboardText(text);
1606
}
1607
CIMGUI_API void igLoadIniSettingsFromDisk(const char* ini_filename)
1608
{
1609
    return ImGui::LoadIniSettingsFromDisk(ini_filename);
1610
}
1611
CIMGUI_API void igLoadIniSettingsFromMemory(const char* ini_data,size_t ini_size)
1612
{
1613
    return ImGui::LoadIniSettingsFromMemory(ini_data,ini_size);
1614
}
1615
CIMGUI_API void igSaveIniSettingsToDisk(const char* ini_filename)
1616
{
1617
    return ImGui::SaveIniSettingsToDisk(ini_filename);
1618
}
1619
CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size)
1620
{
1621
    return ImGui::SaveIniSettingsToMemory(out_ini_size);
1622
}
1623
CIMGUI_API void igDebugTextEncoding(const char* text)
1624
{
1625
    return ImGui::DebugTextEncoding(text);
1626
}
1627
CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
1628
{
1629
    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
1630
}
1631
CIMGUI_API void igSetAllocatorFunctions(ImGuiMemAllocFunc alloc_func,ImGuiMemFreeFunc free_func,void* user_data)
1632
{
1633
    return ImGui::SetAllocatorFunctions(alloc_func,free_func,user_data);
1634
}
1635
CIMGUI_API void igGetAllocatorFunctions(ImGuiMemAllocFunc* p_alloc_func,ImGuiMemFreeFunc* p_free_func,void** p_user_data)
1636
{
1637
    return ImGui::GetAllocatorFunctions(p_alloc_func,p_free_func,p_user_data);
1638
}
1639
CIMGUI_API void* igMemAlloc(size_t size)
1640
{
1641
    return ImGui::MemAlloc(size);
1642
}
1643
CIMGUI_API void igMemFree(void* ptr)
1644
{
1645
    return ImGui::MemFree(ptr);
1646
}
1647
CIMGUI_API ImGuiPlatformIO* igGetPlatformIO()
1648
{
1649
    return &ImGui::GetPlatformIO();
1650
}
1651
CIMGUI_API void igUpdatePlatformWindows()
1652
{
1653
    return ImGui::UpdatePlatformWindows();
1654
}
1655
CIMGUI_API void igRenderPlatformWindowsDefault(void* platform_render_arg,void* renderer_render_arg)
1656
{
1657
    return ImGui::RenderPlatformWindowsDefault(platform_render_arg,renderer_render_arg);
1658
}
1659
CIMGUI_API void igDestroyPlatformWindows()
1660
{
1661
    return ImGui::DestroyPlatformWindows();
1662
}
1663
CIMGUI_API ImGuiViewport* igFindViewportByID(ImGuiID id)
1664
{
1665
    return ImGui::FindViewportByID(id);
1666
}
1667
CIMGUI_API ImGuiViewport* igFindViewportByPlatformHandle(void* platform_handle)
1668
{
1669
    return ImGui::FindViewportByPlatformHandle(platform_handle);
1670
}
1671
CIMGUI_API ImGuiStyle* ImGuiStyle_ImGuiStyle(void)
1672
{
1673
    return IM_NEW(ImGuiStyle)();
1674
}
1675
CIMGUI_API void ImGuiStyle_destroy(ImGuiStyle* self)
1676
{
1677
    IM_DELETE(self);
1678
}
1679
CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
1680
{
1681
    return self->ScaleAllSizes(scale_factor);
1682
}
1683
CIMGUI_API void ImGuiIO_AddKeyEvent(ImGuiIO* self,ImGuiKey key,bool down)
1684
{
1685
    return self->AddKeyEvent(key,down);
1686
}
1687
CIMGUI_API void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self,ImGuiKey key,bool down,float v)
1688
{
1689
    return self->AddKeyAnalogEvent(key,down,v);
1690
}
1691
CIMGUI_API void ImGuiIO_AddMousePosEvent(ImGuiIO* self,float x,float y)
1692
{
1693
    return self->AddMousePosEvent(x,y);
1694
}
1695
CIMGUI_API void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self,int button,bool down)
1696
{
1697
    return self->AddMouseButtonEvent(button,down);
1698
}
1699
CIMGUI_API void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self,float wheel_x,float wheel_y)
1700
{
1701
    return self->AddMouseWheelEvent(wheel_x,wheel_y);
1702
}
1703
CIMGUI_API void ImGuiIO_AddMouseSourceEvent(ImGuiIO* self,ImGuiMouseSource source)
1704
{
1705
    return self->AddMouseSourceEvent(source);
1706
}
1707
CIMGUI_API void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self,ImGuiID id)
1708
{
1709
    return self->AddMouseViewportEvent(id);
1710
}
1711
CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self,bool focused)
1712
{
1713
    return self->AddFocusEvent(focused);
1714
}
1715
CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
1716
{
1717
    return self->AddInputCharacter(c);
1718
}
1719
CIMGUI_API void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self,ImWchar16 c)
1720
{
1721
    return self->AddInputCharacterUTF16(c);
1722
}
1723
CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str)
1724
{
1725
    return self->AddInputCharactersUTF8(str);
1726
}
1727
CIMGUI_API void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self,ImGuiKey key,int native_keycode,int native_scancode,int native_legacy_index)
1728
{
1729
    return self->SetKeyEventNativeData(key,native_keycode,native_scancode,native_legacy_index);
1730
}
1731
CIMGUI_API void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self,bool accepting_events)
1732
{
1733
    return self->SetAppAcceptingEvents(accepting_events);
1734
}
1735
CIMGUI_API void ImGuiIO_ClearEventsQueue(ImGuiIO* self)
1736
{
1737
    return self->ClearEventsQueue();
1738
}
1739
CIMGUI_API void ImGuiIO_ClearInputKeys(ImGuiIO* self)
1740
{
1741
    return self->ClearInputKeys();
1742
}
1743
CIMGUI_API ImGuiIO* ImGuiIO_ImGuiIO(void)
1744
{
1745
    return IM_NEW(ImGuiIO)();
1746
}
1747
CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self)
1748
{
1749
    IM_DELETE(self);
1750
}
1751
CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
1752
{
1753
    return IM_NEW(ImGuiInputTextCallbackData)();
1754
}
1755
CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
1756
{
1757
    IM_DELETE(self);
1758
}
1759
CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
1760
{
1761
    return self->DeleteChars(pos,bytes_count);
1762
}
1763
CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
1764
{
1765
    return self->InsertChars(pos,text,text_end);
1766
}
1767
CIMGUI_API void ImGuiInputTextCallbackData_SelectAll(ImGuiInputTextCallbackData* self)
1768
{
1769
    return self->SelectAll();
1770
}
1771
CIMGUI_API void ImGuiInputTextCallbackData_ClearSelection(ImGuiInputTextCallbackData* self)
1772
{
1773
    return self->ClearSelection();
1774
}
1775
CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
1776
{
1777
    return self->HasSelection();
1778
}
1779
CIMGUI_API ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass(void)
1780
{
1781
    return IM_NEW(ImGuiWindowClass)();
1782
}
1783
CIMGUI_API void ImGuiWindowClass_destroy(ImGuiWindowClass* self)
1784
{
1785
    IM_DELETE(self);
1786
}
1787
CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
1788
{
1789
    return IM_NEW(ImGuiPayload)();
1790
}
1791
CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
1792
{
1793
    IM_DELETE(self);
1794
}
1795
CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
1796
{
1797
    return self->Clear();
1798
}
1799
CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
1800
{
1801
    return self->IsDataType(type);
1802
}
1803
CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
1804
{
1805
    return self->IsPreview();
1806
}
1807
CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
1808
{
1809
    return self->IsDelivery();
1810
}
1811
CIMGUI_API ImGuiTableColumnSortSpecs* ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs(void)
1812
{
1813
    return IM_NEW(ImGuiTableColumnSortSpecs)();
1814
}
1815
CIMGUI_API void ImGuiTableColumnSortSpecs_destroy(ImGuiTableColumnSortSpecs* self)
1816
{
1817
    IM_DELETE(self);
1818
}
1819
CIMGUI_API ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs(void)
1820
{
1821
    return IM_NEW(ImGuiTableSortSpecs)();
1822
}
1823
CIMGUI_API void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self)
1824
{
1825
    IM_DELETE(self);
1826
}
1827
CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void)
1828
{
1829
    return IM_NEW(ImGuiOnceUponAFrame)();
1830
}
1831
CIMGUI_API void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self)
1832
{
1833
    IM_DELETE(self);
1834
}
1835
CIMGUI_API ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(const char* default_filter)
1836
{
1837
    return IM_NEW(ImGuiTextFilter)(default_filter);
1838
}
1839
CIMGUI_API void ImGuiTextFilter_destroy(ImGuiTextFilter* self)
1840
{
1841
    IM_DELETE(self);
1842
}
1843
CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width)
1844
{
1845
    return self->Draw(label,width);
1846
}
1847
CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end)
1848
{
1849
    return self->PassFilter(text,text_end);
1850
}
1851
CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self)
1852
{
1853
    return self->Build();
1854
}
1855
CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self)
1856
{
1857
    return self->Clear();
1858
}
1859
CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
1860
{
1861
    return self->IsActive();
1862
}
1863
CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Nil(void)
1864
{
1865
    return IM_NEW(ImGuiTextRange)();
1866
}
1867
CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
1868
{
1869
    IM_DELETE(self);
1870
}
1871
CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Str(const char* _b,const char* _e)
1872
{
1873
    return IM_NEW(ImGuiTextRange)(_b,_e);
1874
}
1875
CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
1876
{
1877
    return self->empty();
1878
}
1879
CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
1880
{
1881
    return self->split(separator,out);
1882
}
1883
CIMGUI_API ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void)
1884
{
1885
    return IM_NEW(ImGuiTextBuffer)();
1886
}
1887
CIMGUI_API void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self)
1888
{
1889
    IM_DELETE(self);
1890
}
1891
CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self)
1892
{
1893
    return self->begin();
1894
}
1895
CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self)
1896
{
1897
    return self->end();
1898
}
1899
CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self)
1900
{
1901
    return self->size();
1902
}
1903
CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self)
1904
{
1905
    return self->empty();
1906
}
1907
CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self)
1908
{
1909
    return self->clear();
1910
}
1911
CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity)
1912
{
1913
    return self->reserve(capacity);
1914
}
1915
CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
1916
{
1917
    return self->c_str();
1918
}
1919
CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
1920
{
1921
    return self->append(str,str_end);
1922
}
1923
CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
1924
{
1925
    return self->appendfv(fmt,args);
1926
}
1927
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Int(ImGuiID _key,int _val_i)
1928
{
1929
    return IM_NEW(ImGuiStoragePair)(_key,_val_i);
1930
}
1931
CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
1932
{
1933
    IM_DELETE(self);
1934
}
1935
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(ImGuiID _key,float _val_f)
1936
{
1937
    return IM_NEW(ImGuiStoragePair)(_key,_val_f);
1938
}
1939
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(ImGuiID _key,void* _val_p)
1940
{
1941
    return IM_NEW(ImGuiStoragePair)(_key,_val_p);
1942
}
1943
CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
1944
{
1945
    return self->Clear();
1946
}
1947
CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val)
1948
{
1949
    return self->GetInt(key,default_val);
1950
}
1951
CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val)
1952
{
1953
    return self->SetInt(key,val);
1954
}
1955
CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key,bool default_val)
1956
{
1957
    return self->GetBool(key,default_val);
1958
}
1959
CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key,bool val)
1960
{
1961
    return self->SetBool(key,val);
1962
}
1963
CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val)
1964
{
1965
    return self->GetFloat(key,default_val);
1966
}
1967
CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val)
1968
{
1969
    return self->SetFloat(key,val);
1970
}
1971
CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key)
1972
{
1973
    return self->GetVoidPtr(key);
1974
}
1975
CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val)
1976
{
1977
    return self->SetVoidPtr(key,val);
1978
}
1979
CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val)
1980
{
1981
    return self->GetIntRef(key,default_val);
1982
}
1983
CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key,bool default_val)
1984
{
1985
    return self->GetBoolRef(key,default_val);
1986
}
1987
CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val)
1988
{
1989
    return self->GetFloatRef(key,default_val);
1990
}
1991
CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val)
1992
{
1993
    return self->GetVoidPtrRef(key,default_val);
1994
}
1995
CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val)
1996
{
1997
    return self->SetAllInt(val);
1998
}
1999
CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self)
2000
{
2001
    return self->BuildSortByKey();
2002
}
2003
CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(void)
2004
{
2005
    return IM_NEW(ImGuiListClipper)();
2006
}
2007
CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
2008
{
2009
    IM_DELETE(self);
2010
}
2011
CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
2012
{
2013
    return self->Begin(items_count,items_height);
2014
}
2015
CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
2016
{
2017
    return self->End();
2018
}
2019
CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
2020
{
2021
    return self->Step();
2022
}
2023
CIMGUI_API void ImGuiListClipper_IncludeItemByIndex(ImGuiListClipper* self,int item_index)
2024
{
2025
    return self->IncludeItemByIndex(item_index);
2026
}
2027
CIMGUI_API void ImGuiListClipper_IncludeItemsByIndex(ImGuiListClipper* self,int item_begin,int item_end)
2028
{
2029
    return self->IncludeItemsByIndex(item_begin,item_end);
2030
}
2031
CIMGUI_API ImColor* ImColor_ImColor_Nil(void)
2032
{
2033
    return IM_NEW(ImColor)();
2034
}
2035
CIMGUI_API void ImColor_destroy(ImColor* self)
2036
{
2037
    IM_DELETE(self);
2038
}
2039
CIMGUI_API ImColor* ImColor_ImColor_Float(float r,float g,float b,float a)
2040
{
2041
    return IM_NEW(ImColor)(r,g,b,a);
2042
}
2043
CIMGUI_API ImColor* ImColor_ImColor_Vec4(const ImVec4 col)
2044
{
2045
    return IM_NEW(ImColor)(col);
2046
}
2047
CIMGUI_API ImColor* ImColor_ImColor_Int(int r,int g,int b,int a)
2048
{
2049
    return IM_NEW(ImColor)(r,g,b,a);
2050
}
2051
CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba)
2052
{
2053
    return IM_NEW(ImColor)(rgba);
2054
}
2055
CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a)
2056
{
2057
    return self->SetHSV(h,s,v,a);
2058
}
2059
CIMGUI_API void ImColor_HSV(ImColor *pOut,float h,float s,float v,float a)
2060
{
2061
    *pOut = ImColor::HSV(h,s,v,a);
2062
}
2063
CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void)
2064
{
2065
    return IM_NEW(ImDrawCmd)();
2066
}
2067
CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
2068
{
2069
    IM_DELETE(self);
2070
}
2071
CIMGUI_API ImTextureID ImDrawCmd_GetTexID(ImDrawCmd* self)
2072
{
2073
    return self->GetTexID();
2074
}
2075
CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
2076
{
2077
    return IM_NEW(ImDrawListSplitter)();
2078
}
2079
CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
2080
{
2081
    IM_DELETE(self);
2082
}
2083
CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
2084
{
2085
    return self->Clear();
2086
}
2087
CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
2088
{
2089
    return self->ClearFreeMemory();
2090
}
2091
CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
2092
{
2093
    return self->Split(draw_list,count);
2094
}
2095
CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
2096
{
2097
    return self->Merge(draw_list);
2098
}
2099
CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
2100
{
2101
    return self->SetCurrentChannel(draw_list,channel_idx);
2102
}
2103
CIMGUI_API ImDrawList* ImDrawList_ImDrawList(ImDrawListSharedData* shared_data)
2104
{
2105
    return IM_NEW(ImDrawList)(shared_data);
2106
}
2107
CIMGUI_API void ImDrawList_destroy(ImDrawList* self)
2108
{
2109
    IM_DELETE(self);
2110
}
2111
CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
2112
{
2113
    return self->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
2114
}
2115
CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self)
2116
{
2117
    return self->PushClipRectFullScreen();
2118
}
2119
CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self)
2120
{
2121
    return self->PopClipRect();
2122
}
2123
CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id)
2124
{
2125
    return self->PushTextureID(texture_id);
2126
}
2127
CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self)
2128
{
2129
    return self->PopTextureID();
2130
}
2131
CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2 *pOut,ImDrawList* self)
2132
{
2133
    *pOut = self->GetClipRectMin();
2134
}
2135
CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2 *pOut,ImDrawList* self)
2136
{
2137
    *pOut = self->GetClipRectMax();
2138
}
2139
CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
2140
{
2141
    return self->AddLine(p1,p2,col,thickness);
2142
}
2143
CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags,float thickness)
2144
{
2145
    return self->AddRect(p_min,p_max,col,rounding,flags,thickness);
2146
}
2147
CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags)
2148
{
2149
    return self->AddRectFilled(p_min,p_max,col,rounding,flags);
2150
}
2151
CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
2152
{
2153
    return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
2154
}
2155
CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
2156
{
2157
    return self->AddQuad(p1,p2,p3,p4,col,thickness);
2158
}
2159
CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
2160
{
2161
    return self->AddQuadFilled(p1,p2,p3,p4,col);
2162
}
2163
CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
2164
{
2165
    return self->AddTriangle(p1,p2,p3,col,thickness);
2166
}
2167
CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
2168
{
2169
    return self->AddTriangleFilled(p1,p2,p3,col);
2170
}
2171
CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
2172
{
2173
    return self->AddCircle(center,radius,col,num_segments,thickness);
2174
}
2175
CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
2176
{
2177
    return self->AddCircleFilled(center,radius,col,num_segments);
2178
}
2179
CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
2180
{
2181
    return self->AddNgon(center,radius,col,num_segments,thickness);
2182
}
2183
CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
2184
{
2185
    return self->AddNgonFilled(center,radius,col,num_segments);
2186
}
2187
CIMGUI_API void ImDrawList_AddText_Vec2(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
2188
{
2189
    return self->AddText(pos,col,text_begin,text_end);
2190
}
2191
CIMGUI_API void ImDrawList_AddText_FontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect)
2192
{
2193
    return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
2194
}
2195
CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,ImDrawFlags flags,float thickness)
2196
{
2197
    return self->AddPolyline(points,num_points,col,flags,thickness);
2198
}
2199
CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
2200
{
2201
    return self->AddConvexPolyFilled(points,num_points,col);
2202
}
2203
CIMGUI_API void ImDrawList_AddBezierCubic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments)
2204
{
2205
    return self->AddBezierCubic(p1,p2,p3,p4,col,thickness,num_segments);
2206
}
2207
CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness,int num_segments)
2208
{
2209
    return self->AddBezierQuadratic(p1,p2,p3,col,thickness,num_segments);
2210
}
2211
CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)
2212
{
2213
    return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
2214
}
2215
CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)
2216
{
2217
    return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
2218
}
2219
CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawFlags flags)
2220
{
2221
    return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,flags);
2222
}
2223
CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
2224
{
2225
    return self->PathClear();
2226
}
2227
CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos)
2228
{
2229
    return self->PathLineTo(pos);
2230
}
2231
CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos)
2232
{
2233
    return self->PathLineToMergeDuplicate(pos);
2234
}
2235
CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col)
2236
{
2237
    return self->PathFillConvex(col);
2238
}
2239
CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,ImDrawFlags flags,float thickness)
2240
{
2241
    return self->PathStroke(col,flags,thickness);
2242
}
2243
CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
2244
{
2245
    return self->PathArcTo(center,radius,a_min,a_max,num_segments);
2246
}
2247
CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
2248
{
2249
    return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
2250
}
2251
CIMGUI_API void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,int num_segments)
2252
{
2253
    return self->PathBezierCubicCurveTo(p2,p3,p4,num_segments);
2254
}
2255
CIMGUI_API void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,int num_segments)
2256
{
2257
    return self->PathBezierQuadraticCurveTo(p2,p3,num_segments);
2258
}
2259
CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawFlags flags)
2260
{
2261
    return self->PathRect(rect_min,rect_max,rounding,flags);
2262
}
2263
CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
2264
{
2265
    return self->AddCallback(callback,callback_data);
2266
}
2267
CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self)
2268
{
2269
    return self->AddDrawCmd();
2270
}
2271
CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
2272
{
2273
    return self->CloneOutput();
2274
}
2275
CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
2276
{
2277
    return self->ChannelsSplit(count);
2278
}
2279
CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
2280
{
2281
    return self->ChannelsMerge();
2282
}
2283
CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
2284
{
2285
    return self->ChannelsSetCurrent(n);
2286
}
2287
CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count)
2288
{
2289
    return self->PrimReserve(idx_count,vtx_count);
2290
}
2291
CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,int idx_count,int vtx_count)
2292
{
2293
    return self->PrimUnreserve(idx_count,vtx_count);
2294
}
2295
CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)
2296
{
2297
    return self->PrimRect(a,b,col);
2298
}
2299
CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
2300
{
2301
    return self->PrimRectUV(a,b,uv_a,uv_b,col);
2302
}
2303
CIMGUI_API void ImDrawList_PrimQuadUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)
2304
{
2305
    return self->PrimQuadUV(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
2306
}
2307
CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)
2308
{
2309
    return self->PrimWriteVtx(pos,uv,col);
2310
}
2311
CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx)
2312
{
2313
    return self->PrimWriteIdx(idx);
2314
}
2315
CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)
2316
{
2317
    return self->PrimVtx(pos,uv,col);
2318
}
2319
CIMGUI_API void ImDrawList__ResetForNewFrame(ImDrawList* self)
2320
{
2321
    return self->_ResetForNewFrame();
2322
}
2323
CIMGUI_API void ImDrawList__ClearFreeMemory(ImDrawList* self)
2324
{
2325
    return self->_ClearFreeMemory();
2326
}
2327
CIMGUI_API void ImDrawList__PopUnusedDrawCmd(ImDrawList* self)
2328
{
2329
    return self->_PopUnusedDrawCmd();
2330
}
2331
CIMGUI_API void ImDrawList__TryMergeDrawCmds(ImDrawList* self)
2332
{
2333
    return self->_TryMergeDrawCmds();
2334
}
2335
CIMGUI_API void ImDrawList__OnChangedClipRect(ImDrawList* self)
2336
{
2337
    return self->_OnChangedClipRect();
2338
}
2339
CIMGUI_API void ImDrawList__OnChangedTextureID(ImDrawList* self)
2340
{
2341
    return self->_OnChangedTextureID();
2342
}
2343
CIMGUI_API void ImDrawList__OnChangedVtxOffset(ImDrawList* self)
2344
{
2345
    return self->_OnChangedVtxOffset();
2346
}
2347
CIMGUI_API int ImDrawList__CalcCircleAutoSegmentCount(ImDrawList* self,float radius)
2348
{
2349
    return self->_CalcCircleAutoSegmentCount(radius);
2350
}
2351
CIMGUI_API void ImDrawList__PathArcToFastEx(ImDrawList* self,const ImVec2 center,float radius,int a_min_sample,int a_max_sample,int a_step)
2352
{
2353
    return self->_PathArcToFastEx(center,radius,a_min_sample,a_max_sample,a_step);
2354
}
2355
CIMGUI_API void ImDrawList__PathArcToN(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
2356
{
2357
    return self->_PathArcToN(center,radius,a_min,a_max,num_segments);
2358
}
2359
CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void)
2360
{
2361
    return IM_NEW(ImDrawData)();
2362
}
2363
CIMGUI_API void ImDrawData_destroy(ImDrawData* self)
2364
{
2365
    IM_DELETE(self);
2366
}
2367
CIMGUI_API void ImDrawData_Clear(ImDrawData* self)
2368
{
2369
    return self->Clear();
2370
}
2371
CIMGUI_API void ImDrawData_AddDrawList(ImDrawData* self,ImDrawList* draw_list)
2372
{
2373
    return self->AddDrawList(draw_list);
2374
}
2375
CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
2376
{
2377
    return self->DeIndexAllBuffers();
2378
}
2379
CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
2380
{
2381
    return self->ScaleClipRects(fb_scale);
2382
}
2383
CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
2384
{
2385
    return IM_NEW(ImFontConfig)();
2386
}
2387
CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self)
2388
{
2389
    IM_DELETE(self);
2390
}
2391
CIMGUI_API ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void)
2392
{
2393
    return IM_NEW(ImFontGlyphRangesBuilder)();
2394
}
2395
CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
2396
{
2397
    IM_DELETE(self);
2398
}
2399
CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
2400
{
2401
    return self->Clear();
2402
}
2403
CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,size_t n)
2404
{
2405
    return self->GetBit(n);
2406
}
2407
CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,size_t n)
2408
{
2409
    return self->SetBit(n);
2410
}
2411
CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c)
2412
{
2413
    return self->AddChar(c);
2414
}
2415
CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)
2416
{
2417
    return self->AddText(text,text_end);
2418
}
2419
CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)
2420
{
2421
    return self->AddRanges(ranges);
2422
}
2423
CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
2424
{
2425
    return self->BuildRanges(out_ranges);
2426
}
2427
CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
2428
{
2429
    return IM_NEW(ImFontAtlasCustomRect)();
2430
}
2431
CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
2432
{
2433
    IM_DELETE(self);
2434
}
2435
CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
2436
{
2437
    return self->IsPacked();
2438
}
2439
CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
2440
{
2441
    return IM_NEW(ImFontAtlas)();
2442
}
2443
CIMGUI_API void ImFontAtlas_destroy(ImFontAtlas* self)
2444
{
2445
    IM_DELETE(self);
2446
}
2447
CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg)
2448
{
2449
    return self->AddFont(font_cfg);
2450
}
2451
CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg)
2452
{
2453
    return self->AddFontDefault(font_cfg);
2454
}
2455
CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2456
{
2457
    return self->AddFontFromFileTTF(filename,size_pixels,font_cfg,glyph_ranges);
2458
}
2459
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2460
{
2461
    return self->AddFontFromMemoryTTF(font_data,font_size,size_pixels,font_cfg,glyph_ranges);
2462
}
2463
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2464
{
2465
    return self->AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges);
2466
}
2467
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2468
{
2469
    return self->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges);
2470
}
2471
CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self)
2472
{
2473
    return self->ClearInputData();
2474
}
2475
CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self)
2476
{
2477
    return self->ClearTexData();
2478
}
2479
CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self)
2480
{
2481
    return self->ClearFonts();
2482
}
2483
CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self)
2484
{
2485
    return self->Clear();
2486
}
2487
CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self)
2488
{
2489
    return self->Build();
2490
}
2491
CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
2492
{
2493
    return self->GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel);
2494
}
2495
CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
2496
{
2497
    return self->GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel);
2498
}
2499
CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
2500
{
2501
    return self->IsBuilt();
2502
}
2503
CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id)
2504
{
2505
    return self->SetTexID(id);
2506
}
2507
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self)
2508
{
2509
    return self->GetGlyphRangesDefault();
2510
}
2511
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self)
2512
{
2513
    return self->GetGlyphRangesGreek();
2514
}
2515
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self)
2516
{
2517
    return self->GetGlyphRangesKorean();
2518
}
2519
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self)
2520
{
2521
    return self->GetGlyphRangesJapanese();
2522
}
2523
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self)
2524
{
2525
    return self->GetGlyphRangesChineseFull();
2526
}
2527
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self)
2528
{
2529
    return self->GetGlyphRangesChineseSimplifiedCommon();
2530
}
2531
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self)
2532
{
2533
    return self->GetGlyphRangesCyrillic();
2534
}
2535
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
2536
{
2537
    return self->GetGlyphRangesThai();
2538
}
2539
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
2540
{
2541
    return self->GetGlyphRangesVietnamese();
2542
}
2543
CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,int width,int height)
2544
{
2545
    return self->AddCustomRectRegular(width,height);
2546
}
2547
CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset)
2548
{
2549
    return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
2550
}
2551
CIMGUI_API ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
2552
{
2553
    return self->GetCustomRectByIndex(index);
2554
}
2555
CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
2556
{
2557
    return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
2558
}
2559
CIMGUI_API bool ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])
2560
{
2561
    return self->GetMouseCursorTexData(cursor,out_offset,out_size,out_uv_border,out_uv_fill);
2562
}
2563
CIMGUI_API ImFont* ImFont_ImFont(void)
2564
{
2565
    return IM_NEW(ImFont)();
2566
}
2567
CIMGUI_API void ImFont_destroy(ImFont* self)
2568
{
2569
    IM_DELETE(self);
2570
}
2571
CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
2572
{
2573
    return self->FindGlyph(c);
2574
}
2575
CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
2576
{
2577
    return self->FindGlyphNoFallback(c);
2578
}
2579
CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
2580
{
2581
    return self->GetCharAdvance(c);
2582
}
2583
CIMGUI_API bool ImFont_IsLoaded(ImFont* self)
2584
{
2585
    return self->IsLoaded();
2586
}
2587
CIMGUI_API const char* ImFont_GetDebugName(ImFont* self)
2588
{
2589
    return self->GetDebugName();
2590
}
2591
CIMGUI_API void ImFont_CalcTextSizeA(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)
2592
{
2593
    *pOut = self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining);
2594
}
2595
CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width)
2596
{
2597
    return self->CalcWordWrapPositionA(scale,text,text_end,wrap_width);
2598
}
2599
CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,ImWchar c)
2600
{
2601
    return self->RenderChar(draw_list,size,pos,col,c);
2602
}
2603
CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip)
2604
{
2605
    return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
2606
}
2607
CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
2608
{
2609
    return self->BuildLookupTable();
2610
}
2611
CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
2612
{
2613
    return self->ClearOutputData();
2614
}
2615
CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
2616
{
2617
    return self->GrowIndex(new_size);
2618
}
2619
CIMGUI_API void ImFont_AddGlyph(ImFont* self,const ImFontConfig* src_cfg,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)
2620
{
2621
    return self->AddGlyph(src_cfg,c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x);
2622
}
2623
CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst)
2624
{
2625
    return self->AddRemapChar(dst,src,overwrite_dst);
2626
}
2627
CIMGUI_API void ImFont_SetGlyphVisible(ImFont* self,ImWchar c,bool visible)
2628
{
2629
    return self->SetGlyphVisible(c,visible);
2630
}
2631
CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,unsigned int c_begin,unsigned int c_last)
2632
{
2633
    return self->IsGlyphRangeUnused(c_begin,c_last);
2634
}
2635
CIMGUI_API ImGuiViewport* ImGuiViewport_ImGuiViewport(void)
2636
{
2637
    return IM_NEW(ImGuiViewport)();
2638
}
2639
CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self)
2640
{
2641
    IM_DELETE(self);
2642
}
2643
CIMGUI_API void ImGuiViewport_GetCenter(ImVec2 *pOut,ImGuiViewport* self)
2644
{
2645
    *pOut = self->GetCenter();
2646
}
2647
CIMGUI_API void ImGuiViewport_GetWorkCenter(ImVec2 *pOut,ImGuiViewport* self)
2648
{
2649
    *pOut = self->GetWorkCenter();
2650
}
2651
CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void)
2652
{
2653
    return IM_NEW(ImGuiPlatformIO)();
2654
}
2655
CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self)
2656
{
2657
    IM_DELETE(self);
2658
}
2659
CIMGUI_API ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor(void)
2660
{
2661
    return IM_NEW(ImGuiPlatformMonitor)();
2662
}
2663
CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self)
2664
{
2665
    IM_DELETE(self);
2666
}
2667
CIMGUI_API ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData(void)
2668
{
2669
    return IM_NEW(ImGuiPlatformImeData)();
2670
}
2671
CIMGUI_API void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self)
2672
{
2673
    IM_DELETE(self);
2674
}
2675
CIMGUI_API ImGuiKey igGetKeyIndex(ImGuiKey key)
2676
{
2677
    return ImGui::GetKeyIndex(key);
2678
}
2679
CIMGUI_API ImGuiID igImHashData(const void* data,size_t data_size,ImGuiID seed)
2680
{
2681
    return ImHashData(data,data_size,seed);
2682
}
2683
CIMGUI_API ImGuiID igImHashStr(const char* data,size_t data_size,ImGuiID seed)
2684
{
2685
    return ImHashStr(data,data_size,seed);
2686
}
2687
CIMGUI_API void igImQsort(void* base,size_t count,size_t size_of_element,int(*compare_func)(void const*,void const*))
2688
{
2689
    return ImQsort(base,count,size_of_element,compare_func);
2690
}
2691
CIMGUI_API ImU32 igImAlphaBlendColors(ImU32 col_a,ImU32 col_b)
2692
{
2693
    return ImAlphaBlendColors(col_a,col_b);
2694
}
2695
CIMGUI_API bool igImIsPowerOfTwo_Int(int v)
2696
{
2697
    return ImIsPowerOfTwo(v);
2698
}
2699
CIMGUI_API bool igImIsPowerOfTwo_U64(ImU64 v)
2700
{
2701
    return ImIsPowerOfTwo(v);
2702
}
2703
CIMGUI_API int igImUpperPowerOfTwo(int v)
2704
{
2705
    return ImUpperPowerOfTwo(v);
2706
}
2707
CIMGUI_API int igImStricmp(const char* str1,const char* str2)
2708
{
2709
    return ImStricmp(str1,str2);
2710
}
2711
CIMGUI_API int igImStrnicmp(const char* str1,const char* str2,size_t count)
2712
{
2713
    return ImStrnicmp(str1,str2,count);
2714
}
2715
CIMGUI_API void igImStrncpy(char* dst,const char* src,size_t count)
2716
{
2717
    return ImStrncpy(dst,src,count);
2718
}
2719
CIMGUI_API char* igImStrdup(const char* str)
2720
{
2721
    return ImStrdup(str);
2722
}
2723
CIMGUI_API char* igImStrdupcpy(char* dst,size_t* p_dst_size,const char* str)
2724
{
2725
    return ImStrdupcpy(dst,p_dst_size,str);
2726
}
2727
CIMGUI_API const char* igImStrchrRange(const char* str_begin,const char* str_end,char c)
2728
{
2729
    return ImStrchrRange(str_begin,str_end,c);
2730
}
2731
CIMGUI_API int igImStrlenW(const ImWchar* str)
2732
{
2733
    return ImStrlenW(str);
2734
}
2735
CIMGUI_API const char* igImStreolRange(const char* str,const char* str_end)
2736
{
2737
    return ImStreolRange(str,str_end);
2738
}
2739
CIMGUI_API const ImWchar* igImStrbolW(const ImWchar* buf_mid_line,const ImWchar* buf_begin)
2740
{
2741
    return ImStrbolW(buf_mid_line,buf_begin);
2742
}
2743
CIMGUI_API const char* igImStristr(const char* haystack,const char* haystack_end,const char* needle,const char* needle_end)
2744
{
2745
    return ImStristr(haystack,haystack_end,needle,needle_end);
2746
}
2747
CIMGUI_API void igImStrTrimBlanks(char* str)
2748
{
2749
    return ImStrTrimBlanks(str);
2750
}
2751
CIMGUI_API const char* igImStrSkipBlank(const char* str)
2752
{
2753
    return ImStrSkipBlank(str);
2754
}
2755
CIMGUI_API char igImToUpper(char c)
2756
{
2757
    return ImToUpper(c);
2758
}
2759
CIMGUI_API bool igImCharIsBlankA(char c)
2760
{
2761
    return ImCharIsBlankA(c);
2762
}
2763
CIMGUI_API bool igImCharIsBlankW(unsigned int c)
2764
{
2765
    return ImCharIsBlankW(c);
2766
}
2767
CIMGUI_API int igImFormatString(char* buf,size_t buf_size,const char* fmt,...)
2768
{
2769
    va_list args;
2770
    va_start(args, fmt);
2771
    int ret = ImFormatStringV(buf,buf_size,fmt,args);
2772
    va_end(args);
2773
    return ret;
2774
}
2775
CIMGUI_API int igImFormatStringV(char* buf,size_t buf_size,const char* fmt,va_list args)
2776
{
2777
    return ImFormatStringV(buf,buf_size,fmt,args);
2778
}
2779
CIMGUI_API void igImFormatStringToTempBuffer(const char** out_buf,const char** out_buf_end,const char* fmt,...)
2780
{
2781
    va_list args;
2782
    va_start(args, fmt);
2783
    ImFormatStringToTempBufferV(out_buf,out_buf_end,fmt,args);
2784
    va_end(args);
2785
}
2786
CIMGUI_API void igImFormatStringToTempBufferV(const char** out_buf,const char** out_buf_end,const char* fmt,va_list args)
2787
{
2788
    return ImFormatStringToTempBufferV(out_buf,out_buf_end,fmt,args);
2789
}
2790
CIMGUI_API const char* igImParseFormatFindStart(const char* format)
2791
{
2792
    return ImParseFormatFindStart(format);
2793
}
2794
CIMGUI_API const char* igImParseFormatFindEnd(const char* format)
2795
{
2796
    return ImParseFormatFindEnd(format);
2797
}
2798
CIMGUI_API const char* igImParseFormatTrimDecorations(const char* format,char* buf,size_t buf_size)
2799
{
2800
    return ImParseFormatTrimDecorations(format,buf,buf_size);
2801
}
2802
CIMGUI_API void igImParseFormatSanitizeForPrinting(const char* fmt_in,char* fmt_out,size_t fmt_out_size)
2803
{
2804
    return ImParseFormatSanitizeForPrinting(fmt_in,fmt_out,fmt_out_size);
2805
}
2806
CIMGUI_API const char* igImParseFormatSanitizeForScanning(const char* fmt_in,char* fmt_out,size_t fmt_out_size)
2807
{
2808
    return ImParseFormatSanitizeForScanning(fmt_in,fmt_out,fmt_out_size);
2809
}
2810
CIMGUI_API int igImParseFormatPrecision(const char* format,int default_value)
2811
{
2812
    return ImParseFormatPrecision(format,default_value);
2813
}
2814
CIMGUI_API const char* igImTextCharToUtf8(char out_buf[5],unsigned int c)
2815
{
2816
    return ImTextCharToUtf8(out_buf,c);
2817
}
2818
CIMGUI_API int igImTextStrToUtf8(char* out_buf,int out_buf_size,const ImWchar* in_text,const ImWchar* in_text_end)
2819
{
2820
    return ImTextStrToUtf8(out_buf,out_buf_size,in_text,in_text_end);
2821
}
2822
CIMGUI_API int igImTextCharFromUtf8(unsigned int* out_char,const char* in_text,const char* in_text_end)
2823
{
2824
    return ImTextCharFromUtf8(out_char,in_text,in_text_end);
2825
}
2826
CIMGUI_API int igImTextStrFromUtf8(ImWchar* out_buf,int out_buf_size,const char* in_text,const char* in_text_end,const char** in_remaining)
2827
{
2828
    return ImTextStrFromUtf8(out_buf,out_buf_size,in_text,in_text_end,in_remaining);
2829
}
2830
CIMGUI_API int igImTextCountCharsFromUtf8(const char* in_text,const char* in_text_end)
2831
{
2832
    return ImTextCountCharsFromUtf8(in_text,in_text_end);
2833
}
2834
CIMGUI_API int igImTextCountUtf8BytesFromChar(const char* in_text,const char* in_text_end)
2835
{
2836
    return ImTextCountUtf8BytesFromChar(in_text,in_text_end);
2837
}
2838
CIMGUI_API int igImTextCountUtf8BytesFromStr(const ImWchar* in_text,const ImWchar* in_text_end)
2839
{
2840
    return ImTextCountUtf8BytesFromStr(in_text,in_text_end);
2841
}
2842
CIMGUI_API ImFileHandle igImFileOpen(const char* filename,const char* mode)
2843
{
2844
    return ImFileOpen(filename,mode);
2845
}
2846
CIMGUI_API bool igImFileClose(ImFileHandle file)
2847
{
2848
    return ImFileClose(file);
2849
}
2850
CIMGUI_API ImU64 igImFileGetSize(ImFileHandle file)
2851
{
2852
    return ImFileGetSize(file);
2853
}
2854
CIMGUI_API ImU64 igImFileRead(void* data,ImU64 size,ImU64 count,ImFileHandle file)
2855
{
2856
    return ImFileRead(data,size,count,file);
2857
}
2858
CIMGUI_API ImU64 igImFileWrite(const void* data,ImU64 size,ImU64 count,ImFileHandle file)
2859
{
2860
    return ImFileWrite(data,size,count,file);
2861
}
2862
CIMGUI_API void* igImFileLoadToMemory(const char* filename,const char* mode,size_t* out_file_size,int padding_bytes)
2863
{
2864
    return ImFileLoadToMemory(filename,mode,out_file_size,padding_bytes);
2865
}
2866
CIMGUI_API float igImPow_Float(float x,float y)
2867
{
2868
    return ImPow(x,y);
2869
}
2870
CIMGUI_API double igImPow_double(double x,double y)
2871
{
2872
    return ImPow(x,y);
2873
}
2874
CIMGUI_API float igImLog_Float(float x)
2875
{
2876
    return ImLog(x);
2877
}
2878
CIMGUI_API double igImLog_double(double x)
2879
{
2880
    return ImLog(x);
2881
}
2882
CIMGUI_API int igImAbs_Int(int x)
2883
{
2884
    return ImAbs(x);
2885
}
2886
CIMGUI_API float igImAbs_Float(float x)
2887
{
2888
    return ImAbs(x);
2889
}
2890
CIMGUI_API double igImAbs_double(double x)
2891
{
2892
    return ImAbs(x);
2893
}
2894
CIMGUI_API float igImSign_Float(float x)
2895
{
2896
    return ImSign(x);
2897
}
2898
CIMGUI_API double igImSign_double(double x)
2899
{
2900
    return ImSign(x);
2901
}
2902
CIMGUI_API float igImRsqrt_Float(float x)
2903
{
2904
    return ImRsqrt(x);
2905
}
2906
CIMGUI_API double igImRsqrt_double(double x)
2907
{
2908
    return ImRsqrt(x);
2909
}
2910
CIMGUI_API void igImMin(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
2911
{
2912
    *pOut = ImMin(lhs,rhs);
2913
}
2914
CIMGUI_API void igImMax(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
2915
{
2916
    *pOut = ImMax(lhs,rhs);
2917
}
2918
CIMGUI_API void igImClamp(ImVec2 *pOut,const ImVec2 v,const ImVec2 mn,ImVec2 mx)
2919
{
2920
    *pOut = ImClamp(v,mn,mx);
2921
}
2922
CIMGUI_API void igImLerp_Vec2Float(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,float t)
2923
{
2924
    *pOut = ImLerp(a,b,t);
2925
}
2926
CIMGUI_API void igImLerp_Vec2Vec2(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 t)
2927
{
2928
    *pOut = ImLerp(a,b,t);
2929
}
2930
CIMGUI_API void igImLerp_Vec4(ImVec4 *pOut,const ImVec4 a,const ImVec4 b,float t)
2931
{
2932
    *pOut = ImLerp(a,b,t);
2933
}
2934
CIMGUI_API float igImSaturate(float f)
2935
{
2936
    return ImSaturate(f);
2937
}
2938
CIMGUI_API float igImLengthSqr_Vec2(const ImVec2 lhs)
2939
{
2940
    return ImLengthSqr(lhs);
2941
}
2942
CIMGUI_API float igImLengthSqr_Vec4(const ImVec4 lhs)
2943
{
2944
    return ImLengthSqr(lhs);
2945
}
2946
CIMGUI_API float igImInvLength(const ImVec2 lhs,float fail_value)
2947
{
2948
    return ImInvLength(lhs,fail_value);
2949
}
2950
CIMGUI_API float igImFloor_Float(float f)
2951
{
2952
    return ImFloor(f);
2953
}
2954
CIMGUI_API float igImFloorSigned_Float(float f)
2955
{
2956
    return ImFloorSigned(f);
2957
}
2958
CIMGUI_API void igImFloor_Vec2(ImVec2 *pOut,const ImVec2 v)
2959
{
2960
    *pOut = ImFloor(v);
2961
}
2962
CIMGUI_API void igImFloorSigned_Vec2(ImVec2 *pOut,const ImVec2 v)
2963
{
2964
    *pOut = ImFloorSigned(v);
2965
}
2966
CIMGUI_API int igImModPositive(int a,int b)
2967
{
2968
    return ImModPositive(a,b);
2969
}
2970
CIMGUI_API float igImDot(const ImVec2 a,const ImVec2 b)
2971
{
2972
    return ImDot(a,b);
2973
}
2974
CIMGUI_API void igImRotate(ImVec2 *pOut,const ImVec2 v,float cos_a,float sin_a)
2975
{
2976
    *pOut = ImRotate(v,cos_a,sin_a);
2977
}
2978
CIMGUI_API float igImLinearSweep(float current,float target,float speed)
2979
{
2980
    return ImLinearSweep(current,target,speed);
2981
}
2982
CIMGUI_API void igImMul(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
2983
{
2984
    *pOut = ImMul(lhs,rhs);
2985
}
2986
CIMGUI_API bool igImIsFloatAboveGuaranteedIntegerPrecision(float f)
2987
{
2988
    return ImIsFloatAboveGuaranteedIntegerPrecision(f);
2989
}
2990
CIMGUI_API float igImExponentialMovingAverage(float avg,float sample,int n)
2991
{
2992
    return ImExponentialMovingAverage(avg,sample,n);
2993
}
2994
CIMGUI_API void igImBezierCubicCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t)
2995
{
2996
    *pOut = ImBezierCubicCalc(p1,p2,p3,p4,t);
2997
}
2998
CIMGUI_API void igImBezierCubicClosestPoint(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments)
2999
{
3000
    *pOut = ImBezierCubicClosestPoint(p1,p2,p3,p4,p,num_segments);
3001
}
3002
CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol)
3003
{
3004
    *pOut = ImBezierCubicClosestPointCasteljau(p1,p2,p3,p4,p,tess_tol);
3005
}
3006
CIMGUI_API void igImBezierQuadraticCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t)
3007
{
3008
    *pOut = ImBezierQuadraticCalc(p1,p2,p3,t);
3009
}
3010
CIMGUI_API void igImLineClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 p)
3011
{
3012
    *pOut = ImLineClosestPoint(a,b,p);
3013
}
3014
CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
3015
{
3016
    return ImTriangleContainsPoint(a,b,c,p);
3017
}
3018
CIMGUI_API void igImTriangleClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
3019
{
3020
    *pOut = ImTriangleClosestPoint(a,b,c,p);
3021
}
3022
CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w)
3023
{
3024
    return ImTriangleBarycentricCoords(a,b,c,p,*out_u,*out_v,*out_w);
3025
}
3026
CIMGUI_API float igImTriangleArea(const ImVec2 a,const ImVec2 b,const ImVec2 c)
3027
{
3028
    return ImTriangleArea(a,b,c);
3029
}
3030
CIMGUI_API ImVec1* ImVec1_ImVec1_Nil(void)
3031
{
3032
    return IM_NEW(ImVec1)();
3033
}
3034
CIMGUI_API void ImVec1_destroy(ImVec1* self)
3035
{
3036
    IM_DELETE(self);
3037
}
3038
CIMGUI_API ImVec1* ImVec1_ImVec1_Float(float _x)
3039
{
3040
    return IM_NEW(ImVec1)(_x);
3041
}
3042
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Nil(void)
3043
{
3044
    return IM_NEW(ImVec2ih)();
3045
}
3046
CIMGUI_API void ImVec2ih_destroy(ImVec2ih* self)
3047
{
3048
    IM_DELETE(self);
3049
}
3050
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_short(short _x,short _y)
3051
{
3052
    return IM_NEW(ImVec2ih)(_x,_y);
3053
}
3054
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Vec2(const ImVec2 rhs)
3055
{
3056
    return IM_NEW(ImVec2ih)(rhs);
3057
}
3058
CIMGUI_API ImRect* ImRect_ImRect_Nil(void)
3059
{
3060
    return IM_NEW(ImRect)();
3061
}
3062
CIMGUI_API void ImRect_destroy(ImRect* self)
3063
{
3064
    IM_DELETE(self);
3065
}
3066
CIMGUI_API ImRect* ImRect_ImRect_Vec2(const ImVec2 min,const ImVec2 max)
3067
{
3068
    return IM_NEW(ImRect)(min,max);
3069
}
3070
CIMGUI_API ImRect* ImRect_ImRect_Vec4(const ImVec4 v)
3071
{
3072
    return IM_NEW(ImRect)(v);
3073
}
3074
CIMGUI_API ImRect* ImRect_ImRect_Float(float x1,float y1,float x2,float y2)
3075
{
3076
    return IM_NEW(ImRect)(x1,y1,x2,y2);
3077
}
3078
CIMGUI_API void ImRect_GetCenter(ImVec2 *pOut,ImRect* self)
3079
{
3080
    *pOut = self->GetCenter();
3081
}
3082
CIMGUI_API void ImRect_GetSize(ImVec2 *pOut,ImRect* self)
3083
{
3084
    *pOut = self->GetSize();
3085
}
3086
CIMGUI_API float ImRect_GetWidth(ImRect* self)
3087
{
3088
    return self->GetWidth();
3089
}
3090
CIMGUI_API float ImRect_GetHeight(ImRect* self)
3091
{
3092
    return self->GetHeight();
3093
}
3094
CIMGUI_API float ImRect_GetArea(ImRect* self)
3095
{
3096
    return self->GetArea();
3097
}
3098
CIMGUI_API void ImRect_GetTL(ImVec2 *pOut,ImRect* self)
3099
{
3100
    *pOut = self->GetTL();
3101
}
3102
CIMGUI_API void ImRect_GetTR(ImVec2 *pOut,ImRect* self)
3103
{
3104
    *pOut = self->GetTR();
3105
}
3106
CIMGUI_API void ImRect_GetBL(ImVec2 *pOut,ImRect* self)
3107
{
3108
    *pOut = self->GetBL();
3109
}
3110
CIMGUI_API void ImRect_GetBR(ImVec2 *pOut,ImRect* self)
3111
{
3112
    *pOut = self->GetBR();
3113
}
3114
CIMGUI_API bool ImRect_Contains_Vec2(ImRect* self,const ImVec2 p)
3115
{
3116
    return self->Contains(p);
3117
}
3118
CIMGUI_API bool ImRect_Contains_Rect(ImRect* self,const ImRect r)
3119
{
3120
    return self->Contains(r);
3121
}
3122
CIMGUI_API bool ImRect_Overlaps(ImRect* self,const ImRect r)
3123
{
3124
    return self->Overlaps(r);
3125
}
3126
CIMGUI_API void ImRect_Add_Vec2(ImRect* self,const ImVec2 p)
3127
{
3128
    return self->Add(p);
3129
}
3130
CIMGUI_API void ImRect_Add_Rect(ImRect* self,const ImRect r)
3131
{
3132
    return self->Add(r);
3133
}
3134
CIMGUI_API void ImRect_Expand_Float(ImRect* self,const float amount)
3135
{
3136
    return self->Expand(amount);
3137
}
3138
CIMGUI_API void ImRect_Expand_Vec2(ImRect* self,const ImVec2 amount)
3139
{
3140
    return self->Expand(amount);
3141
}
3142
CIMGUI_API void ImRect_Translate(ImRect* self,const ImVec2 d)
3143
{
3144
    return self->Translate(d);
3145
}
3146
CIMGUI_API void ImRect_TranslateX(ImRect* self,float dx)
3147
{
3148
    return self->TranslateX(dx);
3149
}
3150
CIMGUI_API void ImRect_TranslateY(ImRect* self,float dy)
3151
{
3152
    return self->TranslateY(dy);
3153
}
3154
CIMGUI_API void ImRect_ClipWith(ImRect* self,const ImRect r)
3155
{
3156
    return self->ClipWith(r);
3157
}
3158
CIMGUI_API void ImRect_ClipWithFull(ImRect* self,const ImRect r)
3159
{
3160
    return self->ClipWithFull(r);
3161
}
3162
CIMGUI_API void ImRect_Floor(ImRect* self)
3163
{
3164
    return self->Floor();
3165
}
3166
CIMGUI_API bool ImRect_IsInverted(ImRect* self)
3167
{
3168
    return self->IsInverted();
3169
}
3170
CIMGUI_API void ImRect_ToVec4(ImVec4 *pOut,ImRect* self)
3171
{
3172
    *pOut = self->ToVec4();
3173
}
3174
CIMGUI_API size_t igImBitArrayGetStorageSizeInBytes(int bitcount)
3175
{
3176
    return ImBitArrayGetStorageSizeInBytes(bitcount);
3177
}
3178
CIMGUI_API void igImBitArrayClearAllBits(ImU32* arr,int bitcount)
3179
{
3180
    return ImBitArrayClearAllBits(arr,bitcount);
3181
}
3182
CIMGUI_API bool igImBitArrayTestBit(const ImU32* arr,int n)
3183
{
3184
    return ImBitArrayTestBit(arr,n);
3185
}
3186
CIMGUI_API void igImBitArrayClearBit(ImU32* arr,int n)
3187
{
3188
    return ImBitArrayClearBit(arr,n);
3189
}
3190
CIMGUI_API void igImBitArraySetBit(ImU32* arr,int n)
3191
{
3192
    return ImBitArraySetBit(arr,n);
3193
}
3194
CIMGUI_API void igImBitArraySetBitRange(ImU32* arr,int n,int n2)
3195
{
3196
    return ImBitArraySetBitRange(arr,n,n2);
3197
}
3198
CIMGUI_API void ImBitVector_Create(ImBitVector* self,int sz)
3199
{
3200
    return self->Create(sz);
3201
}
3202
CIMGUI_API void ImBitVector_Clear(ImBitVector* self)
3203
{
3204
    return self->Clear();
3205
}
3206
CIMGUI_API bool ImBitVector_TestBit(ImBitVector* self,int n)
3207
{
3208
    return self->TestBit(n);
3209
}
3210
CIMGUI_API void ImBitVector_SetBit(ImBitVector* self,int n)
3211
{
3212
    return self->SetBit(n);
3213
}
3214
CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self,int n)
3215
{
3216
    return self->ClearBit(n);
3217
}
3218
CIMGUI_API void ImGuiTextIndex_clear(ImGuiTextIndex* self)
3219
{
3220
    return self->clear();
3221
}
3222
CIMGUI_API int ImGuiTextIndex_size(ImGuiTextIndex* self)
3223
{
3224
    return self->size();
3225
}
3226
CIMGUI_API const char* ImGuiTextIndex_get_line_begin(ImGuiTextIndex* self,const char* base,int n)
3227
{
3228
    return self->get_line_begin(base,n);
3229
}
3230
CIMGUI_API const char* ImGuiTextIndex_get_line_end(ImGuiTextIndex* self,const char* base,int n)
3231
{
3232
    return self->get_line_end(base,n);
3233
}
3234
CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self,const char* base,int old_size,int new_size)
3235
{
3236
    return self->append(base,old_size,new_size);
3237
}
3238
CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(void)
3239
{
3240
    return IM_NEW(ImDrawListSharedData)();
3241
}
3242
CIMGUI_API void ImDrawListSharedData_destroy(ImDrawListSharedData* self)
3243
{
3244
    IM_DELETE(self);
3245
}
3246
CIMGUI_API void ImDrawListSharedData_SetCircleTessellationMaxError(ImDrawListSharedData* self,float max_error)
3247
{
3248
    return self->SetCircleTessellationMaxError(max_error);
3249
}
3250
CIMGUI_API ImDrawDataBuilder* ImDrawDataBuilder_ImDrawDataBuilder(void)
3251
{
3252
    return IM_NEW(ImDrawDataBuilder)();
3253
}
3254
CIMGUI_API void ImDrawDataBuilder_destroy(ImDrawDataBuilder* self)
3255
{
3256
    IM_DELETE(self);
3257
}
3258
CIMGUI_API void* ImGuiDataVarInfo_GetVarPtr(ImGuiDataVarInfo* self,void* parent)
3259
{
3260
    return self->GetVarPtr(parent);
3261
}
3262
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Int(ImGuiStyleVar idx,int v)
3263
{
3264
    return IM_NEW(ImGuiStyleMod)(idx,v);
3265
}
3266
CIMGUI_API void ImGuiStyleMod_destroy(ImGuiStyleMod* self)
3267
{
3268
    IM_DELETE(self);
3269
}
3270
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Float(ImGuiStyleVar idx,float v)
3271
{
3272
    return IM_NEW(ImGuiStyleMod)(idx,v);
3273
}
3274
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Vec2(ImGuiStyleVar idx,ImVec2 v)
3275
{
3276
    return IM_NEW(ImGuiStyleMod)(idx,v);
3277
}
3278
CIMGUI_API ImGuiComboPreviewData* ImGuiComboPreviewData_ImGuiComboPreviewData(void)
3279
{
3280
    return IM_NEW(ImGuiComboPreviewData)();
3281
}
3282
CIMGUI_API void ImGuiComboPreviewData_destroy(ImGuiComboPreviewData* self)
3283
{
3284
    IM_DELETE(self);
3285
}
3286
CIMGUI_API ImGuiMenuColumns* ImGuiMenuColumns_ImGuiMenuColumns(void)
3287
{
3288
    return IM_NEW(ImGuiMenuColumns)();
3289
}
3290
CIMGUI_API void ImGuiMenuColumns_destroy(ImGuiMenuColumns* self)
3291
{
3292
    IM_DELETE(self);
3293
}
3294
CIMGUI_API void ImGuiMenuColumns_Update(ImGuiMenuColumns* self,float spacing,bool window_reappearing)
3295
{
3296
    return self->Update(spacing,window_reappearing);
3297
}
3298
CIMGUI_API float ImGuiMenuColumns_DeclColumns(ImGuiMenuColumns* self,float w_icon,float w_label,float w_shortcut,float w_mark)
3299
{
3300
    return self->DeclColumns(w_icon,w_label,w_shortcut,w_mark);
3301
}
3302
CIMGUI_API void ImGuiMenuColumns_CalcNextTotalWidth(ImGuiMenuColumns* self,bool update_offsets)
3303
{
3304
    return self->CalcNextTotalWidth(update_offsets);
3305
}
3306
CIMGUI_API ImGuiInputTextDeactivatedState* ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState(void)
3307
{
3308
    return IM_NEW(ImGuiInputTextDeactivatedState)();
3309
}
3310
CIMGUI_API void ImGuiInputTextDeactivatedState_destroy(ImGuiInputTextDeactivatedState* self)
3311
{
3312
    IM_DELETE(self);
3313
}
3314
CIMGUI_API void ImGuiInputTextDeactivatedState_ClearFreeMemory(ImGuiInputTextDeactivatedState* self)
3315
{
3316
    return self->ClearFreeMemory();
3317
}
3318
CIMGUI_API ImGuiInputTextState* ImGuiInputTextState_ImGuiInputTextState(void)
3319
{
3320
    return IM_NEW(ImGuiInputTextState)();
3321
}
3322
CIMGUI_API void ImGuiInputTextState_destroy(ImGuiInputTextState* self)
3323
{
3324
    IM_DELETE(self);
3325
}
3326
CIMGUI_API void ImGuiInputTextState_ClearText(ImGuiInputTextState* self)
3327
{
3328
    return self->ClearText();
3329
}
3330
CIMGUI_API void ImGuiInputTextState_ClearFreeMemory(ImGuiInputTextState* self)
3331
{
3332
    return self->ClearFreeMemory();
3333
}
3334
CIMGUI_API int ImGuiInputTextState_GetUndoAvailCount(ImGuiInputTextState* self)
3335
{
3336
    return self->GetUndoAvailCount();
3337
}
3338
CIMGUI_API int ImGuiInputTextState_GetRedoAvailCount(ImGuiInputTextState* self)
3339
{
3340
    return self->GetRedoAvailCount();
3341
}
3342
CIMGUI_API void ImGuiInputTextState_OnKeyPressed(ImGuiInputTextState* self,int key)
3343
{
3344
    return self->OnKeyPressed(key);
3345
}
3346
CIMGUI_API void ImGuiInputTextState_CursorAnimReset(ImGuiInputTextState* self)
3347
{
3348
    return self->CursorAnimReset();
3349
}
3350
CIMGUI_API void ImGuiInputTextState_CursorClamp(ImGuiInputTextState* self)
3351
{
3352
    return self->CursorClamp();
3353
}
3354
CIMGUI_API bool ImGuiInputTextState_HasSelection(ImGuiInputTextState* self)
3355
{
3356
    return self->HasSelection();
3357
}
3358
CIMGUI_API void ImGuiInputTextState_ClearSelection(ImGuiInputTextState* self)
3359
{
3360
    return self->ClearSelection();
3361
}
3362
CIMGUI_API int ImGuiInputTextState_GetCursorPos(ImGuiInputTextState* self)
3363
{
3364
    return self->GetCursorPos();
3365
}
3366
CIMGUI_API int ImGuiInputTextState_GetSelectionStart(ImGuiInputTextState* self)
3367
{
3368
    return self->GetSelectionStart();
3369
}
3370
CIMGUI_API int ImGuiInputTextState_GetSelectionEnd(ImGuiInputTextState* self)
3371
{
3372
    return self->GetSelectionEnd();
3373
}
3374
CIMGUI_API void ImGuiInputTextState_SelectAll(ImGuiInputTextState* self)
3375
{
3376
    return self->SelectAll();
3377
}
3378
CIMGUI_API ImGuiPopupData* ImGuiPopupData_ImGuiPopupData(void)
3379
{
3380
    return IM_NEW(ImGuiPopupData)();
3381
}
3382
CIMGUI_API void ImGuiPopupData_destroy(ImGuiPopupData* self)
3383
{
3384
    IM_DELETE(self);
3385
}
3386
CIMGUI_API ImGuiNextWindowData* ImGuiNextWindowData_ImGuiNextWindowData(void)
3387
{
3388
    return IM_NEW(ImGuiNextWindowData)();
3389
}
3390
CIMGUI_API void ImGuiNextWindowData_destroy(ImGuiNextWindowData* self)
3391
{
3392
    IM_DELETE(self);
3393
}
3394
CIMGUI_API void ImGuiNextWindowData_ClearFlags(ImGuiNextWindowData* self)
3395
{
3396
    return self->ClearFlags();
3397
}
3398
CIMGUI_API ImGuiNextItemData* ImGuiNextItemData_ImGuiNextItemData(void)
3399
{
3400
    return IM_NEW(ImGuiNextItemData)();
3401
}
3402
CIMGUI_API void ImGuiNextItemData_destroy(ImGuiNextItemData* self)
3403
{
3404
    IM_DELETE(self);
3405
}
3406
CIMGUI_API void ImGuiNextItemData_ClearFlags(ImGuiNextItemData* self)
3407
{
3408
    return self->ClearFlags();
3409
}
3410
CIMGUI_API ImGuiLastItemData* ImGuiLastItemData_ImGuiLastItemData(void)
3411
{
3412
    return IM_NEW(ImGuiLastItemData)();
3413
}
3414
CIMGUI_API void ImGuiLastItemData_destroy(ImGuiLastItemData* self)
3415
{
3416
    IM_DELETE(self);
3417
}
3418
CIMGUI_API ImGuiStackSizes* ImGuiStackSizes_ImGuiStackSizes(void)
3419
{
3420
    return IM_NEW(ImGuiStackSizes)();
3421
}
3422
CIMGUI_API void ImGuiStackSizes_destroy(ImGuiStackSizes* self)
3423
{
3424
    IM_DELETE(self);
3425
}
3426
CIMGUI_API void ImGuiStackSizes_SetToContextState(ImGuiStackSizes* self,ImGuiContext* ctx)
3427
{
3428
    return self->SetToContextState(ctx);
3429
}
3430
CIMGUI_API void ImGuiStackSizes_CompareWithContextState(ImGuiStackSizes* self,ImGuiContext* ctx)
3431
{
3432
    return self->CompareWithContextState(ctx);
3433
}
3434
CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr(void* ptr)
3435
{
3436
    return IM_NEW(ImGuiPtrOrIndex)(ptr);
3437
}
3438
CIMGUI_API void ImGuiPtrOrIndex_destroy(ImGuiPtrOrIndex* self)
3439
{
3440
    IM_DELETE(self);
3441
}
3442
CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(int index)
3443
{
3444
    return IM_NEW(ImGuiPtrOrIndex)(index);
3445
}
3446
CIMGUI_API ImGuiInputEvent* ImGuiInputEvent_ImGuiInputEvent(void)
3447
{
3448
    return IM_NEW(ImGuiInputEvent)();
3449
}
3450
CIMGUI_API void ImGuiInputEvent_destroy(ImGuiInputEvent* self)
3451
{
3452
    IM_DELETE(self);
3453
}
3454
CIMGUI_API ImGuiKeyRoutingData* ImGuiKeyRoutingData_ImGuiKeyRoutingData(void)
3455
{
3456
    return IM_NEW(ImGuiKeyRoutingData)();
3457
}
3458
CIMGUI_API void ImGuiKeyRoutingData_destroy(ImGuiKeyRoutingData* self)
3459
{
3460
    IM_DELETE(self);
3461
}
3462
CIMGUI_API ImGuiKeyRoutingTable* ImGuiKeyRoutingTable_ImGuiKeyRoutingTable(void)
3463
{
3464
    return IM_NEW(ImGuiKeyRoutingTable)();
3465
}
3466
CIMGUI_API void ImGuiKeyRoutingTable_destroy(ImGuiKeyRoutingTable* self)
3467
{
3468
    IM_DELETE(self);
3469
}
3470
CIMGUI_API void ImGuiKeyRoutingTable_Clear(ImGuiKeyRoutingTable* self)
3471
{
3472
    return self->Clear();
3473
}
3474
CIMGUI_API ImGuiKeyOwnerData* ImGuiKeyOwnerData_ImGuiKeyOwnerData(void)
3475
{
3476
    return IM_NEW(ImGuiKeyOwnerData)();
3477
}
3478
CIMGUI_API void ImGuiKeyOwnerData_destroy(ImGuiKeyOwnerData* self)
3479
{
3480
    IM_DELETE(self);
3481
}
3482
CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromIndices(int min,int max)
3483
{
3484
    return ImGuiListClipperRange::FromIndices(min,max);
3485
}
3486
CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromPositions(float y1,float y2,int off_min,int off_max)
3487
{
3488
    return ImGuiListClipperRange::FromPositions(y1,y2,off_min,off_max);
3489
}
3490
CIMGUI_API ImGuiListClipperData* ImGuiListClipperData_ImGuiListClipperData(void)
3491
{
3492
    return IM_NEW(ImGuiListClipperData)();
3493
}
3494
CIMGUI_API void ImGuiListClipperData_destroy(ImGuiListClipperData* self)
3495
{
3496
    IM_DELETE(self);
3497
}
3498
CIMGUI_API void ImGuiListClipperData_Reset(ImGuiListClipperData* self,ImGuiListClipper* clipper)
3499
{
3500
    return self->Reset(clipper);
3501
}
3502
CIMGUI_API ImGuiNavItemData* ImGuiNavItemData_ImGuiNavItemData(void)
3503
{
3504
    return IM_NEW(ImGuiNavItemData)();
3505
}
3506
CIMGUI_API void ImGuiNavItemData_destroy(ImGuiNavItemData* self)
3507
{
3508
    IM_DELETE(self);
3509
}
3510
CIMGUI_API void ImGuiNavItemData_Clear(ImGuiNavItemData* self)
3511
{
3512
    return self->Clear();
3513
}
3514
CIMGUI_API ImGuiOldColumnData* ImGuiOldColumnData_ImGuiOldColumnData(void)
3515
{
3516
    return IM_NEW(ImGuiOldColumnData)();
3517
}
3518
CIMGUI_API void ImGuiOldColumnData_destroy(ImGuiOldColumnData* self)
3519
{
3520
    IM_DELETE(self);
3521
}
3522
CIMGUI_API ImGuiOldColumns* ImGuiOldColumns_ImGuiOldColumns(void)
3523
{
3524
    return IM_NEW(ImGuiOldColumns)();
3525
}
3526
CIMGUI_API void ImGuiOldColumns_destroy(ImGuiOldColumns* self)
3527
{
3528
    IM_DELETE(self);
3529
}
3530
CIMGUI_API ImGuiDockNode* ImGuiDockNode_ImGuiDockNode(ImGuiID id)
3531
{
3532
    return IM_NEW(ImGuiDockNode)(id);
3533
}
3534
CIMGUI_API void ImGuiDockNode_destroy(ImGuiDockNode* self)
3535
{
3536
    IM_DELETE(self);
3537
}
3538
CIMGUI_API bool ImGuiDockNode_IsRootNode(ImGuiDockNode* self)
3539
{
3540
    return self->IsRootNode();
3541
}
3542
CIMGUI_API bool ImGuiDockNode_IsDockSpace(ImGuiDockNode* self)
3543
{
3544
    return self->IsDockSpace();
3545
}
3546
CIMGUI_API bool ImGuiDockNode_IsFloatingNode(ImGuiDockNode* self)
3547
{
3548
    return self->IsFloatingNode();
3549
}
3550
CIMGUI_API bool ImGuiDockNode_IsCentralNode(ImGuiDockNode* self)
3551
{
3552
    return self->IsCentralNode();
3553
}
3554
CIMGUI_API bool ImGuiDockNode_IsHiddenTabBar(ImGuiDockNode* self)
3555
{
3556
    return self->IsHiddenTabBar();
3557
}
3558
CIMGUI_API bool ImGuiDockNode_IsNoTabBar(ImGuiDockNode* self)
3559
{
3560
    return self->IsNoTabBar();
3561
}
3562
CIMGUI_API bool ImGuiDockNode_IsSplitNode(ImGuiDockNode* self)
3563
{
3564
    return self->IsSplitNode();
3565
}
3566
CIMGUI_API bool ImGuiDockNode_IsLeafNode(ImGuiDockNode* self)
3567
{
3568
    return self->IsLeafNode();
3569
}
3570
CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self)
3571
{
3572
    return self->IsEmpty();
3573
}
3574
CIMGUI_API void ImGuiDockNode_Rect(ImRect *pOut,ImGuiDockNode* self)
3575
{
3576
    *pOut = self->Rect();
3577
}
3578
CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,ImGuiDockNodeFlags flags)
3579
{
3580
    return self->SetLocalFlags(flags);
3581
}
3582
CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self)
3583
{
3584
    return self->UpdateMergedFlags();
3585
}
3586
CIMGUI_API ImGuiDockContext* ImGuiDockContext_ImGuiDockContext(void)
3587
{
3588
    return IM_NEW(ImGuiDockContext)();
3589
}
3590
CIMGUI_API void ImGuiDockContext_destroy(ImGuiDockContext* self)
3591
{
3592
    IM_DELETE(self);
3593
}
3594
CIMGUI_API ImGuiViewportP* ImGuiViewportP_ImGuiViewportP(void)
3595
{
3596
    return IM_NEW(ImGuiViewportP)();
3597
}
3598
CIMGUI_API void ImGuiViewportP_destroy(ImGuiViewportP* self)
3599
{
3600
    IM_DELETE(self);
3601
}
3602
CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self)
3603
{
3604
    return self->ClearRequestFlags();
3605
}
3606
CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 off_min)
3607
{
3608
    *pOut = self->CalcWorkRectPos(off_min);
3609
}
3610
CIMGUI_API void ImGuiViewportP_CalcWorkRectSize(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 off_min,const ImVec2 off_max)
3611
{
3612
    *pOut = self->CalcWorkRectSize(off_min,off_max);
3613
}
3614
CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self)
3615
{
3616
    return self->UpdateWorkRect();
3617
}
3618
CIMGUI_API void ImGuiViewportP_GetMainRect(ImRect *pOut,ImGuiViewportP* self)
3619
{
3620
    *pOut = self->GetMainRect();
3621
}
3622
CIMGUI_API void ImGuiViewportP_GetWorkRect(ImRect *pOut,ImGuiViewportP* self)
3623
{
3624
    *pOut = self->GetWorkRect();
3625
}
3626
CIMGUI_API void ImGuiViewportP_GetBuildWorkRect(ImRect *pOut,ImGuiViewportP* self)
3627
{
3628
    *pOut = self->GetBuildWorkRect();
3629
}
3630
CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void)
3631
{
3632
    return IM_NEW(ImGuiWindowSettings)();
3633
}
3634
CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self)
3635
{
3636
    IM_DELETE(self);
3637
}
3638
CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self)
3639
{
3640
    return self->GetName();
3641
}
3642
CIMGUI_API ImGuiSettingsHandler* ImGuiSettingsHandler_ImGuiSettingsHandler(void)
3643
{
3644
    return IM_NEW(ImGuiSettingsHandler)();
3645
}
3646
CIMGUI_API void ImGuiSettingsHandler_destroy(ImGuiSettingsHandler* self)
3647
{
3648
    IM_DELETE(self);
3649
}
3650
CIMGUI_API ImGuiStackLevelInfo* ImGuiStackLevelInfo_ImGuiStackLevelInfo(void)
3651
{
3652
    return IM_NEW(ImGuiStackLevelInfo)();
3653
}
3654
CIMGUI_API void ImGuiStackLevelInfo_destroy(ImGuiStackLevelInfo* self)
3655
{
3656
    IM_DELETE(self);
3657
}
3658
CIMGUI_API ImGuiStackTool* ImGuiStackTool_ImGuiStackTool(void)
3659
{
3660
    return IM_NEW(ImGuiStackTool)();
3661
}
3662
CIMGUI_API void ImGuiStackTool_destroy(ImGuiStackTool* self)
3663
{
3664
    IM_DELETE(self);
3665
}
3666
CIMGUI_API ImGuiContextHook* ImGuiContextHook_ImGuiContextHook(void)
3667
{
3668
    return IM_NEW(ImGuiContextHook)();
3669
}
3670
CIMGUI_API void ImGuiContextHook_destroy(ImGuiContextHook* self)
3671
{
3672
    IM_DELETE(self);
3673
}
3674
CIMGUI_API ImGuiContext* ImGuiContext_ImGuiContext(ImFontAtlas* shared_font_atlas)
3675
{
3676
    return IM_NEW(ImGuiContext)(shared_font_atlas);
3677
}
3678
CIMGUI_API void ImGuiContext_destroy(ImGuiContext* self)
3679
{
3680
    IM_DELETE(self);
3681
}
3682
CIMGUI_API ImGuiWindow* ImGuiWindow_ImGuiWindow(ImGuiContext* context,const char* name)
3683
{
3684
    return IM_NEW(ImGuiWindow)(context,name);
3685
}
3686
CIMGUI_API void ImGuiWindow_destroy(ImGuiWindow* self)
3687
{
3688
    IM_DELETE(self);
3689
}
3690
CIMGUI_API ImGuiID ImGuiWindow_GetID_Str(ImGuiWindow* self,const char* str,const char* str_end)
3691
{
3692
    return self->GetID(str,str_end);
3693
}
3694
CIMGUI_API ImGuiID ImGuiWindow_GetID_Ptr(ImGuiWindow* self,const void* ptr)
3695
{
3696
    return self->GetID(ptr);
3697
}
3698
CIMGUI_API ImGuiID ImGuiWindow_GetID_Int(ImGuiWindow* self,int n)
3699
{
3700
    return self->GetID(n);
3701
}
3702
CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,const ImRect r_abs)
3703
{
3704
    return self->GetIDFromRectangle(r_abs);
3705
}
3706
CIMGUI_API void ImGuiWindow_Rect(ImRect *pOut,ImGuiWindow* self)
3707
{
3708
    *pOut = self->Rect();
3709
}
3710
CIMGUI_API float ImGuiWindow_CalcFontSize(ImGuiWindow* self)
3711
{
3712
    return self->CalcFontSize();
3713
}
3714
CIMGUI_API float ImGuiWindow_TitleBarHeight(ImGuiWindow* self)
3715
{
3716
    return self->TitleBarHeight();
3717
}
3718
CIMGUI_API void ImGuiWindow_TitleBarRect(ImRect *pOut,ImGuiWindow* self)
3719
{
3720
    *pOut = self->TitleBarRect();
3721
}
3722
CIMGUI_API float ImGuiWindow_MenuBarHeight(ImGuiWindow* self)
3723
{
3724
    return self->MenuBarHeight();
3725
}
3726
CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect *pOut,ImGuiWindow* self)
3727
{
3728
    *pOut = self->MenuBarRect();
3729
}
3730
CIMGUI_API ImGuiTabItem* ImGuiTabItem_ImGuiTabItem(void)
3731
{
3732
    return IM_NEW(ImGuiTabItem)();
3733
}
3734
CIMGUI_API void ImGuiTabItem_destroy(ImGuiTabItem* self)
3735
{
3736
    IM_DELETE(self);
3737
}
3738
CIMGUI_API ImGuiTabBar* ImGuiTabBar_ImGuiTabBar(void)
3739
{
3740
    return IM_NEW(ImGuiTabBar)();
3741
}
3742
CIMGUI_API void ImGuiTabBar_destroy(ImGuiTabBar* self)
3743
{
3744
    IM_DELETE(self);
3745
}
3746
CIMGUI_API ImGuiTableColumn* ImGuiTableColumn_ImGuiTableColumn(void)
3747
{
3748
    return IM_NEW(ImGuiTableColumn)();
3749
}
3750
CIMGUI_API void ImGuiTableColumn_destroy(ImGuiTableColumn* self)
3751
{
3752
    IM_DELETE(self);
3753
}
3754
CIMGUI_API ImGuiTableInstanceData* ImGuiTableInstanceData_ImGuiTableInstanceData(void)
3755
{
3756
    return IM_NEW(ImGuiTableInstanceData)();
3757
}
3758
CIMGUI_API void ImGuiTableInstanceData_destroy(ImGuiTableInstanceData* self)
3759
{
3760
    IM_DELETE(self);
3761
}
3762
CIMGUI_API ImGuiTable* ImGuiTable_ImGuiTable(void)
3763
{
3764
    return IM_NEW(ImGuiTable)();
3765
}
3766
CIMGUI_API void ImGuiTable_destroy(ImGuiTable* self)
3767
{
3768
    IM_DELETE(self);
3769
}
3770
CIMGUI_API ImGuiTableTempData* ImGuiTableTempData_ImGuiTableTempData(void)
3771
{
3772
    return IM_NEW(ImGuiTableTempData)();
3773
}
3774
CIMGUI_API void ImGuiTableTempData_destroy(ImGuiTableTempData* self)
3775
{
3776
    IM_DELETE(self);
3777
}
3778
CIMGUI_API ImGuiTableColumnSettings* ImGuiTableColumnSettings_ImGuiTableColumnSettings(void)
3779
{
3780
    return IM_NEW(ImGuiTableColumnSettings)();
3781
}
3782
CIMGUI_API void ImGuiTableColumnSettings_destroy(ImGuiTableColumnSettings* self)
3783
{
3784
    IM_DELETE(self);
3785
}
3786
CIMGUI_API ImGuiTableSettings* ImGuiTableSettings_ImGuiTableSettings(void)
3787
{
3788
    return IM_NEW(ImGuiTableSettings)();
3789
}
3790
CIMGUI_API void ImGuiTableSettings_destroy(ImGuiTableSettings* self)
3791
{
3792
    IM_DELETE(self);
3793
}
3794
CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiTableSettings* self)
3795
{
3796
    return self->GetColumnSettings();
3797
}
3798
CIMGUI_API ImGuiWindow* igGetCurrentWindowRead()
3799
{
3800
    return ImGui::GetCurrentWindowRead();
3801
}
3802
CIMGUI_API ImGuiWindow* igGetCurrentWindow()
3803
{
3804
    return ImGui::GetCurrentWindow();
3805
}
3806
CIMGUI_API ImGuiWindow* igFindWindowByID(ImGuiID id)
3807
{
3808
    return ImGui::FindWindowByID(id);
3809
}
3810
CIMGUI_API ImGuiWindow* igFindWindowByName(const char* name)
3811
{
3812
    return ImGui::FindWindowByName(name);
3813
}
3814
CIMGUI_API void igUpdateWindowParentAndRootLinks(ImGuiWindow* window,ImGuiWindowFlags flags,ImGuiWindow* parent_window)
3815
{
3816
    return ImGui::UpdateWindowParentAndRootLinks(window,flags,parent_window);
3817
}
3818
CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2 *pOut,ImGuiWindow* window)
3819
{
3820
    *pOut = ImGui::CalcWindowNextAutoFitSize(window);
3821
}
3822
CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy)
3823
{
3824
    return ImGui::IsWindowChildOf(window,potential_parent,popup_hierarchy,dock_hierarchy);
3825
}
3826
CIMGUI_API bool igIsWindowWithinBeginStackOf(ImGuiWindow* window,ImGuiWindow* potential_parent)
3827
{
3828
    return ImGui::IsWindowWithinBeginStackOf(window,potential_parent);
3829
}
3830
CIMGUI_API bool igIsWindowAbove(ImGuiWindow* potential_above,ImGuiWindow* potential_below)
3831
{
3832
    return ImGui::IsWindowAbove(potential_above,potential_below);
3833
}
3834
CIMGUI_API bool igIsWindowNavFocusable(ImGuiWindow* window)
3835
{
3836
    return ImGui::IsWindowNavFocusable(window);
3837
}
3838
CIMGUI_API void igSetWindowPos_WindowPtr(ImGuiWindow* window,const ImVec2 pos,ImGuiCond cond)
3839
{
3840
    return ImGui::SetWindowPos(window,pos,cond);
3841
}
3842
CIMGUI_API void igSetWindowSize_WindowPtr(ImGuiWindow* window,const ImVec2 size,ImGuiCond cond)
3843
{
3844
    return ImGui::SetWindowSize(window,size,cond);
3845
}
3846
CIMGUI_API void igSetWindowCollapsed_WindowPtr(ImGuiWindow* window,bool collapsed,ImGuiCond cond)
3847
{
3848
    return ImGui::SetWindowCollapsed(window,collapsed,cond);
3849
}
3850
CIMGUI_API void igSetWindowHitTestHole(ImGuiWindow* window,const ImVec2 pos,const ImVec2 size)
3851
{
3852
    return ImGui::SetWindowHitTestHole(window,pos,size);
3853
}
3854
CIMGUI_API void igSetWindowHiddendAndSkipItemsForCurrentFrame(ImGuiWindow* window)
3855
{
3856
    return ImGui::SetWindowHiddendAndSkipItemsForCurrentFrame(window);
3857
}
3858
CIMGUI_API void igWindowRectAbsToRel(ImRect *pOut,ImGuiWindow* window,const ImRect r)
3859
{
3860
    *pOut = ImGui::WindowRectAbsToRel(window,r);
3861
}
3862
CIMGUI_API void igWindowRectRelToAbs(ImRect *pOut,ImGuiWindow* window,const ImRect r)
3863
{
3864
    *pOut = ImGui::WindowRectRelToAbs(window,r);
3865
}
3866
CIMGUI_API void igWindowPosRelToAbs(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p)
3867
{
3868
    *pOut = ImGui::WindowPosRelToAbs(window,p);
3869
}
3870
CIMGUI_API void igFocusWindow(ImGuiWindow* window,ImGuiFocusRequestFlags flags)
3871
{
3872
    return ImGui::FocusWindow(window,flags);
3873
}
3874
CIMGUI_API void igFocusTopMostWindowUnderOne(ImGuiWindow* under_this_window,ImGuiWindow* ignore_window,ImGuiViewport* filter_viewport,ImGuiFocusRequestFlags flags)
3875
{
3876
    return ImGui::FocusTopMostWindowUnderOne(under_this_window,ignore_window,filter_viewport,flags);
3877
}
3878
CIMGUI_API void igBringWindowToFocusFront(ImGuiWindow* window)
3879
{
3880
    return ImGui::BringWindowToFocusFront(window);
3881
}
3882
CIMGUI_API void igBringWindowToDisplayFront(ImGuiWindow* window)
3883
{
3884
    return ImGui::BringWindowToDisplayFront(window);
3885
}
3886
CIMGUI_API void igBringWindowToDisplayBack(ImGuiWindow* window)
3887
{
3888
    return ImGui::BringWindowToDisplayBack(window);
3889
}
3890
CIMGUI_API void igBringWindowToDisplayBehind(ImGuiWindow* window,ImGuiWindow* above_window)
3891
{
3892
    return ImGui::BringWindowToDisplayBehind(window,above_window);
3893
}
3894
CIMGUI_API int igFindWindowDisplayIndex(ImGuiWindow* window)
3895
{
3896
    return ImGui::FindWindowDisplayIndex(window);
3897
}
3898
CIMGUI_API ImGuiWindow* igFindBottomMostVisibleWindowWithinBeginStack(ImGuiWindow* window)
3899
{
3900
    return ImGui::FindBottomMostVisibleWindowWithinBeginStack(window);
3901
}
3902
CIMGUI_API void igSetCurrentFont(ImFont* font)
3903
{
3904
    return ImGui::SetCurrentFont(font);
3905
}
3906
CIMGUI_API ImFont* igGetDefaultFont()
3907
{
3908
    return ImGui::GetDefaultFont();
3909
}
3910
CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window)
3911
{
3912
    return ImGui::GetForegroundDrawList(window);
3913
}
3914
CIMGUI_API void igAddDrawListToDrawDataEx(ImDrawData* draw_data,ImVector_ImDrawListPtr* out_list,ImDrawList* draw_list)
3915
{
3916
    return ImGui::AddDrawListToDrawDataEx(draw_data,out_list,draw_list);
3917
}
3918
CIMGUI_API void igInitialize()
3919
{
3920
    return ImGui::Initialize();
3921
}
3922
CIMGUI_API void igShutdown()
3923
{
3924
    return ImGui::Shutdown();
3925
}
3926
CIMGUI_API void igUpdateInputEvents(bool trickle_fast_inputs)
3927
{
3928
    return ImGui::UpdateInputEvents(trickle_fast_inputs);
3929
}
3930
CIMGUI_API void igUpdateHoveredWindowAndCaptureFlags()
3931
{
3932
    return ImGui::UpdateHoveredWindowAndCaptureFlags();
3933
}
3934
CIMGUI_API void igStartMouseMovingWindow(ImGuiWindow* window)
3935
{
3936
    return ImGui::StartMouseMovingWindow(window);
3937
}
3938
CIMGUI_API void igStartMouseMovingWindowOrNode(ImGuiWindow* window,ImGuiDockNode* node,bool undock_floating_node)
3939
{
3940
    return ImGui::StartMouseMovingWindowOrNode(window,node,undock_floating_node);
3941
}
3942
CIMGUI_API void igUpdateMouseMovingWindowNewFrame()
3943
{
3944
    return ImGui::UpdateMouseMovingWindowNewFrame();
3945
}
3946
CIMGUI_API void igUpdateMouseMovingWindowEndFrame()
3947
{
3948
    return ImGui::UpdateMouseMovingWindowEndFrame();
3949
}
3950
CIMGUI_API ImGuiID igAddContextHook(ImGuiContext* context,const ImGuiContextHook* hook)
3951
{
3952
    return ImGui::AddContextHook(context,hook);
3953
}
3954
CIMGUI_API void igRemoveContextHook(ImGuiContext* context,ImGuiID hook_to_remove)
3955
{
3956
    return ImGui::RemoveContextHook(context,hook_to_remove);
3957
}
3958
CIMGUI_API void igCallContextHooks(ImGuiContext* context,ImGuiContextHookType type)
3959
{
3960
    return ImGui::CallContextHooks(context,type);
3961
}
3962
CIMGUI_API void igTranslateWindowsInViewport(ImGuiViewportP* viewport,const ImVec2 old_pos,const ImVec2 new_pos)
3963
{
3964
    return ImGui::TranslateWindowsInViewport(viewport,old_pos,new_pos);
3965
}
3966
CIMGUI_API void igScaleWindowsInViewport(ImGuiViewportP* viewport,float scale)
3967
{
3968
    return ImGui::ScaleWindowsInViewport(viewport,scale);
3969
}
3970
CIMGUI_API void igDestroyPlatformWindow(ImGuiViewportP* viewport)
3971
{
3972
    return ImGui::DestroyPlatformWindow(viewport);
3973
}
3974
CIMGUI_API void igSetWindowViewport(ImGuiWindow* window,ImGuiViewportP* viewport)
3975
{
3976
    return ImGui::SetWindowViewport(window,viewport);
3977
}
3978
CIMGUI_API void igSetCurrentViewport(ImGuiWindow* window,ImGuiViewportP* viewport)
3979
{
3980
    return ImGui::SetCurrentViewport(window,viewport);
3981
}
3982
CIMGUI_API const ImGuiPlatformMonitor* igGetViewportPlatformMonitor(ImGuiViewport* viewport)
3983
{
3984
    return ImGui::GetViewportPlatformMonitor(viewport);
3985
}
3986
CIMGUI_API ImGuiViewportP* igFindHoveredViewportFromPlatformWindowStack(const ImVec2 mouse_platform_pos)
3987
{
3988
    return ImGui::FindHoveredViewportFromPlatformWindowStack(mouse_platform_pos);
3989
}
3990
CIMGUI_API void igMarkIniSettingsDirty_Nil()
3991
{
3992
    return ImGui::MarkIniSettingsDirty();
3993
}
3994
CIMGUI_API void igMarkIniSettingsDirty_WindowPtr(ImGuiWindow* window)
3995
{
3996
    return ImGui::MarkIniSettingsDirty(window);
3997
}
3998
CIMGUI_API void igClearIniSettings()
3999
{
4000
    return ImGui::ClearIniSettings();
4001
}
4002
CIMGUI_API void igAddSettingsHandler(const ImGuiSettingsHandler* handler)
4003
{
4004
    return ImGui::AddSettingsHandler(handler);
4005
}
4006
CIMGUI_API void igRemoveSettingsHandler(const char* type_name)
4007
{
4008
    return ImGui::RemoveSettingsHandler(type_name);
4009
}
4010
CIMGUI_API ImGuiSettingsHandler* igFindSettingsHandler(const char* type_name)
4011
{
4012
    return ImGui::FindSettingsHandler(type_name);
4013
}
4014
CIMGUI_API ImGuiWindowSettings* igCreateNewWindowSettings(const char* name)
4015
{
4016
    return ImGui::CreateNewWindowSettings(name);
4017
}
4018
CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByID(ImGuiID id)
4019
{
4020
    return ImGui::FindWindowSettingsByID(id);
4021
}
4022
CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByWindow(ImGuiWindow* window)
4023
{
4024
    return ImGui::FindWindowSettingsByWindow(window);
4025
}
4026
CIMGUI_API void igClearWindowSettings(const char* name)
4027
{
4028
    return ImGui::ClearWindowSettings(name);
4029
}
4030
CIMGUI_API void igLocalizeRegisterEntries(const ImGuiLocEntry* entries,int count)
4031
{
4032
    return ImGui::LocalizeRegisterEntries(entries,count);
4033
}
4034
CIMGUI_API const char* igLocalizeGetMsg(ImGuiLocKey key)
4035
{
4036
    return ImGui::LocalizeGetMsg(key);
4037
}
4038
CIMGUI_API void igSetScrollX_WindowPtr(ImGuiWindow* window,float scroll_x)
4039
{
4040
    return ImGui::SetScrollX(window,scroll_x);
4041
}
4042
CIMGUI_API void igSetScrollY_WindowPtr(ImGuiWindow* window,float scroll_y)
4043
{
4044
    return ImGui::SetScrollY(window,scroll_y);
4045
}
4046
CIMGUI_API void igSetScrollFromPosX_WindowPtr(ImGuiWindow* window,float local_x,float center_x_ratio)
4047
{
4048
    return ImGui::SetScrollFromPosX(window,local_x,center_x_ratio);
4049
}
4050
CIMGUI_API void igSetScrollFromPosY_WindowPtr(ImGuiWindow* window,float local_y,float center_y_ratio)
4051
{
4052
    return ImGui::SetScrollFromPosY(window,local_y,center_y_ratio);
4053
}
4054
CIMGUI_API void igScrollToItem(ImGuiScrollFlags flags)
4055
{
4056
    return ImGui::ScrollToItem(flags);
4057
}
4058
CIMGUI_API void igScrollToRect(ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags)
4059
{
4060
    return ImGui::ScrollToRect(window,rect,flags);
4061
}
4062
CIMGUI_API void igScrollToRectEx(ImVec2 *pOut,ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags)
4063
{
4064
    *pOut = ImGui::ScrollToRectEx(window,rect,flags);
4065
}
4066
CIMGUI_API void igScrollToBringRectIntoView(ImGuiWindow* window,const ImRect rect)
4067
{
4068
    return ImGui::ScrollToBringRectIntoView(window,rect);
4069
}
4070
CIMGUI_API ImGuiItemStatusFlags igGetItemStatusFlags()
4071
{
4072
    return ImGui::GetItemStatusFlags();
4073
}
4074
CIMGUI_API ImGuiItemFlags igGetItemFlags()
4075
{
4076
    return ImGui::GetItemFlags();
4077
}
4078
CIMGUI_API ImGuiID igGetActiveID()
4079
{
4080
    return ImGui::GetActiveID();
4081
}
4082
CIMGUI_API ImGuiID igGetFocusID()
4083
{
4084
    return ImGui::GetFocusID();
4085
}
4086
CIMGUI_API void igSetActiveID(ImGuiID id,ImGuiWindow* window)
4087
{
4088
    return ImGui::SetActiveID(id,window);
4089
}
4090
CIMGUI_API void igSetFocusID(ImGuiID id,ImGuiWindow* window)
4091
{
4092
    return ImGui::SetFocusID(id,window);
4093
}
4094
CIMGUI_API void igClearActiveID()
4095
{
4096
    return ImGui::ClearActiveID();
4097
}
4098
CIMGUI_API ImGuiID igGetHoveredID()
4099
{
4100
    return ImGui::GetHoveredID();
4101
}
4102
CIMGUI_API void igSetHoveredID(ImGuiID id)
4103
{
4104
    return ImGui::SetHoveredID(id);
4105
}
4106
CIMGUI_API void igKeepAliveID(ImGuiID id)
4107
{
4108
    return ImGui::KeepAliveID(id);
4109
}
4110
CIMGUI_API void igMarkItemEdited(ImGuiID id)
4111
{
4112
    return ImGui::MarkItemEdited(id);
4113
}
4114
CIMGUI_API void igPushOverrideID(ImGuiID id)
4115
{
4116
    return ImGui::PushOverrideID(id);
4117
}
4118
CIMGUI_API ImGuiID igGetIDWithSeed_Str(const char* str_id_begin,const char* str_id_end,ImGuiID seed)
4119
{
4120
    return ImGui::GetIDWithSeed(str_id_begin,str_id_end,seed);
4121
}
4122
CIMGUI_API ImGuiID igGetIDWithSeed_Int(int n,ImGuiID seed)
4123
{
4124
    return ImGui::GetIDWithSeed(n,seed);
4125
}
4126
CIMGUI_API void igItemSize_Vec2(const ImVec2 size,float text_baseline_y)
4127
{
4128
    return ImGui::ItemSize(size,text_baseline_y);
4129
}
4130
CIMGUI_API void igItemSize_Rect(const ImRect bb,float text_baseline_y)
4131
{
4132
    return ImGui::ItemSize(bb,text_baseline_y);
4133
}
4134
CIMGUI_API bool igItemAdd(const ImRect bb,ImGuiID id,const ImRect* nav_bb,ImGuiItemFlags extra_flags)
4135
{
4136
    return ImGui::ItemAdd(bb,id,nav_bb,extra_flags);
4137
}
4138
CIMGUI_API bool igItemHoverable(const ImRect bb,ImGuiID id,ImGuiItemFlags item_flags)
4139
{
4140
    return ImGui::ItemHoverable(bb,id,item_flags);
4141
}
4142
CIMGUI_API bool igIsWindowContentHoverable(ImGuiWindow* window,ImGuiHoveredFlags flags)
4143
{
4144
    return ImGui::IsWindowContentHoverable(window,flags);
4145
}
4146
CIMGUI_API bool igIsClippedEx(const ImRect bb,ImGuiID id)
4147
{
4148
    return ImGui::IsClippedEx(bb,id);
4149
}
4150
CIMGUI_API void igSetLastItemData(ImGuiID item_id,ImGuiItemFlags in_flags,ImGuiItemStatusFlags status_flags,const ImRect item_rect)
4151
{
4152
    return ImGui::SetLastItemData(item_id,in_flags,status_flags,item_rect);
4153
}
4154
CIMGUI_API void igCalcItemSize(ImVec2 *pOut,ImVec2 size,float default_w,float default_h)
4155
{
4156
    *pOut = ImGui::CalcItemSize(size,default_w,default_h);
4157
}
4158
CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos,float wrap_pos_x)
4159
{
4160
    return ImGui::CalcWrapWidthForPos(pos,wrap_pos_x);
4161
}
4162
CIMGUI_API void igPushMultiItemsWidths(int components,float width_full)
4163
{
4164
    return ImGui::PushMultiItemsWidths(components,width_full);
4165
}
4166
CIMGUI_API bool igIsItemToggledSelection()
4167
{
4168
    return ImGui::IsItemToggledSelection();
4169
}
4170
CIMGUI_API void igGetContentRegionMaxAbs(ImVec2 *pOut)
4171
{
4172
    *pOut = ImGui::GetContentRegionMaxAbs();
4173
}
4174
CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,int count,float width_excess)
4175
{
4176
    return ImGui::ShrinkWidths(items,count,width_excess);
4177
}
4178
CIMGUI_API void igPushItemFlag(ImGuiItemFlags option,bool enabled)
4179
{
4180
    return ImGui::PushItemFlag(option,enabled);
4181
}
4182
CIMGUI_API void igPopItemFlag()
4183
{
4184
    return ImGui::PopItemFlag();
4185
}
4186
CIMGUI_API const ImGuiDataVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx)
4187
{
4188
    return ImGui::GetStyleVarInfo(idx);
4189
}
4190
CIMGUI_API void igLogBegin(ImGuiLogType type,int auto_open_depth)
4191
{
4192
    return ImGui::LogBegin(type,auto_open_depth);
4193
}
4194
CIMGUI_API void igLogToBuffer(int auto_open_depth)
4195
{
4196
    return ImGui::LogToBuffer(auto_open_depth);
4197
}
4198
CIMGUI_API void igLogRenderedText(const ImVec2* ref_pos,const char* text,const char* text_end)
4199
{
4200
    return ImGui::LogRenderedText(ref_pos,text,text_end);
4201
}
4202
CIMGUI_API void igLogSetNextTextDecoration(const char* prefix,const char* suffix)
4203
{
4204
    return ImGui::LogSetNextTextDecoration(prefix,suffix);
4205
}
4206
CIMGUI_API bool igBeginChildEx(const char* name,ImGuiID id,const ImVec2 size_arg,bool border,ImGuiWindowFlags flags)
4207
{
4208
    return ImGui::BeginChildEx(name,id,size_arg,border,flags);
4209
}
4210
CIMGUI_API void igOpenPopupEx(ImGuiID id,ImGuiPopupFlags popup_flags)
4211
{
4212
    return ImGui::OpenPopupEx(id,popup_flags);
4213
}
4214
CIMGUI_API void igClosePopupToLevel(int remaining,bool restore_focus_to_window_under_popup)
4215
{
4216
    return ImGui::ClosePopupToLevel(remaining,restore_focus_to_window_under_popup);
4217
}
4218
CIMGUI_API void igClosePopupsOverWindow(ImGuiWindow* ref_window,bool restore_focus_to_window_under_popup)
4219
{
4220
    return ImGui::ClosePopupsOverWindow(ref_window,restore_focus_to_window_under_popup);
4221
}
4222
CIMGUI_API void igClosePopupsExceptModals()
4223
{
4224
    return ImGui::ClosePopupsExceptModals();
4225
}
4226
CIMGUI_API bool igIsPopupOpen_ID(ImGuiID id,ImGuiPopupFlags popup_flags)
4227
{
4228
    return ImGui::IsPopupOpen(id,popup_flags);
4229
}
4230
CIMGUI_API bool igBeginPopupEx(ImGuiID id,ImGuiWindowFlags extra_flags)
4231
{
4232
    return ImGui::BeginPopupEx(id,extra_flags);
4233
}
4234
CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags)
4235
{
4236
    return ImGui::BeginTooltipEx(tooltip_flags,extra_window_flags);
4237
}
4238
CIMGUI_API void igGetPopupAllowedExtentRect(ImRect *pOut,ImGuiWindow* window)
4239
{
4240
    *pOut = ImGui::GetPopupAllowedExtentRect(window);
4241
}
4242
CIMGUI_API ImGuiWindow* igGetTopMostPopupModal()
4243
{
4244
    return ImGui::GetTopMostPopupModal();
4245
}
4246
CIMGUI_API ImGuiWindow* igGetTopMostAndVisiblePopupModal()
4247
{
4248
    return ImGui::GetTopMostAndVisiblePopupModal();
4249
}
4250
CIMGUI_API ImGuiWindow* igFindBlockingModal(ImGuiWindow* window)
4251
{
4252
    return ImGui::FindBlockingModal(window);
4253
}
4254
CIMGUI_API void igFindBestWindowPosForPopup(ImVec2 *pOut,ImGuiWindow* window)
4255
{
4256
    *pOut = ImGui::FindBestWindowPosForPopup(window);
4257
}
4258
CIMGUI_API void igFindBestWindowPosForPopupEx(ImVec2 *pOut,const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy)
4259
{
4260
    *pOut = ImGui::FindBestWindowPosForPopupEx(ref_pos,size,last_dir,r_outer,r_avoid,policy);
4261
}
4262
CIMGUI_API bool igBeginViewportSideBar(const char* name,ImGuiViewport* viewport,ImGuiDir dir,float size,ImGuiWindowFlags window_flags)
4263
{
4264
    return ImGui::BeginViewportSideBar(name,viewport,dir,size,window_flags);
4265
}
4266
CIMGUI_API bool igBeginMenuEx(const char* label,const char* icon,bool enabled)
4267
{
4268
    return ImGui::BeginMenuEx(label,icon,enabled);
4269
}
4270
CIMGUI_API bool igMenuItemEx(const char* label,const char* icon,const char* shortcut,bool selected,bool enabled)
4271
{
4272
    return ImGui::MenuItemEx(label,icon,shortcut,selected,enabled);
4273
}
4274
CIMGUI_API bool igBeginComboPopup(ImGuiID popup_id,const ImRect bb,ImGuiComboFlags flags)
4275
{
4276
    return ImGui::BeginComboPopup(popup_id,bb,flags);
4277
}
4278
CIMGUI_API bool igBeginComboPreview()
4279
{
4280
    return ImGui::BeginComboPreview();
4281
}
4282
CIMGUI_API void igEndComboPreview()
4283
{
4284
    return ImGui::EndComboPreview();
4285
}
4286
CIMGUI_API void igNavInitWindow(ImGuiWindow* window,bool force_reinit)
4287
{
4288
    return ImGui::NavInitWindow(window,force_reinit);
4289
}
4290
CIMGUI_API void igNavInitRequestApplyResult()
4291
{
4292
    return ImGui::NavInitRequestApplyResult();
4293
}
4294
CIMGUI_API bool igNavMoveRequestButNoResultYet()
4295
{
4296
    return ImGui::NavMoveRequestButNoResultYet();
4297
}
4298
CIMGUI_API void igNavMoveRequestSubmit(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags)
4299
{
4300
    return ImGui::NavMoveRequestSubmit(move_dir,clip_dir,move_flags,scroll_flags);
4301
}
4302
CIMGUI_API void igNavMoveRequestForward(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags)
4303
{
4304
    return ImGui::NavMoveRequestForward(move_dir,clip_dir,move_flags,scroll_flags);
4305
}
4306
CIMGUI_API void igNavMoveRequestResolveWithLastItem(ImGuiNavItemData* result)
4307
{
4308
    return ImGui::NavMoveRequestResolveWithLastItem(result);
4309
}
4310
CIMGUI_API void igNavMoveRequestResolveWithPastTreeNode(ImGuiNavItemData* result,ImGuiNavTreeNodeData* tree_node_data)
4311
{
4312
    return ImGui::NavMoveRequestResolveWithPastTreeNode(result,tree_node_data);
4313
}
4314
CIMGUI_API void igNavMoveRequestCancel()
4315
{
4316
    return ImGui::NavMoveRequestCancel();
4317
}
4318
CIMGUI_API void igNavMoveRequestApplyResult()
4319
{
4320
    return ImGui::NavMoveRequestApplyResult();
4321
}
4322
CIMGUI_API void igNavMoveRequestTryWrapping(ImGuiWindow* window,ImGuiNavMoveFlags move_flags)
4323
{
4324
    return ImGui::NavMoveRequestTryWrapping(window,move_flags);
4325
}
4326
CIMGUI_API void igNavClearPreferredPosForAxis(ImGuiAxis axis)
4327
{
4328
    return ImGui::NavClearPreferredPosForAxis(axis);
4329
}
4330
CIMGUI_API void igNavUpdateCurrentWindowIsScrollPushableX()
4331
{
4332
    return ImGui::NavUpdateCurrentWindowIsScrollPushableX();
4333
}
4334
CIMGUI_API void igSetNavWindow(ImGuiWindow* window)
4335
{
4336
    return ImGui::SetNavWindow(window);
4337
}
4338
CIMGUI_API void igSetNavID(ImGuiID id,ImGuiNavLayer nav_layer,ImGuiID focus_scope_id,const ImRect rect_rel)
4339
{
4340
    return ImGui::SetNavID(id,nav_layer,focus_scope_id,rect_rel);
4341
}
4342
CIMGUI_API void igFocusItem()
4343
{
4344
    return ImGui::FocusItem();
4345
}
4346
CIMGUI_API void igActivateItemByID(ImGuiID id)
4347
{
4348
    return ImGui::ActivateItemByID(id);
4349
}
4350
CIMGUI_API bool igIsNamedKey(ImGuiKey key)
4351
{
4352
    return ImGui::IsNamedKey(key);
4353
}
4354
CIMGUI_API bool igIsNamedKeyOrModKey(ImGuiKey key)
4355
{
4356
    return ImGui::IsNamedKeyOrModKey(key);
4357
}
4358
CIMGUI_API bool igIsLegacyKey(ImGuiKey key)
4359
{
4360
    return ImGui::IsLegacyKey(key);
4361
}
4362
CIMGUI_API bool igIsKeyboardKey(ImGuiKey key)
4363
{
4364
    return ImGui::IsKeyboardKey(key);
4365
}
4366
CIMGUI_API bool igIsGamepadKey(ImGuiKey key)
4367
{
4368
    return ImGui::IsGamepadKey(key);
4369
}
4370
CIMGUI_API bool igIsMouseKey(ImGuiKey key)
4371
{
4372
    return ImGui::IsMouseKey(key);
4373
}
4374
CIMGUI_API bool igIsAliasKey(ImGuiKey key)
4375
{
4376
    return ImGui::IsAliasKey(key);
4377
}
4378
CIMGUI_API ImGuiKeyChord igConvertShortcutMod(ImGuiKeyChord key_chord)
4379
{
4380
    return ImGui::ConvertShortcutMod(key_chord);
4381
}
4382
CIMGUI_API ImGuiKey igConvertSingleModFlagToKey(ImGuiContext* ctx,ImGuiKey key)
4383
{
4384
    return ImGui::ConvertSingleModFlagToKey(ctx,key);
4385
}
4386
CIMGUI_API ImGuiKeyData* igGetKeyData_ContextPtr(ImGuiContext* ctx,ImGuiKey key)
4387
{
4388
    return ImGui::GetKeyData(ctx,key);
4389
}
4390
CIMGUI_API ImGuiKeyData* igGetKeyData_Key(ImGuiKey key)
4391
{
4392
    return ImGui::GetKeyData(key);
4393
}
4394
CIMGUI_API void igGetKeyChordName(ImGuiKeyChord key_chord,char* out_buf,int out_buf_size)
4395
{
4396
    return ImGui::GetKeyChordName(key_chord,out_buf,out_buf_size);
4397
}
4398
CIMGUI_API ImGuiKey igMouseButtonToKey(ImGuiMouseButton button)
4399
{
4400
    return ImGui::MouseButtonToKey(button);
4401
}
4402
CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,float lock_threshold)
4403
{
4404
    return ImGui::IsMouseDragPastThreshold(button,lock_threshold);
4405
}
4406
CIMGUI_API void igGetKeyMagnitude2d(ImVec2 *pOut,ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down)
4407
{
4408
    *pOut = ImGui::GetKeyMagnitude2d(key_left,key_right,key_up,key_down);
4409
}
4410
CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis)
4411
{
4412
    return ImGui::GetNavTweakPressedAmount(axis);
4413
}
4414
CIMGUI_API int igCalcTypematicRepeatAmount(float t0,float t1,float repeat_delay,float repeat_rate)
4415
{
4416
    return ImGui::CalcTypematicRepeatAmount(t0,t1,repeat_delay,repeat_rate);
4417
}
4418
CIMGUI_API void igGetTypematicRepeatRate(ImGuiInputFlags flags,float* repeat_delay,float* repeat_rate)
4419
{
4420
    return ImGui::GetTypematicRepeatRate(flags,repeat_delay,repeat_rate);
4421
}
4422
CIMGUI_API void igSetActiveIdUsingAllKeyboardKeys()
4423
{
4424
    return ImGui::SetActiveIdUsingAllKeyboardKeys();
4425
}
4426
CIMGUI_API bool igIsActiveIdUsingNavDir(ImGuiDir dir)
4427
{
4428
    return ImGui::IsActiveIdUsingNavDir(dir);
4429
}
4430
CIMGUI_API ImGuiID igGetKeyOwner(ImGuiKey key)
4431
{
4432
    return ImGui::GetKeyOwner(key);
4433
}
4434
CIMGUI_API void igSetKeyOwner(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags)
4435
{
4436
    return ImGui::SetKeyOwner(key,owner_id,flags);
4437
}
4438
CIMGUI_API void igSetKeyOwnersForKeyChord(ImGuiKeyChord key,ImGuiID owner_id,ImGuiInputFlags flags)
4439
{
4440
    return ImGui::SetKeyOwnersForKeyChord(key,owner_id,flags);
4441
}
4442
CIMGUI_API void igSetItemKeyOwner(ImGuiKey key,ImGuiInputFlags flags)
4443
{
4444
    return ImGui::SetItemKeyOwner(key,flags);
4445
}
4446
CIMGUI_API bool igTestKeyOwner(ImGuiKey key,ImGuiID owner_id)
4447
{
4448
    return ImGui::TestKeyOwner(key,owner_id);
4449
}
4450
CIMGUI_API ImGuiKeyOwnerData* igGetKeyOwnerData(ImGuiContext* ctx,ImGuiKey key)
4451
{
4452
    return ImGui::GetKeyOwnerData(ctx,key);
4453
}
4454
CIMGUI_API bool igIsKeyDown_ID(ImGuiKey key,ImGuiID owner_id)
4455
{
4456
    return ImGui::IsKeyDown(key,owner_id);
4457
}
4458
CIMGUI_API bool igIsKeyPressed_ID(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags)
4459
{
4460
    return ImGui::IsKeyPressed(key,owner_id,flags);
4461
}
4462
CIMGUI_API bool igIsKeyReleased_ID(ImGuiKey key,ImGuiID owner_id)
4463
{
4464
    return ImGui::IsKeyReleased(key,owner_id);
4465
}
4466
CIMGUI_API bool igIsMouseDown_ID(ImGuiMouseButton button,ImGuiID owner_id)
4467
{
4468
    return ImGui::IsMouseDown(button,owner_id);
4469
}
4470
CIMGUI_API bool igIsMouseClicked_ID(ImGuiMouseButton button,ImGuiID owner_id,ImGuiInputFlags flags)
4471
{
4472
    return ImGui::IsMouseClicked(button,owner_id,flags);
4473
}
4474
CIMGUI_API bool igIsMouseReleased_ID(ImGuiMouseButton button,ImGuiID owner_id)
4475
{
4476
    return ImGui::IsMouseReleased(button,owner_id);
4477
}
4478
CIMGUI_API bool igShortcut(ImGuiKeyChord key_chord,ImGuiID owner_id,ImGuiInputFlags flags)
4479
{
4480
    return ImGui::Shortcut(key_chord,owner_id,flags);
4481
}
4482
CIMGUI_API bool igSetShortcutRouting(ImGuiKeyChord key_chord,ImGuiID owner_id,ImGuiInputFlags flags)
4483
{
4484
    return ImGui::SetShortcutRouting(key_chord,owner_id,flags);
4485
}
4486
CIMGUI_API bool igTestShortcutRouting(ImGuiKeyChord key_chord,ImGuiID owner_id)
4487
{
4488
    return ImGui::TestShortcutRouting(key_chord,owner_id);
4489
}
4490
CIMGUI_API ImGuiKeyRoutingData* igGetShortcutRoutingData(ImGuiKeyChord key_chord)
4491
{
4492
    return ImGui::GetShortcutRoutingData(key_chord);
4493
}
4494
CIMGUI_API void igDockContextInitialize(ImGuiContext* ctx)
4495
{
4496
    return ImGui::DockContextInitialize(ctx);
4497
}
4498
CIMGUI_API void igDockContextShutdown(ImGuiContext* ctx)
4499
{
4500
    return ImGui::DockContextShutdown(ctx);
4501
}
4502
CIMGUI_API void igDockContextClearNodes(ImGuiContext* ctx,ImGuiID root_id,bool clear_settings_refs)
4503
{
4504
    return ImGui::DockContextClearNodes(ctx,root_id,clear_settings_refs);
4505
}
4506
CIMGUI_API void igDockContextRebuildNodes(ImGuiContext* ctx)
4507
{
4508
    return ImGui::DockContextRebuildNodes(ctx);
4509
}
4510
CIMGUI_API void igDockContextNewFrameUpdateUndocking(ImGuiContext* ctx)
4511
{
4512
    return ImGui::DockContextNewFrameUpdateUndocking(ctx);
4513
}
4514
CIMGUI_API void igDockContextNewFrameUpdateDocking(ImGuiContext* ctx)
4515
{
4516
    return ImGui::DockContextNewFrameUpdateDocking(ctx);
4517
}
4518
CIMGUI_API void igDockContextEndFrame(ImGuiContext* ctx)
4519
{
4520
    return ImGui::DockContextEndFrame(ctx);
4521
}
4522
CIMGUI_API ImGuiID igDockContextGenNodeID(ImGuiContext* ctx)
4523
{
4524
    return ImGui::DockContextGenNodeID(ctx);
4525
}
4526
CIMGUI_API void igDockContextQueueDock(ImGuiContext* ctx,ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload,ImGuiDir split_dir,float split_ratio,bool split_outer)
4527
{
4528
    return ImGui::DockContextQueueDock(ctx,target,target_node,payload,split_dir,split_ratio,split_outer);
4529
}
4530
CIMGUI_API void igDockContextQueueUndockWindow(ImGuiContext* ctx,ImGuiWindow* window)
4531
{
4532
    return ImGui::DockContextQueueUndockWindow(ctx,window);
4533
}
4534
CIMGUI_API void igDockContextQueueUndockNode(ImGuiContext* ctx,ImGuiDockNode* node)
4535
{
4536
    return ImGui::DockContextQueueUndockNode(ctx,node);
4537
}
4538
CIMGUI_API void igDockContextProcessUndockWindow(ImGuiContext* ctx,ImGuiWindow* window,bool clear_persistent_docking_ref)
4539
{
4540
    return ImGui::DockContextProcessUndockWindow(ctx,window,clear_persistent_docking_ref);
4541
}
4542
CIMGUI_API void igDockContextProcessUndockNode(ImGuiContext* ctx,ImGuiDockNode* node)
4543
{
4544
    return ImGui::DockContextProcessUndockNode(ctx,node);
4545
}
4546
CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload_window,ImGuiDockNode* payload_node,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos)
4547
{
4548
    return ImGui::DockContextCalcDropPosForDocking(target,target_node,payload_window,payload_node,split_dir,split_outer,out_pos);
4549
}
4550
CIMGUI_API ImGuiDockNode* igDockContextFindNodeByID(ImGuiContext* ctx,ImGuiID id)
4551
{
4552
    return ImGui::DockContextFindNodeByID(ctx,id);
4553
}
4554
CIMGUI_API void igDockNodeWindowMenuHandler_Default(ImGuiContext* ctx,ImGuiDockNode* node,ImGuiTabBar* tab_bar)
4555
{
4556
    return ImGui::DockNodeWindowMenuHandler_Default(ctx,node,tab_bar);
4557
}
4558
CIMGUI_API bool igDockNodeBeginAmendTabBar(ImGuiDockNode* node)
4559
{
4560
    return ImGui::DockNodeBeginAmendTabBar(node);
4561
}
4562
CIMGUI_API void igDockNodeEndAmendTabBar()
4563
{
4564
    return ImGui::DockNodeEndAmendTabBar();
4565
}
4566
CIMGUI_API ImGuiDockNode* igDockNodeGetRootNode(ImGuiDockNode* node)
4567
{
4568
    return ImGui::DockNodeGetRootNode(node);
4569
}
4570
CIMGUI_API bool igDockNodeIsInHierarchyOf(ImGuiDockNode* node,ImGuiDockNode* parent)
4571
{
4572
    return ImGui::DockNodeIsInHierarchyOf(node,parent);
4573
}
4574
CIMGUI_API int igDockNodeGetDepth(const ImGuiDockNode* node)
4575
{
4576
    return ImGui::DockNodeGetDepth(node);
4577
}
4578
CIMGUI_API ImGuiID igDockNodeGetWindowMenuButtonId(const ImGuiDockNode* node)
4579
{
4580
    return ImGui::DockNodeGetWindowMenuButtonId(node);
4581
}
4582
CIMGUI_API ImGuiDockNode* igGetWindowDockNode()
4583
{
4584
    return ImGui::GetWindowDockNode();
4585
}
4586
CIMGUI_API bool igGetWindowAlwaysWantOwnTabBar(ImGuiWindow* window)
4587
{
4588
    return ImGui::GetWindowAlwaysWantOwnTabBar(window);
4589
}
4590
CIMGUI_API void igBeginDocked(ImGuiWindow* window,bool* p_open)
4591
{
4592
    return ImGui::BeginDocked(window,p_open);
4593
}
4594
CIMGUI_API void igBeginDockableDragDropSource(ImGuiWindow* window)
4595
{
4596
    return ImGui::BeginDockableDragDropSource(window);
4597
}
4598
CIMGUI_API void igBeginDockableDragDropTarget(ImGuiWindow* window)
4599
{
4600
    return ImGui::BeginDockableDragDropTarget(window);
4601
}
4602
CIMGUI_API void igSetWindowDock(ImGuiWindow* window,ImGuiID dock_id,ImGuiCond cond)
4603
{
4604
    return ImGui::SetWindowDock(window,dock_id,cond);
4605
}
4606
CIMGUI_API void igDockBuilderDockWindow(const char* window_name,ImGuiID node_id)
4607
{
4608
    return ImGui::DockBuilderDockWindow(window_name,node_id);
4609
}
4610
CIMGUI_API ImGuiDockNode* igDockBuilderGetNode(ImGuiID node_id)
4611
{
4612
    return ImGui::DockBuilderGetNode(node_id);
4613
}
4614
CIMGUI_API ImGuiDockNode* igDockBuilderGetCentralNode(ImGuiID node_id)
4615
{
4616
    return ImGui::DockBuilderGetCentralNode(node_id);
4617
}
4618
CIMGUI_API ImGuiID igDockBuilderAddNode(ImGuiID node_id,ImGuiDockNodeFlags flags)
4619
{
4620
    return ImGui::DockBuilderAddNode(node_id,flags);
4621
}
4622
CIMGUI_API void igDockBuilderRemoveNode(ImGuiID node_id)
4623
{
4624
    return ImGui::DockBuilderRemoveNode(node_id);
4625
}
4626
CIMGUI_API void igDockBuilderRemoveNodeDockedWindows(ImGuiID node_id,bool clear_settings_refs)
4627
{
4628
    return ImGui::DockBuilderRemoveNodeDockedWindows(node_id,clear_settings_refs);
4629
}
4630
CIMGUI_API void igDockBuilderRemoveNodeChildNodes(ImGuiID node_id)
4631
{
4632
    return ImGui::DockBuilderRemoveNodeChildNodes(node_id);
4633
}
4634
CIMGUI_API void igDockBuilderSetNodePos(ImGuiID node_id,ImVec2 pos)
4635
{
4636
    return ImGui::DockBuilderSetNodePos(node_id,pos);
4637
}
4638
CIMGUI_API void igDockBuilderSetNodeSize(ImGuiID node_id,ImVec2 size)
4639
{
4640
    return ImGui::DockBuilderSetNodeSize(node_id,size);
4641
}
4642
CIMGUI_API ImGuiID igDockBuilderSplitNode(ImGuiID node_id,ImGuiDir split_dir,float size_ratio_for_node_at_dir,ImGuiID* out_id_at_dir,ImGuiID* out_id_at_opposite_dir)
4643
{
4644
    return ImGui::DockBuilderSplitNode(node_id,split_dir,size_ratio_for_node_at_dir,out_id_at_dir,out_id_at_opposite_dir);
4645
}
4646
CIMGUI_API void igDockBuilderCopyDockSpace(ImGuiID src_dockspace_id,ImGuiID dst_dockspace_id,ImVector_const_charPtr* in_window_remap_pairs)
4647
{
4648
    return ImGui::DockBuilderCopyDockSpace(src_dockspace_id,dst_dockspace_id,in_window_remap_pairs);
4649
}
4650
CIMGUI_API void igDockBuilderCopyNode(ImGuiID src_node_id,ImGuiID dst_node_id,ImVector_ImGuiID* out_node_remap_pairs)
4651
{
4652
    return ImGui::DockBuilderCopyNode(src_node_id,dst_node_id,out_node_remap_pairs);
4653
}
4654
CIMGUI_API void igDockBuilderCopyWindowSettings(const char* src_name,const char* dst_name)
4655
{
4656
    return ImGui::DockBuilderCopyWindowSettings(src_name,dst_name);
4657
}
4658
CIMGUI_API void igDockBuilderFinish(ImGuiID node_id)
4659
{
4660
    return ImGui::DockBuilderFinish(node_id);
4661
}
4662
CIMGUI_API void igPushFocusScope(ImGuiID id)
4663
{
4664
    return ImGui::PushFocusScope(id);
4665
}
4666
CIMGUI_API void igPopFocusScope()
4667
{
4668
    return ImGui::PopFocusScope();
4669
}
4670
CIMGUI_API ImGuiID igGetCurrentFocusScope()
4671
{
4672
    return ImGui::GetCurrentFocusScope();
4673
}
4674
CIMGUI_API bool igIsDragDropActive()
4675
{
4676
    return ImGui::IsDragDropActive();
4677
}
4678
CIMGUI_API bool igBeginDragDropTargetCustom(const ImRect bb,ImGuiID id)
4679
{
4680
    return ImGui::BeginDragDropTargetCustom(bb,id);
4681
}
4682
CIMGUI_API void igClearDragDrop()
4683
{
4684
    return ImGui::ClearDragDrop();
4685
}
4686
CIMGUI_API bool igIsDragDropPayloadBeingAccepted()
4687
{
4688
    return ImGui::IsDragDropPayloadBeingAccepted();
4689
}
4690
CIMGUI_API void igRenderDragDropTargetRect(const ImRect bb)
4691
{
4692
    return ImGui::RenderDragDropTargetRect(bb);
4693
}
4694
CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,const ImRect clip_rect)
4695
{
4696
    return ImGui::SetWindowClipRectBeforeSetChannel(window,clip_rect);
4697
}
4698
CIMGUI_API void igBeginColumns(const char* str_id,int count,ImGuiOldColumnFlags flags)
4699
{
4700
    return ImGui::BeginColumns(str_id,count,flags);
4701
}
4702
CIMGUI_API void igEndColumns()
4703
{
4704
    return ImGui::EndColumns();
4705
}
4706
CIMGUI_API void igPushColumnClipRect(int column_index)
4707
{
4708
    return ImGui::PushColumnClipRect(column_index);
4709
}
4710
CIMGUI_API void igPushColumnsBackground()
4711
{
4712
    return ImGui::PushColumnsBackground();
4713
}
4714
CIMGUI_API void igPopColumnsBackground()
4715
{
4716
    return ImGui::PopColumnsBackground();
4717
}
4718
CIMGUI_API ImGuiID igGetColumnsID(const char* str_id,int count)
4719
{
4720
    return ImGui::GetColumnsID(str_id,count);
4721
}
4722
CIMGUI_API ImGuiOldColumns* igFindOrCreateColumns(ImGuiWindow* window,ImGuiID id)
4723
{
4724
    return ImGui::FindOrCreateColumns(window,id);
4725
}
4726
CIMGUI_API float igGetColumnOffsetFromNorm(const ImGuiOldColumns* columns,float offset_norm)
4727
{
4728
    return ImGui::GetColumnOffsetFromNorm(columns,offset_norm);
4729
}
4730
CIMGUI_API float igGetColumnNormFromOffset(const ImGuiOldColumns* columns,float offset)
4731
{
4732
    return ImGui::GetColumnNormFromOffset(columns,offset);
4733
}
4734
CIMGUI_API void igTableOpenContextMenu(int column_n)
4735
{
4736
    return ImGui::TableOpenContextMenu(column_n);
4737
}
4738
CIMGUI_API void igTableSetColumnWidth(int column_n,float width)
4739
{
4740
    return ImGui::TableSetColumnWidth(column_n,width);
4741
}
4742
CIMGUI_API void igTableSetColumnSortDirection(int column_n,ImGuiSortDirection sort_direction,bool append_to_sort_specs)
4743
{
4744
    return ImGui::TableSetColumnSortDirection(column_n,sort_direction,append_to_sort_specs);
4745
}
4746
CIMGUI_API int igTableGetHoveredColumn()
4747
{
4748
    return ImGui::TableGetHoveredColumn();
4749
}
4750
CIMGUI_API int igTableGetHoveredRow()
4751
{
4752
    return ImGui::TableGetHoveredRow();
4753
}
4754
CIMGUI_API float igTableGetHeaderRowHeight()
4755
{
4756
    return ImGui::TableGetHeaderRowHeight();
4757
}
4758
CIMGUI_API void igTablePushBackgroundChannel()
4759
{
4760
    return ImGui::TablePushBackgroundChannel();
4761
}
4762
CIMGUI_API void igTablePopBackgroundChannel()
4763
{
4764
    return ImGui::TablePopBackgroundChannel();
4765
}
4766
CIMGUI_API ImGuiTable* igGetCurrentTable()
4767
{
4768
    return ImGui::GetCurrentTable();
4769
}
4770
CIMGUI_API ImGuiTable* igTableFindByID(ImGuiID id)
4771
{
4772
    return ImGui::TableFindByID(id);
4773
}
4774
CIMGUI_API bool igBeginTableEx(const char* name,ImGuiID id,int columns_count,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width)
4775
{
4776
    return ImGui::BeginTableEx(name,id,columns_count,flags,outer_size,inner_width);
4777
}
4778
CIMGUI_API void igTableBeginInitMemory(ImGuiTable* table,int columns_count)
4779
{
4780
    return ImGui::TableBeginInitMemory(table,columns_count);
4781
}
4782
CIMGUI_API void igTableBeginApplyRequests(ImGuiTable* table)
4783
{
4784
    return ImGui::TableBeginApplyRequests(table);
4785
}
4786
CIMGUI_API void igTableSetupDrawChannels(ImGuiTable* table)
4787
{
4788
    return ImGui::TableSetupDrawChannels(table);
4789
}
4790
CIMGUI_API void igTableUpdateLayout(ImGuiTable* table)
4791
{
4792
    return ImGui::TableUpdateLayout(table);
4793
}
4794
CIMGUI_API void igTableUpdateBorders(ImGuiTable* table)
4795
{
4796
    return ImGui::TableUpdateBorders(table);
4797
}
4798
CIMGUI_API void igTableUpdateColumnsWeightFromWidth(ImGuiTable* table)
4799
{
4800
    return ImGui::TableUpdateColumnsWeightFromWidth(table);
4801
}
4802
CIMGUI_API void igTableDrawBorders(ImGuiTable* table)
4803
{
4804
    return ImGui::TableDrawBorders(table);
4805
}
4806
CIMGUI_API void igTableDrawContextMenu(ImGuiTable* table)
4807
{
4808
    return ImGui::TableDrawContextMenu(table);
4809
}
4810
CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table)
4811
{
4812
    return ImGui::TableBeginContextMenuPopup(table);
4813
}
4814
CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table)
4815
{
4816
    return ImGui::TableMergeDrawChannels(table);
4817
}
4818
CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,int instance_no)
4819
{
4820
    return ImGui::TableGetInstanceData(table,instance_no);
4821
}
4822
CIMGUI_API ImGuiID igTableGetInstanceID(ImGuiTable* table,int instance_no)
4823
{
4824
    return ImGui::TableGetInstanceID(table,instance_no);
4825
}
4826
CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table)
4827
{
4828
    return ImGui::TableSortSpecsSanitize(table);
4829
}
4830
CIMGUI_API void igTableSortSpecsBuild(ImGuiTable* table)
4831
{
4832
    return ImGui::TableSortSpecsBuild(table);
4833
}
4834
CIMGUI_API ImGuiSortDirection igTableGetColumnNextSortDirection(ImGuiTableColumn* column)
4835
{
4836
    return ImGui::TableGetColumnNextSortDirection(column);
4837
}
4838
CIMGUI_API void igTableFixColumnSortDirection(ImGuiTable* table,ImGuiTableColumn* column)
4839
{
4840
    return ImGui::TableFixColumnSortDirection(table,column);
4841
}
4842
CIMGUI_API float igTableGetColumnWidthAuto(ImGuiTable* table,ImGuiTableColumn* column)
4843
{
4844
    return ImGui::TableGetColumnWidthAuto(table,column);
4845
}
4846
CIMGUI_API void igTableBeginRow(ImGuiTable* table)
4847
{
4848
    return ImGui::TableBeginRow(table);
4849
}
4850
CIMGUI_API void igTableEndRow(ImGuiTable* table)
4851
{
4852
    return ImGui::TableEndRow(table);
4853
}
4854
CIMGUI_API void igTableBeginCell(ImGuiTable* table,int column_n)
4855
{
4856
    return ImGui::TableBeginCell(table,column_n);
4857
}
4858
CIMGUI_API void igTableEndCell(ImGuiTable* table)
4859
{
4860
    return ImGui::TableEndCell(table);
4861
}
4862
CIMGUI_API void igTableGetCellBgRect(ImRect *pOut,const ImGuiTable* table,int column_n)
4863
{
4864
    *pOut = ImGui::TableGetCellBgRect(table,column_n);
4865
}
4866
CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,int column_n)
4867
{
4868
    return ImGui::TableGetColumnName(table,column_n);
4869
}
4870
CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,int column_n,int instance_no)
4871
{
4872
    return ImGui::TableGetColumnResizeID(table,column_n,instance_no);
4873
}
4874
CIMGUI_API float igTableGetMaxColumnWidth(const ImGuiTable* table,int column_n)
4875
{
4876
    return ImGui::TableGetMaxColumnWidth(table,column_n);
4877
}
4878
CIMGUI_API void igTableSetColumnWidthAutoSingle(ImGuiTable* table,int column_n)
4879
{
4880
    return ImGui::TableSetColumnWidthAutoSingle(table,column_n);
4881
}
4882
CIMGUI_API void igTableSetColumnWidthAutoAll(ImGuiTable* table)
4883
{
4884
    return ImGui::TableSetColumnWidthAutoAll(table);
4885
}
4886
CIMGUI_API void igTableRemove(ImGuiTable* table)
4887
{
4888
    return ImGui::TableRemove(table);
4889
}
4890
CIMGUI_API void igTableGcCompactTransientBuffers_TablePtr(ImGuiTable* table)
4891
{
4892
    return ImGui::TableGcCompactTransientBuffers(table);
4893
}
4894
CIMGUI_API void igTableGcCompactTransientBuffers_TableTempDataPtr(ImGuiTableTempData* table)
4895
{
4896
    return ImGui::TableGcCompactTransientBuffers(table);
4897
}
4898
CIMGUI_API void igTableGcCompactSettings()
4899
{
4900
    return ImGui::TableGcCompactSettings();
4901
}
4902
CIMGUI_API void igTableLoadSettings(ImGuiTable* table)
4903
{
4904
    return ImGui::TableLoadSettings(table);
4905
}
4906
CIMGUI_API void igTableSaveSettings(ImGuiTable* table)
4907
{
4908
    return ImGui::TableSaveSettings(table);
4909
}
4910
CIMGUI_API void igTableResetSettings(ImGuiTable* table)
4911
{
4912
    return ImGui::TableResetSettings(table);
4913
}
4914
CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table)
4915
{
4916
    return ImGui::TableGetBoundSettings(table);
4917
}
4918
CIMGUI_API void igTableSettingsAddSettingsHandler()
4919
{
4920
    return ImGui::TableSettingsAddSettingsHandler();
4921
}
4922
CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,int columns_count)
4923
{
4924
    return ImGui::TableSettingsCreate(id,columns_count);
4925
}
4926
CIMGUI_API ImGuiTableSettings* igTableSettingsFindByID(ImGuiID id)
4927
{
4928
    return ImGui::TableSettingsFindByID(id);
4929
}
4930
CIMGUI_API ImGuiTabBar* igGetCurrentTabBar()
4931
{
4932
    return ImGui::GetCurrentTabBar();
4933
}
4934
CIMGUI_API bool igBeginTabBarEx(ImGuiTabBar* tab_bar,const ImRect bb,ImGuiTabBarFlags flags,ImGuiDockNode* dock_node)
4935
{
4936
    return ImGui::BeginTabBarEx(tab_bar,bb,flags,dock_node);
4937
}
4938
CIMGUI_API ImGuiTabItem* igTabBarFindTabByID(ImGuiTabBar* tab_bar,ImGuiID tab_id)
4939
{
4940
    return ImGui::TabBarFindTabByID(tab_bar,tab_id);
4941
}
4942
CIMGUI_API ImGuiTabItem* igTabBarFindTabByOrder(ImGuiTabBar* tab_bar,int order)
4943
{
4944
    return ImGui::TabBarFindTabByOrder(tab_bar,order);
4945
}
4946
CIMGUI_API ImGuiTabItem* igTabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar)
4947
{
4948
    return ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar);
4949
}
4950
CIMGUI_API ImGuiTabItem* igTabBarGetCurrentTab(ImGuiTabBar* tab_bar)
4951
{
4952
    return ImGui::TabBarGetCurrentTab(tab_bar);
4953
}
4954
CIMGUI_API int igTabBarGetTabOrder(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)
4955
{
4956
    return ImGui::TabBarGetTabOrder(tab_bar,tab);
4957
}
4958
CIMGUI_API const char* igTabBarGetTabName(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)
4959
{
4960
    return ImGui::TabBarGetTabName(tab_bar,tab);
4961
}
4962
CIMGUI_API void igTabBarAddTab(ImGuiTabBar* tab_bar,ImGuiTabItemFlags tab_flags,ImGuiWindow* window)
4963
{
4964
    return ImGui::TabBarAddTab(tab_bar,tab_flags,window);
4965
}
4966
CIMGUI_API void igTabBarRemoveTab(ImGuiTabBar* tab_bar,ImGuiID tab_id)
4967
{
4968
    return ImGui::TabBarRemoveTab(tab_bar,tab_id);
4969
}
4970
CIMGUI_API void igTabBarCloseTab(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)
4971
{
4972
    return ImGui::TabBarCloseTab(tab_bar,tab);
4973
}
4974
CIMGUI_API void igTabBarQueueFocus(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)
4975
{
4976
    return ImGui::TabBarQueueFocus(tab_bar,tab);
4977
}
4978
CIMGUI_API void igTabBarQueueReorder(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,int offset)
4979
{
4980
    return ImGui::TabBarQueueReorder(tab_bar,tab,offset);
4981
}
4982
CIMGUI_API void igTabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,ImVec2 mouse_pos)
4983
{
4984
    return ImGui::TabBarQueueReorderFromMousePos(tab_bar,tab,mouse_pos);
4985
}
4986
CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar)
4987
{
4988
    return ImGui::TabBarProcessReorder(tab_bar);
4989
}
4990
CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags,ImGuiWindow* docked_window)
4991
{
4992
    return ImGui::TabItemEx(tab_bar,label,p_open,flags,docked_window);
4993
}
4994
CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker)
4995
{
4996
    *pOut = ImGui::TabItemCalcSize(label,has_close_button_or_unsaved_marker);
4997
}
4998
CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2 *pOut,ImGuiWindow* window)
4999
{
5000
    *pOut = ImGui::TabItemCalcSize(window);
5001
}
5002
CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col)
5003
{
5004
    return ImGui::TabItemBackground(draw_list,bb,flags,col);
5005
}
5006
CIMGUI_API void igTabItemLabelAndCloseButton(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id,bool is_contents_visible,bool* out_just_closed,bool* out_text_clipped)
5007
{
5008
    return ImGui::TabItemLabelAndCloseButton(draw_list,bb,flags,frame_padding,label,tab_id,close_button_id,is_contents_visible,out_just_closed,out_text_clipped);
5009
}
5010
CIMGUI_API void igRenderText(ImVec2 pos,const char* text,const char* text_end,bool hide_text_after_hash)
5011
{
5012
    return ImGui::RenderText(pos,text,text_end,hide_text_after_hash);
5013
}
5014
CIMGUI_API void igRenderTextWrapped(ImVec2 pos,const char* text,const char* text_end,float wrap_width)
5015
{
5016
    return ImGui::RenderTextWrapped(pos,text,text_end,wrap_width);
5017
}
5018
CIMGUI_API void igRenderTextClipped(const ImVec2 pos_min,const ImVec2 pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2 align,const ImRect* clip_rect)
5019
{
5020
    return ImGui::RenderTextClipped(pos_min,pos_max,text,text_end,text_size_if_known,align,clip_rect);
5021
}
5022
CIMGUI_API void igRenderTextClippedEx(ImDrawList* draw_list,const ImVec2 pos_min,const ImVec2 pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2 align,const ImRect* clip_rect)
5023
{
5024
    return ImGui::RenderTextClippedEx(draw_list,pos_min,pos_max,text,text_end,text_size_if_known,align,clip_rect);
5025
}
5026
CIMGUI_API void igRenderTextEllipsis(ImDrawList* draw_list,const ImVec2 pos_min,const ImVec2 pos_max,float clip_max_x,float ellipsis_max_x,const char* text,const char* text_end,const ImVec2* text_size_if_known)
5027
{
5028
    return ImGui::RenderTextEllipsis(draw_list,pos_min,pos_max,clip_max_x,ellipsis_max_x,text,text_end,text_size_if_known);
5029
}
5030
CIMGUI_API void igRenderFrame(ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,bool border,float rounding)
5031
{
5032
    return ImGui::RenderFrame(p_min,p_max,fill_col,border,rounding);
5033
}
5034
CIMGUI_API void igRenderFrameBorder(ImVec2 p_min,ImVec2 p_max,float rounding)
5035
{
5036
    return ImGui::RenderFrameBorder(p_min,p_max,rounding);
5037
}
5038
CIMGUI_API void igRenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list,ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,float grid_step,ImVec2 grid_off,float rounding,ImDrawFlags flags)
5039
{
5040
    return ImGui::RenderColorRectWithAlphaCheckerboard(draw_list,p_min,p_max,fill_col,grid_step,grid_off,rounding,flags);
5041
}
5042
CIMGUI_API void igRenderNavHighlight(const ImRect bb,ImGuiID id,ImGuiNavHighlightFlags flags)
5043
{
5044
    return ImGui::RenderNavHighlight(bb,id,flags);
5045
}
5046
CIMGUI_API const char* igFindRenderedTextEnd(const char* text,const char* text_end)
5047
{
5048
    return ImGui::FindRenderedTextEnd(text,text_end);
5049
}
5050
CIMGUI_API void igRenderMouseCursor(ImVec2 pos,float scale,ImGuiMouseCursor mouse_cursor,ImU32 col_fill,ImU32 col_border,ImU32 col_shadow)
5051
{
5052
    return ImGui::RenderMouseCursor(pos,scale,mouse_cursor,col_fill,col_border,col_shadow);
5053
}
5054
CIMGUI_API void igRenderArrow(ImDrawList* draw_list,ImVec2 pos,ImU32 col,ImGuiDir dir,float scale)
5055
{
5056
    return ImGui::RenderArrow(draw_list,pos,col,dir,scale);
5057
}
5058
CIMGUI_API void igRenderBullet(ImDrawList* draw_list,ImVec2 pos,ImU32 col)
5059
{
5060
    return ImGui::RenderBullet(draw_list,pos,col);
5061
}
5062
CIMGUI_API void igRenderCheckMark(ImDrawList* draw_list,ImVec2 pos,ImU32 col,float sz)
5063
{
5064
    return ImGui::RenderCheckMark(draw_list,pos,col,sz);
5065
}
5066
CIMGUI_API void igRenderArrowPointingAt(ImDrawList* draw_list,ImVec2 pos,ImVec2 half_sz,ImGuiDir direction,ImU32 col)
5067
{
5068
    return ImGui::RenderArrowPointingAt(draw_list,pos,half_sz,direction,col);
5069
}
5070
CIMGUI_API void igRenderArrowDockMenu(ImDrawList* draw_list,ImVec2 p_min,float sz,ImU32 col)
5071
{
5072
    return ImGui::RenderArrowDockMenu(draw_list,p_min,sz,col);
5073
}
5074
CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,const ImRect rect,ImU32 col,float x_start_norm,float x_end_norm,float rounding)
5075
{
5076
    return ImGui::RenderRectFilledRangeH(draw_list,rect,col,x_start_norm,x_end_norm,rounding);
5077
}
5078
CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,const ImRect outer,const ImRect inner,ImU32 col,float rounding)
5079
{
5080
    return ImGui::RenderRectFilledWithHole(draw_list,outer,inner,col,rounding);
5081
}
5082
CIMGUI_API ImDrawFlags igCalcRoundingFlagsForRectInRect(const ImRect r_in,const ImRect r_outer,float threshold)
5083
{
5084
    return ImGui::CalcRoundingFlagsForRectInRect(r_in,r_outer,threshold);
5085
}
5086
CIMGUI_API void igTextEx(const char* text,const char* text_end,ImGuiTextFlags flags)
5087
{
5088
    return ImGui::TextEx(text,text_end,flags);
5089
}
5090
CIMGUI_API bool igButtonEx(const char* label,const ImVec2 size_arg,ImGuiButtonFlags flags)
5091
{
5092
    return ImGui::ButtonEx(label,size_arg,flags);
5093
}
5094
CIMGUI_API bool igArrowButtonEx(const char* str_id,ImGuiDir dir,ImVec2 size_arg,ImGuiButtonFlags flags)
5095
{
5096
    return ImGui::ArrowButtonEx(str_id,dir,size_arg,flags);
5097
}
5098
CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags)
5099
{
5100
    return ImGui::ImageButtonEx(id,texture_id,size,uv0,uv1,bg_col,tint_col,flags);
5101
}
5102
CIMGUI_API void igSeparatorEx(ImGuiSeparatorFlags flags,float thickness)
5103
{
5104
    return ImGui::SeparatorEx(flags,thickness);
5105
}
5106
CIMGUI_API void igSeparatorTextEx(ImGuiID id,const char* label,const char* label_end,float extra_width)
5107
{
5108
    return ImGui::SeparatorTextEx(id,label,label_end,extra_width);
5109
}
5110
CIMGUI_API bool igCheckboxFlags_S64Ptr(const char* label,ImS64* flags,ImS64 flags_value)
5111
{
5112
    return ImGui::CheckboxFlags(label,flags,flags_value);
5113
}
5114
CIMGUI_API bool igCheckboxFlags_U64Ptr(const char* label,ImU64* flags,ImU64 flags_value)
5115
{
5116
    return ImGui::CheckboxFlags(label,flags,flags_value);
5117
}
5118
CIMGUI_API bool igCloseButton(ImGuiID id,const ImVec2 pos)
5119
{
5120
    return ImGui::CloseButton(id,pos);
5121
}
5122
CIMGUI_API bool igCollapseButton(ImGuiID id,const ImVec2 pos,ImGuiDockNode* dock_node)
5123
{
5124
    return ImGui::CollapseButton(id,pos,dock_node);
5125
}
5126
CIMGUI_API void igScrollbar(ImGuiAxis axis)
5127
{
5128
    return ImGui::Scrollbar(axis);
5129
}
5130
CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags flags)
5131
{
5132
    return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,flags);
5133
}
5134
CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis)
5135
{
5136
    *pOut = ImGui::GetWindowScrollbarRect(window,axis);
5137
}
5138
CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window,ImGuiAxis axis)
5139
{
5140
    return ImGui::GetWindowScrollbarID(window,axis);
5141
}
5142
CIMGUI_API ImGuiID igGetWindowResizeCornerID(ImGuiWindow* window,int n)
5143
{
5144
    return ImGui::GetWindowResizeCornerID(window,n);
5145
}
5146
CIMGUI_API ImGuiID igGetWindowResizeBorderID(ImGuiWindow* window,ImGuiDir dir)
5147
{
5148
    return ImGui::GetWindowResizeBorderID(window,dir);
5149
}
5150
CIMGUI_API bool igButtonBehavior(const ImRect bb,ImGuiID id,bool* out_hovered,bool* out_held,ImGuiButtonFlags flags)
5151
{
5152
    return ImGui::ButtonBehavior(bb,id,out_hovered,out_held,flags);
5153
}
5154
CIMGUI_API bool igDragBehavior(ImGuiID id,ImGuiDataType data_type,void* p_v,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
5155
{
5156
    return ImGui::DragBehavior(id,data_type,p_v,v_speed,p_min,p_max,format,flags);
5157
}
5158
CIMGUI_API bool igSliderBehavior(const ImRect bb,ImGuiID id,ImGuiDataType data_type,void* p_v,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags,ImRect* out_grab_bb)
5159
{
5160
    return ImGui::SliderBehavior(bb,id,data_type,p_v,p_min,p_max,format,flags,out_grab_bb);
5161
}
5162
CIMGUI_API bool igSplitterBehavior(const ImRect bb,ImGuiID id,ImGuiAxis axis,float* size1,float* size2,float min_size1,float min_size2,float hover_extend,float hover_visibility_delay,ImU32 bg_col)
5163
{
5164
    return ImGui::SplitterBehavior(bb,id,axis,size1,size2,min_size1,min_size2,hover_extend,hover_visibility_delay,bg_col);
5165
}
5166
CIMGUI_API bool igTreeNodeBehavior(ImGuiID id,ImGuiTreeNodeFlags flags,const char* label,const char* label_end)
5167
{
5168
    return ImGui::TreeNodeBehavior(id,flags,label,label_end);
5169
}
5170
CIMGUI_API void igTreePushOverrideID(ImGuiID id)
5171
{
5172
    return ImGui::TreePushOverrideID(id);
5173
}
5174
CIMGUI_API void igTreeNodeSetOpen(ImGuiID id,bool open)
5175
{
5176
    return ImGui::TreeNodeSetOpen(id,open);
5177
}
5178
CIMGUI_API bool igTreeNodeUpdateNextOpen(ImGuiID id,ImGuiTreeNodeFlags flags)
5179
{
5180
    return ImGui::TreeNodeUpdateNextOpen(id,flags);
5181
}
5182
CIMGUI_API const ImGuiDataTypeInfo* igDataTypeGetInfo(ImGuiDataType data_type)
5183
{
5184
    return ImGui::DataTypeGetInfo(data_type);
5185
}
5186
CIMGUI_API int igDataTypeFormatString(char* buf,int buf_size,ImGuiDataType data_type,const void* p_data,const char* format)
5187
{
5188
    return ImGui::DataTypeFormatString(buf,buf_size,data_type,p_data,format);
5189
}
5190
CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,int op,void* output,const void* arg_1,const void* arg_2)
5191
{
5192
    return ImGui::DataTypeApplyOp(data_type,op,output,arg_1,arg_2);
5193
}
5194
CIMGUI_API bool igDataTypeApplyFromText(const char* buf,ImGuiDataType data_type,void* p_data,const char* format)
5195
{
5196
    return ImGui::DataTypeApplyFromText(buf,data_type,p_data,format);
5197
}
5198
CIMGUI_API int igDataTypeCompare(ImGuiDataType data_type,const void* arg_1,const void* arg_2)
5199
{
5200
    return ImGui::DataTypeCompare(data_type,arg_1,arg_2);
5201
}
5202
CIMGUI_API bool igDataTypeClamp(ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max)
5203
{
5204
    return ImGui::DataTypeClamp(data_type,p_data,p_min,p_max);
5205
}
5206
CIMGUI_API bool igInputTextEx(const char* label,const char* hint,char* buf,int buf_size,const ImVec2 size_arg,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
5207
{
5208
    return ImGui::InputTextEx(label,hint,buf,buf_size,size_arg,flags,callback,user_data);
5209
}
5210
CIMGUI_API void igInputTextDeactivateHook(ImGuiID id)
5211
{
5212
    return ImGui::InputTextDeactivateHook(id);
5213
}
5214
CIMGUI_API bool igTempInputText(const ImRect bb,ImGuiID id,const char* label,char* buf,int buf_size,ImGuiInputTextFlags flags)
5215
{
5216
    return ImGui::TempInputText(bb,id,label,buf,buf_size,flags);
5217
}
5218
CIMGUI_API bool igTempInputScalar(const ImRect bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format,const void* p_clamp_min,const void* p_clamp_max)
5219
{
5220
    return ImGui::TempInputScalar(bb,id,label,data_type,p_data,format,p_clamp_min,p_clamp_max);
5221
}
5222
CIMGUI_API bool igTempInputIsActive(ImGuiID id)
5223
{
5224
    return ImGui::TempInputIsActive(id);
5225
}
5226
CIMGUI_API ImGuiInputTextState* igGetInputTextState(ImGuiID id)
5227
{
5228
    return ImGui::GetInputTextState(id);
5229
}
5230
CIMGUI_API void igColorTooltip(const char* text,const float* col,ImGuiColorEditFlags flags)
5231
{
5232
    return ImGui::ColorTooltip(text,col,flags);
5233
}
5234
CIMGUI_API void igColorEditOptionsPopup(const float* col,ImGuiColorEditFlags flags)
5235
{
5236
    return ImGui::ColorEditOptionsPopup(col,flags);
5237
}
5238
CIMGUI_API void igColorPickerOptionsPopup(const float* ref_col,ImGuiColorEditFlags flags)
5239
{
5240
    return ImGui::ColorPickerOptionsPopup(ref_col,flags);
5241
}
5242
CIMGUI_API int igPlotEx(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,const ImVec2 size_arg)
5243
{
5244
    return ImGui::PlotEx(plot_type,label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,size_arg);
5245
}
5246
CIMGUI_API void igShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,ImVec2 gradient_p0,ImVec2 gradient_p1,ImU32 col0,ImU32 col1)
5247
{
5248
    return ImGui::ShadeVertsLinearColorGradientKeepAlpha(draw_list,vert_start_idx,vert_end_idx,gradient_p0,gradient_p1,col0,col1);
5249
}
5250
CIMGUI_API void igShadeVertsLinearUV(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,bool clamp)
5251
{
5252
    return ImGui::ShadeVertsLinearUV(draw_list,vert_start_idx,vert_end_idx,a,b,uv_a,uv_b,clamp);
5253
}
5254
CIMGUI_API void igGcCompactTransientMiscBuffers()
5255
{
5256
    return ImGui::GcCompactTransientMiscBuffers();
5257
}
5258
CIMGUI_API void igGcCompactTransientWindowBuffers(ImGuiWindow* window)
5259
{
5260
    return ImGui::GcCompactTransientWindowBuffers(window);
5261
}
5262
CIMGUI_API void igGcAwakeTransientWindowBuffers(ImGuiWindow* window)
5263
{
5264
    return ImGui::GcAwakeTransientWindowBuffers(window);
5265
}
5266
CIMGUI_API void igDebugLog(const char* fmt,...)
5267
{
5268
    va_list args;
5269
    va_start(args, fmt);
5270
    ImGui::DebugLogV(fmt,args);
5271
    va_end(args);
5272
}
5273
CIMGUI_API void igDebugLogV(const char* fmt,va_list args)
5274
{
5275
    return ImGui::DebugLogV(fmt,args);
5276
}
5277
CIMGUI_API void igErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback,void* user_data)
5278
{
5279
    return ImGui::ErrorCheckEndFrameRecover(log_callback,user_data);
5280
}
5281
CIMGUI_API void igErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback,void* user_data)
5282
{
5283
    return ImGui::ErrorCheckEndWindowRecover(log_callback,user_data);
5284
}
5285
CIMGUI_API void igErrorCheckUsingSetCursorPosToExtendParentBoundaries()
5286
{
5287
    return ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
5288
}
5289
CIMGUI_API void igDebugDrawCursorPos(ImU32 col)
5290
{
5291
    return ImGui::DebugDrawCursorPos(col);
5292
}
5293
CIMGUI_API void igDebugDrawLineExtents(ImU32 col)
5294
{
5295
    return ImGui::DebugDrawLineExtents(col);
5296
}
5297
CIMGUI_API void igDebugDrawItemRect(ImU32 col)
5298
{
5299
    return ImGui::DebugDrawItemRect(col);
5300
}
5301
CIMGUI_API void igDebugLocateItem(ImGuiID target_id)
5302
{
5303
    return ImGui::DebugLocateItem(target_id);
5304
}
5305
CIMGUI_API void igDebugLocateItemOnHover(ImGuiID target_id)
5306
{
5307
    return ImGui::DebugLocateItemOnHover(target_id);
5308
}
5309
CIMGUI_API void igDebugLocateItemResolveWithLastItem()
5310
{
5311
    return ImGui::DebugLocateItemResolveWithLastItem();
5312
}
5313
CIMGUI_API void igDebugStartItemPicker()
5314
{
5315
    return ImGui::DebugStartItemPicker();
5316
}
5317
CIMGUI_API void igShowFontAtlas(ImFontAtlas* atlas)
5318
{
5319
    return ImGui::ShowFontAtlas(atlas);
5320
}
5321
CIMGUI_API void igDebugHookIdInfo(ImGuiID id,ImGuiDataType data_type,const void* data_id,const void* data_id_end)
5322
{
5323
    return ImGui::DebugHookIdInfo(id,data_type,data_id,data_id_end);
5324
}
5325
CIMGUI_API void igDebugNodeColumns(ImGuiOldColumns* columns)
5326
{
5327
    return ImGui::DebugNodeColumns(columns);
5328
}
5329
CIMGUI_API void igDebugNodeDockNode(ImGuiDockNode* node,const char* label)
5330
{
5331
    return ImGui::DebugNodeDockNode(node,label);
5332
}
5333
CIMGUI_API void igDebugNodeDrawList(ImGuiWindow* window,ImGuiViewportP* viewport,const ImDrawList* draw_list,const char* label)
5334
{
5335
    return ImGui::DebugNodeDrawList(window,viewport,draw_list,label);
5336
}
5337
CIMGUI_API void igDebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawList* out_draw_list,const ImDrawList* draw_list,const ImDrawCmd* draw_cmd,bool show_mesh,bool show_aabb)
5338
{
5339
    return ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(out_draw_list,draw_list,draw_cmd,show_mesh,show_aabb);
5340
}
5341
CIMGUI_API void igDebugNodeFont(ImFont* font)
5342
{
5343
    return ImGui::DebugNodeFont(font);
5344
}
5345
CIMGUI_API void igDebugNodeFontGlyph(ImFont* font,const ImFontGlyph* glyph)
5346
{
5347
    return ImGui::DebugNodeFontGlyph(font,glyph);
5348
}
5349
CIMGUI_API void igDebugNodeStorage(ImGuiStorage* storage,const char* label)
5350
{
5351
    return ImGui::DebugNodeStorage(storage,label);
5352
}
5353
CIMGUI_API void igDebugNodeTabBar(ImGuiTabBar* tab_bar,const char* label)
5354
{
5355
    return ImGui::DebugNodeTabBar(tab_bar,label);
5356
}
5357
CIMGUI_API void igDebugNodeTable(ImGuiTable* table)
5358
{
5359
    return ImGui::DebugNodeTable(table);
5360
}
5361
CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings)
5362
{
5363
    return ImGui::DebugNodeTableSettings(settings);
5364
}
5365
CIMGUI_API void igDebugNodeInputTextState(ImGuiInputTextState* state)
5366
{
5367
    return ImGui::DebugNodeInputTextState(state);
5368
}
5369
CIMGUI_API void igDebugNodeWindow(ImGuiWindow* window,const char* label)
5370
{
5371
    return ImGui::DebugNodeWindow(window,label);
5372
}
5373
CIMGUI_API void igDebugNodeWindowSettings(ImGuiWindowSettings* settings)
5374
{
5375
    return ImGui::DebugNodeWindowSettings(settings);
5376
}
5377
CIMGUI_API void igDebugNodeWindowsList(ImVector_ImGuiWindowPtr* windows,const char* label)
5378
{
5379
    return ImGui::DebugNodeWindowsList(windows,label);
5380
}
5381
CIMGUI_API void igDebugNodeWindowsListByBeginStackParent(ImGuiWindow** windows,int windows_size,ImGuiWindow* parent_in_begin_stack)
5382
{
5383
    return ImGui::DebugNodeWindowsListByBeginStackParent(windows,windows_size,parent_in_begin_stack);
5384
}
5385
CIMGUI_API void igDebugNodeViewport(ImGuiViewportP* viewport)
5386
{
5387
    return ImGui::DebugNodeViewport(viewport);
5388
}
5389
CIMGUI_API void igDebugRenderKeyboardPreview(ImDrawList* draw_list)
5390
{
5391
    return ImGui::DebugRenderKeyboardPreview(draw_list);
5392
}
5393
CIMGUI_API void igDebugRenderViewportThumbnail(ImDrawList* draw_list,ImGuiViewportP* viewport,const ImRect bb)
5394
{
5395
    return ImGui::DebugRenderViewportThumbnail(draw_list,viewport,bb);
5396
}
5397
CIMGUI_API bool igIsKeyPressedMap(ImGuiKey key,bool repeat)
5398
{
5399
    return ImGui::IsKeyPressedMap(key,repeat);
5400
}
5401
CIMGUI_API const ImFontBuilderIO* igImFontAtlasGetBuilderForStbTruetype()
5402
{
5403
    return ImFontAtlasGetBuilderForStbTruetype();
5404
}
5405
CIMGUI_API void igImFontAtlasBuildInit(ImFontAtlas* atlas)
5406
{
5407
    return ImFontAtlasBuildInit(atlas);
5408
}
5409
CIMGUI_API void igImFontAtlasBuildSetupFont(ImFontAtlas* atlas,ImFont* font,ImFontConfig* font_config,float ascent,float descent)
5410
{
5411
    return ImFontAtlasBuildSetupFont(atlas,font,font_config,ascent,descent);
5412
}
5413
CIMGUI_API void igImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas,void* stbrp_context_opaque)
5414
{
5415
    return ImFontAtlasBuildPackCustomRects(atlas,stbrp_context_opaque);
5416
}
5417
CIMGUI_API void igImFontAtlasBuildFinish(ImFontAtlas* atlas)
5418
{
5419
    return ImFontAtlasBuildFinish(atlas);
5420
}
5421
CIMGUI_API void igImFontAtlasBuildRender8bppRectFromString(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned char in_marker_pixel_value)
5422
{
5423
    return ImFontAtlasBuildRender8bppRectFromString(atlas,x,y,w,h,in_str,in_marker_char,in_marker_pixel_value);
5424
}
5425
CIMGUI_API void igImFontAtlasBuildRender32bppRectFromString(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned int in_marker_pixel_value)
5426
{
5427
    return ImFontAtlasBuildRender32bppRectFromString(atlas,x,y,w,h,in_str,in_marker_char,in_marker_pixel_value);
5428
}
5429
CIMGUI_API void igImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256],float in_multiply_factor)
5430
{
5431
    return ImFontAtlasBuildMultiplyCalcLookupTable(out_table,in_multiply_factor);
5432
}
5433
CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256],unsigned char* pixels,int x,int y,int w,int h,int stride)
5434
{
5435
    return ImFontAtlasBuildMultiplyRectAlpha8(table,pixels,x,y,w,h,stride);
5436
}
5437

5438

5439

5440
/////////////////////////////manual written functions
5441
CIMGUI_API void igLogText(CONST char *fmt, ...)
5442
{
5443
    char buffer[256];
5444
    va_list args;
5445
    va_start(args, fmt);
5446
    vsnprintf(buffer, 256, fmt, args);
5447
    va_end(args);
5448

5449
    ImGui::LogText("%s", buffer);
5450
}
5451
CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...)
5452
{
5453
    va_list args;
5454
    va_start(args, fmt);
5455
    buffer->appendfv(fmt, args);
5456
    va_end(args);
5457
}
5458

5459
CIMGUI_API float igGET_FLT_MAX()
5460
{
5461
    return FLT_MAX;
5462
}
5463

5464
CIMGUI_API float igGET_FLT_MIN()
5465
{
5466
    return FLT_MIN;
5467
}
5468

5469

5470
CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
5471
{
5472
	return IM_NEW(ImVector<ImWchar>) ();
5473
}
5474

5475
CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
5476
{
5477
    IM_DELETE(self);
5478
}
5479

5480
CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
5481
{
5482
	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
5483
}
5484
CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p)
5485
{
5486
	p->~ImVector<ImWchar>();
5487
}
5488

5489

5490
#ifdef IMGUI_HAS_DOCK
5491

5492
// NOTE: Some function pointers in the ImGuiPlatformIO structure are not C-compatible because of their
5493
// use of a complex return type. To work around this, we store a custom CimguiStorage object inside
5494
// ImGuiIO::BackendLanguageUserData, which contains C-compatible function pointer variants for these
5495
// functions. When a user function pointer is provided, we hook up the underlying ImGuiPlatformIO
5496
// function pointer to a thunk which accesses the user function pointer through CimguiStorage.
5497

5498
struct CimguiStorage
5499
{
5500
    void(*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos);
5501
    void(*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos);
5502
};
5503

5504
// Gets a reference to the CimguiStorage object stored in the current ImGui context's BackendLanguageUserData.
5505
CimguiStorage& GetCimguiStorage()
5506
{
5507
    ImGuiIO& io = ImGui::GetIO();
5508
    if (io.BackendLanguageUserData == NULL)
5509
    {
5510
        io.BackendLanguageUserData = new CimguiStorage();
5511
    }
5512

5513
    return *(CimguiStorage*)io.BackendLanguageUserData;
5514
}
5515

5516
// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos.
5517
ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp)
5518
{
5519
    ImVec2 pos;
5520
    GetCimguiStorage().Platform_GetWindowPos(vp, &pos);
5521
    return pos;
5522
};
5523

5524
// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowPos.
5525
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_pos))
5526
{
5527
    CimguiStorage& storage = GetCimguiStorage();
5528
    storage.Platform_GetWindowPos = user_callback;
5529
    platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook;
5530
}
5531

5532
// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize.
5533
ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp)
5534
{
5535
    ImVec2 size;
5536
    GetCimguiStorage().Platform_GetWindowSize(vp, &size);
5537
    return size;
5538
};
5539

5540
// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowSize.
5541
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_size))
5542
{
5543
    CimguiStorage& storage = GetCimguiStorage();
5544
    storage.Platform_GetWindowSize = user_callback;
5545
    platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook;
5546
}
5547

5548
#endif
5549