Applied-Software/ghostty
5
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2025-07-14 15:56:13 +03:00
Code Issues Packages Projects Releases Wiki Activity
ghostty/pkg/cimgui/vendor/cimgui.cpp
Mitchell Hashimoto a11c7ac785 update Dear Imgui to 1.90.6
2024-05-10 10:17:33 -07:00

5944 lines
233 KiB
C++
Vendored
Raw Blame History

// This file is automatically generated by generator.lua from
// https://github.com/cimgui/cimgui based on imgui.h file version "1.90.6" 19060
// from Dear ImGui https://github.com/ocornut/imgui with imgui_internal.h api
// docking branch
#define IMGUI_ENABLE_FREETYPE
#ifdef IMGUI_ENABLE_FREETYPE
#ifndef CIMGUI_FREETYPE
#error "IMGUI_FREETYPE should be defined for Freetype linking"
#endif
#else
#ifdef CIMGUI_FREETYPE
#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
#endif
#endif
#include "imgui.h"
#ifdef IMGUI_ENABLE_FREETYPE
#include "misc/freetype/imgui_freetype.h"
#endif
#include "imgui_internal.h"
#include "cimgui.h"
CIMGUI_API ImVec2* ImVec2_ImVec2_Nil(void) {
return IM_NEW(ImVec2)();
}
CIMGUI_API void ImVec2_destroy(ImVec2* self) {
IM_DELETE(self);
}
CIMGUI_API ImVec2* ImVec2_ImVec2_Float(float _x, float _y) {
return IM_NEW(ImVec2)(_x, _y);
}
CIMGUI_API ImVec4* ImVec4_ImVec4_Nil(void) {
return IM_NEW(ImVec4)();
}
CIMGUI_API void ImVec4_destroy(ImVec4* self) {
IM_DELETE(self);
}
CIMGUI_API ImVec4* ImVec4_ImVec4_Float(float _x, float _y, float _z, float _w) {
return IM_NEW(ImVec4)(_x, _y, _z, _w);
}
CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas) {
return ImGui::CreateContext(shared_font_atlas);
}
CIMGUI_API void igDestroyContext(ImGuiContext* ctx) {
return ImGui::DestroyContext(ctx);
}
CIMGUI_API ImGuiContext* igGetCurrentContext() {
return ImGui::GetCurrentContext();
}
CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx) {
return ImGui::SetCurrentContext(ctx);
}
CIMGUI_API ImGuiIO* igGetIO() {
return &ImGui::GetIO();
}
CIMGUI_API ImGuiStyle* igGetStyle() {
return &ImGui::GetStyle();
}
CIMGUI_API void igNewFrame() {
return ImGui::NewFrame();
}
CIMGUI_API void igEndFrame() {
return ImGui::EndFrame();
}
CIMGUI_API void igRender() {
return ImGui::Render();
}
CIMGUI_API ImDrawData* igGetDrawData() {
return ImGui::GetDrawData();
}
CIMGUI_API void igShowDemoWindow(bool* p_open) {
return ImGui::ShowDemoWindow(p_open);
}
CIMGUI_API void igShowMetricsWindow(bool* p_open) {
return ImGui::ShowMetricsWindow(p_open);
}
CIMGUI_API void igShowDebugLogWindow(bool* p_open) {
return ImGui::ShowDebugLogWindow(p_open);
}
CIMGUI_API void igShowIDStackToolWindow(bool* p_open) {
return ImGui::ShowIDStackToolWindow(p_open);
}
CIMGUI_API void igShowAboutWindow(bool* p_open) {
return ImGui::ShowAboutWindow(p_open);
}
CIMGUI_API void igShowStyleEditor(ImGuiStyle* ref) {
return ImGui::ShowStyleEditor(ref);
}
CIMGUI_API bool igShowStyleSelector(const char* label) {
return ImGui::ShowStyleSelector(label);
}
CIMGUI_API void igShowFontSelector(const char* label) {
return ImGui::ShowFontSelector(label);
}
CIMGUI_API void igShowUserGuide() {
return ImGui::ShowUserGuide();
}
CIMGUI_API const char* igGetVersion() {
return ImGui::GetVersion();
}
CIMGUI_API void igStyleColorsDark(ImGuiStyle* dst) {
return ImGui::StyleColorsDark(dst);
}
CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst) {
return ImGui::StyleColorsLight(dst);
}
CIMGUI_API void igStyleColorsClassic(ImGuiStyle* dst) {
return ImGui::StyleColorsClassic(dst);
}
CIMGUI_API bool igBegin(const char* name,
bool* p_open,
ImGuiWindowFlags flags) {
return ImGui::Begin(name, p_open, flags);
}
CIMGUI_API void igEnd() {
return ImGui::End();
}
CIMGUI_API bool igBeginChild_Str(const char* str_id,
const ImVec2 size,
ImGuiChildFlags child_flags,
ImGuiWindowFlags window_flags) {
return ImGui::BeginChild(str_id, size, child_flags, window_flags);
}
CIMGUI_API bool igBeginChild_ID(ImGuiID id,
const ImVec2 size,
ImGuiChildFlags child_flags,
ImGuiWindowFlags window_flags) {
return ImGui::BeginChild(id, size, child_flags, window_flags);
}
CIMGUI_API void igEndChild() {
return ImGui::EndChild();
}
CIMGUI_API bool igIsWindowAppearing() {
return ImGui::IsWindowAppearing();
}
CIMGUI_API bool igIsWindowCollapsed() {
return ImGui::IsWindowCollapsed();
}
CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags) {
return ImGui::IsWindowFocused(flags);
}
CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags) {
return ImGui::IsWindowHovered(flags);
}
CIMGUI_API ImDrawList* igGetWindowDrawList() {
return ImGui::GetWindowDrawList();
}
CIMGUI_API float igGetWindowDpiScale() {
return ImGui::GetWindowDpiScale();
}
CIMGUI_API void igGetWindowPos(ImVec2* pOut) {
*pOut = ImGui::GetWindowPos();
}
CIMGUI_API void igGetWindowSize(ImVec2* pOut) {
*pOut = ImGui::GetWindowSize();
}
CIMGUI_API float igGetWindowWidth() {
return ImGui::GetWindowWidth();
}
CIMGUI_API float igGetWindowHeight() {
return ImGui::GetWindowHeight();
}
CIMGUI_API ImGuiViewport* igGetWindowViewport() {
return ImGui::GetWindowViewport();
}
CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,
ImGuiCond cond,
const ImVec2 pivot) {
return ImGui::SetNextWindowPos(pos, cond, pivot);
}
CIMGUI_API void igSetNextWindowSize(const ImVec2 size, ImGuiCond cond) {
return ImGui::SetNextWindowSize(size, cond);
}
CIMGUI_API void igSetNextWindowSizeConstraints(
const ImVec2 size_min,
const ImVec2 size_max,
ImGuiSizeCallback custom_callback,
void* custom_callback_data) {
return ImGui::SetNextWindowSizeConstraints(
size_min, size_max, custom_callback, custom_callback_data);
}
CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size) {
return ImGui::SetNextWindowContentSize(size);
}
CIMGUI_API void igSetNextWindowCollapsed(bool collapsed, ImGuiCond cond) {
return ImGui::SetNextWindowCollapsed(collapsed, cond);
}
CIMGUI_API void igSetNextWindowFocus() {
return ImGui::SetNextWindowFocus();
}
CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll) {
return ImGui::SetNextWindowScroll(scroll);
}
CIMGUI_API void igSetNextWindowBgAlpha(float alpha) {
return ImGui::SetNextWindowBgAlpha(alpha);
}
CIMGUI_API void igSetNextWindowViewport(ImGuiID viewport_id) {
return ImGui::SetNextWindowViewport(viewport_id);
}
CIMGUI_API void igSetWindowPos_Vec2(const ImVec2 pos, ImGuiCond cond) {
return ImGui::SetWindowPos(pos, cond);
}
CIMGUI_API void igSetWindowSize_Vec2(const ImVec2 size, ImGuiCond cond) {
return ImGui::SetWindowSize(size, cond);
}
CIMGUI_API void igSetWindowCollapsed_Bool(bool collapsed, ImGuiCond cond) {
return ImGui::SetWindowCollapsed(collapsed, cond);
}
CIMGUI_API void igSetWindowFocus_Nil() {
return ImGui::SetWindowFocus();
}
CIMGUI_API void igSetWindowFontScale(float scale) {
return ImGui::SetWindowFontScale(scale);
}
CIMGUI_API void igSetWindowPos_Str(const char* name,
const ImVec2 pos,
ImGuiCond cond) {
return ImGui::SetWindowPos(name, pos, cond);
}
CIMGUI_API void igSetWindowSize_Str(const char* name,
const ImVec2 size,
ImGuiCond cond) {
return ImGui::SetWindowSize(name, size, cond);
}
CIMGUI_API void igSetWindowCollapsed_Str(const char* name,
bool collapsed,
ImGuiCond cond) {
return ImGui::SetWindowCollapsed(name, collapsed, cond);
}
CIMGUI_API void igSetWindowFocus_Str(const char* name) {
return ImGui::SetWindowFocus(name);
}
CIMGUI_API void igGetContentRegionAvail(ImVec2* pOut) {
*pOut = ImGui::GetContentRegionAvail();
}
CIMGUI_API void igGetContentRegionMax(ImVec2* pOut) {
*pOut = ImGui::GetContentRegionMax();
}
CIMGUI_API void igGetWindowContentRegionMin(ImVec2* pOut) {
*pOut = ImGui::GetWindowContentRegionMin();
}
CIMGUI_API void igGetWindowContentRegionMax(ImVec2* pOut) {
*pOut = ImGui::GetWindowContentRegionMax();
}
CIMGUI_API float igGetScrollX() {
return ImGui::GetScrollX();
}
CIMGUI_API float igGetScrollY() {
return ImGui::GetScrollY();
}
CIMGUI_API void igSetScrollX_Float(float scroll_x) {
return ImGui::SetScrollX(scroll_x);
}
CIMGUI_API void igSetScrollY_Float(float scroll_y) {
return ImGui::SetScrollY(scroll_y);
}
CIMGUI_API float igGetScrollMaxX() {
return ImGui::GetScrollMaxX();
}
CIMGUI_API float igGetScrollMaxY() {
return ImGui::GetScrollMaxY();
}
CIMGUI_API void igSetScrollHereX(float center_x_ratio) {
return ImGui::SetScrollHereX(center_x_ratio);
}
CIMGUI_API void igSetScrollHereY(float center_y_ratio) {
return ImGui::SetScrollHereY(center_y_ratio);
}
CIMGUI_API void igSetScrollFromPosX_Float(float local_x, float center_x_ratio) {
return ImGui::SetScrollFromPosX(local_x, center_x_ratio);
}
CIMGUI_API void igSetScrollFromPosY_Float(float local_y, float center_y_ratio) {
return ImGui::SetScrollFromPosY(local_y, center_y_ratio);
}
CIMGUI_API void igPushFont(ImFont* font) {
return ImGui::PushFont(font);
}
CIMGUI_API void igPopFont() {
return ImGui::PopFont();
}
CIMGUI_API void igPushStyleColor_U32(ImGuiCol idx, ImU32 col) {
return ImGui::PushStyleColor(idx, col);
}
CIMGUI_API void igPushStyleColor_Vec4(ImGuiCol idx, const ImVec4 col) {
return ImGui::PushStyleColor(idx, col);
}
CIMGUI_API void igPopStyleColor(int count) {
return ImGui::PopStyleColor(count);
}
CIMGUI_API void igPushStyleVar_Float(ImGuiStyleVar idx, float val) {
return ImGui::PushStyleVar(idx, val);
}
CIMGUI_API void igPushStyleVar_Vec2(ImGuiStyleVar idx, const ImVec2 val) {
return ImGui::PushStyleVar(idx, val);
}
CIMGUI_API void igPopStyleVar(int count) {
return ImGui::PopStyleVar(count);
}
CIMGUI_API void igPushTabStop(bool tab_stop) {
return ImGui::PushTabStop(tab_stop);
}
CIMGUI_API void igPopTabStop() {
return ImGui::PopTabStop();
}
CIMGUI_API void igPushButtonRepeat(bool repeat) {
return ImGui::PushButtonRepeat(repeat);
}
CIMGUI_API void igPopButtonRepeat() {
return ImGui::PopButtonRepeat();
}
CIMGUI_API void igPushItemWidth(float item_width) {
return ImGui::PushItemWidth(item_width);
}
CIMGUI_API void igPopItemWidth() {
return ImGui::PopItemWidth();
}
CIMGUI_API void igSetNextItemWidth(float item_width) {
return ImGui::SetNextItemWidth(item_width);
}
CIMGUI_API float igCalcItemWidth() {
return ImGui::CalcItemWidth();
}
CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x) {
return ImGui::PushTextWrapPos(wrap_local_pos_x);
}
CIMGUI_API void igPopTextWrapPos() {
return ImGui::PopTextWrapPos();
}
CIMGUI_API ImFont* igGetFont() {
return ImGui::GetFont();
}
CIMGUI_API float igGetFontSize() {
return ImGui::GetFontSize();
}
CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2* pOut) {
*pOut = ImGui::GetFontTexUvWhitePixel();
}
CIMGUI_API ImU32 igGetColorU32_Col(ImGuiCol idx, float alpha_mul) {
return ImGui::GetColorU32(idx, alpha_mul);
}
CIMGUI_API ImU32 igGetColorU32_Vec4(const ImVec4 col) {
return ImGui::GetColorU32(col);
}
CIMGUI_API ImU32 igGetColorU32_U32(ImU32 col, float alpha_mul) {
return ImGui::GetColorU32(col, alpha_mul);
}
CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx) {
return &ImGui::GetStyleColorVec4(idx);
}
CIMGUI_API void igGetCursorScreenPos(ImVec2* pOut) {
*pOut = ImGui::GetCursorScreenPos();
}
CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos) {
return ImGui::SetCursorScreenPos(pos);
}
CIMGUI_API void igGetCursorPos(ImVec2* pOut) {
*pOut = ImGui::GetCursorPos();
}
CIMGUI_API float igGetCursorPosX() {
return ImGui::GetCursorPosX();
}
CIMGUI_API float igGetCursorPosY() {
return ImGui::GetCursorPosY();
}
CIMGUI_API void igSetCursorPos(const ImVec2 local_pos) {
return ImGui::SetCursorPos(local_pos);
}
CIMGUI_API void igSetCursorPosX(float local_x) {
return ImGui::SetCursorPosX(local_x);
}
CIMGUI_API void igSetCursorPosY(float local_y) {
return ImGui::SetCursorPosY(local_y);
}
CIMGUI_API void igGetCursorStartPos(ImVec2* pOut) {
*pOut = ImGui::GetCursorStartPos();
}
CIMGUI_API void igSeparator() {
return ImGui::Separator();
}
CIMGUI_API void igSameLine(float offset_from_start_x, float spacing) {
return ImGui::SameLine(offset_from_start_x, spacing);
}
CIMGUI_API void igNewLine() {
return ImGui::NewLine();
}
CIMGUI_API void igSpacing() {
return ImGui::Spacing();
}
CIMGUI_API void igDummy(const ImVec2 size) {
return ImGui::Dummy(size);
}
CIMGUI_API void igIndent(float indent_w) {
return ImGui::Indent(indent_w);
}
CIMGUI_API void igUnindent(float indent_w) {
return ImGui::Unindent(indent_w);
}
CIMGUI_API void igBeginGroup() {
return ImGui::BeginGroup();
}
CIMGUI_API void igEndGroup() {
return ImGui::EndGroup();
}
CIMGUI_API void igAlignTextToFramePadding() {
return ImGui::AlignTextToFramePadding();
}
CIMGUI_API float igGetTextLineHeight() {
return ImGui::GetTextLineHeight();
}
CIMGUI_API float igGetTextLineHeightWithSpacing() {
return ImGui::GetTextLineHeightWithSpacing();
}
CIMGUI_API float igGetFrameHeight() {
return ImGui::GetFrameHeight();
}
CIMGUI_API float igGetFrameHeightWithSpacing() {
return ImGui::GetFrameHeightWithSpacing();
}
CIMGUI_API void igPushID_Str(const char* str_id) {
return ImGui::PushID(str_id);
}
CIMGUI_API void igPushID_StrStr(const char* str_id_begin,
const char* str_id_end) {
return ImGui::PushID(str_id_begin, str_id_end);
}
CIMGUI_API void igPushID_Ptr(const void* ptr_id) {
return ImGui::PushID(ptr_id);
}
CIMGUI_API void igPushID_Int(int int_id) {
return ImGui::PushID(int_id);
}
CIMGUI_API void igPopID() {
return ImGui::PopID();
}
CIMGUI_API ImGuiID igGetID_Str(const char* str_id) {
return ImGui::GetID(str_id);
}
CIMGUI_API ImGuiID igGetID_StrStr(const char* str_id_begin,
const char* str_id_end) {
return ImGui::GetID(str_id_begin, str_id_end);
}
CIMGUI_API ImGuiID igGetID_Ptr(const void* ptr_id) {
return ImGui::GetID(ptr_id);
}
CIMGUI_API void igTextUnformatted(const char* text, const char* text_end) {
return ImGui::TextUnformatted(text, text_end);
}
CIMGUI_API void igText(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::TextV(fmt, args);
va_end(args);
}
CIMGUI_API void igTextV(const char* fmt, va_list args) {
return ImGui::TextV(fmt, args);
}
CIMGUI_API void igTextColored(const ImVec4 col, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::TextColoredV(col, fmt, args);
va_end(args);
}
CIMGUI_API void igTextColoredV(const ImVec4 col,
const char* fmt,
va_list args) {
return ImGui::TextColoredV(col, fmt, args);
}
CIMGUI_API void igTextDisabled(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::TextDisabledV(fmt, args);
va_end(args);
}
CIMGUI_API void igTextDisabledV(const char* fmt, va_list args) {
return ImGui::TextDisabledV(fmt, args);
}
CIMGUI_API void igTextWrapped(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::TextWrappedV(fmt, args);
va_end(args);
}
CIMGUI_API void igTextWrappedV(const char* fmt, va_list args) {
return ImGui::TextWrappedV(fmt, args);
}
CIMGUI_API void igLabelText(const char* label, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::LabelTextV(label, fmt, args);
va_end(args);
}
CIMGUI_API void igLabelTextV(const char* label, const char* fmt, va_list args) {
return ImGui::LabelTextV(label, fmt, args);
}
CIMGUI_API void igBulletText(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::BulletTextV(fmt, args);
va_end(args);
}
CIMGUI_API void igBulletTextV(const char* fmt, va_list args) {
return ImGui::BulletTextV(fmt, args);
}
CIMGUI_API void igSeparatorText(const char* label) {
return ImGui::SeparatorText(label);
}
CIMGUI_API bool igButton(const char* label, const ImVec2 size) {
return ImGui::Button(label, size);
}
CIMGUI_API bool igSmallButton(const char* label) {
return ImGui::SmallButton(label);
}
CIMGUI_API bool igInvisibleButton(const char* str_id,
const ImVec2 size,
ImGuiButtonFlags flags) {
return ImGui::InvisibleButton(str_id, size, flags);
}
CIMGUI_API bool igArrowButton(const char* str_id, ImGuiDir dir) {
return ImGui::ArrowButton(str_id, dir);
}
CIMGUI_API bool igCheckbox(const char* label, bool* v) {
return ImGui::Checkbox(label, v);
}
CIMGUI_API bool igCheckboxFlags_IntPtr(const char* label,
int* flags,
int flags_value) {
return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igCheckboxFlags_UintPtr(const char* label,
unsigned int* flags,
unsigned int flags_value) {
return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igRadioButton_Bool(const char* label, bool active) {
return ImGui::RadioButton(label, active);
}
CIMGUI_API bool igRadioButton_IntPtr(const char* label, int* v, int v_button) {
return ImGui::RadioButton(label, v, v_button);
}
CIMGUI_API void igProgressBar(float fraction,
const ImVec2 size_arg,
const char* overlay) {
return ImGui::ProgressBar(fraction, size_arg, overlay);
}
CIMGUI_API void igBullet() {
return ImGui::Bullet();
}
CIMGUI_API void igImage(ImTextureID user_texture_id,
const ImVec2 image_size,
const ImVec2 uv0,
const ImVec2 uv1,
const ImVec4 tint_col,
const ImVec4 border_col) {
return ImGui::Image(user_texture_id, image_size, uv0, uv1, tint_col,
border_col);
}
CIMGUI_API bool igImageButton(const char* str_id,
ImTextureID user_texture_id,
const ImVec2 image_size,
const ImVec2 uv0,
const ImVec2 uv1,
const ImVec4 bg_col,
const ImVec4 tint_col) {
return ImGui::ImageButton(str_id, user_texture_id, image_size, uv0, uv1,
bg_col, tint_col);
}
CIMGUI_API bool igBeginCombo(const char* label,
const char* preview_value,
ImGuiComboFlags flags) {
return ImGui::BeginCombo(label, preview_value, flags);
}
CIMGUI_API void igEndCombo() {
return ImGui::EndCombo();
}
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) {
return ImGui::Combo(label, current_item, items, items_count,
popup_max_height_in_items);
}
CIMGUI_API bool igCombo_Str(const char* label,
int* current_item,
const char* items_separated_by_zeros,
int popup_max_height_in_items) {
return ImGui::Combo(label, current_item, items_separated_by_zeros,
popup_max_height_in_items);
}
CIMGUI_API bool igCombo_FnStrPtr(const char* label,
int* current_item,
const char* (*getter)(void* user_data,
int idx),
void* user_data,
int items_count,
int popup_max_height_in_items) {
return ImGui::Combo(label, current_item, getter, user_data, items_count,
popup_max_height_in_items);
}
CIMGUI_API bool igDragFloat(const char* label,
float* v,
float v_speed,
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragFloat(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloat2(const char* label,
float v[2],
float v_speed,
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragFloat2(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloat3(const char* label,
float v[3],
float v_speed,
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragFloat3(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloat4(const char* label,
float v[4],
float v_speed,
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragFloat4(label, v, v_speed, v_min, v_max, format, flags);
}
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) {
return ImGui::DragFloatRange2(label, v_current_min, v_current_max, v_speed,
v_min, v_max, format, format_max, flags);
}
CIMGUI_API bool igDragInt(const char* label,
int* v,
float v_speed,
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragInt(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragInt2(const char* label,
int v[2],
float v_speed,
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragInt3(const char* label,
int v[3],
float v_speed,
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragInt3(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragInt4(const char* label,
int v[4],
float v_speed,
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::DragInt4(label, v, v_speed, v_min, v_max, format, flags);
}
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) {
return ImGui::DragIntRange2(label, v_current_min, v_current_max, v_speed,
v_min, v_max, format, format_max, flags);
}
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) {
return ImGui::DragScalar(label, data_type, p_data, v_speed, p_min, p_max,
format, flags);
}
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) {
return ImGui::DragScalarN(label, data_type, p_data, components, v_speed,
p_min, p_max, format, flags);
}
CIMGUI_API bool igSliderFloat(const char* label,
float* v,
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderFloat(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderFloat2(const char* label,
float v[2],
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderFloat2(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderFloat3(const char* label,
float v[3],
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderFloat3(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderFloat4(const char* label,
float v[4],
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderFloat4(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderAngle(const char* label,
float* v_rad,
float v_degrees_min,
float v_degrees_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderAngle(label, v_rad, v_degrees_min, v_degrees_max, format,
flags);
}
CIMGUI_API bool igSliderInt(const char* label,
int* v,
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderInt(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderInt2(const char* label,
int v[2],
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderInt2(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderInt3(const char* label,
int v[3],
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderInt3(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderInt4(const char* label,
int v[4],
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::SliderInt4(label, v, v_min, v_max, format, flags);
}
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) {
return ImGui::SliderScalar(label, data_type, p_data, p_min, p_max, format,
flags);
}
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) {
return ImGui::SliderScalarN(label, data_type, p_data, components, p_min,
p_max, format, flags);
}
CIMGUI_API bool igVSliderFloat(const char* label,
const ImVec2 size,
float* v,
float v_min,
float v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::VSliderFloat(label, size, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igVSliderInt(const char* label,
const ImVec2 size,
int* v,
int v_min,
int v_max,
const char* format,
ImGuiSliderFlags flags) {
return ImGui::VSliderInt(label, size, v, v_min, v_max, format, flags);
}
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) {
return ImGui::VSliderScalar(label, size, data_type, p_data, p_min, p_max,
format, flags);
}
CIMGUI_API bool igInputText(const char* label,
char* buf,
size_t buf_size,
ImGuiInputTextFlags flags,
ImGuiInputTextCallback callback,
void* user_data) {
return ImGui::InputText(label, buf, buf_size, flags, callback, user_data);
}
CIMGUI_API bool igInputTextMultiline(const char* label,
char* buf,
size_t buf_size,
const ImVec2 size,
ImGuiInputTextFlags flags,
ImGuiInputTextCallback callback,
void* user_data) {
return ImGui::InputTextMultiline(label, buf, buf_size, size, flags, callback,
user_data);
}
CIMGUI_API bool igInputTextWithHint(const char* label,
const char* hint,
char* buf,
size_t buf_size,
ImGuiInputTextFlags flags,
ImGuiInputTextCallback callback,
void* user_data) {
return ImGui::InputTextWithHint(label, hint, buf, buf_size, flags, callback,
user_data);
}
CIMGUI_API bool igInputFloat(const char* label,
float* v,
float step,
float step_fast,
const char* format,
ImGuiInputTextFlags flags) {
return ImGui::InputFloat(label, v, step, step_fast, format, flags);
}
CIMGUI_API bool igInputFloat2(const char* label,
float v[2],
const char* format,
ImGuiInputTextFlags flags) {
return ImGui::InputFloat2(label, v, format, flags);
}
CIMGUI_API bool igInputFloat3(const char* label,
float v[3],
const char* format,
ImGuiInputTextFlags flags) {
return ImGui::InputFloat3(label, v, format, flags);
}
CIMGUI_API bool igInputFloat4(const char* label,
float v[4],
const char* format,
ImGuiInputTextFlags flags) {
return ImGui::InputFloat4(label, v, format, flags);
}
CIMGUI_API bool igInputInt(const char* label,
int* v,
int step,
int step_fast,
ImGuiInputTextFlags flags) {
return ImGui::InputInt(label, v, step, step_fast, flags);
}
CIMGUI_API bool igInputInt2(const char* label,
int v[2],
ImGuiInputTextFlags flags) {
return ImGui::InputInt2(label, v, flags);
}
CIMGUI_API bool igInputInt3(const char* label,
int v[3],
ImGuiInputTextFlags flags) {
return ImGui::InputInt3(label, v, flags);
}
CIMGUI_API bool igInputInt4(const char* label,
int v[4],
ImGuiInputTextFlags flags) {
return ImGui::InputInt4(label, v, flags);
}
CIMGUI_API bool igInputDouble(const char* label,
double* v,
double step,
double step_fast,
const char* format,
ImGuiInputTextFlags flags) {
return ImGui::InputDouble(label, v, step, step_fast, format, flags);
}
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) {
return ImGui::InputScalar(label, data_type, p_data, p_step, p_step_fast,
format, flags);
}
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) {
return ImGui::InputScalarN(label, data_type, p_data, components, p_step,
p_step_fast, format, flags);
}
CIMGUI_API bool igColorEdit3(const char* label,
float col[3],
ImGuiColorEditFlags flags) {
return ImGui::ColorEdit3(label, col, flags);
}
CIMGUI_API bool igColorEdit4(const char* label,
float col[4],
ImGuiColorEditFlags flags) {
return ImGui::ColorEdit4(label, col, flags);
}
CIMGUI_API bool igColorPicker3(const char* label,
float col[3],
ImGuiColorEditFlags flags) {
return ImGui::ColorPicker3(label, col, flags);
}
CIMGUI_API bool igColorPicker4(const char* label,
float col[4],
ImGuiColorEditFlags flags,
const float* ref_col) {
return ImGui::ColorPicker4(label, col, flags, ref_col);
}
CIMGUI_API bool igColorButton(const char* desc_id,
const ImVec4 col,
ImGuiColorEditFlags flags,
const ImVec2 size) {
return ImGui::ColorButton(desc_id, col, flags, size);
}
CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags) {
return ImGui::SetColorEditOptions(flags);
}
CIMGUI_API bool igTreeNode_Str(const char* label) {
return ImGui::TreeNode(label);
}
CIMGUI_API bool igTreeNode_StrStr(const char* str_id, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
bool ret = ImGui::TreeNodeV(str_id, fmt, args);
va_end(args);
return ret;
}
CIMGUI_API bool igTreeNode_Ptr(const void* ptr_id, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
bool ret = ImGui::TreeNodeV(ptr_id, fmt, args);
va_end(args);
return ret;
}
CIMGUI_API bool igTreeNodeV_Str(const char* str_id,
const char* fmt,
va_list args) {
return ImGui::TreeNodeV(str_id, fmt, args);
}
CIMGUI_API bool igTreeNodeV_Ptr(const void* ptr_id,
const char* fmt,
va_list args) {
return ImGui::TreeNodeV(ptr_id, fmt, args);
}
CIMGUI_API bool igTreeNodeEx_Str(const char* label, ImGuiTreeNodeFlags flags) {
return ImGui::TreeNodeEx(label, flags);
}
CIMGUI_API bool igTreeNodeEx_StrStr(const char* str_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
...) {
va_list args;
va_start(args, fmt);
bool ret = ImGui::TreeNodeExV(str_id, flags, fmt, args);
va_end(args);
return ret;
}
CIMGUI_API bool igTreeNodeEx_Ptr(const void* ptr_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
...) {
va_list args;
va_start(args, fmt);
bool ret = ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
va_end(args);
return ret;
}
CIMGUI_API bool igTreeNodeExV_Str(const char* str_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
va_list args) {
return ImGui::TreeNodeExV(str_id, flags, fmt, args);
}
CIMGUI_API bool igTreeNodeExV_Ptr(const void* ptr_id,
ImGuiTreeNodeFlags flags,
const char* fmt,
va_list args) {
return ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
}
CIMGUI_API void igTreePush_Str(const char* str_id) {
return ImGui::TreePush(str_id);
}
CIMGUI_API void igTreePush_Ptr(const void* ptr_id) {
return ImGui::TreePush(ptr_id);
}
CIMGUI_API void igTreePop() {
return ImGui::TreePop();
}
CIMGUI_API float igGetTreeNodeToLabelSpacing() {
return ImGui::GetTreeNodeToLabelSpacing();
}
CIMGUI_API bool igCollapsingHeader_TreeNodeFlags(const char* label,
ImGuiTreeNodeFlags flags) {
return ImGui::CollapsingHeader(label, flags);
}
CIMGUI_API bool igCollapsingHeader_BoolPtr(const char* label,
bool* p_visible,
ImGuiTreeNodeFlags flags) {
return ImGui::CollapsingHeader(label, p_visible, flags);
}
CIMGUI_API void igSetNextItemOpen(bool is_open, ImGuiCond cond) {
return ImGui::SetNextItemOpen(is_open, cond);
}
CIMGUI_API bool igSelectable_Bool(const char* label,
bool selected,
ImGuiSelectableFlags flags,
const ImVec2 size) {
return ImGui::Selectable(label, selected, flags, size);
}
CIMGUI_API bool igSelectable_BoolPtr(const char* label,
bool* p_selected,
ImGuiSelectableFlags flags,
const ImVec2 size) {
return ImGui::Selectable(label, p_selected, flags, size);
}
CIMGUI_API bool igBeginListBox(const char* label, const ImVec2 size) {
return ImGui::BeginListBox(label, size);
}
CIMGUI_API void igEndListBox() {
return ImGui::EndListBox();
}
CIMGUI_API bool igListBox_Str_arr(const char* label,
int* current_item,
const char* const items[],
int items_count,
int height_in_items) {
return ImGui::ListBox(label, current_item, items, items_count,
height_in_items);
}
CIMGUI_API bool igListBox_FnStrPtr(const char* label,
int* current_item,
const char* (*getter)(void* user_data,
int idx),
void* user_data,
int items_count,
int height_in_items) {
return ImGui::ListBox(label, current_item, getter, user_data, items_count,
height_in_items);
}
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) {
return ImGui::PlotLines(label, values, values_count, values_offset,
overlay_text, scale_min, scale_max, graph_size,
stride);
}
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) {
return ImGui::PlotLines(label, values_getter, data, values_count,
values_offset, overlay_text, scale_min, scale_max,
graph_size);
}
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) {
return ImGui::PlotHistogram(label, values, values_count, values_offset,
overlay_text, scale_min, scale_max, graph_size,
stride);
}
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) {
return ImGui::PlotHistogram(label, values_getter, data, values_count,
values_offset, overlay_text, scale_min, scale_max,
graph_size);
}
CIMGUI_API void igValue_Bool(const char* prefix, bool b) {
return ImGui::Value(prefix, b);
}
CIMGUI_API void igValue_Int(const char* prefix, int v) {
return ImGui::Value(prefix, v);
}
CIMGUI_API void igValue_Uint(const char* prefix, unsigned int v) {
return ImGui::Value(prefix, v);
}
CIMGUI_API void igValue_Float(const char* prefix,
float v,
const char* float_format) {
return ImGui::Value(prefix, v, float_format);
}
CIMGUI_API bool igBeginMenuBar() {
return ImGui::BeginMenuBar();
}
CIMGUI_API void igEndMenuBar() {
return ImGui::EndMenuBar();
}
CIMGUI_API bool igBeginMainMenuBar() {
return ImGui::BeginMainMenuBar();
}
CIMGUI_API void igEndMainMenuBar() {
return ImGui::EndMainMenuBar();
}
CIMGUI_API bool igBeginMenu(const char* label, bool enabled) {
return ImGui::BeginMenu(label, enabled);
}
CIMGUI_API void igEndMenu() {
return ImGui::EndMenu();
}
CIMGUI_API bool igMenuItem_Bool(const char* label,
const char* shortcut,
bool selected,
bool enabled) {
return ImGui::MenuItem(label, shortcut, selected, enabled);
}
CIMGUI_API bool igMenuItem_BoolPtr(const char* label,
const char* shortcut,
bool* p_selected,
bool enabled) {
return ImGui::MenuItem(label, shortcut, p_selected, enabled);
}
CIMGUI_API bool igBeginTooltip() {
return ImGui::BeginTooltip();
}
CIMGUI_API void igEndTooltip() {
return ImGui::EndTooltip();
}
CIMGUI_API void igSetTooltip(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::SetTooltipV(fmt, args);
va_end(args);
}
CIMGUI_API void igSetTooltipV(const char* fmt, va_list args) {
return ImGui::SetTooltipV(fmt, args);
}
CIMGUI_API bool igBeginItemTooltip() {
return ImGui::BeginItemTooltip();
}
CIMGUI_API void igSetItemTooltip(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::SetItemTooltipV(fmt, args);
va_end(args);
}
CIMGUI_API void igSetItemTooltipV(const char* fmt, va_list args) {
return ImGui::SetItemTooltipV(fmt, args);
}
CIMGUI_API bool igBeginPopup(const char* str_id, ImGuiWindowFlags flags) {
return ImGui::BeginPopup(str_id, flags);
}
CIMGUI_API bool igBeginPopupModal(const char* name,
bool* p_open,
ImGuiWindowFlags flags) {
return ImGui::BeginPopupModal(name, p_open, flags);
}
CIMGUI_API void igEndPopup() {
return ImGui::EndPopup();
}
CIMGUI_API void igOpenPopup_Str(const char* str_id,
ImGuiPopupFlags popup_flags) {
return ImGui::OpenPopup(str_id, popup_flags);
}
CIMGUI_API void igOpenPopup_ID(ImGuiID id, ImGuiPopupFlags popup_flags) {
return ImGui::OpenPopup(id, popup_flags);
}
CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,
ImGuiPopupFlags popup_flags) {
return ImGui::OpenPopupOnItemClick(str_id, popup_flags);
}
CIMGUI_API void igCloseCurrentPopup() {
return ImGui::CloseCurrentPopup();
}
CIMGUI_API bool igBeginPopupContextItem(const char* str_id,
ImGuiPopupFlags popup_flags) {
return ImGui::BeginPopupContextItem(str_id, popup_flags);
}
CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,
ImGuiPopupFlags popup_flags) {
return ImGui::BeginPopupContextWindow(str_id, popup_flags);
}
CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,
ImGuiPopupFlags popup_flags) {
return ImGui::BeginPopupContextVoid(str_id, popup_flags);
}
CIMGUI_API bool igIsPopupOpen_Str(const char* str_id, ImGuiPopupFlags flags) {
return ImGui::IsPopupOpen(str_id, flags);
}
CIMGUI_API bool igBeginTable(const char* str_id,
int column,
ImGuiTableFlags flags,
const ImVec2 outer_size,
float inner_width) {
return ImGui::BeginTable(str_id, column, flags, outer_size, inner_width);
}
CIMGUI_API void igEndTable() {
return ImGui::EndTable();
}
CIMGUI_API void igTableNextRow(ImGuiTableRowFlags row_flags,
float min_row_height) {
return ImGui::TableNextRow(row_flags, min_row_height);
}
CIMGUI_API bool igTableNextColumn() {
return ImGui::TableNextColumn();
}
CIMGUI_API bool igTableSetColumnIndex(int column_n) {
return ImGui::TableSetColumnIndex(column_n);
}
CIMGUI_API void igTableSetupColumn(const char* label,
ImGuiTableColumnFlags flags,
float init_width_or_weight,
ImGuiID user_id) {
return ImGui::TableSetupColumn(label, flags, init_width_or_weight, user_id);
}
CIMGUI_API void igTableSetupScrollFreeze(int cols, int rows) {
return ImGui::TableSetupScrollFreeze(cols, rows);
}
CIMGUI_API void igTableHeader(const char* label) {
return ImGui::TableHeader(label);
}
CIMGUI_API void igTableHeadersRow() {
return ImGui::TableHeadersRow();
}
CIMGUI_API void igTableAngledHeadersRow() {
return ImGui::TableAngledHeadersRow();
}
CIMGUI_API ImGuiTableSortSpecs* igTableGetSortSpecs() {
return ImGui::TableGetSortSpecs();
}
CIMGUI_API int igTableGetColumnCount() {
return ImGui::TableGetColumnCount();
}
CIMGUI_API int igTableGetColumnIndex() {
return ImGui::TableGetColumnIndex();
}
CIMGUI_API int igTableGetRowIndex() {
return ImGui::TableGetRowIndex();
}
CIMGUI_API const char* igTableGetColumnName_Int(int column_n) {
return ImGui::TableGetColumnName(column_n);
}
CIMGUI_API ImGuiTableColumnFlags igTableGetColumnFlags(int column_n) {
return ImGui::TableGetColumnFlags(column_n);
}
CIMGUI_API void igTableSetColumnEnabled(int column_n, bool v) {
return ImGui::TableSetColumnEnabled(column_n, v);
}
CIMGUI_API void igTableSetBgColor(ImGuiTableBgTarget target,
ImU32 color,
int column_n) {
return ImGui::TableSetBgColor(target, color, column_n);
}
CIMGUI_API void igColumns(int count, const char* id, bool border) {
return ImGui::Columns(count, id, border);
}
CIMGUI_API void igNextColumn() {
return ImGui::NextColumn();
}
CIMGUI_API int igGetColumnIndex() {
return ImGui::GetColumnIndex();
}
CIMGUI_API float igGetColumnWidth(int column_index) {
return ImGui::GetColumnWidth(column_index);
}
CIMGUI_API void igSetColumnWidth(int column_index, float width) {
return ImGui::SetColumnWidth(column_index, width);
}
CIMGUI_API float igGetColumnOffset(int column_index) {
return ImGui::GetColumnOffset(column_index);
}
CIMGUI_API void igSetColumnOffset(int column_index, float offset_x) {
return ImGui::SetColumnOffset(column_index, offset_x);
}
CIMGUI_API int igGetColumnsCount() {
return ImGui::GetColumnsCount();
}
CIMGUI_API bool igBeginTabBar(const char* str_id, ImGuiTabBarFlags flags) {
return ImGui::BeginTabBar(str_id, flags);
}
CIMGUI_API void igEndTabBar() {
return ImGui::EndTabBar();
}
CIMGUI_API bool igBeginTabItem(const char* label,
bool* p_open,
ImGuiTabItemFlags flags) {
return ImGui::BeginTabItem(label, p_open, flags);
}
CIMGUI_API void igEndTabItem() {
return ImGui::EndTabItem();
}
CIMGUI_API bool igTabItemButton(const char* label, ImGuiTabItemFlags flags) {
return ImGui::TabItemButton(label, flags);
}
CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label) {
return ImGui::SetTabItemClosed(tab_or_docked_window_label);
}
CIMGUI_API ImGuiID igDockSpace(ImGuiID id,
const ImVec2 size,
ImGuiDockNodeFlags flags,
const ImGuiWindowClass* window_class) {
return ImGui::DockSpace(id, size, flags, window_class);
}
CIMGUI_API ImGuiID
igDockSpaceOverViewport(const ImGuiViewport* viewport,
ImGuiDockNodeFlags flags,
const ImGuiWindowClass* window_class) {
return ImGui::DockSpaceOverViewport(viewport, flags, window_class);
}
CIMGUI_API void igSetNextWindowDockID(ImGuiID dock_id, ImGuiCond cond) {
return ImGui::SetNextWindowDockID(dock_id, cond);
}
CIMGUI_API void igSetNextWindowClass(const ImGuiWindowClass* window_class) {
return ImGui::SetNextWindowClass(window_class);
}
CIMGUI_API ImGuiID igGetWindowDockID() {
return ImGui::GetWindowDockID();
}
CIMGUI_API bool igIsWindowDocked() {
return ImGui::IsWindowDocked();
}
CIMGUI_API void igLogToTTY(int auto_open_depth) {
return ImGui::LogToTTY(auto_open_depth);
}
CIMGUI_API void igLogToFile(int auto_open_depth, const char* filename) {
return ImGui::LogToFile(auto_open_depth, filename);
}
CIMGUI_API void igLogToClipboard(int auto_open_depth) {
return ImGui::LogToClipboard(auto_open_depth);
}
CIMGUI_API void igLogFinish() {
return ImGui::LogFinish();
}
CIMGUI_API void igLogButtons() {
return ImGui::LogButtons();
}
CIMGUI_API void igLogTextV(const char* fmt, va_list args) {
return ImGui::LogTextV(fmt, args);
}
CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags) {
return ImGui::BeginDragDropSource(flags);
}
CIMGUI_API bool igSetDragDropPayload(const char* type,
const void* data,
size_t sz,
ImGuiCond cond) {
return ImGui::SetDragDropPayload(type, data, sz, cond);
}
CIMGUI_API void igEndDragDropSource() {
return ImGui::EndDragDropSource();
}
CIMGUI_API bool igBeginDragDropTarget() {
return ImGui::BeginDragDropTarget();
}
CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(
const char* type,
ImGuiDragDropFlags flags) {
return ImGui::AcceptDragDropPayload(type, flags);
}
CIMGUI_API void igEndDragDropTarget() {
return ImGui::EndDragDropTarget();
}
CIMGUI_API const ImGuiPayload* igGetDragDropPayload() {
return ImGui::GetDragDropPayload();
}
CIMGUI_API void igBeginDisabled(bool disabled) {
return ImGui::BeginDisabled(disabled);
}
CIMGUI_API void igEndDisabled() {
return ImGui::EndDisabled();
}
CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,
const ImVec2 clip_rect_max,
bool intersect_with_current_clip_rect) {
return ImGui::PushClipRect(clip_rect_min, clip_rect_max,
intersect_with_current_clip_rect);
}
CIMGUI_API void igPopClipRect() {
return ImGui::PopClipRect();
}
CIMGUI_API void igSetItemDefaultFocus() {
return ImGui::SetItemDefaultFocus();
}
CIMGUI_API void igSetKeyboardFocusHere(int offset) {
return ImGui::SetKeyboardFocusHere(offset);
}
CIMGUI_API void igSetNextItemAllowOverlap() {
return ImGui::SetNextItemAllowOverlap();
}
CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags) {
return ImGui::IsItemHovered(flags);
}
CIMGUI_API bool igIsItemActive() {
return ImGui::IsItemActive();
}
CIMGUI_API bool igIsItemFocused() {
return ImGui::IsItemFocused();
}
CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button) {
return ImGui::IsItemClicked(mouse_button);
}
CIMGUI_API bool igIsItemVisible() {
return ImGui::IsItemVisible();
}
CIMGUI_API bool igIsItemEdited() {
return ImGui::IsItemEdited();
}
CIMGUI_API bool igIsItemActivated() {
return ImGui::IsItemActivated();
}
CIMGUI_API bool igIsItemDeactivated() {
return ImGui::IsItemDeactivated();
}
CIMGUI_API bool igIsItemDeactivatedAfterEdit() {
return ImGui::IsItemDeactivatedAfterEdit();
}
CIMGUI_API bool igIsItemToggledOpen() {
return ImGui::IsItemToggledOpen();
}
CIMGUI_API bool igIsAnyItemHovered() {
return ImGui::IsAnyItemHovered();
}
CIMGUI_API bool igIsAnyItemActive() {
return ImGui::IsAnyItemActive();
}
CIMGUI_API bool igIsAnyItemFocused() {
return ImGui::IsAnyItemFocused();
}
CIMGUI_API ImGuiID igGetItemID() {
return ImGui::GetItemID();
}
CIMGUI_API void igGetItemRectMin(ImVec2* pOut) {
*pOut = ImGui::GetItemRectMin();
}
CIMGUI_API void igGetItemRectMax(ImVec2* pOut) {
*pOut = ImGui::GetItemRectMax();
}
CIMGUI_API void igGetItemRectSize(ImVec2* pOut) {
*pOut = ImGui::GetItemRectSize();
}
CIMGUI_API ImGuiViewport* igGetMainViewport() {
return ImGui::GetMainViewport();
}
CIMGUI_API ImDrawList* igGetBackgroundDrawList_Nil() {
return ImGui::GetBackgroundDrawList();
}
CIMGUI_API ImDrawList* igGetForegroundDrawList_Nil() {
return ImGui::GetForegroundDrawList();
}
CIMGUI_API ImDrawList* igGetBackgroundDrawList_ViewportPtr(
ImGuiViewport* viewport) {
return ImGui::GetBackgroundDrawList(viewport);
}
CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(
ImGuiViewport* viewport) {
return ImGui::GetForegroundDrawList(viewport);
}
CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size) {
return ImGui::IsRectVisible(size);
}
CIMGUI_API bool igIsRectVisible_Vec2(const ImVec2 rect_min,
const ImVec2 rect_max) {
return ImGui::IsRectVisible(rect_min, rect_max);
}
CIMGUI_API double igGetTime() {
return ImGui::GetTime();
}
CIMGUI_API int igGetFrameCount() {
return ImGui::GetFrameCount();
}
CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData() {
return ImGui::GetDrawListSharedData();
}
CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx) {
return ImGui::GetStyleColorName(idx);
}
CIMGUI_API void igSetStateStorage(ImGuiStorage* storage) {
return ImGui::SetStateStorage(storage);
}
CIMGUI_API ImGuiStorage* igGetStateStorage() {
return ImGui::GetStateStorage();
}
CIMGUI_API void igCalcTextSize(ImVec2* pOut,
const char* text,
const char* text_end,
bool hide_text_after_double_hash,
float wrap_width) {
*pOut = ImGui::CalcTextSize(text, text_end, hide_text_after_double_hash,
wrap_width);
}
CIMGUI_API void igColorConvertU32ToFloat4(ImVec4* pOut, ImU32 in) {
*pOut = ImGui::ColorConvertU32ToFloat4(in);
}
CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in) {
return ImGui::ColorConvertFloat4ToU32(in);
}
CIMGUI_API void igColorConvertRGBtoHSV(float r,
float g,
float b,
float* out_h,
float* out_s,
float* out_v) {
return ImGui::ColorConvertRGBtoHSV(r, g, b, *out_h, *out_s, *out_v);
}
CIMGUI_API void igColorConvertHSVtoRGB(float h,
float s,
float v,
float* out_r,
float* out_g,
float* out_b) {
return ImGui::ColorConvertHSVtoRGB(h, s, v, *out_r, *out_g, *out_b);
}
CIMGUI_API bool igIsKeyDown_Nil(ImGuiKey key) {
return ImGui::IsKeyDown(key);
}
CIMGUI_API bool igIsKeyPressed_Bool(ImGuiKey key, bool repeat) {
return ImGui::IsKeyPressed(key, repeat);
}
CIMGUI_API bool igIsKeyReleased_Nil(ImGuiKey key) {
return ImGui::IsKeyReleased(key);
}
CIMGUI_API bool igIsKeyChordPressed_Nil(ImGuiKeyChord key_chord) {
return ImGui::IsKeyChordPressed(key_chord);
}
CIMGUI_API int igGetKeyPressedAmount(ImGuiKey key,
float repeat_delay,
float rate) {
return ImGui::GetKeyPressedAmount(key, repeat_delay, rate);
}
CIMGUI_API const char* igGetKeyName(ImGuiKey key) {
return ImGui::GetKeyName(key);
}
CIMGUI_API void igSetNextFrameWantCaptureKeyboard(bool want_capture_keyboard) {
return ImGui::SetNextFrameWantCaptureKeyboard(want_capture_keyboard);
}
CIMGUI_API bool igIsMouseDown_Nil(ImGuiMouseButton button) {
return ImGui::IsMouseDown(button);
}
CIMGUI_API bool igIsMouseClicked_Bool(ImGuiMouseButton button, bool repeat) {
return ImGui::IsMouseClicked(button, repeat);
}
CIMGUI_API bool igIsMouseReleased_Nil(ImGuiMouseButton button) {
return ImGui::IsMouseReleased(button);
}
CIMGUI_API bool igIsMouseDoubleClicked_Nil(ImGuiMouseButton button) {
return ImGui::IsMouseDoubleClicked(button);
}
CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button) {
return ImGui::GetMouseClickedCount(button);
}
CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,
const ImVec2 r_max,
bool clip) {
return ImGui::IsMouseHoveringRect(r_min, r_max, clip);
}
CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos) {
return ImGui::IsMousePosValid(mouse_pos);
}
CIMGUI_API bool igIsAnyMouseDown() {
return ImGui::IsAnyMouseDown();
}
CIMGUI_API void igGetMousePos(ImVec2* pOut) {
*pOut = ImGui::GetMousePos();
}
CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2* pOut) {
*pOut = ImGui::GetMousePosOnOpeningCurrentPopup();
}
CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,
float lock_threshold) {
return ImGui::IsMouseDragging(button, lock_threshold);
}
CIMGUI_API void igGetMouseDragDelta(ImVec2* pOut,
ImGuiMouseButton button,
float lock_threshold) {
*pOut = ImGui::GetMouseDragDelta(button, lock_threshold);
}
CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button) {
return ImGui::ResetMouseDragDelta(button);
}
CIMGUI_API ImGuiMouseCursor igGetMouseCursor() {
return ImGui::GetMouseCursor();
}
CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type) {
return ImGui::SetMouseCursor(cursor_type);
}
CIMGUI_API void igSetNextFrameWantCaptureMouse(bool want_capture_mouse) {
return ImGui::SetNextFrameWantCaptureMouse(want_capture_mouse);
}
CIMGUI_API const char* igGetClipboardText() {
return ImGui::GetClipboardText();
}
CIMGUI_API void igSetClipboardText(const char* text) {
return ImGui::SetClipboardText(text);
}
CIMGUI_API void igLoadIniSettingsFromDisk(const char* ini_filename) {
return ImGui::LoadIniSettingsFromDisk(ini_filename);
}
CIMGUI_API void igLoadIniSettingsFromMemory(const char* ini_data,
size_t ini_size) {
return ImGui::LoadIniSettingsFromMemory(ini_data, ini_size);
}
CIMGUI_API void igSaveIniSettingsToDisk(const char* ini_filename) {
return ImGui::SaveIniSettingsToDisk(ini_filename);
}
CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size) {
return ImGui::SaveIniSettingsToMemory(out_ini_size);
}
CIMGUI_API void igDebugTextEncoding(const char* text) {
return ImGui::DebugTextEncoding(text);
}
CIMGUI_API void igDebugFlashStyleColor(ImGuiCol idx) {
return ImGui::DebugFlashStyleColor(idx);
}
CIMGUI_API void igDebugStartItemPicker() {
return ImGui::DebugStartItemPicker();
}
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) {
return ImGui::DebugCheckVersionAndDataLayout(
version_str, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
}
CIMGUI_API void igSetAllocatorFunctions(ImGuiMemAllocFunc alloc_func,
ImGuiMemFreeFunc free_func,
void* user_data) {
return ImGui::SetAllocatorFunctions(alloc_func, free_func, user_data);
}
CIMGUI_API void igGetAllocatorFunctions(ImGuiMemAllocFunc* p_alloc_func,
ImGuiMemFreeFunc* p_free_func,
void** p_user_data) {
return ImGui::GetAllocatorFunctions(p_alloc_func, p_free_func, p_user_data);
}
CIMGUI_API void* igMemAlloc(size_t size) {
return ImGui::MemAlloc(size);
}
CIMGUI_API void igMemFree(void* ptr) {
return ImGui::MemFree(ptr);
}
CIMGUI_API ImGuiPlatformIO* igGetPlatformIO() {
return &ImGui::GetPlatformIO();
}
CIMGUI_API void igUpdatePlatformWindows() {
return ImGui::UpdatePlatformWindows();
}
CIMGUI_API void igRenderPlatformWindowsDefault(void* platform_render_arg,
void* renderer_render_arg) {
return ImGui::RenderPlatformWindowsDefault(platform_render_arg,
renderer_render_arg);
}
CIMGUI_API void igDestroyPlatformWindows() {
return ImGui::DestroyPlatformWindows();
}
CIMGUI_API ImGuiViewport* igFindViewportByID(ImGuiID id) {
return ImGui::FindViewportByID(id);
}
CIMGUI_API ImGuiViewport* igFindViewportByPlatformHandle(
void* platform_handle) {
return ImGui::FindViewportByPlatformHandle(platform_handle);
}
CIMGUI_API ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs(void) {
return IM_NEW(ImGuiTableSortSpecs)();
}
CIMGUI_API void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumnSortSpecs*
ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs(void) {
return IM_NEW(ImGuiTableColumnSortSpecs)();
}
CIMGUI_API void ImGuiTableColumnSortSpecs_destroy(
ImGuiTableColumnSortSpecs* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiStyle* ImGuiStyle_ImGuiStyle(void) {
return IM_NEW(ImGuiStyle)();
}
CIMGUI_API void ImGuiStyle_destroy(ImGuiStyle* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self, float scale_factor) {
return self->ScaleAllSizes(scale_factor);
}
CIMGUI_API void ImGuiIO_AddKeyEvent(ImGuiIO* self, ImGuiKey key, bool down) {
return self->AddKeyEvent(key, down);
}
CIMGUI_API void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self,
ImGuiKey key,
bool down,
float v) {
return self->AddKeyAnalogEvent(key, down, v);
}
CIMGUI_API void ImGuiIO_AddMousePosEvent(ImGuiIO* self, float x, float y) {
return self->AddMousePosEvent(x, y);
}
CIMGUI_API void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self,
int button,
bool down) {
return self->AddMouseButtonEvent(button, down);
}
CIMGUI_API void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self,
float wheel_x,
float wheel_y) {
return self->AddMouseWheelEvent(wheel_x, wheel_y);
}
CIMGUI_API void ImGuiIO_AddMouseSourceEvent(ImGuiIO* self,
ImGuiMouseSource source) {
return self->AddMouseSourceEvent(source);
}
CIMGUI_API void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self, ImGuiID id) {
return self->AddMouseViewportEvent(id);
}
CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self, bool focused) {
return self->AddFocusEvent(focused);
}
CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self, unsigned int c) {
return self->AddInputCharacter(c);
}
CIMGUI_API void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self, ImWchar16 c) {
return self->AddInputCharacterUTF16(c);
}
CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self, const char* str) {
return self->AddInputCharactersUTF8(str);
}
CIMGUI_API void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self,
ImGuiKey key,
int native_keycode,
int native_scancode,
int native_legacy_index) {
return self->SetKeyEventNativeData(key, native_keycode, native_scancode,
native_legacy_index);
}
CIMGUI_API void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self,
bool accepting_events) {
return self->SetAppAcceptingEvents(accepting_events);
}
CIMGUI_API void ImGuiIO_ClearEventsQueue(ImGuiIO* self) {
return self->ClearEventsQueue();
}
CIMGUI_API void ImGuiIO_ClearInputKeys(ImGuiIO* self) {
return self->ClearInputKeys();
}
CIMGUI_API ImGuiIO* ImGuiIO_ImGuiIO(void) {
return IM_NEW(ImGuiIO)();
}
CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiInputTextCallbackData*
ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void) {
return IM_NEW(ImGuiInputTextCallbackData)();
}
CIMGUI_API void ImGuiInputTextCallbackData_destroy(
ImGuiInputTextCallbackData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(
ImGuiInputTextCallbackData* self,
int pos,
int bytes_count) {
return self->DeleteChars(pos, bytes_count);
}
CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(
ImGuiInputTextCallbackData* self,
int pos,
const char* text,
const char* text_end) {
return self->InsertChars(pos, text, text_end);
}
CIMGUI_API void ImGuiInputTextCallbackData_SelectAll(
ImGuiInputTextCallbackData* self) {
return self->SelectAll();
}
CIMGUI_API void ImGuiInputTextCallbackData_ClearSelection(
ImGuiInputTextCallbackData* self) {
return self->ClearSelection();
}
CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(
ImGuiInputTextCallbackData* self) {
return self->HasSelection();
}
CIMGUI_API ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass(void) {
return IM_NEW(ImGuiWindowClass)();
}
CIMGUI_API void ImGuiWindowClass_destroy(ImGuiWindowClass* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void) {
return IM_NEW(ImGuiPayload)();
}
CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self) {
return self->Clear();
}
CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self, const char* type) {
return self->IsDataType(type);
}
CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self) {
return self->IsPreview();
}
CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self) {
return self->IsDelivery();
}
CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void) {
return IM_NEW(ImGuiOnceUponAFrame)();
}
CIMGUI_API void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(
const char* default_filter) {
return IM_NEW(ImGuiTextFilter)(default_filter);
}
CIMGUI_API void ImGuiTextFilter_destroy(ImGuiTextFilter* self) {
IM_DELETE(self);
}
CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,
const char* label,
float width) {
return self->Draw(label, width);
}
CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,
const char* text,
const char* text_end) {
return self->PassFilter(text, text_end);
}
CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self) {
return self->Build();
}
CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self) {
return self->Clear();
}
CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self) {
return self->IsActive();
}
CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Nil(void) {
return IM_NEW(ImGuiTextRange)();
}
CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Str(const char* _b,
const char* _e) {
return IM_NEW(ImGuiTextRange)(_b, _e);
}
CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self) {
return self->empty();
}
CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,
char separator,
ImVector_ImGuiTextRange* out) {
return self->split(separator, out);
}
CIMGUI_API ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void) {
return IM_NEW(ImGuiTextBuffer)();
}
CIMGUI_API void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self) {
IM_DELETE(self);
}
CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self) {
return self->begin();
}
CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self) {
return self->end();
}
CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self) {
return self->size();
}
CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self) {
return self->empty();
}
CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self) {
return self->clear();
}
CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self, int capacity) {
return self->reserve(capacity);
}
CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self) {
return self->c_str();
}
CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,
const char* str,
const char* str_end) {
return self->append(str, str_end);
}
CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,
const char* fmt,
va_list args) {
return self->appendfv(fmt, args);
}
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Int(ImGuiID _key,
int _val) {
return IM_NEW(ImGuiStoragePair)(_key, _val);
}
CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(
ImGuiID _key,
float _val) {
return IM_NEW(ImGuiStoragePair)(_key, _val);
}
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(ImGuiID _key,
void* _val) {
return IM_NEW(ImGuiStoragePair)(_key, _val);
}
CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self) {
return self->Clear();
}
CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,
ImGuiID key,
int default_val) {
return self->GetInt(key, default_val);
}
CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self, ImGuiID key, int val) {
return self->SetInt(key, val);
}
CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,
ImGuiID key,
bool default_val) {
return self->GetBool(key, default_val);
}
CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,
ImGuiID key,
bool val) {
return self->SetBool(key, val);
}
CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,
ImGuiID key,
float default_val) {
return self->GetFloat(key, default_val);
}
CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,
ImGuiID key,
float val) {
return self->SetFloat(key, val);
}
CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self, ImGuiID key) {
return self->GetVoidPtr(key);
}
CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,
ImGuiID key,
void* val) {
return self->SetVoidPtr(key, val);
}
CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,
ImGuiID key,
int default_val) {
return self->GetIntRef(key, default_val);
}
CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,
ImGuiID key,
bool default_val) {
return self->GetBoolRef(key, default_val);
}
CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,
ImGuiID key,
float default_val) {
return self->GetFloatRef(key, default_val);
}
CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,
ImGuiID key,
void* default_val) {
return self->GetVoidPtrRef(key, default_val);
}
CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self) {
return self->BuildSortByKey();
}
CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self, int val) {
return self->SetAllInt(val);
}
CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(void) {
return IM_NEW(ImGuiListClipper)();
}
CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,
int items_count,
float items_height) {
return self->Begin(items_count, items_height);
}
CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self) {
return self->End();
}
CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self) {
return self->Step();
}
CIMGUI_API void ImGuiListClipper_IncludeItemByIndex(ImGuiListClipper* self,
int item_index) {
return self->IncludeItemByIndex(item_index);
}
CIMGUI_API void ImGuiListClipper_IncludeItemsByIndex(ImGuiListClipper* self,
int item_begin,
int item_end) {
return self->IncludeItemsByIndex(item_begin, item_end);
}
CIMGUI_API ImColor* ImColor_ImColor_Nil(void) {
return IM_NEW(ImColor)();
}
CIMGUI_API void ImColor_destroy(ImColor* self) {
IM_DELETE(self);
}
CIMGUI_API ImColor* ImColor_ImColor_Float(float r, float g, float b, float a) {
return IM_NEW(ImColor)(r, g, b, a);
}
CIMGUI_API ImColor* ImColor_ImColor_Vec4(const ImVec4 col) {
return IM_NEW(ImColor)(col);
}
CIMGUI_API ImColor* ImColor_ImColor_Int(int r, int g, int b, int a) {
return IM_NEW(ImColor)(r, g, b, a);
}
CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba) {
return IM_NEW(ImColor)(rgba);
}
CIMGUI_API void ImColor_SetHSV(ImColor* self,
float h,
float s,
float v,
float a) {
return self->SetHSV(h, s, v, a);
}
CIMGUI_API void ImColor_HSV(ImColor* pOut, float h, float s, float v, float a) {
*pOut = ImColor::HSV(h, s, v, a);
}
CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void) {
return IM_NEW(ImDrawCmd)();
}
CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self) {
IM_DELETE(self);
}
CIMGUI_API ImTextureID ImDrawCmd_GetTexID(ImDrawCmd* self) {
return self->GetTexID();
}
CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void) {
return IM_NEW(ImDrawListSplitter)();
}
CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self) {
IM_DELETE(self);
}
CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self) {
return self->Clear();
}
CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self) {
return self->ClearFreeMemory();
}
CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,
ImDrawList* draw_list,
int count) {
return self->Split(draw_list, count);
}
CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,
ImDrawList* draw_list) {
return self->Merge(draw_list);
}
CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,
ImDrawList* draw_list,
int channel_idx) {
return self->SetCurrentChannel(draw_list, channel_idx);
}
CIMGUI_API ImDrawList* ImDrawList_ImDrawList(
ImDrawListSharedData* shared_data) {
return IM_NEW(ImDrawList)(shared_data);
}
CIMGUI_API void ImDrawList_destroy(ImDrawList* self) {
IM_DELETE(self);
}
CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,
const ImVec2 clip_rect_min,
const ImVec2 clip_rect_max,
bool intersect_with_current_clip_rect) {
return self->PushClipRect(clip_rect_min, clip_rect_max,
intersect_with_current_clip_rect);
}
CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self) {
return self->PushClipRectFullScreen();
}
CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self) {
return self->PopClipRect();
}
CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,
ImTextureID texture_id) {
return self->PushTextureID(texture_id);
}
CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self) {
return self->PopTextureID();
}
CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2* pOut, ImDrawList* self) {
*pOut = self->GetClipRectMin();
}
CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2* pOut, ImDrawList* self) {
*pOut = self->GetClipRectMax();
}
CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,
const ImVec2 p1,
const ImVec2 p2,
ImU32 col,
float thickness) {
return self->AddLine(p1, p2, col, thickness);
}
CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,
const ImVec2 p_min,
const ImVec2 p_max,
ImU32 col,
float rounding,
ImDrawFlags flags,
float thickness) {
return self->AddRect(p_min, p_max, col, rounding, flags, thickness);
}
CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,
const ImVec2 p_min,
const ImVec2 p_max,
ImU32 col,
float rounding,
ImDrawFlags flags) {
return self->AddRectFilled(p_min, p_max, col, rounding, flags);
}
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) {
return self->AddRectFilledMultiColor(
p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
}
CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
const ImVec2 p4,
ImU32 col,
float thickness) {
return self->AddQuad(p1, p2, p3, p4, col, thickness);
}
CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
const ImVec2 p4,
ImU32 col) {
return self->AddQuadFilled(p1, p2, p3, p4, col);
}
CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
ImU32 col,
float thickness) {
return self->AddTriangle(p1, p2, p3, col, thickness);
}
CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
ImU32 col) {
return self->AddTriangleFilled(p1, p2, p3, col);
}
CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,
const ImVec2 center,
float radius,
ImU32 col,
int num_segments,
float thickness) {
return self->AddCircle(center, radius, col, num_segments, thickness);
}
CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,
const ImVec2 center,
float radius,
ImU32 col,
int num_segments) {
return self->AddCircleFilled(center, radius, col, num_segments);
}
CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,
const ImVec2 center,
float radius,
ImU32 col,
int num_segments,
float thickness) {
return self->AddNgon(center, radius, col, num_segments, thickness);
}
CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,
const ImVec2 center,
float radius,
ImU32 col,
int num_segments) {
return self->AddNgonFilled(center, radius, col, num_segments);
}
CIMGUI_API void ImDrawList_AddEllipse(ImDrawList* self,
const ImVec2 center,
const ImVec2 radius,
ImU32 col,
float rot,
int num_segments,
float thickness) {
return self->AddEllipse(center, radius, col, rot, num_segments, thickness);
}
CIMGUI_API void ImDrawList_AddEllipseFilled(ImDrawList* self,
const ImVec2 center,
const ImVec2 radius,
ImU32 col,
float rot,
int num_segments) {
return self->AddEllipseFilled(center, radius, col, rot, num_segments);
}
CIMGUI_API void ImDrawList_AddText_Vec2(ImDrawList* self,
const ImVec2 pos,
ImU32 col,
const char* text_begin,
const char* text_end) {
return self->AddText(pos, col, text_begin, text_end);
}
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) {
return self->AddText(font, font_size, pos, col, text_begin, text_end,
wrap_width, cpu_fine_clip_rect);
}
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) {
return self->AddBezierCubic(p1, p2, p3, p4, col, thickness, num_segments);
}
CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
ImU32 col,
float thickness,
int num_segments) {
return self->AddBezierQuadratic(p1, p2, p3, col, thickness, num_segments);
}
CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,
const ImVec2* points,
int num_points,
ImU32 col,
ImDrawFlags flags,
float thickness) {
return self->AddPolyline(points, num_points, col, flags, thickness);
}
CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,
const ImVec2* points,
int num_points,
ImU32 col) {
return self->AddConvexPolyFilled(points, num_points, col);
}
CIMGUI_API void ImDrawList_AddConcavePolyFilled(ImDrawList* self,
const ImVec2* points,
int num_points,
ImU32 col) {
return self->AddConcavePolyFilled(points, num_points, col);
}
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) {
return self->AddImage(user_texture_id, p_min, p_max, uv_min, uv_max, col);
}
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) {
return self->AddImageQuad(user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4,
col);
}
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) {
return self->AddImageRounded(user_texture_id, p_min, p_max, uv_min, uv_max,
col, rounding, flags);
}
CIMGUI_API void ImDrawList_PathClear(ImDrawList* self) {
return self->PathClear();
}
CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* self, const ImVec2 pos) {
return self->PathLineTo(pos);
}
CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,
const ImVec2 pos) {
return self->PathLineToMergeDuplicate(pos);
}
CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* self, ImU32 col) {
return self->PathFillConvex(col);
}
CIMGUI_API void ImDrawList_PathFillConcave(ImDrawList* self, ImU32 col) {
return self->PathFillConcave(col);
}
CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,
ImU32 col,
ImDrawFlags flags,
float thickness) {
return self->PathStroke(col, flags, thickness);
}
CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,
const ImVec2 center,
float radius,
float a_min,
float a_max,
int num_segments) {
return self->PathArcTo(center, radius, a_min, a_max, num_segments);
}
CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,
const ImVec2 center,
float radius,
int a_min_of_12,
int a_max_of_12) {
return self->PathArcToFast(center, radius, a_min_of_12, a_max_of_12);
}
CIMGUI_API void ImDrawList_PathEllipticalArcTo(ImDrawList* self,
const ImVec2 center,
const ImVec2 radius,
float rot,
float a_min,
float a_max,
int num_segments) {
return self->PathEllipticalArcTo(center, radius, rot, a_min, a_max,
num_segments);
}
CIMGUI_API void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self,
const ImVec2 p2,
const ImVec2 p3,
const ImVec2 p4,
int num_segments) {
return self->PathBezierCubicCurveTo(p2, p3, p4, num_segments);
}
CIMGUI_API void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self,
const ImVec2 p2,
const ImVec2 p3,
int num_segments) {
return self->PathBezierQuadraticCurveTo(p2, p3, num_segments);
}
CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,
const ImVec2 rect_min,
const ImVec2 rect_max,
float rounding,
ImDrawFlags flags) {
return self->PathRect(rect_min, rect_max, rounding, flags);
}
CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,
ImDrawCallback callback,
void* callback_data) {
return self->AddCallback(callback, callback_data);
}
CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self) {
return self->AddDrawCmd();
}
CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self) {
return self->CloneOutput();
}
CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self, int count) {
return self->ChannelsSplit(count);
}
CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self) {
return self->ChannelsMerge();
}
CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self, int n) {
return self->ChannelsSetCurrent(n);
}
CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,
int idx_count,
int vtx_count) {
return self->PrimReserve(idx_count, vtx_count);
}
CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,
int idx_count,
int vtx_count) {
return self->PrimUnreserve(idx_count, vtx_count);
}
CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,
const ImVec2 a,
const ImVec2 b,
ImU32 col) {
return self->PrimRect(a, b, col);
}
CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,
const ImVec2 a,
const ImVec2 b,
const ImVec2 uv_a,
const ImVec2 uv_b,
ImU32 col) {
return self->PrimRectUV(a, b, uv_a, uv_b, col);
}
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) {
return self->PrimQuadUV(a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
}
CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* self,
const ImVec2 pos,
const ImVec2 uv,
ImU32 col) {
return self->PrimWriteVtx(pos, uv, col);
}
CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* self, ImDrawIdx idx) {
return self->PrimWriteIdx(idx);
}
CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,
const ImVec2 pos,
const ImVec2 uv,
ImU32 col) {
return self->PrimVtx(pos, uv, col);
}
CIMGUI_API void ImDrawList__ResetForNewFrame(ImDrawList* self) {
return self->_ResetForNewFrame();
}
CIMGUI_API void ImDrawList__ClearFreeMemory(ImDrawList* self) {
return self->_ClearFreeMemory();
}
CIMGUI_API void ImDrawList__PopUnusedDrawCmd(ImDrawList* self) {
return self->_PopUnusedDrawCmd();
}
CIMGUI_API void ImDrawList__TryMergeDrawCmds(ImDrawList* self) {
return self->_TryMergeDrawCmds();
}
CIMGUI_API void ImDrawList__OnChangedClipRect(ImDrawList* self) {
return self->_OnChangedClipRect();
}
CIMGUI_API void ImDrawList__OnChangedTextureID(ImDrawList* self) {
return self->_OnChangedTextureID();
}
CIMGUI_API void ImDrawList__OnChangedVtxOffset(ImDrawList* self) {
return self->_OnChangedVtxOffset();
}
CIMGUI_API int ImDrawList__CalcCircleAutoSegmentCount(ImDrawList* self,
float radius) {
return self->_CalcCircleAutoSegmentCount(radius);
}
CIMGUI_API void ImDrawList__PathArcToFastEx(ImDrawList* self,
const ImVec2 center,
float radius,
int a_min_sample,
int a_max_sample,
int a_step) {
return self->_PathArcToFastEx(center, radius, a_min_sample, a_max_sample,
a_step);
}
CIMGUI_API void ImDrawList__PathArcToN(ImDrawList* self,
const ImVec2 center,
float radius,
float a_min,
float a_max,
int num_segments) {
return self->_PathArcToN(center, radius, a_min, a_max, num_segments);
}
CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void) {
return IM_NEW(ImDrawData)();
}
CIMGUI_API void ImDrawData_destroy(ImDrawData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImDrawData_Clear(ImDrawData* self) {
return self->Clear();
}
CIMGUI_API void ImDrawData_AddDrawList(ImDrawData* self,
ImDrawList* draw_list) {
return self->AddDrawList(draw_list);
}
CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self) {
return self->DeIndexAllBuffers();
}
CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,
const ImVec2 fb_scale) {
return self->ScaleClipRects(fb_scale);
}
CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void) {
return IM_NEW(ImFontConfig)();
}
CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self) {
IM_DELETE(self);
}
CIMGUI_API ImFontGlyphRangesBuilder*
ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void) {
return IM_NEW(ImFontGlyphRangesBuilder)();
}
CIMGUI_API void ImFontGlyphRangesBuilder_destroy(
ImFontGlyphRangesBuilder* self) {
IM_DELETE(self);
}
CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self) {
return self->Clear();
}
CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,
size_t n) {
return self->GetBit(n);
}
CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,
size_t n) {
return self->SetBit(n);
}
CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,
ImWchar c) {
return self->AddChar(c);
}
CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,
const char* text,
const char* text_end) {
return self->AddText(text, text_end);
}
CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(
ImFontGlyphRangesBuilder* self,
const ImWchar* ranges) {
return self->AddRanges(ranges);
}
CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(
ImFontGlyphRangesBuilder* self,
ImVector_ImWchar* out_ranges) {
return self->BuildRanges(out_ranges);
}
CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(
void) {
return IM_NEW(ImFontAtlasCustomRect)();
}
CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self) {
IM_DELETE(self);
}
CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self) {
return self->IsPacked();
}
CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void) {
return IM_NEW(ImFontAtlas)();
}
CIMGUI_API void ImFontAtlas_destroy(ImFontAtlas* self) {
IM_DELETE(self);
}
CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,
const ImFontConfig* font_cfg) {
return self->AddFont(font_cfg);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,
const ImFontConfig* font_cfg) {
return self->AddFontDefault(font_cfg);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,
const char* filename,
float size_pixels,
const ImFontConfig* font_cfg,
const ImWchar* glyph_ranges) {
return self->AddFontFromFileTTF(filename, size_pixels, font_cfg,
glyph_ranges);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(
ImFontAtlas* self,
void* font_data,
int font_data_size,
float size_pixels,
const ImFontConfig* font_cfg,
const ImWchar* glyph_ranges) {
return self->AddFontFromMemoryTTF(font_data, font_data_size, size_pixels,
font_cfg, glyph_ranges);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(
ImFontAtlas* self,
const void* compressed_font_data,
int compressed_font_data_size,
float size_pixels,
const ImFontConfig* font_cfg,
const ImWchar* glyph_ranges) {
return self->AddFontFromMemoryCompressedTTF(
compressed_font_data, compressed_font_data_size, size_pixels, font_cfg,
glyph_ranges);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(
ImFontAtlas* self,
const char* compressed_font_data_base85,
float size_pixels,
const ImFontConfig* font_cfg,
const ImWchar* glyph_ranges) {
return self->AddFontFromMemoryCompressedBase85TTF(
compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
}
CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self) {
return self->ClearInputData();
}
CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self) {
return self->ClearTexData();
}
CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self) {
return self->ClearFonts();
}
CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self) {
return self->Clear();
}
CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self) {
return self->Build();
}
CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,
unsigned char** out_pixels,
int* out_width,
int* out_height,
int* out_bytes_per_pixel) {
return self->GetTexDataAsAlpha8(out_pixels, out_width, out_height,
out_bytes_per_pixel);
}
CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,
unsigned char** out_pixels,
int* out_width,
int* out_height,
int* out_bytes_per_pixel) {
return self->GetTexDataAsRGBA32(out_pixels, out_width, out_height,
out_bytes_per_pixel);
}
CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self) {
return self->IsBuilt();
}
CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self, ImTextureID id) {
return self->SetTexID(id);
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self) {
return self->GetGlyphRangesDefault();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self) {
return self->GetGlyphRangesGreek();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self) {
return self->GetGlyphRangesKorean();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(
ImFontAtlas* self) {
return self->GetGlyphRangesJapanese();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(
ImFontAtlas* self) {
return self->GetGlyphRangesChineseFull();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(
ImFontAtlas* self) {
return self->GetGlyphRangesChineseSimplifiedCommon();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(
ImFontAtlas* self) {
return self->GetGlyphRangesCyrillic();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self) {
return self->GetGlyphRangesThai();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(
ImFontAtlas* self) {
return self->GetGlyphRangesVietnamese();
}
CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,
int width,
int height) {
return self->AddCustomRectRegular(width, height);
}
CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,
ImFont* font,
ImWchar id,
int width,
int height,
float advance_x,
const ImVec2 offset) {
return self->AddCustomRectFontGlyph(font, id, width, height, advance_x,
offset);
}
CIMGUI_API ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(
ImFontAtlas* self,
int index) {
return self->GetCustomRectByIndex(index);
}
CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,
const ImFontAtlasCustomRect* rect,
ImVec2* out_uv_min,
ImVec2* out_uv_max) {
return self->CalcCustomRectUV(rect, out_uv_min, out_uv_max);
}
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]) {
return self->GetMouseCursorTexData(cursor, out_offset, out_size,
out_uv_border, out_uv_fill);
}
CIMGUI_API ImFont* ImFont_ImFont(void) {
return IM_NEW(ImFont)();
}
CIMGUI_API void ImFont_destroy(ImFont* self) {
IM_DELETE(self);
}
CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self, ImWchar c) {
return self->FindGlyph(c);
}
CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,
ImWchar c) {
return self->FindGlyphNoFallback(c);
}
CIMGUI_API float ImFont_GetCharAdvance(ImFont* self, ImWchar c) {
return self->GetCharAdvance(c);
}
CIMGUI_API bool ImFont_IsLoaded(ImFont* self) {
return self->IsLoaded();
}
CIMGUI_API const char* ImFont_GetDebugName(ImFont* self) {
return self->GetDebugName();
}
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) {
*pOut = self->CalcTextSizeA(size, max_width, wrap_width, text_begin, text_end,
remaining);
}
CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,
float scale,
const char* text,
const char* text_end,
float wrap_width) {
return self->CalcWordWrapPositionA(scale, text, text_end, wrap_width);
}
CIMGUI_API void ImFont_RenderChar(ImFont* self,
ImDrawList* draw_list,
float size,
const ImVec2 pos,
ImU32 col,
ImWchar c) {
return self->RenderChar(draw_list, size, pos, col, c);
}
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) {
return self->RenderText(draw_list, size, pos, col, clip_rect, text_begin,
text_end, wrap_width, cpu_fine_clip);
}
CIMGUI_API void ImFont_BuildLookupTable(ImFont* self) {
return self->BuildLookupTable();
}
CIMGUI_API void ImFont_ClearOutputData(ImFont* self) {
return self->ClearOutputData();
}
CIMGUI_API void ImFont_GrowIndex(ImFont* self, int new_size) {
return self->GrowIndex(new_size);
}
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) {
return self->AddGlyph(src_cfg, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
}
CIMGUI_API void ImFont_AddRemapChar(ImFont* self,
ImWchar dst,
ImWchar src,
bool overwrite_dst) {
return self->AddRemapChar(dst, src, overwrite_dst);
}
CIMGUI_API void ImFont_SetGlyphVisible(ImFont* self, ImWchar c, bool visible) {
return self->SetGlyphVisible(c, visible);
}
CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,
unsigned int c_begin,
unsigned int c_last) {
return self->IsGlyphRangeUnused(c_begin, c_last);
}
CIMGUI_API ImGuiViewport* ImGuiViewport_ImGuiViewport(void) {
return IM_NEW(ImGuiViewport)();
}
CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiViewport_GetCenter(ImVec2* pOut, ImGuiViewport* self) {
*pOut = self->GetCenter();
}
CIMGUI_API void ImGuiViewport_GetWorkCenter(ImVec2* pOut, ImGuiViewport* self) {
*pOut = self->GetWorkCenter();
}
CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void) {
return IM_NEW(ImGuiPlatformIO)();
}
CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor(
void) {
return IM_NEW(ImGuiPlatformMonitor)();
}
CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData(
void) {
return IM_NEW(ImGuiPlatformImeData)();
}
CIMGUI_API void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiID igImHashData(const void* data,
size_t data_size,
ImGuiID seed) {
return ImHashData(data, data_size, seed);
}
CIMGUI_API ImGuiID igImHashStr(const char* data,
size_t data_size,
ImGuiID seed) {
return ImHashStr(data, data_size, seed);
}
CIMGUI_API void igImQsort(void* base,
size_t count,
size_t size_of_element,
int (*compare_func)(void const*, void const*)) {
return ImQsort(base, count, size_of_element, compare_func);
}
CIMGUI_API ImU32 igImAlphaBlendColors(ImU32 col_a, ImU32 col_b) {
return ImAlphaBlendColors(col_a, col_b);
}
CIMGUI_API bool igImIsPowerOfTwo_Int(int v) {
return ImIsPowerOfTwo(v);
}
CIMGUI_API bool igImIsPowerOfTwo_U64(ImU64 v) {
return ImIsPowerOfTwo(v);
}
CIMGUI_API int igImUpperPowerOfTwo(int v) {
return ImUpperPowerOfTwo(v);
}
CIMGUI_API int igImStricmp(const char* str1, const char* str2) {
return ImStricmp(str1, str2);
}
CIMGUI_API int igImStrnicmp(const char* str1, const char* str2, size_t count) {
return ImStrnicmp(str1, str2, count);
}
CIMGUI_API void igImStrncpy(char* dst, const char* src, size_t count) {
return ImStrncpy(dst, src, count);
}
CIMGUI_API char* igImStrdup(const char* str) {
return ImStrdup(str);
}
CIMGUI_API char* igImStrdupcpy(char* dst, size_t* p_dst_size, const char* str) {
return ImStrdupcpy(dst, p_dst_size, str);
}
CIMGUI_API const char* igImStrchrRange(const char* str_begin,
const char* str_end,
char c) {
return ImStrchrRange(str_begin, str_end, c);
}
CIMGUI_API const char* igImStreolRange(const char* str, const char* str_end) {
return ImStreolRange(str, str_end);
}
CIMGUI_API const char* igImStristr(const char* haystack,
const char* haystack_end,
const char* needle,
const char* needle_end) {
return ImStristr(haystack, haystack_end, needle, needle_end);
}
CIMGUI_API void igImStrTrimBlanks(char* str) {
return ImStrTrimBlanks(str);
}
CIMGUI_API const char* igImStrSkipBlank(const char* str) {
return ImStrSkipBlank(str);
}
CIMGUI_API int igImStrlenW(const ImWchar* str) {
return ImStrlenW(str);
}
CIMGUI_API const ImWchar* igImStrbolW(const ImWchar* buf_mid_line,
const ImWchar* buf_begin) {
return ImStrbolW(buf_mid_line, buf_begin);
}
CIMGUI_API char igImToUpper(char c) {
return ImToUpper(c);
}
CIMGUI_API bool igImCharIsBlankA(char c) {
return ImCharIsBlankA(c);
}
CIMGUI_API bool igImCharIsBlankW(unsigned int c) {
return ImCharIsBlankW(c);
}
CIMGUI_API int igImFormatString(char* buf,
size_t buf_size,
const char* fmt,
...) {
va_list args;
va_start(args, fmt);
int ret = ImFormatStringV(buf, buf_size, fmt, args);
va_end(args);
return ret;
}
CIMGUI_API int igImFormatStringV(char* buf,
size_t buf_size,
const char* fmt,
va_list args) {
return ImFormatStringV(buf, buf_size, fmt, args);
}
CIMGUI_API void igImFormatStringToTempBuffer(const char** out_buf,
const char** out_buf_end,
const char* fmt,
...) {
va_list args;
va_start(args, fmt);
ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args);
va_end(args);
}
CIMGUI_API void igImFormatStringToTempBufferV(const char** out_buf,
const char** out_buf_end,
const char* fmt,
va_list args) {
return ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args);
}
CIMGUI_API const char* igImParseFormatFindStart(const char* format) {
return ImParseFormatFindStart(format);
}
CIMGUI_API const char* igImParseFormatFindEnd(const char* format) {
return ImParseFormatFindEnd(format);
}
CIMGUI_API const char* igImParseFormatTrimDecorations(const char* format,
char* buf,
size_t buf_size) {
return ImParseFormatTrimDecorations(format, buf, buf_size);
}
CIMGUI_API void igImParseFormatSanitizeForPrinting(const char* fmt_in,
char* fmt_out,
size_t fmt_out_size) {
return ImParseFormatSanitizeForPrinting(fmt_in, fmt_out, fmt_out_size);
}
CIMGUI_API const char* igImParseFormatSanitizeForScanning(const char* fmt_in,
char* fmt_out,
size_t fmt_out_size) {
return ImParseFormatSanitizeForScanning(fmt_in, fmt_out, fmt_out_size);
}
CIMGUI_API int igImParseFormatPrecision(const char* format, int default_value) {
return ImParseFormatPrecision(format, default_value);
}
CIMGUI_API const char* igImTextCharToUtf8(char out_buf[5], unsigned int c) {
return ImTextCharToUtf8(out_buf, c);
}
CIMGUI_API int igImTextStrToUtf8(char* out_buf,
int out_buf_size,
const ImWchar* in_text,
const ImWchar* in_text_end) {
return ImTextStrToUtf8(out_buf, out_buf_size, in_text, in_text_end);
}
CIMGUI_API int igImTextCharFromUtf8(unsigned int* out_char,
const char* in_text,
const char* in_text_end) {
return ImTextCharFromUtf8(out_char, in_text, in_text_end);
}
CIMGUI_API int igImTextStrFromUtf8(ImWchar* out_buf,
int out_buf_size,
const char* in_text,
const char* in_text_end,
const char** in_remaining) {
return ImTextStrFromUtf8(out_buf, out_buf_size, in_text, in_text_end,
in_remaining);
}
CIMGUI_API int igImTextCountCharsFromUtf8(const char* in_text,
const char* in_text_end) {
return ImTextCountCharsFromUtf8(in_text, in_text_end);
}
CIMGUI_API int igImTextCountUtf8BytesFromChar(const char* in_text,
const char* in_text_end) {
return ImTextCountUtf8BytesFromChar(in_text, in_text_end);
}
CIMGUI_API int igImTextCountUtf8BytesFromStr(const ImWchar* in_text,
const ImWchar* in_text_end) {
return ImTextCountUtf8BytesFromStr(in_text, in_text_end);
}
CIMGUI_API const char* igImTextFindPreviousUtf8Codepoint(
const char* in_text_start,
const char* in_text_curr) {
return ImTextFindPreviousUtf8Codepoint(in_text_start, in_text_curr);
}
CIMGUI_API int igImTextCountLines(const char* in_text,
const char* in_text_end) {
return ImTextCountLines(in_text, in_text_end);
}
CIMGUI_API ImFileHandle igImFileOpen(const char* filename, const char* mode) {
return ImFileOpen(filename, mode);
}
CIMGUI_API bool igImFileClose(ImFileHandle file) {
return ImFileClose(file);
}
CIMGUI_API ImU64 igImFileGetSize(ImFileHandle file) {
return ImFileGetSize(file);
}
CIMGUI_API ImU64 igImFileRead(void* data,
ImU64 size,
ImU64 count,
ImFileHandle file) {
return ImFileRead(data, size, count, file);
}
CIMGUI_API ImU64 igImFileWrite(const void* data,
ImU64 size,
ImU64 count,
ImFileHandle file) {
return ImFileWrite(data, size, count, file);
}
CIMGUI_API void* igImFileLoadToMemory(const char* filename,
const char* mode,
size_t* out_file_size,
int padding_bytes) {
return ImFileLoadToMemory(filename, mode, out_file_size, padding_bytes);
}
CIMGUI_API float igImPow_Float(float x, float y) {
return ImPow(x, y);
}
CIMGUI_API double igImPow_double(double x, double y) {
return ImPow(x, y);
}
CIMGUI_API float igImLog_Float(float x) {
return ImLog(x);
}
CIMGUI_API double igImLog_double(double x) {
return ImLog(x);
}
CIMGUI_API int igImAbs_Int(int x) {
return ImAbs(x);
}
CIMGUI_API float igImAbs_Float(float x) {
return ImAbs(x);
}
CIMGUI_API double igImAbs_double(double x) {
return ImAbs(x);
}
CIMGUI_API float igImSign_Float(float x) {
return ImSign(x);
}
CIMGUI_API double igImSign_double(double x) {
return ImSign(x);
}
CIMGUI_API float igImRsqrt_Float(float x) {
return ImRsqrt(x);
}
CIMGUI_API double igImRsqrt_double(double x) {
return ImRsqrt(x);
}
CIMGUI_API void igImMin(ImVec2* pOut, const ImVec2 lhs, const ImVec2 rhs) {
*pOut = ImMin(lhs, rhs);
}
CIMGUI_API void igImMax(ImVec2* pOut, const ImVec2 lhs, const ImVec2 rhs) {
*pOut = ImMax(lhs, rhs);
}
CIMGUI_API void igImClamp(ImVec2* pOut,
const ImVec2 v,
const ImVec2 mn,
ImVec2 mx) {
*pOut = ImClamp(v, mn, mx);
}
CIMGUI_API void igImLerp_Vec2Float(ImVec2* pOut,
const ImVec2 a,
const ImVec2 b,
float t) {
*pOut = ImLerp(a, b, t);
}
CIMGUI_API void igImLerp_Vec2Vec2(ImVec2* pOut,
const ImVec2 a,
const ImVec2 b,
const ImVec2 t) {
*pOut = ImLerp(a, b, t);
}
CIMGUI_API void igImLerp_Vec4(ImVec4* pOut,
const ImVec4 a,
const ImVec4 b,
float t) {
*pOut = ImLerp(a, b, t);
}
CIMGUI_API float igImSaturate(float f) {
return ImSaturate(f);
}
CIMGUI_API float igImLengthSqr_Vec2(const ImVec2 lhs) {
return ImLengthSqr(lhs);
}
CIMGUI_API float igImLengthSqr_Vec4(const ImVec4 lhs) {
return ImLengthSqr(lhs);
}
CIMGUI_API float igImInvLength(const ImVec2 lhs, float fail_value) {
return ImInvLength(lhs, fail_value);
}
CIMGUI_API float igImTrunc_Float(float f) {
return ImTrunc(f);
}
CIMGUI_API void igImTrunc_Vec2(ImVec2* pOut, const ImVec2 v) {
*pOut = ImTrunc(v);
}
CIMGUI_API float igImFloor_Float(float f) {
return ImFloor(f);
}
CIMGUI_API void igImFloor_Vec2(ImVec2* pOut, const ImVec2 v) {
*pOut = ImFloor(v);
}
CIMGUI_API int igImModPositive(int a, int b) {
return ImModPositive(a, b);
}
CIMGUI_API float igImDot(const ImVec2 a, const ImVec2 b) {
return ImDot(a, b);
}
CIMGUI_API void igImRotate(ImVec2* pOut,
const ImVec2 v,
float cos_a,
float sin_a) {
*pOut = ImRotate(v, cos_a, sin_a);
}
CIMGUI_API float igImLinearSweep(float current, float target, float speed) {
return ImLinearSweep(current, target, speed);
}
CIMGUI_API void igImMul(ImVec2* pOut, const ImVec2 lhs, const ImVec2 rhs) {
*pOut = ImMul(lhs, rhs);
}
CIMGUI_API bool igImIsFloatAboveGuaranteedIntegerPrecision(float f) {
return ImIsFloatAboveGuaranteedIntegerPrecision(f);
}
CIMGUI_API float igImExponentialMovingAverage(float avg, float sample, int n) {
return ImExponentialMovingAverage(avg, sample, n);
}
CIMGUI_API void igImBezierCubicCalc(ImVec2* pOut,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
const ImVec2 p4,
float t) {
*pOut = ImBezierCubicCalc(p1, p2, p3, p4, t);
}
CIMGUI_API void igImBezierCubicClosestPoint(ImVec2* pOut,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
const ImVec2 p4,
const ImVec2 p,
int num_segments) {
*pOut = ImBezierCubicClosestPoint(p1, p2, p3, p4, p, num_segments);
}
CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2* pOut,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
const ImVec2 p4,
const ImVec2 p,
float tess_tol) {
*pOut = ImBezierCubicClosestPointCasteljau(p1, p2, p3, p4, p, tess_tol);
}
CIMGUI_API void igImBezierQuadraticCalc(ImVec2* pOut,
const ImVec2 p1,
const ImVec2 p2,
const ImVec2 p3,
float t) {
*pOut = ImBezierQuadraticCalc(p1, p2, p3, t);
}
CIMGUI_API void igImLineClosestPoint(ImVec2* pOut,
const ImVec2 a,
const ImVec2 b,
const ImVec2 p) {
*pOut = ImLineClosestPoint(a, b, p);
}
CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,
const ImVec2 b,
const ImVec2 c,
const ImVec2 p) {
return ImTriangleContainsPoint(a, b, c, p);
}
CIMGUI_API void igImTriangleClosestPoint(ImVec2* pOut,
const ImVec2 a,
const ImVec2 b,
const ImVec2 c,
const ImVec2 p) {
*pOut = ImTriangleClosestPoint(a, b, c, p);
}
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) {
return ImTriangleBarycentricCoords(a, b, c, p, *out_u, *out_v, *out_w);
}
CIMGUI_API float igImTriangleArea(const ImVec2 a,
const ImVec2 b,
const ImVec2 c) {
return ImTriangleArea(a, b, c);
}
CIMGUI_API bool igImTriangleIsClockwise(const ImVec2 a,
const ImVec2 b,
const ImVec2 c) {
return ImTriangleIsClockwise(a, b, c);
}
CIMGUI_API ImVec1* ImVec1_ImVec1_Nil(void) {
return IM_NEW(ImVec1)();
}
CIMGUI_API void ImVec1_destroy(ImVec1* self) {
IM_DELETE(self);
}
CIMGUI_API ImVec1* ImVec1_ImVec1_Float(float _x) {
return IM_NEW(ImVec1)(_x);
}
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Nil(void) {
return IM_NEW(ImVec2ih)();
}
CIMGUI_API void ImVec2ih_destroy(ImVec2ih* self) {
IM_DELETE(self);
}
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_short(short _x, short _y) {
return IM_NEW(ImVec2ih)(_x, _y);
}
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Vec2(const ImVec2 rhs) {
return IM_NEW(ImVec2ih)(rhs);
}
CIMGUI_API ImRect* ImRect_ImRect_Nil(void) {
return IM_NEW(ImRect)();
}
CIMGUI_API void ImRect_destroy(ImRect* self) {
IM_DELETE(self);
}
CIMGUI_API ImRect* ImRect_ImRect_Vec2(const ImVec2 min, const ImVec2 max) {
return IM_NEW(ImRect)(min, max);
}
CIMGUI_API ImRect* ImRect_ImRect_Vec4(const ImVec4 v) {
return IM_NEW(ImRect)(v);
}
CIMGUI_API ImRect* ImRect_ImRect_Float(float x1, float y1, float x2, float y2) {
return IM_NEW(ImRect)(x1, y1, x2, y2);
}
CIMGUI_API void ImRect_GetCenter(ImVec2* pOut, ImRect* self) {
*pOut = self->GetCenter();
}
CIMGUI_API void ImRect_GetSize(ImVec2* pOut, ImRect* self) {
*pOut = self->GetSize();
}
CIMGUI_API float ImRect_GetWidth(ImRect* self) {
return self->GetWidth();
}
CIMGUI_API float ImRect_GetHeight(ImRect* self) {
return self->GetHeight();
}
CIMGUI_API float ImRect_GetArea(ImRect* self) {
return self->GetArea();
}
CIMGUI_API void ImRect_GetTL(ImVec2* pOut, ImRect* self) {
*pOut = self->GetTL();
}
CIMGUI_API void ImRect_GetTR(ImVec2* pOut, ImRect* self) {
*pOut = self->GetTR();
}
CIMGUI_API void ImRect_GetBL(ImVec2* pOut, ImRect* self) {
*pOut = self->GetBL();
}
CIMGUI_API void ImRect_GetBR(ImVec2* pOut, ImRect* self) {
*pOut = self->GetBR();
}
CIMGUI_API bool ImRect_Contains_Vec2(ImRect* self, const ImVec2 p) {
return self->Contains(p);
}
CIMGUI_API bool ImRect_Contains_Rect(ImRect* self, const ImRect r) {
return self->Contains(r);
}
CIMGUI_API bool ImRect_ContainsWithPad(ImRect* self,
const ImVec2 p,
const ImVec2 pad) {
return self->ContainsWithPad(p, pad);
}
CIMGUI_API bool ImRect_Overlaps(ImRect* self, const ImRect r) {
return self->Overlaps(r);
}
CIMGUI_API void ImRect_Add_Vec2(ImRect* self, const ImVec2 p) {
return self->Add(p);
}
CIMGUI_API void ImRect_Add_Rect(ImRect* self, const ImRect r) {
return self->Add(r);
}
CIMGUI_API void ImRect_Expand_Float(ImRect* self, const float amount) {
return self->Expand(amount);
}
CIMGUI_API void ImRect_Expand_Vec2(ImRect* self, const ImVec2 amount) {
return self->Expand(amount);
}
CIMGUI_API void ImRect_Translate(ImRect* self, const ImVec2 d) {
return self->Translate(d);
}
CIMGUI_API void ImRect_TranslateX(ImRect* self, float dx) {
return self->TranslateX(dx);
}
CIMGUI_API void ImRect_TranslateY(ImRect* self, float dy) {
return self->TranslateY(dy);
}
CIMGUI_API void ImRect_ClipWith(ImRect* self, const ImRect r) {
return self->ClipWith(r);
}
CIMGUI_API void ImRect_ClipWithFull(ImRect* self, const ImRect r) {
return self->ClipWithFull(r);
}
CIMGUI_API void ImRect_Floor(ImRect* self) {
return self->Floor();
}
CIMGUI_API bool ImRect_IsInverted(ImRect* self) {
return self->IsInverted();
}
CIMGUI_API void ImRect_ToVec4(ImVec4* pOut, ImRect* self) {
*pOut = self->ToVec4();
}
CIMGUI_API size_t igImBitArrayGetStorageSizeInBytes(int bitcount) {
return ImBitArrayGetStorageSizeInBytes(bitcount);
}
CIMGUI_API void igImBitArrayClearAllBits(ImU32* arr, int bitcount) {
return ImBitArrayClearAllBits(arr, bitcount);
}
CIMGUI_API bool igImBitArrayTestBit(const ImU32* arr, int n) {
return ImBitArrayTestBit(arr, n);
}
CIMGUI_API void igImBitArrayClearBit(ImU32* arr, int n) {
return ImBitArrayClearBit(arr, n);
}
CIMGUI_API void igImBitArraySetBit(ImU32* arr, int n) {
return ImBitArraySetBit(arr, n);
}
CIMGUI_API void igImBitArraySetBitRange(ImU32* arr, int n, int n2) {
return ImBitArraySetBitRange(arr, n, n2);
}
CIMGUI_API void ImBitVector_Create(ImBitVector* self, int sz) {
return self->Create(sz);
}
CIMGUI_API void ImBitVector_Clear(ImBitVector* self) {
return self->Clear();
}
CIMGUI_API bool ImBitVector_TestBit(ImBitVector* self, int n) {
return self->TestBit(n);
}
CIMGUI_API void ImBitVector_SetBit(ImBitVector* self, int n) {
return self->SetBit(n);
}
CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self, int n) {
return self->ClearBit(n);
}
CIMGUI_API void ImGuiTextIndex_clear(ImGuiTextIndex* self) {
return self->clear();
}
CIMGUI_API int ImGuiTextIndex_size(ImGuiTextIndex* self) {
return self->size();
}
CIMGUI_API const char* ImGuiTextIndex_get_line_begin(ImGuiTextIndex* self,
const char* base,
int n) {
return self->get_line_begin(base, n);
}
CIMGUI_API const char* ImGuiTextIndex_get_line_end(ImGuiTextIndex* self,
const char* base,
int n) {
return self->get_line_end(base, n);
}
CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self,
const char* base,
int old_size,
int new_size) {
return self->append(base, old_size, new_size);
}
CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(
void) {
return IM_NEW(ImDrawListSharedData)();
}
CIMGUI_API void ImDrawListSharedData_destroy(ImDrawListSharedData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImDrawListSharedData_SetCircleTessellationMaxError(
ImDrawListSharedData* self,
float max_error) {
return self->SetCircleTessellationMaxError(max_error);
}
CIMGUI_API ImDrawDataBuilder* ImDrawDataBuilder_ImDrawDataBuilder(void) {
return IM_NEW(ImDrawDataBuilder)();
}
CIMGUI_API void ImDrawDataBuilder_destroy(ImDrawDataBuilder* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Int(ImGuiStyleVar idx,
int v) {
return IM_NEW(ImGuiStyleMod)(idx, v);
}
CIMGUI_API void ImGuiStyleMod_destroy(ImGuiStyleMod* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Float(ImGuiStyleVar idx,
float v) {
return IM_NEW(ImGuiStyleMod)(idx, v);
}
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Vec2(ImGuiStyleVar idx,
ImVec2 v) {
return IM_NEW(ImGuiStyleMod)(idx, v);
}
CIMGUI_API ImGuiComboPreviewData* ImGuiComboPreviewData_ImGuiComboPreviewData(
void) {
return IM_NEW(ImGuiComboPreviewData)();
}
CIMGUI_API void ImGuiComboPreviewData_destroy(ImGuiComboPreviewData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiMenuColumns* ImGuiMenuColumns_ImGuiMenuColumns(void) {
return IM_NEW(ImGuiMenuColumns)();
}
CIMGUI_API void ImGuiMenuColumns_destroy(ImGuiMenuColumns* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiMenuColumns_Update(ImGuiMenuColumns* self,
float spacing,
bool window_reappearing) {
return self->Update(spacing, window_reappearing);
}
CIMGUI_API float ImGuiMenuColumns_DeclColumns(ImGuiMenuColumns* self,
float w_icon,
float w_label,
float w_shortcut,
float w_mark) {
return self->DeclColumns(w_icon, w_label, w_shortcut, w_mark);
}
CIMGUI_API void ImGuiMenuColumns_CalcNextTotalWidth(ImGuiMenuColumns* self,
bool update_offsets) {
return self->CalcNextTotalWidth(update_offsets);
}
CIMGUI_API ImGuiInputTextDeactivatedState*
ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState(void) {
return IM_NEW(ImGuiInputTextDeactivatedState)();
}
CIMGUI_API void ImGuiInputTextDeactivatedState_destroy(
ImGuiInputTextDeactivatedState* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiInputTextDeactivatedState_ClearFreeMemory(
ImGuiInputTextDeactivatedState* self) {
return self->ClearFreeMemory();
}
CIMGUI_API ImGuiInputTextState* ImGuiInputTextState_ImGuiInputTextState(void) {
return IM_NEW(ImGuiInputTextState)();
}
CIMGUI_API void ImGuiInputTextState_destroy(ImGuiInputTextState* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiInputTextState_ClearText(ImGuiInputTextState* self) {
return self->ClearText();
}
CIMGUI_API void ImGuiInputTextState_ClearFreeMemory(ImGuiInputTextState* self) {
return self->ClearFreeMemory();
}
CIMGUI_API int ImGuiInputTextState_GetUndoAvailCount(
ImGuiInputTextState* self) {
return self->GetUndoAvailCount();
}
CIMGUI_API int ImGuiInputTextState_GetRedoAvailCount(
ImGuiInputTextState* self) {
return self->GetRedoAvailCount();
}
CIMGUI_API void ImGuiInputTextState_OnKeyPressed(ImGuiInputTextState* self,
int key) {
return self->OnKeyPressed(key);
}
CIMGUI_API void ImGuiInputTextState_CursorAnimReset(ImGuiInputTextState* self) {
return self->CursorAnimReset();
}
CIMGUI_API void ImGuiInputTextState_CursorClamp(ImGuiInputTextState* self) {
return self->CursorClamp();
}
CIMGUI_API bool ImGuiInputTextState_HasSelection(ImGuiInputTextState* self) {
return self->HasSelection();
}
CIMGUI_API void ImGuiInputTextState_ClearSelection(ImGuiInputTextState* self) {
return self->ClearSelection();
}
CIMGUI_API int ImGuiInputTextState_GetCursorPos(ImGuiInputTextState* self) {
return self->GetCursorPos();
}
CIMGUI_API int ImGuiInputTextState_GetSelectionStart(
ImGuiInputTextState* self) {
return self->GetSelectionStart();
}
CIMGUI_API int ImGuiInputTextState_GetSelectionEnd(ImGuiInputTextState* self) {
return self->GetSelectionEnd();
}
CIMGUI_API void ImGuiInputTextState_SelectAll(ImGuiInputTextState* self) {
return self->SelectAll();
}
CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndSelectAll(
ImGuiInputTextState* self) {
return self->ReloadUserBufAndSelectAll();
}
CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndKeepSelection(
ImGuiInputTextState* self) {
return self->ReloadUserBufAndKeepSelection();
}
CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndMoveToEnd(
ImGuiInputTextState* self) {
return self->ReloadUserBufAndMoveToEnd();
}
CIMGUI_API ImGuiNextWindowData* ImGuiNextWindowData_ImGuiNextWindowData(void) {
return IM_NEW(ImGuiNextWindowData)();
}
CIMGUI_API void ImGuiNextWindowData_destroy(ImGuiNextWindowData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiNextWindowData_ClearFlags(ImGuiNextWindowData* self) {
return self->ClearFlags();
}
CIMGUI_API ImGuiNextItemData* ImGuiNextItemData_ImGuiNextItemData(void) {
return IM_NEW(ImGuiNextItemData)();
}
CIMGUI_API void ImGuiNextItemData_destroy(ImGuiNextItemData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiNextItemData_ClearFlags(ImGuiNextItemData* self) {
return self->ClearFlags();
}
CIMGUI_API ImGuiLastItemData* ImGuiLastItemData_ImGuiLastItemData(void) {
return IM_NEW(ImGuiLastItemData)();
}
CIMGUI_API void ImGuiLastItemData_destroy(ImGuiLastItemData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiStackSizes* ImGuiStackSizes_ImGuiStackSizes(void) {
return IM_NEW(ImGuiStackSizes)();
}
CIMGUI_API void ImGuiStackSizes_destroy(ImGuiStackSizes* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiStackSizes_SetToContextState(ImGuiStackSizes* self,
ImGuiContext* ctx) {
return self->SetToContextState(ctx);
}
CIMGUI_API void ImGuiStackSizes_CompareWithContextState(ImGuiStackSizes* self,
ImGuiContext* ctx) {
return self->CompareWithContextState(ctx);
}
CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr(void* ptr) {
return IM_NEW(ImGuiPtrOrIndex)(ptr);
}
CIMGUI_API void ImGuiPtrOrIndex_destroy(ImGuiPtrOrIndex* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(int index) {
return IM_NEW(ImGuiPtrOrIndex)(index);
}
CIMGUI_API void* ImGuiDataVarInfo_GetVarPtr(ImGuiDataVarInfo* self,
void* parent) {
return self->GetVarPtr(parent);
}
CIMGUI_API ImGuiPopupData* ImGuiPopupData_ImGuiPopupData(void) {
return IM_NEW(ImGuiPopupData)();
}
CIMGUI_API void ImGuiPopupData_destroy(ImGuiPopupData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiInputEvent* ImGuiInputEvent_ImGuiInputEvent(void) {
return IM_NEW(ImGuiInputEvent)();
}
CIMGUI_API void ImGuiInputEvent_destroy(ImGuiInputEvent* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiKeyRoutingData* ImGuiKeyRoutingData_ImGuiKeyRoutingData(void) {
return IM_NEW(ImGuiKeyRoutingData)();
}
CIMGUI_API void ImGuiKeyRoutingData_destroy(ImGuiKeyRoutingData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiKeyRoutingTable* ImGuiKeyRoutingTable_ImGuiKeyRoutingTable(
void) {
return IM_NEW(ImGuiKeyRoutingTable)();
}
CIMGUI_API void ImGuiKeyRoutingTable_destroy(ImGuiKeyRoutingTable* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiKeyRoutingTable_Clear(ImGuiKeyRoutingTable* self) {
return self->Clear();
}
CIMGUI_API ImGuiKeyOwnerData* ImGuiKeyOwnerData_ImGuiKeyOwnerData(void) {
return IM_NEW(ImGuiKeyOwnerData)();
}
CIMGUI_API void ImGuiKeyOwnerData_destroy(ImGuiKeyOwnerData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromIndices(int min,
int max) {
return ImGuiListClipperRange::FromIndices(min, max);
}
CIMGUI_API ImGuiListClipperRange
ImGuiListClipperRange_FromPositions(float y1,
float y2,
int off_min,
int off_max) {
return ImGuiListClipperRange::FromPositions(y1, y2, off_min, off_max);
}
CIMGUI_API ImGuiListClipperData* ImGuiListClipperData_ImGuiListClipperData(
void) {
return IM_NEW(ImGuiListClipperData)();
}
CIMGUI_API void ImGuiListClipperData_destroy(ImGuiListClipperData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiListClipperData_Reset(ImGuiListClipperData* self,
ImGuiListClipper* clipper) {
return self->Reset(clipper);
}
CIMGUI_API ImGuiNavItemData* ImGuiNavItemData_ImGuiNavItemData(void) {
return IM_NEW(ImGuiNavItemData)();
}
CIMGUI_API void ImGuiNavItemData_destroy(ImGuiNavItemData* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiNavItemData_Clear(ImGuiNavItemData* self) {
return self->Clear();
}
CIMGUI_API ImGuiTypingSelectState*
ImGuiTypingSelectState_ImGuiTypingSelectState(void) {
return IM_NEW(ImGuiTypingSelectState)();
}
CIMGUI_API void ImGuiTypingSelectState_destroy(ImGuiTypingSelectState* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiTypingSelectState_Clear(ImGuiTypingSelectState* self) {
return self->Clear();
}
CIMGUI_API ImGuiOldColumnData* ImGuiOldColumnData_ImGuiOldColumnData(void) {
return IM_NEW(ImGuiOldColumnData)();
}
CIMGUI_API void ImGuiOldColumnData_destroy(ImGuiOldColumnData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiOldColumns* ImGuiOldColumns_ImGuiOldColumns(void) {
return IM_NEW(ImGuiOldColumns)();
}
CIMGUI_API void ImGuiOldColumns_destroy(ImGuiOldColumns* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiDockNode* ImGuiDockNode_ImGuiDockNode(ImGuiID id) {
return IM_NEW(ImGuiDockNode)(id);
}
CIMGUI_API void ImGuiDockNode_destroy(ImGuiDockNode* self) {
IM_DELETE(self);
}
CIMGUI_API bool ImGuiDockNode_IsRootNode(ImGuiDockNode* self) {
return self->IsRootNode();
}
CIMGUI_API bool ImGuiDockNode_IsDockSpace(ImGuiDockNode* self) {
return self->IsDockSpace();
}
CIMGUI_API bool ImGuiDockNode_IsFloatingNode(ImGuiDockNode* self) {
return self->IsFloatingNode();
}
CIMGUI_API bool ImGuiDockNode_IsCentralNode(ImGuiDockNode* self) {
return self->IsCentralNode();
}
CIMGUI_API bool ImGuiDockNode_IsHiddenTabBar(ImGuiDockNode* self) {
return self->IsHiddenTabBar();
}
CIMGUI_API bool ImGuiDockNode_IsNoTabBar(ImGuiDockNode* self) {
return self->IsNoTabBar();
}
CIMGUI_API bool ImGuiDockNode_IsSplitNode(ImGuiDockNode* self) {
return self->IsSplitNode();
}
CIMGUI_API bool ImGuiDockNode_IsLeafNode(ImGuiDockNode* self) {
return self->IsLeafNode();
}
CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self) {
return self->IsEmpty();
}
CIMGUI_API void ImGuiDockNode_Rect(ImRect* pOut, ImGuiDockNode* self) {
*pOut = self->Rect();
}
CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,
ImGuiDockNodeFlags flags) {
return self->SetLocalFlags(flags);
}
CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self) {
return self->UpdateMergedFlags();
}
CIMGUI_API ImGuiDockContext* ImGuiDockContext_ImGuiDockContext(void) {
return IM_NEW(ImGuiDockContext)();
}
CIMGUI_API void ImGuiDockContext_destroy(ImGuiDockContext* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiViewportP* ImGuiViewportP_ImGuiViewportP(void) {
return IM_NEW(ImGuiViewportP)();
}
CIMGUI_API void ImGuiViewportP_destroy(ImGuiViewportP* self) {
IM_DELETE(self);
}
CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self) {
return self->ClearRequestFlags();
}
CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2* pOut,
ImGuiViewportP* self,
const ImVec2 off_min) {
*pOut = self->CalcWorkRectPos(off_min);
}
CIMGUI_API void ImGuiViewportP_CalcWorkRectSize(ImVec2* pOut,
ImGuiViewportP* self,
const ImVec2 off_min,
const ImVec2 off_max) {
*pOut = self->CalcWorkRectSize(off_min, off_max);
}
CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self) {
return self->UpdateWorkRect();
}
CIMGUI_API void ImGuiViewportP_GetMainRect(ImRect* pOut, ImGuiViewportP* self) {
*pOut = self->GetMainRect();
}
CIMGUI_API void ImGuiViewportP_GetWorkRect(ImRect* pOut, ImGuiViewportP* self) {
*pOut = self->GetWorkRect();
}
CIMGUI_API void ImGuiViewportP_GetBuildWorkRect(ImRect* pOut,
ImGuiViewportP* self) {
*pOut = self->GetBuildWorkRect();
}
CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void) {
return IM_NEW(ImGuiWindowSettings)();
}
CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self) {
IM_DELETE(self);
}
CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self) {
return self->GetName();
}
CIMGUI_API ImGuiSettingsHandler* ImGuiSettingsHandler_ImGuiSettingsHandler(
void) {
return IM_NEW(ImGuiSettingsHandler)();
}
CIMGUI_API void ImGuiSettingsHandler_destroy(ImGuiSettingsHandler* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiDebugAllocInfo* ImGuiDebugAllocInfo_ImGuiDebugAllocInfo(void) {
return IM_NEW(ImGuiDebugAllocInfo)();
}
CIMGUI_API void ImGuiDebugAllocInfo_destroy(ImGuiDebugAllocInfo* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiStackLevelInfo* ImGuiStackLevelInfo_ImGuiStackLevelInfo(void) {
return IM_NEW(ImGuiStackLevelInfo)();
}
CIMGUI_API void ImGuiStackLevelInfo_destroy(ImGuiStackLevelInfo* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiIDStackTool* ImGuiIDStackTool_ImGuiIDStackTool(void) {
return IM_NEW(ImGuiIDStackTool)();
}
CIMGUI_API void ImGuiIDStackTool_destroy(ImGuiIDStackTool* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiContextHook* ImGuiContextHook_ImGuiContextHook(void) {
return IM_NEW(ImGuiContextHook)();
}
CIMGUI_API void ImGuiContextHook_destroy(ImGuiContextHook* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiContext* ImGuiContext_ImGuiContext(
ImFontAtlas* shared_font_atlas) {
return IM_NEW(ImGuiContext)(shared_font_atlas);
}
CIMGUI_API void ImGuiContext_destroy(ImGuiContext* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiWindow* ImGuiWindow_ImGuiWindow(ImGuiContext* context,
const char* name) {
return IM_NEW(ImGuiWindow)(context, name);
}
CIMGUI_API void ImGuiWindow_destroy(ImGuiWindow* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiID ImGuiWindow_GetID_Str(ImGuiWindow* self,
const char* str,
const char* str_end) {
return self->GetID(str, str_end);
}
CIMGUI_API ImGuiID ImGuiWindow_GetID_Ptr(ImGuiWindow* self, const void* ptr) {
return self->GetID(ptr);
}
CIMGUI_API ImGuiID ImGuiWindow_GetID_Int(ImGuiWindow* self, int n) {
return self->GetID(n);
}
CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,
const ImRect r_abs) {
return self->GetIDFromRectangle(r_abs);
}
CIMGUI_API void ImGuiWindow_Rect(ImRect* pOut, ImGuiWindow* self) {
*pOut = self->Rect();
}
CIMGUI_API float ImGuiWindow_CalcFontSize(ImGuiWindow* self) {
return self->CalcFontSize();
}
CIMGUI_API float ImGuiWindow_TitleBarHeight(ImGuiWindow* self) {
return self->TitleBarHeight();
}
CIMGUI_API void ImGuiWindow_TitleBarRect(ImRect* pOut, ImGuiWindow* self) {
*pOut = self->TitleBarRect();
}
CIMGUI_API float ImGuiWindow_MenuBarHeight(ImGuiWindow* self) {
return self->MenuBarHeight();
}
CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect* pOut, ImGuiWindow* self) {
*pOut = self->MenuBarRect();
}
CIMGUI_API ImGuiTabItem* ImGuiTabItem_ImGuiTabItem(void) {
return IM_NEW(ImGuiTabItem)();
}
CIMGUI_API void ImGuiTabItem_destroy(ImGuiTabItem* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTabBar* ImGuiTabBar_ImGuiTabBar(void) {
return IM_NEW(ImGuiTabBar)();
}
CIMGUI_API void ImGuiTabBar_destroy(ImGuiTabBar* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumn* ImGuiTableColumn_ImGuiTableColumn(void) {
return IM_NEW(ImGuiTableColumn)();
}
CIMGUI_API void ImGuiTableColumn_destroy(ImGuiTableColumn* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableInstanceData*
ImGuiTableInstanceData_ImGuiTableInstanceData(void) {
return IM_NEW(ImGuiTableInstanceData)();
}
CIMGUI_API void ImGuiTableInstanceData_destroy(ImGuiTableInstanceData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTable* ImGuiTable_ImGuiTable(void) {
return IM_NEW(ImGuiTable)();
}
CIMGUI_API void ImGuiTable_destroy(ImGuiTable* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableTempData* ImGuiTableTempData_ImGuiTableTempData(void) {
return IM_NEW(ImGuiTableTempData)();
}
CIMGUI_API void ImGuiTableTempData_destroy(ImGuiTableTempData* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumnSettings*
ImGuiTableColumnSettings_ImGuiTableColumnSettings(void) {
return IM_NEW(ImGuiTableColumnSettings)();
}
CIMGUI_API void ImGuiTableColumnSettings_destroy(
ImGuiTableColumnSettings* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableSettings* ImGuiTableSettings_ImGuiTableSettings(void) {
return IM_NEW(ImGuiTableSettings)();
}
CIMGUI_API void ImGuiTableSettings_destroy(ImGuiTableSettings* self) {
IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(
ImGuiTableSettings* self) {
return self->GetColumnSettings();
}
CIMGUI_API ImGuiWindow* igGetCurrentWindowRead() {
return ImGui::GetCurrentWindowRead();
}
CIMGUI_API ImGuiWindow* igGetCurrentWindow() {
return ImGui::GetCurrentWindow();
}
CIMGUI_API ImGuiWindow* igFindWindowByID(ImGuiID id) {
return ImGui::FindWindowByID(id);
}
CIMGUI_API ImGuiWindow* igFindWindowByName(const char* name) {
return ImGui::FindWindowByName(name);
}
CIMGUI_API void igUpdateWindowParentAndRootLinks(ImGuiWindow* window,
ImGuiWindowFlags flags,
ImGuiWindow* parent_window) {
return ImGui::UpdateWindowParentAndRootLinks(window, flags, parent_window);
}
CIMGUI_API void igUpdateWindowSkipRefresh(ImGuiWindow* window) {
return ImGui::UpdateWindowSkipRefresh(window);
}
CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2* pOut, ImGuiWindow* window) {
*pOut = ImGui::CalcWindowNextAutoFitSize(window);
}
CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,
ImGuiWindow* potential_parent,
bool popup_hierarchy,
bool dock_hierarchy) {
return ImGui::IsWindowChildOf(window, potential_parent, popup_hierarchy,
dock_hierarchy);
}
CIMGUI_API bool igIsWindowWithinBeginStackOf(ImGuiWindow* window,
ImGuiWindow* potential_parent) {
return ImGui::IsWindowWithinBeginStackOf(window, potential_parent);
}
CIMGUI_API bool igIsWindowAbove(ImGuiWindow* potential_above,
ImGuiWindow* potential_below) {
return ImGui::IsWindowAbove(potential_above, potential_below);
}
CIMGUI_API bool igIsWindowNavFocusable(ImGuiWindow* window) {
return ImGui::IsWindowNavFocusable(window);
}
CIMGUI_API void igSetWindowPos_WindowPtr(ImGuiWindow* window,
const ImVec2 pos,
ImGuiCond cond) {
return ImGui::SetWindowPos(window, pos, cond);
}
CIMGUI_API void igSetWindowSize_WindowPtr(ImGuiWindow* window,
const ImVec2 size,
ImGuiCond cond) {
return ImGui::SetWindowSize(window, size, cond);
}
CIMGUI_API void igSetWindowCollapsed_WindowPtr(ImGuiWindow* window,
bool collapsed,
ImGuiCond cond) {
return ImGui::SetWindowCollapsed(window, collapsed, cond);
}
CIMGUI_API void igSetWindowHitTestHole(ImGuiWindow* window,
const ImVec2 pos,
const ImVec2 size) {
return ImGui::SetWindowHitTestHole(window, pos, size);
}
CIMGUI_API void igSetWindowHiddenAndSkipItemsForCurrentFrame(
ImGuiWindow* window) {
return ImGui::SetWindowHiddenAndSkipItemsForCurrentFrame(window);
}
CIMGUI_API void igSetWindowParentWindowForFocusRoute(
ImGuiWindow* window,
ImGuiWindow* parent_window) {
return ImGui::SetWindowParentWindowForFocusRoute(window, parent_window);
}
CIMGUI_API void igWindowRectAbsToRel(ImRect* pOut,
ImGuiWindow* window,
const ImRect r) {
*pOut = ImGui::WindowRectAbsToRel(window, r);
}
CIMGUI_API void igWindowRectRelToAbs(ImRect* pOut,
ImGuiWindow* window,
const ImRect r) {
*pOut = ImGui::WindowRectRelToAbs(window, r);
}
CIMGUI_API void igWindowPosRelToAbs(ImVec2* pOut,
ImGuiWindow* window,
const ImVec2 p) {
*pOut = ImGui::WindowPosRelToAbs(window, p);
}
CIMGUI_API void igFocusWindow(ImGuiWindow* window,
ImGuiFocusRequestFlags flags) {
return ImGui::FocusWindow(window, flags);
}
CIMGUI_API void igFocusTopMostWindowUnderOne(ImGuiWindow* under_this_window,
ImGuiWindow* ignore_window,
ImGuiViewport* filter_viewport,
ImGuiFocusRequestFlags flags) {
return ImGui::FocusTopMostWindowUnderOne(under_this_window, ignore_window,
filter_viewport, flags);
}
CIMGUI_API void igBringWindowToFocusFront(ImGuiWindow* window) {
return ImGui::BringWindowToFocusFront(window);
}
CIMGUI_API void igBringWindowToDisplayFront(ImGuiWindow* window) {
return ImGui::BringWindowToDisplayFront(window);
}
CIMGUI_API void igBringWindowToDisplayBack(ImGuiWindow* window) {
return ImGui::BringWindowToDisplayBack(window);
}
CIMGUI_API void igBringWindowToDisplayBehind(ImGuiWindow* window,
ImGuiWindow* above_window) {
return ImGui::BringWindowToDisplayBehind(window, above_window);
}
CIMGUI_API int igFindWindowDisplayIndex(ImGuiWindow* window) {
return ImGui::FindWindowDisplayIndex(window);
}
CIMGUI_API ImGuiWindow* igFindBottomMostVisibleWindowWithinBeginStack(
ImGuiWindow* window) {
return ImGui::FindBottomMostVisibleWindowWithinBeginStack(window);
}
CIMGUI_API void igSetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags) {
return ImGui::SetNextWindowRefreshPolicy(flags);
}
CIMGUI_API void igSetCurrentFont(ImFont* font) {
return ImGui::SetCurrentFont(font);
}
CIMGUI_API ImFont* igGetDefaultFont() {
return ImGui::GetDefaultFont();
}
CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window) {
return ImGui::GetForegroundDrawList(window);
}
CIMGUI_API void igAddDrawListToDrawDataEx(ImDrawData* draw_data,
ImVector_ImDrawListPtr* out_list,
ImDrawList* draw_list) {
return ImGui::AddDrawListToDrawDataEx(draw_data, out_list, draw_list);
}
CIMGUI_API void igInitialize() {
return ImGui::Initialize();
}
CIMGUI_API void igShutdown() {
return ImGui::Shutdown();
}
CIMGUI_API void igUpdateInputEvents(bool trickle_fast_inputs) {
return ImGui::UpdateInputEvents(trickle_fast_inputs);
}
CIMGUI_API void igUpdateHoveredWindowAndCaptureFlags() {
return ImGui::UpdateHoveredWindowAndCaptureFlags();
}
CIMGUI_API void igStartMouseMovingWindow(ImGuiWindow* window) {
return ImGui::StartMouseMovingWindow(window);
}
CIMGUI_API void igStartMouseMovingWindowOrNode(ImGuiWindow* window,
ImGuiDockNode* node,
bool undock) {
return ImGui::StartMouseMovingWindowOrNode(window, node, undock);
}
CIMGUI_API void igUpdateMouseMovingWindowNewFrame() {
return ImGui::UpdateMouseMovingWindowNewFrame();
}
CIMGUI_API void igUpdateMouseMovingWindowEndFrame() {
return ImGui::UpdateMouseMovingWindowEndFrame();
}
CIMGUI_API ImGuiID igAddContextHook(ImGuiContext* context,
const ImGuiContextHook* hook) {
return ImGui::AddContextHook(context, hook);
}
CIMGUI_API void igRemoveContextHook(ImGuiContext* context,
ImGuiID hook_to_remove) {
return ImGui::RemoveContextHook(context, hook_to_remove);
}
CIMGUI_API void igCallContextHooks(ImGuiContext* context,
ImGuiContextHookType type) {
return ImGui::CallContextHooks(context, type);
}
CIMGUI_API void igTranslateWindowsInViewport(ImGuiViewportP* viewport,
const ImVec2 old_pos,
const ImVec2 new_pos) {
return ImGui::TranslateWindowsInViewport(viewport, old_pos, new_pos);
}
CIMGUI_API void igScaleWindowsInViewport(ImGuiViewportP* viewport,
float scale) {
return ImGui::ScaleWindowsInViewport(viewport, scale);
}
CIMGUI_API void igDestroyPlatformWindow(ImGuiViewportP* viewport) {
return ImGui::DestroyPlatformWindow(viewport);
}
CIMGUI_API void igSetWindowViewport(ImGuiWindow* window,
ImGuiViewportP* viewport) {
return ImGui::SetWindowViewport(window, viewport);
}
CIMGUI_API void igSetCurrentViewport(ImGuiWindow* window,
ImGuiViewportP* viewport) {
return ImGui::SetCurrentViewport(window, viewport);
}
CIMGUI_API const ImGuiPlatformMonitor* igGetViewportPlatformMonitor(
ImGuiViewport* viewport) {
return ImGui::GetViewportPlatformMonitor(viewport);
}
CIMGUI_API ImGuiViewportP* igFindHoveredViewportFromPlatformWindowStack(
const ImVec2 mouse_platform_pos) {
return ImGui::FindHoveredViewportFromPlatformWindowStack(mouse_platform_pos);
}
CIMGUI_API void igMarkIniSettingsDirty_Nil() {
return ImGui::MarkIniSettingsDirty();
}
CIMGUI_API void igMarkIniSettingsDirty_WindowPtr(ImGuiWindow* window) {
return ImGui::MarkIniSettingsDirty(window);
}
CIMGUI_API void igClearIniSettings() {
return ImGui::ClearIniSettings();
}
CIMGUI_API void igAddSettingsHandler(const ImGuiSettingsHandler* handler) {
return ImGui::AddSettingsHandler(handler);
}
CIMGUI_API void igRemoveSettingsHandler(const char* type_name) {
return ImGui::RemoveSettingsHandler(type_name);
}
CIMGUI_API ImGuiSettingsHandler* igFindSettingsHandler(const char* type_name) {
return ImGui::FindSettingsHandler(type_name);
}
CIMGUI_API ImGuiWindowSettings* igCreateNewWindowSettings(const char* name) {
return ImGui::CreateNewWindowSettings(name);
}
CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByID(ImGuiID id) {
return ImGui::FindWindowSettingsByID(id);
}
CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByWindow(
ImGuiWindow* window) {
return ImGui::FindWindowSettingsByWindow(window);
}
CIMGUI_API void igClearWindowSettings(const char* name) {
return ImGui::ClearWindowSettings(name);
}
CIMGUI_API void igLocalizeRegisterEntries(const ImGuiLocEntry* entries,
int count) {
return ImGui::LocalizeRegisterEntries(entries, count);
}
CIMGUI_API const char* igLocalizeGetMsg(ImGuiLocKey key) {
return ImGui::LocalizeGetMsg(key);
}
CIMGUI_API void igSetScrollX_WindowPtr(ImGuiWindow* window, float scroll_x) {
return ImGui::SetScrollX(window, scroll_x);
}
CIMGUI_API void igSetScrollY_WindowPtr(ImGuiWindow* window, float scroll_y) {
return ImGui::SetScrollY(window, scroll_y);
}
CIMGUI_API void igSetScrollFromPosX_WindowPtr(ImGuiWindow* window,
float local_x,
float center_x_ratio) {
return ImGui::SetScrollFromPosX(window, local_x, center_x_ratio);
}
CIMGUI_API void igSetScrollFromPosY_WindowPtr(ImGuiWindow* window,
float local_y,
float center_y_ratio) {
return ImGui::SetScrollFromPosY(window, local_y, center_y_ratio);
}
CIMGUI_API void igScrollToItem(ImGuiScrollFlags flags) {
return ImGui::ScrollToItem(flags);
}
CIMGUI_API void igScrollToRect(ImGuiWindow* window,
const ImRect rect,
ImGuiScrollFlags flags) {
return ImGui::ScrollToRect(window, rect, flags);
}
CIMGUI_API void igScrollToRectEx(ImVec2* pOut,
ImGuiWindow* window,
const ImRect rect,
ImGuiScrollFlags flags) {
*pOut = ImGui::ScrollToRectEx(window, rect, flags);
}
CIMGUI_API void igScrollToBringRectIntoView(ImGuiWindow* window,
const ImRect rect) {
return ImGui::ScrollToBringRectIntoView(window, rect);
}
CIMGUI_API ImGuiItemStatusFlags igGetItemStatusFlags() {
return ImGui::GetItemStatusFlags();
}
CIMGUI_API ImGuiItemFlags igGetItemFlags() {
return ImGui::GetItemFlags();
}
CIMGUI_API ImGuiID igGetActiveID() {
return ImGui::GetActiveID();
}
CIMGUI_API ImGuiID igGetFocusID() {
return ImGui::GetFocusID();
}
CIMGUI_API void igSetActiveID(ImGuiID id, ImGuiWindow* window) {
return ImGui::SetActiveID(id, window);
}
CIMGUI_API void igSetFocusID(ImGuiID id, ImGuiWindow* window) {
return ImGui::SetFocusID(id, window);
}
CIMGUI_API void igClearActiveID() {
return ImGui::ClearActiveID();
}
CIMGUI_API ImGuiID igGetHoveredID() {
return ImGui::GetHoveredID();
}
CIMGUI_API void igSetHoveredID(ImGuiID id) {
return ImGui::SetHoveredID(id);
}
CIMGUI_API void igKeepAliveID(ImGuiID id) {
return ImGui::KeepAliveID(id);
}
CIMGUI_API void igMarkItemEdited(ImGuiID id) {
return ImGui::MarkItemEdited(id);
}
CIMGUI_API void igPushOverrideID(ImGuiID id) {
return ImGui::PushOverrideID(id);
}
CIMGUI_API ImGuiID igGetIDWithSeed_Str(const char* str_id_begin,
const char* str_id_end,
ImGuiID seed) {
return ImGui::GetIDWithSeed(str_id_begin, str_id_end, seed);
}
CIMGUI_API ImGuiID igGetIDWithSeed_Int(int n, ImGuiID seed) {
return ImGui::GetIDWithSeed(n, seed);
}
CIMGUI_API void igItemSize_Vec2(const ImVec2 size, float text_baseline_y) {
return ImGui::ItemSize(size, text_baseline_y);
}
CIMGUI_API void igItemSize_Rect(const ImRect bb, float text_baseline_y) {
return ImGui::ItemSize(bb, text_baseline_y);
}
CIMGUI_API bool igItemAdd(const ImRect bb,
ImGuiID id,
const ImRect* nav_bb,
ImGuiItemFlags extra_flags) {
return ImGui::ItemAdd(bb, id, nav_bb, extra_flags);
}
CIMGUI_API bool igItemHoverable(const ImRect bb,
ImGuiID id,
ImGuiItemFlags item_flags) {
return ImGui::ItemHoverable(bb, id, item_flags);
}
CIMGUI_API bool igIsWindowContentHoverable(ImGuiWindow* window,
ImGuiHoveredFlags flags) {
return ImGui::IsWindowContentHoverable(window, flags);
}
CIMGUI_API bool igIsClippedEx(const ImRect bb, ImGuiID id) {
return ImGui::IsClippedEx(bb, id);
}
CIMGUI_API void igSetLastItemData(ImGuiID item_id,
ImGuiItemFlags in_flags,
ImGuiItemStatusFlags status_flags,
const ImRect item_rect) {
return ImGui::SetLastItemData(item_id, in_flags, status_flags, item_rect);
}
CIMGUI_API void igCalcItemSize(ImVec2* pOut,
ImVec2 size,
float default_w,
float default_h) {
*pOut = ImGui::CalcItemSize(size, default_w, default_h);
}
CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos, float wrap_pos_x) {
return ImGui::CalcWrapWidthForPos(pos, wrap_pos_x);
}
CIMGUI_API void igPushMultiItemsWidths(int components, float width_full) {
return ImGui::PushMultiItemsWidths(components, width_full);
}
CIMGUI_API bool igIsItemToggledSelection() {
return ImGui::IsItemToggledSelection();
}
CIMGUI_API void igGetContentRegionMaxAbs(ImVec2* pOut) {
*pOut = ImGui::GetContentRegionMaxAbs();
}
CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,
int count,
float width_excess) {
return ImGui::ShrinkWidths(items, count, width_excess);
}
CIMGUI_API void igPushItemFlag(ImGuiItemFlags option, bool enabled) {
return ImGui::PushItemFlag(option, enabled);
}
CIMGUI_API void igPopItemFlag() {
return ImGui::PopItemFlag();
}
CIMGUI_API const ImGuiDataVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx) {
return ImGui::GetStyleVarInfo(idx);
}
CIMGUI_API void igLogBegin(ImGuiLogType type, int auto_open_depth) {
return ImGui::LogBegin(type, auto_open_depth);
}
CIMGUI_API void igLogToBuffer(int auto_open_depth) {
return ImGui::LogToBuffer(auto_open_depth);
}
CIMGUI_API void igLogRenderedText(const ImVec2* ref_pos,
const char* text,
const char* text_end) {
return ImGui::LogRenderedText(ref_pos, text, text_end);
}
CIMGUI_API void igLogSetNextTextDecoration(const char* prefix,
const char* suffix) {
return ImGui::LogSetNextTextDecoration(prefix, suffix);
}
CIMGUI_API bool igBeginChildEx(const char* name,
ImGuiID id,
const ImVec2 size_arg,
ImGuiChildFlags child_flags,
ImGuiWindowFlags window_flags) {
return ImGui::BeginChildEx(name, id, size_arg, child_flags, window_flags);
}
CIMGUI_API void igOpenPopupEx(ImGuiID id, ImGuiPopupFlags popup_flags) {
return ImGui::OpenPopupEx(id, popup_flags);
}
CIMGUI_API void igClosePopupToLevel(int remaining,
bool restore_focus_to_window_under_popup) {
return ImGui::ClosePopupToLevel(remaining,
restore_focus_to_window_under_popup);
}
CIMGUI_API void igClosePopupsOverWindow(
ImGuiWindow* ref_window,
bool restore_focus_to_window_under_popup) {
return ImGui::ClosePopupsOverWindow(ref_window,
restore_focus_to_window_under_popup);
}
CIMGUI_API void igClosePopupsExceptModals() {
return ImGui::ClosePopupsExceptModals();
}
CIMGUI_API bool igIsPopupOpen_ID(ImGuiID id, ImGuiPopupFlags popup_flags) {
return ImGui::IsPopupOpen(id, popup_flags);
}
CIMGUI_API bool igBeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags) {
return ImGui::BeginPopupEx(id, extra_flags);
}
CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,
ImGuiWindowFlags extra_window_flags) {
return ImGui::BeginTooltipEx(tooltip_flags, extra_window_flags);
}
CIMGUI_API bool igBeginTooltipHidden() {
return ImGui::BeginTooltipHidden();
}
CIMGUI_API void igGetPopupAllowedExtentRect(ImRect* pOut, ImGuiWindow* window) {
*pOut = ImGui::GetPopupAllowedExtentRect(window);
}
CIMGUI_API ImGuiWindow* igGetTopMostPopupModal() {
return ImGui::GetTopMostPopupModal();
}
CIMGUI_API ImGuiWindow* igGetTopMostAndVisiblePopupModal() {
return ImGui::GetTopMostAndVisiblePopupModal();
}
CIMGUI_API ImGuiWindow* igFindBlockingModal(ImGuiWindow* window) {
return ImGui::FindBlockingModal(window);
}
CIMGUI_API void igFindBestWindowPosForPopup(ImVec2* pOut, ImGuiWindow* window) {
*pOut = ImGui::FindBestWindowPosForPopup(window);
}
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) {
*pOut = ImGui::FindBestWindowPosForPopupEx(ref_pos, size, last_dir, r_outer,
r_avoid, policy);
}
CIMGUI_API bool igBeginViewportSideBar(const char* name,
ImGuiViewport* viewport,
ImGuiDir dir,
float size,
ImGuiWindowFlags window_flags) {
return ImGui::BeginViewportSideBar(name, viewport, dir, size, window_flags);
}
CIMGUI_API bool igBeginMenuEx(const char* label,
const char* icon,
bool enabled) {
return ImGui::BeginMenuEx(label, icon, enabled);
}
CIMGUI_API bool igMenuItemEx(const char* label,
const char* icon,
const char* shortcut,
bool selected,
bool enabled) {
return ImGui::MenuItemEx(label, icon, shortcut, selected, enabled);
}
CIMGUI_API bool igBeginComboPopup(ImGuiID popup_id,
const ImRect bb,
ImGuiComboFlags flags) {
return ImGui::BeginComboPopup(popup_id, bb, flags);
}
CIMGUI_API bool igBeginComboPreview() {
return ImGui::BeginComboPreview();
}
CIMGUI_API void igEndComboPreview() {
return ImGui::EndComboPreview();
}
CIMGUI_API void igNavInitWindow(ImGuiWindow* window, bool force_reinit) {
return ImGui::NavInitWindow(window, force_reinit);
}
CIMGUI_API void igNavInitRequestApplyResult() {
return ImGui::NavInitRequestApplyResult();
}
CIMGUI_API bool igNavMoveRequestButNoResultYet() {
return ImGui::NavMoveRequestButNoResultYet();
}
CIMGUI_API void igNavMoveRequestSubmit(ImGuiDir move_dir,
ImGuiDir clip_dir,
ImGuiNavMoveFlags move_flags,
ImGuiScrollFlags scroll_flags) {
return ImGui::NavMoveRequestSubmit(move_dir, clip_dir, move_flags,
scroll_flags);
}
CIMGUI_API void igNavMoveRequestForward(ImGuiDir move_dir,
ImGuiDir clip_dir,
ImGuiNavMoveFlags move_flags,
ImGuiScrollFlags scroll_flags) {
return ImGui::NavMoveRequestForward(move_dir, clip_dir, move_flags,
scroll_flags);
}
CIMGUI_API void igNavMoveRequestResolveWithLastItem(ImGuiNavItemData* result) {
return ImGui::NavMoveRequestResolveWithLastItem(result);
}
CIMGUI_API void igNavMoveRequestResolveWithPastTreeNode(
ImGuiNavItemData* result,
ImGuiNavTreeNodeData* tree_node_data) {
return ImGui::NavMoveRequestResolveWithPastTreeNode(result, tree_node_data);
}
CIMGUI_API void igNavMoveRequestCancel() {
return ImGui::NavMoveRequestCancel();
}
CIMGUI_API void igNavMoveRequestApplyResult() {
return ImGui::NavMoveRequestApplyResult();
}
CIMGUI_API void igNavMoveRequestTryWrapping(ImGuiWindow* window,
ImGuiNavMoveFlags move_flags) {
return ImGui::NavMoveRequestTryWrapping(window, move_flags);
}
CIMGUI_API void igNavHighlightActivated(ImGuiID id) {
return ImGui::NavHighlightActivated(id);
}
CIMGUI_API void igNavClearPreferredPosForAxis(ImGuiAxis axis) {
return ImGui::NavClearPreferredPosForAxis(axis);
}
CIMGUI_API void igNavRestoreHighlightAfterMove() {
return ImGui::NavRestoreHighlightAfterMove();
}
CIMGUI_API void igNavUpdateCurrentWindowIsScrollPushableX() {
return ImGui::NavUpdateCurrentWindowIsScrollPushableX();
}
CIMGUI_API void igSetNavWindow(ImGuiWindow* window) {
return ImGui::SetNavWindow(window);
}
CIMGUI_API void igSetNavID(ImGuiID id,
ImGuiNavLayer nav_layer,
ImGuiID focus_scope_id,
const ImRect rect_rel) {
return ImGui::SetNavID(id, nav_layer, focus_scope_id, rect_rel);
}
CIMGUI_API void igSetNavFocusScope(ImGuiID focus_scope_id) {
return ImGui::SetNavFocusScope(focus_scope_id);
}
CIMGUI_API void igFocusItem() {
return ImGui::FocusItem();
}
CIMGUI_API void igActivateItemByID(ImGuiID id) {
return ImGui::ActivateItemByID(id);
}
CIMGUI_API bool igIsNamedKey(ImGuiKey key) {
return ImGui::IsNamedKey(key);
}
CIMGUI_API bool igIsNamedKeyOrModKey(ImGuiKey key) {
return ImGui::IsNamedKeyOrModKey(key);
}
CIMGUI_API bool igIsLegacyKey(ImGuiKey key) {
return ImGui::IsLegacyKey(key);
}
CIMGUI_API bool igIsKeyboardKey(ImGuiKey key) {
return ImGui::IsKeyboardKey(key);
}
CIMGUI_API bool igIsGamepadKey(ImGuiKey key) {
return ImGui::IsGamepadKey(key);
}
CIMGUI_API bool igIsMouseKey(ImGuiKey key) {
return ImGui::IsMouseKey(key);
}
CIMGUI_API bool igIsAliasKey(ImGuiKey key) {
return ImGui::IsAliasKey(key);
}
CIMGUI_API bool igIsModKey(ImGuiKey key) {
return ImGui::IsModKey(key);
}
CIMGUI_API ImGuiKeyChord igFixupKeyChord(ImGuiContext* ctx,
ImGuiKeyChord key_chord) {
return ImGui::FixupKeyChord(ctx, key_chord);
}
CIMGUI_API ImGuiKey igConvertSingleModFlagToKey(ImGuiContext* ctx,
ImGuiKey key) {
return ImGui::ConvertSingleModFlagToKey(ctx, key);
}
CIMGUI_API ImGuiKeyData* igGetKeyData_ContextPtr(ImGuiContext* ctx,
ImGuiKey key) {
return ImGui::GetKeyData(ctx, key);
}
CIMGUI_API ImGuiKeyData* igGetKeyData_Key(ImGuiKey key) {
return ImGui::GetKeyData(key);
}
CIMGUI_API const char* igGetKeyChordName(ImGuiKeyChord key_chord) {
return ImGui::GetKeyChordName(key_chord);
}
CIMGUI_API ImGuiKey igMouseButtonToKey(ImGuiMouseButton button) {
return ImGui::MouseButtonToKey(button);
}
CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,
float lock_threshold) {
return ImGui::IsMouseDragPastThreshold(button, lock_threshold);
}
CIMGUI_API void igGetKeyMagnitude2d(ImVec2* pOut,
ImGuiKey key_left,
ImGuiKey key_right,
ImGuiKey key_up,
ImGuiKey key_down) {
*pOut = ImGui::GetKeyMagnitude2d(key_left, key_right, key_up, key_down);
}
CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis) {
return ImGui::GetNavTweakPressedAmount(axis);
}
CIMGUI_API int igCalcTypematicRepeatAmount(float t0,
float t1,
float repeat_delay,
float repeat_rate) {
return ImGui::CalcTypematicRepeatAmount(t0, t1, repeat_delay, repeat_rate);
}
CIMGUI_API void igGetTypematicRepeatRate(ImGuiInputFlags flags,
float* repeat_delay,
float* repeat_rate) {
return ImGui::GetTypematicRepeatRate(flags, repeat_delay, repeat_rate);
}
CIMGUI_API void igTeleportMousePos(const ImVec2 pos) {
return ImGui::TeleportMousePos(pos);
}
CIMGUI_API void igSetActiveIdUsingAllKeyboardKeys() {
return ImGui::SetActiveIdUsingAllKeyboardKeys();
}
CIMGUI_API bool igIsActiveIdUsingNavDir(ImGuiDir dir) {
return ImGui::IsActiveIdUsingNavDir(dir);
}
CIMGUI_API ImGuiID igGetKeyOwner(ImGuiKey key) {
return ImGui::GetKeyOwner(key);
}
CIMGUI_API void igSetKeyOwner(ImGuiKey key,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::SetKeyOwner(key, owner_id, flags);
}
CIMGUI_API void igSetKeyOwnersForKeyChord(ImGuiKeyChord key,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::SetKeyOwnersForKeyChord(key, owner_id, flags);
}
CIMGUI_API void igSetItemKeyOwner(ImGuiKey key, ImGuiInputFlags flags) {
return ImGui::SetItemKeyOwner(key, flags);
}
CIMGUI_API bool igTestKeyOwner(ImGuiKey key, ImGuiID owner_id) {
return ImGui::TestKeyOwner(key, owner_id);
}
CIMGUI_API ImGuiKeyOwnerData* igGetKeyOwnerData(ImGuiContext* ctx,
ImGuiKey key) {
return ImGui::GetKeyOwnerData(ctx, key);
}
CIMGUI_API bool igIsKeyDown_ID(ImGuiKey key, ImGuiID owner_id) {
return ImGui::IsKeyDown(key, owner_id);
}
CIMGUI_API bool igIsKeyPressed_ID(ImGuiKey key,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::IsKeyPressed(key, owner_id, flags);
}
CIMGUI_API bool igIsKeyReleased_ID(ImGuiKey key, ImGuiID owner_id) {
return ImGui::IsKeyReleased(key, owner_id);
}
CIMGUI_API bool igIsMouseDown_ID(ImGuiMouseButton button, ImGuiID owner_id) {
return ImGui::IsMouseDown(button, owner_id);
}
CIMGUI_API bool igIsMouseClicked_ID(ImGuiMouseButton button,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::IsMouseClicked(button, owner_id, flags);
}
CIMGUI_API bool igIsMouseReleased_ID(ImGuiMouseButton button,
ImGuiID owner_id) {
return ImGui::IsMouseReleased(button, owner_id);
}
CIMGUI_API bool igIsMouseDoubleClicked_ID(ImGuiMouseButton button,
ImGuiID owner_id) {
return ImGui::IsMouseDoubleClicked(button, owner_id);
}
CIMGUI_API bool igIsKeyChordPressed_ID(ImGuiKeyChord key_chord,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::IsKeyChordPressed(key_chord, owner_id, flags);
}
CIMGUI_API void igSetNextItemShortcut(ImGuiKeyChord key_chord) {
return ImGui::SetNextItemShortcut(key_chord);
}
CIMGUI_API bool igShortcut(ImGuiKeyChord key_chord,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::Shortcut(key_chord, owner_id, flags);
}
CIMGUI_API bool igSetShortcutRouting(ImGuiKeyChord key_chord,
ImGuiID owner_id,
ImGuiInputFlags flags) {
return ImGui::SetShortcutRouting(key_chord, owner_id, flags);
}
CIMGUI_API bool igTestShortcutRouting(ImGuiKeyChord key_chord,
ImGuiID owner_id) {
return ImGui::TestShortcutRouting(key_chord, owner_id);
}
CIMGUI_API ImGuiKeyRoutingData* igGetShortcutRoutingData(
ImGuiKeyChord key_chord) {
return ImGui::GetShortcutRoutingData(key_chord);
}
CIMGUI_API void igDockContextInitialize(ImGuiContext* ctx) {
return ImGui::DockContextInitialize(ctx);
}
CIMGUI_API void igDockContextShutdown(ImGuiContext* ctx) {
return ImGui::DockContextShutdown(ctx);
}
CIMGUI_API void igDockContextClearNodes(ImGuiContext* ctx,
ImGuiID root_id,
bool clear_settings_refs) {
return ImGui::DockContextClearNodes(ctx, root_id, clear_settings_refs);
}
CIMGUI_API void igDockContextRebuildNodes(ImGuiContext* ctx) {
return ImGui::DockContextRebuildNodes(ctx);
}
CIMGUI_API void igDockContextNewFrameUpdateUndocking(ImGuiContext* ctx) {
return ImGui::DockContextNewFrameUpdateUndocking(ctx);
}
CIMGUI_API void igDockContextNewFrameUpdateDocking(ImGuiContext* ctx) {
return ImGui::DockContextNewFrameUpdateDocking(ctx);
}
CIMGUI_API void igDockContextEndFrame(ImGuiContext* ctx) {
return ImGui::DockContextEndFrame(ctx);
}
CIMGUI_API ImGuiID igDockContextGenNodeID(ImGuiContext* ctx) {
return ImGui::DockContextGenNodeID(ctx);
}
CIMGUI_API void igDockContextQueueDock(ImGuiContext* ctx,
ImGuiWindow* target,
ImGuiDockNode* target_node,
ImGuiWindow* payload,
ImGuiDir split_dir,
float split_ratio,
bool split_outer) {
return ImGui::DockContextQueueDock(ctx, target, target_node, payload,
split_dir, split_ratio, split_outer);
}
CIMGUI_API void igDockContextQueueUndockWindow(ImGuiContext* ctx,
ImGuiWindow* window) {
return ImGui::DockContextQueueUndockWindow(ctx, window);
}
CIMGUI_API void igDockContextQueueUndockNode(ImGuiContext* ctx,
ImGuiDockNode* node) {
return ImGui::DockContextQueueUndockNode(ctx, node);
}
CIMGUI_API void igDockContextProcessUndockWindow(
ImGuiContext* ctx,
ImGuiWindow* window,
bool clear_persistent_docking_ref) {
return ImGui::DockContextProcessUndockWindow(ctx, window,
clear_persistent_docking_ref);
}
CIMGUI_API void igDockContextProcessUndockNode(ImGuiContext* ctx,
ImGuiDockNode* node) {
return ImGui::DockContextProcessUndockNode(ctx, node);
}
CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,
ImGuiDockNode* target_node,
ImGuiWindow* payload_window,
ImGuiDockNode* payload_node,
ImGuiDir split_dir,
bool split_outer,
ImVec2* out_pos) {
return ImGui::DockContextCalcDropPosForDocking(
target, target_node, payload_window, payload_node, split_dir, split_outer,
out_pos);
}
CIMGUI_API ImGuiDockNode* igDockContextFindNodeByID(ImGuiContext* ctx,
ImGuiID id) {
return ImGui::DockContextFindNodeByID(ctx, id);
}
CIMGUI_API void igDockNodeWindowMenuHandler_Default(ImGuiContext* ctx,
ImGuiDockNode* node,
ImGuiTabBar* tab_bar) {
return ImGui::DockNodeWindowMenuHandler_Default(ctx, node, tab_bar);
}
CIMGUI_API bool igDockNodeBeginAmendTabBar(ImGuiDockNode* node) {
return ImGui::DockNodeBeginAmendTabBar(node);
}
CIMGUI_API void igDockNodeEndAmendTabBar() {
return ImGui::DockNodeEndAmendTabBar();
}
CIMGUI_API ImGuiDockNode* igDockNodeGetRootNode(ImGuiDockNode* node) {
return ImGui::DockNodeGetRootNode(node);
}
CIMGUI_API bool igDockNodeIsInHierarchyOf(ImGuiDockNode* node,
ImGuiDockNode* parent) {
return ImGui::DockNodeIsInHierarchyOf(node, parent);
}
CIMGUI_API int igDockNodeGetDepth(const ImGuiDockNode* node) {
return ImGui::DockNodeGetDepth(node);
}
CIMGUI_API ImGuiID igDockNodeGetWindowMenuButtonId(const ImGuiDockNode* node) {
return ImGui::DockNodeGetWindowMenuButtonId(node);
}
CIMGUI_API ImGuiDockNode* igGetWindowDockNode() {
return ImGui::GetWindowDockNode();
}
CIMGUI_API bool igGetWindowAlwaysWantOwnTabBar(ImGuiWindow* window) {
return ImGui::GetWindowAlwaysWantOwnTabBar(window);
}
CIMGUI_API void igBeginDocked(ImGuiWindow* window, bool* p_open) {
return ImGui::BeginDocked(window, p_open);
}
CIMGUI_API void igBeginDockableDragDropSource(ImGuiWindow* window) {
return ImGui::BeginDockableDragDropSource(window);
}
CIMGUI_API void igBeginDockableDragDropTarget(ImGuiWindow* window) {
return ImGui::BeginDockableDragDropTarget(window);
}
CIMGUI_API void igSetWindowDock(ImGuiWindow* window,
ImGuiID dock_id,
ImGuiCond cond) {
return ImGui::SetWindowDock(window, dock_id, cond);
}
CIMGUI_API void igDockBuilderDockWindow(const char* window_name,
ImGuiID node_id) {
return ImGui::DockBuilderDockWindow(window_name, node_id);
}
CIMGUI_API ImGuiDockNode* igDockBuilderGetNode(ImGuiID node_id) {
return ImGui::DockBuilderGetNode(node_id);
}
CIMGUI_API ImGuiDockNode* igDockBuilderGetCentralNode(ImGuiID node_id) {
return ImGui::DockBuilderGetCentralNode(node_id);
}
CIMGUI_API ImGuiID igDockBuilderAddNode(ImGuiID node_id,
ImGuiDockNodeFlags flags) {
return ImGui::DockBuilderAddNode(node_id, flags);
}
CIMGUI_API void igDockBuilderRemoveNode(ImGuiID node_id) {
return ImGui::DockBuilderRemoveNode(node_id);
}
CIMGUI_API void igDockBuilderRemoveNodeDockedWindows(ImGuiID node_id,
bool clear_settings_refs) {
return ImGui::DockBuilderRemoveNodeDockedWindows(node_id,
clear_settings_refs);
}
CIMGUI_API void igDockBuilderRemoveNodeChildNodes(ImGuiID node_id) {
return ImGui::DockBuilderRemoveNodeChildNodes(node_id);
}
CIMGUI_API void igDockBuilderSetNodePos(ImGuiID node_id, ImVec2 pos) {
return ImGui::DockBuilderSetNodePos(node_id, pos);
}
CIMGUI_API void igDockBuilderSetNodeSize(ImGuiID node_id, ImVec2 size) {
return ImGui::DockBuilderSetNodeSize(node_id, size);
}
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) {
return ImGui::DockBuilderSplitNode(node_id, split_dir,
size_ratio_for_node_at_dir, out_id_at_dir,
out_id_at_opposite_dir);
}
CIMGUI_API void igDockBuilderCopyDockSpace(
ImGuiID src_dockspace_id,
ImGuiID dst_dockspace_id,
ImVector_const_charPtr* in_window_remap_pairs) {
return ImGui::DockBuilderCopyDockSpace(src_dockspace_id, dst_dockspace_id,
in_window_remap_pairs);
}
CIMGUI_API void igDockBuilderCopyNode(ImGuiID src_node_id,
ImGuiID dst_node_id,
ImVector_ImGuiID* out_node_remap_pairs) {
return ImGui::DockBuilderCopyNode(src_node_id, dst_node_id,
out_node_remap_pairs);
}
CIMGUI_API void igDockBuilderCopyWindowSettings(const char* src_name,
const char* dst_name) {
return ImGui::DockBuilderCopyWindowSettings(src_name, dst_name);
}
CIMGUI_API void igDockBuilderFinish(ImGuiID node_id) {
return ImGui::DockBuilderFinish(node_id);
}
CIMGUI_API void igPushFocusScope(ImGuiID id) {
return ImGui::PushFocusScope(id);
}
CIMGUI_API void igPopFocusScope() {
return ImGui::PopFocusScope();
}
CIMGUI_API ImGuiID igGetCurrentFocusScope() {
return ImGui::GetCurrentFocusScope();
}
CIMGUI_API bool igIsDragDropActive() {
return ImGui::IsDragDropActive();
}
CIMGUI_API bool igBeginDragDropTargetCustom(const ImRect bb, ImGuiID id) {
return ImGui::BeginDragDropTargetCustom(bb, id);
}
CIMGUI_API void igClearDragDrop() {
return ImGui::ClearDragDrop();
}
CIMGUI_API bool igIsDragDropPayloadBeingAccepted() {
return ImGui::IsDragDropPayloadBeingAccepted();
}
CIMGUI_API void igRenderDragDropTargetRect(const ImRect bb,
const ImRect item_clip_rect) {
return ImGui::RenderDragDropTargetRect(bb, item_clip_rect);
}
CIMGUI_API ImGuiTypingSelectRequest* igGetTypingSelectRequest(
ImGuiTypingSelectFlags flags) {
return ImGui::GetTypingSelectRequest(flags);
}
CIMGUI_API int igTypingSelectFindMatch(ImGuiTypingSelectRequest* req,
int items_count,
const char* (*get_item_name_func)(void*,
int),
void* user_data,
int nav_item_idx) {
return ImGui::TypingSelectFindMatch(req, items_count, get_item_name_func,
user_data, nav_item_idx);
}
CIMGUI_API int igTypingSelectFindNextSingleCharMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char* (*get_item_name_func)(void*, int),
void* user_data,
int nav_item_idx) {
return ImGui::TypingSelectFindNextSingleCharMatch(
req, items_count, get_item_name_func, user_data, nav_item_idx);
}
CIMGUI_API int igTypingSelectFindBestLeadingMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char* (*get_item_name_func)(void*, int),
void* user_data) {
return ImGui::TypingSelectFindBestLeadingMatch(req, items_count,
get_item_name_func, user_data);
}
CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,
const ImRect clip_rect) {
return ImGui::SetWindowClipRectBeforeSetChannel(window, clip_rect);
}
CIMGUI_API void igBeginColumns(const char* str_id,
int count,
ImGuiOldColumnFlags flags) {
return ImGui::BeginColumns(str_id, count, flags);
}
CIMGUI_API void igEndColumns() {
return ImGui::EndColumns();
}
CIMGUI_API void igPushColumnClipRect(int column_index) {
return ImGui::PushColumnClipRect(column_index);
}
CIMGUI_API void igPushColumnsBackground() {
return ImGui::PushColumnsBackground();
}
CIMGUI_API void igPopColumnsBackground() {
return ImGui::PopColumnsBackground();
}
CIMGUI_API ImGuiID igGetColumnsID(const char* str_id, int count) {
return ImGui::GetColumnsID(str_id, count);
}
CIMGUI_API ImGuiOldColumns* igFindOrCreateColumns(ImGuiWindow* window,
ImGuiID id) {
return ImGui::FindOrCreateColumns(window, id);
}
CIMGUI_API float igGetColumnOffsetFromNorm(const ImGuiOldColumns* columns,
float offset_norm) {
return ImGui::GetColumnOffsetFromNorm(columns, offset_norm);
}
CIMGUI_API float igGetColumnNormFromOffset(const ImGuiOldColumns* columns,
float offset) {
return ImGui::GetColumnNormFromOffset(columns, offset);
}
CIMGUI_API void igTableOpenContextMenu(int column_n) {
return ImGui::TableOpenContextMenu(column_n);
}
CIMGUI_API void igTableSetColumnWidth(int column_n, float width) {
return ImGui::TableSetColumnWidth(column_n, width);
}
CIMGUI_API void igTableSetColumnSortDirection(int column_n,
ImGuiSortDirection sort_direction,
bool append_to_sort_specs) {
return ImGui::TableSetColumnSortDirection(column_n, sort_direction,
append_to_sort_specs);
}
CIMGUI_API int igTableGetHoveredColumn() {
return ImGui::TableGetHoveredColumn();
}
CIMGUI_API int igTableGetHoveredRow() {
return ImGui::TableGetHoveredRow();
}
CIMGUI_API float igTableGetHeaderRowHeight() {
return ImGui::TableGetHeaderRowHeight();
}
CIMGUI_API float igTableGetHeaderAngledMaxLabelWidth() {
return ImGui::TableGetHeaderAngledMaxLabelWidth();
}
CIMGUI_API void igTablePushBackgroundChannel() {
return ImGui::TablePushBackgroundChannel();
}
CIMGUI_API void igTablePopBackgroundChannel() {
return ImGui::TablePopBackgroundChannel();
}
CIMGUI_API void igTableAngledHeadersRowEx(ImGuiID row_id,
float angle,
float max_label_width,
const ImGuiTableHeaderData* data,
int data_count) {
return ImGui::TableAngledHeadersRowEx(row_id, angle, max_label_width, data,
data_count);
}
CIMGUI_API ImGuiTable* igGetCurrentTable() {
return ImGui::GetCurrentTable();
}
CIMGUI_API ImGuiTable* igTableFindByID(ImGuiID id) {
return ImGui::TableFindByID(id);
}
CIMGUI_API bool igBeginTableEx(const char* name,
ImGuiID id,
int columns_count,
ImGuiTableFlags flags,
const ImVec2 outer_size,
float inner_width) {
return ImGui::BeginTableEx(name, id, columns_count, flags, outer_size,
inner_width);
}
CIMGUI_API void igTableBeginInitMemory(ImGuiTable* table, int columns_count) {
return ImGui::TableBeginInitMemory(table, columns_count);
}
CIMGUI_API void igTableBeginApplyRequests(ImGuiTable* table) {
return ImGui::TableBeginApplyRequests(table);
}
CIMGUI_API void igTableSetupDrawChannels(ImGuiTable* table) {
return ImGui::TableSetupDrawChannels(table);
}
CIMGUI_API void igTableUpdateLayout(ImGuiTable* table) {
return ImGui::TableUpdateLayout(table);
}
CIMGUI_API void igTableUpdateBorders(ImGuiTable* table) {
return ImGui::TableUpdateBorders(table);
}
CIMGUI_API void igTableUpdateColumnsWeightFromWidth(ImGuiTable* table) {
return ImGui::TableUpdateColumnsWeightFromWidth(table);
}
CIMGUI_API void igTableDrawBorders(ImGuiTable* table) {
return ImGui::TableDrawBorders(table);
}
CIMGUI_API void igTableDrawDefaultContextMenu(
ImGuiTable* table,
ImGuiTableFlags flags_for_section_to_display) {
return ImGui::TableDrawDefaultContextMenu(table,
flags_for_section_to_display);
}
CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table) {
return ImGui::TableBeginContextMenuPopup(table);
}
CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table) {
return ImGui::TableMergeDrawChannels(table);
}
CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,
int instance_no) {
return ImGui::TableGetInstanceData(table, instance_no);
}
CIMGUI_API ImGuiID igTableGetInstanceID(ImGuiTable* table, int instance_no) {
return ImGui::TableGetInstanceID(table, instance_no);
}
CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table) {
return ImGui::TableSortSpecsSanitize(table);
}
CIMGUI_API void igTableSortSpecsBuild(ImGuiTable* table) {
return ImGui::TableSortSpecsBuild(table);
}
CIMGUI_API ImGuiSortDirection
igTableGetColumnNextSortDirection(ImGuiTableColumn* column) {
return ImGui::TableGetColumnNextSortDirection(column);
}
CIMGUI_API void igTableFixColumnSortDirection(ImGuiTable* table,
ImGuiTableColumn* column) {
return ImGui::TableFixColumnSortDirection(table, column);
}
CIMGUI_API float igTableGetColumnWidthAuto(ImGuiTable* table,
ImGuiTableColumn* column) {
return ImGui::TableGetColumnWidthAuto(table, column);
}
CIMGUI_API void igTableBeginRow(ImGuiTable* table) {
return ImGui::TableBeginRow(table);
}
CIMGUI_API void igTableEndRow(ImGuiTable* table) {
return ImGui::TableEndRow(table);
}
CIMGUI_API void igTableBeginCell(ImGuiTable* table, int column_n) {
return ImGui::TableBeginCell(table, column_n);
}
CIMGUI_API void igTableEndCell(ImGuiTable* table) {
return ImGui::TableEndCell(table);
}
CIMGUI_API void igTableGetCellBgRect(ImRect* pOut,
const ImGuiTable* table,
int column_n) {
*pOut = ImGui::TableGetCellBgRect(table, column_n);
}
CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,
int column_n) {
return ImGui::TableGetColumnName(table, column_n);
}
CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,
int column_n,
int instance_no) {
return ImGui::TableGetColumnResizeID(table, column_n, instance_no);
}
CIMGUI_API float igTableGetMaxColumnWidth(const ImGuiTable* table,
int column_n) {
return ImGui::TableGetMaxColumnWidth(table, column_n);
}
CIMGUI_API void igTableSetColumnWidthAutoSingle(ImGuiTable* table,
int column_n) {
return ImGui::TableSetColumnWidthAutoSingle(table, column_n);
}
CIMGUI_API void igTableSetColumnWidthAutoAll(ImGuiTable* table) {
return ImGui::TableSetColumnWidthAutoAll(table);
}
CIMGUI_API void igTableRemove(ImGuiTable* table) {
return ImGui::TableRemove(table);
}
CIMGUI_API void igTableGcCompactTransientBuffers_TablePtr(ImGuiTable* table) {
return ImGui::TableGcCompactTransientBuffers(table);
}
CIMGUI_API void igTableGcCompactTransientBuffers_TableTempDataPtr(
ImGuiTableTempData* table) {
return ImGui::TableGcCompactTransientBuffers(table);
}
CIMGUI_API void igTableGcCompactSettings() {
return ImGui::TableGcCompactSettings();
}
CIMGUI_API void igTableLoadSettings(ImGuiTable* table) {
return ImGui::TableLoadSettings(table);
}
CIMGUI_API void igTableSaveSettings(ImGuiTable* table) {
return ImGui::TableSaveSettings(table);
}
CIMGUI_API void igTableResetSettings(ImGuiTable* table) {
return ImGui::TableResetSettings(table);
}
CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table) {
return ImGui::TableGetBoundSettings(table);
}
CIMGUI_API void igTableSettingsAddSettingsHandler() {
return ImGui::TableSettingsAddSettingsHandler();
}
CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,
int columns_count) {
return ImGui::TableSettingsCreate(id, columns_count);
}
CIMGUI_API ImGuiTableSettings* igTableSettingsFindByID(ImGuiID id) {
return ImGui::TableSettingsFindByID(id);
}
CIMGUI_API ImGuiTabBar* igGetCurrentTabBar() {
return ImGui::GetCurrentTabBar();
}
CIMGUI_API bool igBeginTabBarEx(ImGuiTabBar* tab_bar,
const ImRect bb,
ImGuiTabBarFlags flags) {
return ImGui::BeginTabBarEx(tab_bar, bb, flags);
}
CIMGUI_API ImGuiTabItem* igTabBarFindTabByID(ImGuiTabBar* tab_bar,
ImGuiID tab_id) {
return ImGui::TabBarFindTabByID(tab_bar, tab_id);
}
CIMGUI_API ImGuiTabItem* igTabBarFindTabByOrder(ImGuiTabBar* tab_bar,
int order) {
return ImGui::TabBarFindTabByOrder(tab_bar, order);
}
CIMGUI_API ImGuiTabItem* igTabBarFindMostRecentlySelectedTabForActiveWindow(
ImGuiTabBar* tab_bar) {
return ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar);
}
CIMGUI_API ImGuiTabItem* igTabBarGetCurrentTab(ImGuiTabBar* tab_bar) {
return ImGui::TabBarGetCurrentTab(tab_bar);
}
CIMGUI_API int igTabBarGetTabOrder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) {
return ImGui::TabBarGetTabOrder(tab_bar, tab);
}
CIMGUI_API const char* igTabBarGetTabName(ImGuiTabBar* tab_bar,
ImGuiTabItem* tab) {
return ImGui::TabBarGetTabName(tab_bar, tab);
}
CIMGUI_API void igTabBarAddTab(ImGuiTabBar* tab_bar,
ImGuiTabItemFlags tab_flags,
ImGuiWindow* window) {
return ImGui::TabBarAddTab(tab_bar, tab_flags, window);
}
CIMGUI_API void igTabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id) {
return ImGui::TabBarRemoveTab(tab_bar, tab_id);
}
CIMGUI_API void igTabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) {
return ImGui::TabBarCloseTab(tab_bar, tab);
}
CIMGUI_API void igTabBarQueueFocus(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) {
return ImGui::TabBarQueueFocus(tab_bar, tab);
}
CIMGUI_API void igTabBarQueueReorder(ImGuiTabBar* tab_bar,
ImGuiTabItem* tab,
int offset) {
return ImGui::TabBarQueueReorder(tab_bar, tab, offset);
}
CIMGUI_API void igTabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar,
ImGuiTabItem* tab,
ImVec2 mouse_pos) {
return ImGui::TabBarQueueReorderFromMousePos(tab_bar, tab, mouse_pos);
}
CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar) {
return ImGui::TabBarProcessReorder(tab_bar);
}
CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,
const char* label,
bool* p_open,
ImGuiTabItemFlags flags,
ImGuiWindow* docked_window) {
return ImGui::TabItemEx(tab_bar, label, p_open, flags, docked_window);
}
CIMGUI_API void igTabItemCalcSize_Str(ImVec2* pOut,
const char* label,
bool has_close_button_or_unsaved_marker) {
*pOut = ImGui::TabItemCalcSize(label, has_close_button_or_unsaved_marker);
}
CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2* pOut, ImGuiWindow* window) {
*pOut = ImGui::TabItemCalcSize(window);
}
CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,
const ImRect bb,
ImGuiTabItemFlags flags,
ImU32 col) {
return ImGui::TabItemBackground(draw_list, bb, flags, col);
}
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) {
return ImGui::TabItemLabelAndCloseButton(
draw_list, bb, flags, frame_padding, label, tab_id, close_button_id,
is_contents_visible, out_just_closed, out_text_clipped);
}
CIMGUI_API void igRenderText(ImVec2 pos,
const char* text,
const char* text_end,
bool hide_text_after_hash) {
return ImGui::RenderText(pos, text, text_end, hide_text_after_hash);
}
CIMGUI_API void igRenderTextWrapped(ImVec2 pos,
const char* text,
const char* text_end,
float wrap_width) {
return ImGui::RenderTextWrapped(pos, text, text_end, wrap_width);
}
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) {
return ImGui::RenderTextClipped(pos_min, pos_max, text, text_end,
text_size_if_known, align, clip_rect);
}
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) {
return ImGui::RenderTextClippedEx(draw_list, pos_min, pos_max, text, text_end,
text_size_if_known, align, clip_rect);
}
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) {
return ImGui::RenderTextEllipsis(draw_list, pos_min, pos_max, clip_max_x,
ellipsis_max_x, text, text_end,
text_size_if_known);
}
CIMGUI_API void igRenderFrame(ImVec2 p_min,
ImVec2 p_max,
ImU32 fill_col,
bool border,
float rounding) {
return ImGui::RenderFrame(p_min, p_max, fill_col, border, rounding);
}
CIMGUI_API void igRenderFrameBorder(ImVec2 p_min,
ImVec2 p_max,
float rounding) {
return ImGui::RenderFrameBorder(p_min, p_max, rounding);
}
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) {
return ImGui::RenderColorRectWithAlphaCheckerboard(
draw_list, p_min, p_max, fill_col, grid_step, grid_off, rounding, flags);
}
CIMGUI_API void igRenderNavHighlight(const ImRect bb,
ImGuiID id,
ImGuiNavHighlightFlags flags) {
return ImGui::RenderNavHighlight(bb, id, flags);
}
CIMGUI_API const char* igFindRenderedTextEnd(const char* text,
const char* text_end) {
return ImGui::FindRenderedTextEnd(text, text_end);
}
CIMGUI_API void igRenderMouseCursor(ImVec2 pos,
float scale,
ImGuiMouseCursor mouse_cursor,
ImU32 col_fill,
ImU32 col_border,
ImU32 col_shadow) {
return ImGui::RenderMouseCursor(pos, scale, mouse_cursor, col_fill,
col_border, col_shadow);
}
CIMGUI_API void igRenderArrow(ImDrawList* draw_list,
ImVec2 pos,
ImU32 col,
ImGuiDir dir,
float scale) {
return ImGui::RenderArrow(draw_list, pos, col, dir, scale);
}
CIMGUI_API void igRenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col) {
return ImGui::RenderBullet(draw_list, pos, col);
}
CIMGUI_API void igRenderCheckMark(ImDrawList* draw_list,
ImVec2 pos,
ImU32 col,
float sz) {
return ImGui::RenderCheckMark(draw_list, pos, col, sz);
}
CIMGUI_API void igRenderArrowPointingAt(ImDrawList* draw_list,
ImVec2 pos,
ImVec2 half_sz,
ImGuiDir direction,
ImU32 col) {
return ImGui::RenderArrowPointingAt(draw_list, pos, half_sz, direction, col);
}
CIMGUI_API void igRenderArrowDockMenu(ImDrawList* draw_list,
ImVec2 p_min,
float sz,
ImU32 col) {
return ImGui::RenderArrowDockMenu(draw_list, p_min, sz, col);
}
CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,
const ImRect rect,
ImU32 col,
float x_start_norm,
float x_end_norm,
float rounding) {
return ImGui::RenderRectFilledRangeH(draw_list, rect, col, x_start_norm,
x_end_norm, rounding);
}
CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,
const ImRect outer,
const ImRect inner,
ImU32 col,
float rounding) {
return ImGui::RenderRectFilledWithHole(draw_list, outer, inner, col,
rounding);
}
CIMGUI_API ImDrawFlags igCalcRoundingFlagsForRectInRect(const ImRect r_in,
const ImRect r_outer,
float threshold) {
return ImGui::CalcRoundingFlagsForRectInRect(r_in, r_outer, threshold);
}
CIMGUI_API void igTextEx(const char* text,
const char* text_end,
ImGuiTextFlags flags) {
return ImGui::TextEx(text, text_end, flags);
}
CIMGUI_API bool igButtonEx(const char* label,
const ImVec2 size_arg,
ImGuiButtonFlags flags) {
return ImGui::ButtonEx(label, size_arg, flags);
}
CIMGUI_API bool igArrowButtonEx(const char* str_id,
ImGuiDir dir,
ImVec2 size_arg,
ImGuiButtonFlags flags) {
return ImGui::ArrowButtonEx(str_id, dir, size_arg, flags);
}
CIMGUI_API bool igImageButtonEx(ImGuiID id,
ImTextureID texture_id,
const ImVec2 image_size,
const ImVec2 uv0,
const ImVec2 uv1,
const ImVec4 bg_col,
const ImVec4 tint_col,
ImGuiButtonFlags flags) {
return ImGui::ImageButtonEx(id, texture_id, image_size, uv0, uv1, bg_col,
tint_col, flags);
}
CIMGUI_API void igSeparatorEx(ImGuiSeparatorFlags flags, float thickness) {
return ImGui::SeparatorEx(flags, thickness);
}
CIMGUI_API void igSeparatorTextEx(ImGuiID id,
const char* label,
const char* label_end,
float extra_width) {
return ImGui::SeparatorTextEx(id, label, label_end, extra_width);
}
CIMGUI_API bool igCheckboxFlags_S64Ptr(const char* label,
ImS64* flags,
ImS64 flags_value) {
return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igCheckboxFlags_U64Ptr(const char* label,
ImU64* flags,
ImU64 flags_value) {
return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igCloseButton(ImGuiID id, const ImVec2 pos) {
return ImGui::CloseButton(id, pos);
}
CIMGUI_API bool igCollapseButton(ImGuiID id,
const ImVec2 pos,
ImGuiDockNode* dock_node) {
return ImGui::CollapseButton(id, pos, dock_node);
}
CIMGUI_API void igScrollbar(ImGuiAxis axis) {
return ImGui::Scrollbar(axis);
}
CIMGUI_API bool igScrollbarEx(const ImRect bb,
ImGuiID id,
ImGuiAxis axis,
ImS64* p_scroll_v,
ImS64 avail_v,
ImS64 contents_v,
ImDrawFlags flags) {
return ImGui::ScrollbarEx(bb, id, axis, p_scroll_v, avail_v, contents_v,
flags);
}
CIMGUI_API void igGetWindowScrollbarRect(ImRect* pOut,
ImGuiWindow* window,
ImGuiAxis axis) {
*pOut = ImGui::GetWindowScrollbarRect(window, axis);
}
CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis) {
return ImGui::GetWindowScrollbarID(window, axis);
}
CIMGUI_API ImGuiID igGetWindowResizeCornerID(ImGuiWindow* window, int n) {
return ImGui::GetWindowResizeCornerID(window, n);
}
CIMGUI_API ImGuiID igGetWindowResizeBorderID(ImGuiWindow* window,
ImGuiDir dir) {
return ImGui::GetWindowResizeBorderID(window, dir);
}
CIMGUI_API bool igButtonBehavior(const ImRect bb,
ImGuiID id,
bool* out_hovered,
bool* out_held,
ImGuiButtonFlags flags) {
return ImGui::ButtonBehavior(bb, id, out_hovered, out_held, flags);
}
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) {
return ImGui::DragBehavior(id, data_type, p_v, v_speed, p_min, p_max, format,
flags);
}
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) {
return ImGui::SliderBehavior(bb, id, data_type, p_v, p_min, p_max, format,
flags, out_grab_bb);
}
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) {
return ImGui::SplitterBehavior(bb, id, axis, size1, size2, min_size1,
min_size2, hover_extend,
hover_visibility_delay, bg_col);
}
CIMGUI_API bool igTreeNodeBehavior(ImGuiID id,
ImGuiTreeNodeFlags flags,
const char* label,
const char* label_end) {
return ImGui::TreeNodeBehavior(id, flags, label, label_end);
}
CIMGUI_API void igTreePushOverrideID(ImGuiID id) {
return ImGui::TreePushOverrideID(id);
}
CIMGUI_API void igTreeNodeSetOpen(ImGuiID id, bool open) {
return ImGui::TreeNodeSetOpen(id, open);
}
CIMGUI_API bool igTreeNodeUpdateNextOpen(ImGuiID id, ImGuiTreeNodeFlags flags) {
return ImGui::TreeNodeUpdateNextOpen(id, flags);
}
CIMGUI_API void igSetNextItemSelectionUserData(
ImGuiSelectionUserData selection_user_data) {
return ImGui::SetNextItemSelectionUserData(selection_user_data);
}
CIMGUI_API const ImGuiDataTypeInfo* igDataTypeGetInfo(ImGuiDataType data_type) {
return ImGui::DataTypeGetInfo(data_type);
}
CIMGUI_API int igDataTypeFormatString(char* buf,
int buf_size,
ImGuiDataType data_type,
const void* p_data,
const char* format) {
return ImGui::DataTypeFormatString(buf, buf_size, data_type, p_data, format);
}
CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,
int op,
void* output,
const void* arg_1,
const void* arg_2) {
return ImGui::DataTypeApplyOp(data_type, op, output, arg_1, arg_2);
}
CIMGUI_API bool igDataTypeApplyFromText(const char* buf,
ImGuiDataType data_type,
void* p_data,
const char* format) {
return ImGui::DataTypeApplyFromText(buf, data_type, p_data, format);
}
CIMGUI_API int igDataTypeCompare(ImGuiDataType data_type,
const void* arg_1,
const void* arg_2) {
return ImGui::DataTypeCompare(data_type, arg_1, arg_2);
}
CIMGUI_API bool igDataTypeClamp(ImGuiDataType data_type,
void* p_data,
const void* p_min,
const void* p_max) {
return ImGui::DataTypeClamp(data_type, p_data, p_min, p_max);
}
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) {
return ImGui::InputTextEx(label, hint, buf, buf_size, size_arg, flags,
callback, user_data);
}
CIMGUI_API void igInputTextDeactivateHook(ImGuiID id) {
return ImGui::InputTextDeactivateHook(id);
}
CIMGUI_API bool igTempInputText(const ImRect bb,
ImGuiID id,
const char* label,
char* buf,
int buf_size,
ImGuiInputTextFlags flags) {
return ImGui::TempInputText(bb, id, label, buf, buf_size, flags);
}
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) {
return ImGui::TempInputScalar(bb, id, label, data_type, p_data, format,
p_clamp_min, p_clamp_max);
}
CIMGUI_API bool igTempInputIsActive(ImGuiID id) {
return ImGui::TempInputIsActive(id);
}
CIMGUI_API ImGuiInputTextState* igGetInputTextState(ImGuiID id) {
return ImGui::GetInputTextState(id);
}
CIMGUI_API void igColorTooltip(const char* text,
const float* col,
ImGuiColorEditFlags flags) {
return ImGui::ColorTooltip(text, col, flags);
}
CIMGUI_API void igColorEditOptionsPopup(const float* col,
ImGuiColorEditFlags flags) {
return ImGui::ColorEditOptionsPopup(col, flags);
}
CIMGUI_API void igColorPickerOptionsPopup(const float* ref_col,
ImGuiColorEditFlags flags) {
return ImGui::ColorPickerOptionsPopup(ref_col, flags);
}
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) {
return ImGui::PlotEx(plot_type, label, values_getter, data, values_count,
values_offset, overlay_text, scale_min, scale_max,
size_arg);
}
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) {
return ImGui::ShadeVertsLinearColorGradientKeepAlpha(
draw_list, vert_start_idx, vert_end_idx, gradient_p0, gradient_p1, col0,
col1);
}
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) {
return ImGui::ShadeVertsLinearUV(draw_list, vert_start_idx, vert_end_idx, a,
b, uv_a, uv_b, clamp);
}
CIMGUI_API void igShadeVertsTransformPos(ImDrawList* draw_list,
int vert_start_idx,
int vert_end_idx,
const ImVec2 pivot_in,
float cos_a,
float sin_a,
const ImVec2 pivot_out) {
return ImGui::ShadeVertsTransformPos(draw_list, vert_start_idx, vert_end_idx,
pivot_in, cos_a, sin_a, pivot_out);
}
CIMGUI_API void igGcCompactTransientMiscBuffers() {
return ImGui::GcCompactTransientMiscBuffers();
}
CIMGUI_API void igGcCompactTransientWindowBuffers(ImGuiWindow* window) {
return ImGui::GcCompactTransientWindowBuffers(window);
}
CIMGUI_API void igGcAwakeTransientWindowBuffers(ImGuiWindow* window) {
return ImGui::GcAwakeTransientWindowBuffers(window);
}
CIMGUI_API void igDebugLog(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
ImGui::DebugLogV(fmt, args);
va_end(args);
}
CIMGUI_API void igDebugLogV(const char* fmt, va_list args) {
return ImGui::DebugLogV(fmt, args);
}
CIMGUI_API void igDebugAllocHook(ImGuiDebugAllocInfo* info,
int frame_count,
void* ptr,
size_t size) {
return ImGui::DebugAllocHook(info, frame_count, ptr, size);
}
CIMGUI_API void igErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback,
void* user_data) {
return ImGui::ErrorCheckEndFrameRecover(log_callback, user_data);
}
CIMGUI_API void igErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback,
void* user_data) {
return ImGui::ErrorCheckEndWindowRecover(log_callback, user_data);
}
CIMGUI_API void igErrorCheckUsingSetCursorPosToExtendParentBoundaries() {
return ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
}
CIMGUI_API void igDebugDrawCursorPos(ImU32 col) {
return ImGui::DebugDrawCursorPos(col);
}
CIMGUI_API void igDebugDrawLineExtents(ImU32 col) {
return ImGui::DebugDrawLineExtents(col);
}
CIMGUI_API void igDebugDrawItemRect(ImU32 col) {
return ImGui::DebugDrawItemRect(col);
}
CIMGUI_API void igDebugLocateItem(ImGuiID target_id) {
return ImGui::DebugLocateItem(target_id);
}
CIMGUI_API void igDebugLocateItemOnHover(ImGuiID target_id) {
return ImGui::DebugLocateItemOnHover(target_id);
}
CIMGUI_API void igDebugLocateItemResolveWithLastItem() {
return ImGui::DebugLocateItemResolveWithLastItem();
}
CIMGUI_API void igDebugBreakClearData() {
return ImGui::DebugBreakClearData();
}
CIMGUI_API bool igDebugBreakButton(const char* label,
const char* description_of_location) {
return ImGui::DebugBreakButton(label, description_of_location);
}
CIMGUI_API void igDebugBreakButtonTooltip(bool keyboard_only,
const char* description_of_location) {
return ImGui::DebugBreakButtonTooltip(keyboard_only, description_of_location);
}
CIMGUI_API void igShowFontAtlas(ImFontAtlas* atlas) {
return ImGui::ShowFontAtlas(atlas);
}
CIMGUI_API void igDebugHookIdInfo(ImGuiID id,
ImGuiDataType data_type,
const void* data_id,
const void* data_id_end) {
return ImGui::DebugHookIdInfo(id, data_type, data_id, data_id_end);
}
CIMGUI_API void igDebugNodeColumns(ImGuiOldColumns* columns) {
return ImGui::DebugNodeColumns(columns);
}
CIMGUI_API void igDebugNodeDockNode(ImGuiDockNode* node, const char* label) {
return ImGui::DebugNodeDockNode(node, label);
}
CIMGUI_API void igDebugNodeDrawList(ImGuiWindow* window,
ImGuiViewportP* viewport,
const ImDrawList* draw_list,
const char* label) {
return ImGui::DebugNodeDrawList(window, viewport, draw_list, label);
}
CIMGUI_API void igDebugNodeDrawCmdShowMeshAndBoundingBox(
ImDrawList* out_draw_list,
const ImDrawList* draw_list,
const ImDrawCmd* draw_cmd,
bool show_mesh,
bool show_aabb) {
return ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(
out_draw_list, draw_list, draw_cmd, show_mesh, show_aabb);
}
CIMGUI_API void igDebugNodeFont(ImFont* font) {
return ImGui::DebugNodeFont(font);
}
CIMGUI_API void igDebugNodeFontGlyph(ImFont* font, const ImFontGlyph* glyph) {
return ImGui::DebugNodeFontGlyph(font, glyph);
}
CIMGUI_API void igDebugNodeStorage(ImGuiStorage* storage, const char* label) {
return ImGui::DebugNodeStorage(storage, label);
}
CIMGUI_API void igDebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label) {
return ImGui::DebugNodeTabBar(tab_bar, label);
}
CIMGUI_API void igDebugNodeTable(ImGuiTable* table) {
return ImGui::DebugNodeTable(table);
}
CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings) {
return ImGui::DebugNodeTableSettings(settings);
}
CIMGUI_API void igDebugNodeInputTextState(ImGuiInputTextState* state) {
return ImGui::DebugNodeInputTextState(state);
}
CIMGUI_API void igDebugNodeTypingSelectState(ImGuiTypingSelectState* state) {
return ImGui::DebugNodeTypingSelectState(state);
}
CIMGUI_API void igDebugNodeWindow(ImGuiWindow* window, const char* label) {
return ImGui::DebugNodeWindow(window, label);
}
CIMGUI_API void igDebugNodeWindowSettings(ImGuiWindowSettings* settings) {
return ImGui::DebugNodeWindowSettings(settings);
}
CIMGUI_API void igDebugNodeWindowsList(ImVector_ImGuiWindowPtr* windows,
const char* label) {
return ImGui::DebugNodeWindowsList(windows, label);
}
CIMGUI_API void igDebugNodeWindowsListByBeginStackParent(
ImGuiWindow** windows,
int windows_size,
ImGuiWindow* parent_in_begin_stack) {
return ImGui::DebugNodeWindowsListByBeginStackParent(windows, windows_size,
parent_in_begin_stack);
}
CIMGUI_API void igDebugNodeViewport(ImGuiViewportP* viewport) {
return ImGui::DebugNodeViewport(viewport);
}
CIMGUI_API void igDebugRenderKeyboardPreview(ImDrawList* draw_list) {
return ImGui::DebugRenderKeyboardPreview(draw_list);
}
CIMGUI_API void igDebugRenderViewportThumbnail(ImDrawList* draw_list,
ImGuiViewportP* viewport,
const ImRect bb) {
return ImGui::DebugRenderViewportThumbnail(draw_list, viewport, bb);
}
CIMGUI_API void igImFontAtlasUpdateConfigDataPointers(ImFontAtlas* atlas) {
return ImFontAtlasUpdateConfigDataPointers(atlas);
}
CIMGUI_API void igImFontAtlasBuildInit(ImFontAtlas* atlas) {
return ImFontAtlasBuildInit(atlas);
}
CIMGUI_API void igImFontAtlasBuildSetupFont(ImFontAtlas* atlas,
ImFont* font,
ImFontConfig* font_config,
float ascent,
float descent) {
return ImFontAtlasBuildSetupFont(atlas, font, font_config, ascent, descent);
}
CIMGUI_API void igImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas,
void* stbrp_context_opaque) {
return ImFontAtlasBuildPackCustomRects(atlas, stbrp_context_opaque);
}
CIMGUI_API void igImFontAtlasBuildFinish(ImFontAtlas* atlas) {
return ImFontAtlasBuildFinish(atlas);
}
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) {
return ImFontAtlasBuildRender8bppRectFromString(
atlas, x, y, w, h, in_str, in_marker_char, in_marker_pixel_value);
}
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) {
return ImFontAtlasBuildRender32bppRectFromString(
atlas, x, y, w, h, in_str, in_marker_char, in_marker_pixel_value);
}
CIMGUI_API void igImFontAtlasBuildMultiplyCalcLookupTable(
unsigned char out_table[256],
float in_multiply_factor) {
return ImFontAtlasBuildMultiplyCalcLookupTable(out_table, in_multiply_factor);
}
CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(
const unsigned char table[256],
unsigned char* pixels,
int x,
int y,
int w,
int h,
int stride) {
return ImFontAtlasBuildMultiplyRectAlpha8(table, pixels, x, y, w, h, stride);
}
/////////////////////////////manual written functions
CIMGUI_API void igLogText(CONST char* fmt, ...) {
char buffer[256];
va_list args;
va_start(args, fmt);
vsnprintf(buffer, 256, fmt, args);
va_end(args);
ImGui::LogText("%s", buffer);
}
CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer* buffer,
const char* fmt,
...) {
va_list args;
va_start(args, fmt);
buffer->appendfv(fmt, args);
va_end(args);
}
CIMGUI_API float igGET_FLT_MAX() {
return FLT_MAX;
}
CIMGUI_API float igGET_FLT_MIN() {
return FLT_MIN;
}
CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create() {
return IM_NEW(ImVector<ImWchar>)();
}
CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self) {
IM_DELETE(self);
}
CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p) {
IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
}
CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p) {
p->~ImVector<ImWchar>();
}
#ifdef IMGUI_HAS_DOCK
// NOTE: Some function pointers in the ImGuiPlatformIO structure are not
// C-compatible because of their use of a complex return type. To work around
// this, we store a custom CimguiStorage object inside
// ImGuiIO::BackendLanguageUserData, which contains C-compatible function
// pointer variants for these functions. When a user function pointer is
// provided, we hook up the underlying ImGuiPlatformIO function pointer to a
// thunk which accesses the user function pointer through CimguiStorage.
struct CimguiStorage {
void (*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos);
void (*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos);
};
// Gets a reference to the CimguiStorage object stored in the current ImGui
// context's BackendLanguageUserData.
CimguiStorage& GetCimguiStorage() {
ImGuiIO& io = ImGui::GetIO();
if (io.BackendLanguageUserData == NULL) {
io.BackendLanguageUserData = new CimguiStorage();
}
return *(CimguiStorage*)io.BackendLanguageUserData;
}
// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos.
ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp) {
ImVec2 pos;
GetCimguiStorage().Platform_GetWindowPos(vp, &pos);
return pos;
};
// Fully C-compatible function pointer setter for
// ImGuiPlatformIO::Platform_GetWindowPos.
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(
ImGuiPlatformIO* platform_io,
void (*user_callback)(ImGuiViewport* vp, ImVec2* out_pos)) {
CimguiStorage& storage = GetCimguiStorage();
storage.Platform_GetWindowPos = user_callback;
platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook;
}
// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize.
ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp) {
ImVec2 size;
GetCimguiStorage().Platform_GetWindowSize(vp, &size);
return size;
};
// Fully C-compatible function pointer setter for
// ImGuiPlatformIO::Platform_GetWindowSize.
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(
ImGuiPlatformIO* platform_io,
void (*user_callback)(ImGuiViewport* vp, ImVec2* out_size)) {
CimguiStorage& storage = GetCimguiStorage();
storage.Platform_GetWindowSize = user_callback;
platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook;
}
#endif
Reference in New Issue View Git Blame Copy Permalink