4573 lines
196 KiB
Java
4573 lines
196 KiB
Java
package imgui;
|
|
|
|
import imgui.enums.ImGuiInputTextFlags;
|
|
|
|
import java.nio.ByteBuffer;
|
|
|
|
public final class ImGui {
|
|
private final static String LIB_NAME_PROP = "imgui.library.name";
|
|
private final static String LIB_NAME_DEFAULT = "imgui-java";
|
|
|
|
private static final ImDrawData DRAW_DATA = new ImDrawData(100_000, 100_000, 1000);
|
|
private static final ImGuiIO IMGUI_IO = new ImGuiIO();
|
|
private static final ImGuiStyle IMGUI_STYLE = new ImGuiStyle();
|
|
private static final ImDrawList IM_DRAW_LIST = new ImDrawList(ImDrawList.TYPE_DEFAULT);
|
|
private static final ImDrawList IM_DRAW_LIST_BACKGROUND = new ImDrawList(ImDrawList.TYPE_BACKGROUND);
|
|
private static final ImDrawList IM_DRAW_LIST_FOREGROUND = new ImDrawList(ImDrawList.TYPE_FOREGROUND);
|
|
|
|
static {
|
|
System.loadLibrary(System.getProperty(LIB_NAME_PROP, LIB_NAME_DEFAULT));
|
|
initJniCommon();
|
|
ImDrawList.nInit();
|
|
ImDrawData.nInit();
|
|
nInitInputTextData();
|
|
}
|
|
|
|
private ImGui() {
|
|
}
|
|
|
|
/*JNI
|
|
#include <imgui.h>
|
|
#include "jni_common.h"
|
|
*/
|
|
|
|
private native static void initJniCommon(); /*
|
|
Jni::InitCommon(env);
|
|
*/
|
|
|
|
// Context creation and access
|
|
// Each context create its own ImFontAtlas by default.
|
|
// You may instance one yourself and pass it to CreateContext() to share a font atlas between imgui contexts.
|
|
// None of those functions is reliant on the current context.
|
|
//
|
|
// BINDING NOTICE: Getting of the current context is not implemented since it's a part of internal API which is not exposed here.
|
|
|
|
public native static void CreateContext(); /*
|
|
ImGui::CreateContext();
|
|
*/
|
|
|
|
// public static void CreateContext(ImFontAtlas sharedFontAtlas) TODO create context with fonts
|
|
|
|
public native static void DestroyContext(); /*
|
|
ImGui::DestroyContext();
|
|
*/
|
|
|
|
// Main
|
|
|
|
/**
|
|
* Access the IO structure (mouse/keyboard/gamepad inputs, time, various configuration options/flags).
|
|
*/
|
|
public static ImGuiIO GetIO() {
|
|
return IMGUI_IO;
|
|
}
|
|
|
|
/**
|
|
* Access the Style structure (colors, sizes). Always use PushStyleCol(), PushStyleVar() to modify style mid-frame.
|
|
*/
|
|
public static ImGuiStyle GetStyle() {
|
|
return IMGUI_STYLE;
|
|
}
|
|
|
|
/**
|
|
* Start a new Dear ImGui frame, you can submit any command from this point until Render()/EndFrame().
|
|
*/
|
|
public native static void NewFrame(); /*
|
|
ImGui::NewFrame();
|
|
*/
|
|
|
|
/**
|
|
* Ends the Dear ImGui frame. automatically called by Render(), you likely don't need to call that yourself directly.
|
|
* If you don't need to render data (skipping rendering) you may call EndFrame() but you'll have wasted CPU already!
|
|
* If you don't need to render, better to not create any imgui windows and not call NewFrame() at all!
|
|
*/
|
|
public native static void EndFrame(); /*
|
|
ImGui::EndFrame();
|
|
*/
|
|
|
|
/**
|
|
* Ends the Dear ImGui frame, finalize the draw data.
|
|
* You can get call GetDrawData() to obtain it and run your rendering function.
|
|
*/
|
|
public native static void Render(); /*
|
|
ImGui::Render();
|
|
*/
|
|
|
|
/**
|
|
* Valid after Render() and until the next call to NewFrame(). this is what you have to render.
|
|
*/
|
|
public static ImDrawData GetDrawData() {
|
|
ByteBuffer cmdByteBuffer = DRAW_DATA.cmdByteBuffer;
|
|
ByteBuffer vByteBuffer = DRAW_DATA.vByteBuffer;
|
|
ByteBuffer iByteBuffer = DRAW_DATA.iByteBuffer;
|
|
vByteBuffer.position(0);
|
|
iByteBuffer.position(0);
|
|
cmdByteBuffer.position(0);
|
|
DRAW_DATA.nFillDrawData(iByteBuffer, vByteBuffer, cmdByteBuffer);
|
|
return DRAW_DATA;
|
|
}
|
|
|
|
// Demo, Debug, Information
|
|
|
|
/**
|
|
* Create Demo window (previously called ShowTestWindow). demonstrate most ImGui features.
|
|
* Call this to learn about the library!
|
|
*/
|
|
public native static void ShowDemoWindow(); /*
|
|
ImGui::ShowDemoWindow();
|
|
*/
|
|
|
|
public static void ShowDemoWindow(ImBool pOpen) {
|
|
nShowDemoWindow(pOpen.data);
|
|
}
|
|
|
|
private native static void nShowDemoWindow(boolean[] pOpen); /*
|
|
ImGui::ShowDemoWindow(&pOpen[0]);
|
|
*/
|
|
|
|
/**
|
|
* Create About window. display Dear ImGui version, credits and build/system information.
|
|
*/
|
|
public native static void ShowAboutWindow(); /*
|
|
ImGui::ShowAboutWindow();
|
|
*/
|
|
|
|
public static void ShowAboutWindow(ImBool pOpen) {
|
|
nShowAboutWindow(pOpen.data);
|
|
}
|
|
|
|
private native static void nShowAboutWindow(boolean[] pOpen); /*
|
|
ImGui::ShowAboutWindow(&pOpen[0]);
|
|
*/
|
|
|
|
/**
|
|
* Create Metrics/Debug window.
|
|
* Display Dear ImGui internals: draw commands (with individual draw calls and vertices), window list, basic internal state, etc.
|
|
*/
|
|
public native static void ShowMetricsWindow(); /*
|
|
ImGui::ShowMetricsWindow();
|
|
*/
|
|
|
|
public static void ShowMetricsWindow(ImBool pOpen) {
|
|
nShowMetricsWindow(pOpen.data);
|
|
}
|
|
|
|
private native static void nShowMetricsWindow(boolean[] pOpen); /*
|
|
ImGui::ShowMetricsWindow(&pOpen[0]);
|
|
*/
|
|
|
|
/**
|
|
* Add style editor block (not a window).
|
|
* You can pass in a reference ImGuiStyle structure to compare to, revert to and save to (else it uses the default style)
|
|
*/
|
|
public native static void ShowStyleEditor(); /*
|
|
ImGui::ShowStyleEditor();
|
|
*/
|
|
|
|
/**
|
|
* Add style selector block (not a window), essentially a combo listing the default styles.
|
|
*/
|
|
public native static boolean ShowStyleSelector(String label); /*
|
|
return ImGui::ShowStyleSelector(label);
|
|
*/
|
|
|
|
/**
|
|
* Add font selector block (not a window), essentially a combo listing the loaded fonts.
|
|
*/
|
|
public native static void ShowFontSelector(String label); /*
|
|
ImGui::ShowFontSelector(label);
|
|
*/
|
|
|
|
/**
|
|
* Add basic help/info block (not a window): how to manipulate ImGui as a end-user (mouse/keyboard controls).
|
|
*/
|
|
public native static void ShowUserGuide(); /*
|
|
ImGui::ShowUserGuide();
|
|
*/
|
|
|
|
/**
|
|
* Get the compiled version string e.g. "1.23" (essentially the compiled value for IMGUI_VERSION)
|
|
*/
|
|
public native static String GetVersion(); /*
|
|
return env->NewStringUTF(ImGui::GetVersion());
|
|
*/
|
|
|
|
// Styles
|
|
|
|
/**
|
|
* New, recommended style (default)
|
|
*/
|
|
public native static void StyleColorsDark(); /*
|
|
ImGui::StyleColorsDark();
|
|
*/
|
|
|
|
/**
|
|
* Classic imgui style
|
|
*/
|
|
public native static void StyleColorsClassic(); /*
|
|
ImGui::StyleColorsClassic();
|
|
*/
|
|
|
|
/**
|
|
* Best used with borders and a custom, thicker font
|
|
*/
|
|
public native static void StyleColorsLight(); /*
|
|
ImGui::StyleColorsLight();
|
|
*/
|
|
|
|
// Windows
|
|
// - Begin() = push window to the stack and start appending to it. End() = pop window from the stack.
|
|
// - You may append multiple times to the same window during the same frame.
|
|
// - Passing 'bool* pOpen != NULL' shows a window-closing widget in the upper-right corner of the window,
|
|
// which clicking will set the boolean to false when clicked.
|
|
// - Begin() return false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting
|
|
// anything to the window. Always call a matching End() for each Begin() call, regardless of its return value!
|
|
// [Important: due to legacy reason, this is inconsistent with most other functions such as BeginMenu/EndMenu,
|
|
// BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function
|
|
// returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.]
|
|
// - Note that the bottom of window stack always contains a window called "Debug".
|
|
|
|
public native static boolean Begin(String title); /*
|
|
return ImGui::Begin(title);
|
|
*/
|
|
|
|
public static boolean Begin(String title, ImBool pOpen) {
|
|
return nBegin(title, pOpen.data, 0);
|
|
}
|
|
|
|
public static boolean Begin(String title, ImBool pOpen, int imGuiWindowFlags) {
|
|
return nBegin(title, pOpen.data, imGuiWindowFlags);
|
|
}
|
|
|
|
private native static boolean nBegin(String title, boolean[] pOpen, int imGuiWindowFlags); /*
|
|
return ImGui::Begin(title, &pOpen[0], imGuiWindowFlags);
|
|
*/
|
|
|
|
public native static void End(); /*
|
|
ImGui::End();
|
|
*/
|
|
|
|
// Child Windows
|
|
// - Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child.
|
|
// - For each independent axis of 'size': ==0.0f: use remaining host window size / >0.0f: fixed size / <0.0f: use remaining window size minus abs(size) / Each axis can use a different mode, e.g. ImVec2(0,400).
|
|
// - BeginChild() returns false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window.
|
|
// Always call a matching EndChild() for each BeginChild() call, regardless of its return value [this is due to legacy reason and is inconsistent with most other functions such as BeginMenu/EndMenu, BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function returned true.]
|
|
|
|
public native static boolean BeginChild(String strId); /*
|
|
return ImGui::BeginChild(strId);
|
|
*/
|
|
|
|
public static native boolean BeginChild(String str_id, float width, float height); /*
|
|
return ImGui::BeginChild(str_id, ImVec2(width, height));
|
|
*/
|
|
|
|
public static native boolean BeginChild(String str_id, float width, float height, boolean border); /*
|
|
return ImGui::BeginChild(str_id, ImVec2(width, height), border);
|
|
*/
|
|
|
|
public static native boolean BeginChild(String str_id, float width, float height, boolean border, int imGuiWindowFlags); /*
|
|
return ImGui::BeginChild(str_id, ImVec2(width, height), border, imGuiWindowFlags);
|
|
*/
|
|
|
|
public static native boolean BeginChild(int imGuiID); /*
|
|
return ImGui::BeginChild(imGuiID);
|
|
*/
|
|
|
|
public static native boolean BeginChild(int imGuiID, float width, float height, boolean border); /*
|
|
return ImGui::BeginChild(imGuiID, ImVec2(width, height), border);
|
|
*/
|
|
|
|
public static native boolean BeginChild(int imGuiID, float width, float height, boolean border, int imGuiWindowFlags); /*
|
|
return ImGui::BeginChild(imGuiID, ImVec2(width, height), border, imGuiWindowFlags);
|
|
*/
|
|
|
|
public static native void EndChild(); /*
|
|
ImGui::EndChild();
|
|
*/
|
|
|
|
// Windows Utilities
|
|
// - "current window" = the window we are appending into while inside a Begin()/End() block. "next window" = next window we will Begin() into.
|
|
|
|
public static native boolean IsWindowAppearing(); /*
|
|
return ImGui::IsWindowAppearing();
|
|
*/
|
|
|
|
public static native boolean IsWindowCollapsed(); /*
|
|
return ImGui::IsWindowCollapsed();
|
|
*/
|
|
|
|
/**
|
|
* Is current window focused? or its root/child, depending on flags. see flags for options.
|
|
*/
|
|
public static native boolean IsWindowFocused(); /*
|
|
return ImGui::IsWindowFocused();
|
|
*/
|
|
|
|
/**
|
|
* Is current window focused? or its root/child, depending on flags. see flags for options.
|
|
*/
|
|
public static native boolean IsWindowFocused(int imGuiFocusedFlags); /*
|
|
return ImGui::IsWindowFocused(imGuiFocusedFlags);
|
|
*/
|
|
|
|
/**
|
|
* Is current window hovered (and typically: not blocked by a popup/modal)? see flags for options.
|
|
* NB: If you are trying to check whether your mouse should be dispatched to imgui or to your app,
|
|
* you should use the 'io.WantCaptureMouse' boolean for that! Please read the FAQ!
|
|
*/
|
|
public static native boolean IsWindowHovered(); /*
|
|
return ImGui::IsWindowHovered();
|
|
*/
|
|
|
|
/**
|
|
* Is current window hovered (and typically: not blocked by a popup/modal)? see flags for options.
|
|
* NB: If you are trying to check whether your mouse should be dispatched to imgui or to your app,
|
|
* you should use the 'io.WantCaptureMouse' boolean for that! Please read the FAQ!
|
|
*/
|
|
public static native boolean IsWindowHovered(int imGuiHoveredFlags); /*
|
|
return ImGui::IsWindowHovered(imGuiHoveredFlags);
|
|
*/
|
|
|
|
/**
|
|
* Get draw list associated to the current window, to append your own drawing primitives
|
|
*/
|
|
public static ImDrawList GetWindowDrawList() {
|
|
return IM_DRAW_LIST;
|
|
}
|
|
|
|
/**
|
|
* Get current window position in screen space (useful if you want to do your own drawing via the DrawList API)
|
|
*/
|
|
public native static void GetWindowPos(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetWindowPos(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Get current window size
|
|
*/
|
|
public static native void GetWindowSize(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetWindowSize(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Get current window width (shortcut for GetWindowSize().x)
|
|
*/
|
|
public static native float GetWindowWidth(); /*
|
|
return ImGui::GetWindowWidth();
|
|
*/
|
|
|
|
/**
|
|
* Get current window height (shortcut for GetWindowSize().y)
|
|
*/
|
|
public static native float GetWindowHeight(); /*
|
|
return ImGui::GetWindowHeight();
|
|
*/
|
|
|
|
// Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin).
|
|
|
|
/**
|
|
* Set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
|
|
*/
|
|
public static native void SetNextWindowPos(float x, float y); /*
|
|
ImGui::SetNextWindowPos(ImVec2(x, y));
|
|
*/
|
|
|
|
/**
|
|
* Set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
|
|
*/
|
|
public static native void SetNextWindowPos(float x, float y, int imGuiCond); /*
|
|
ImGui::SetNextWindowPos(ImVec2(x, y), imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
|
|
*/
|
|
public static native void SetNextWindowPos(float x, float y, int imGuiCond, float pivotX, float pivotY); /*
|
|
ImGui::SetNextWindowPos(ImVec2(x, y), imGuiCond, ImVec2(pivotX, pivotY));
|
|
*/
|
|
|
|
/**
|
|
* Set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
|
|
*/
|
|
public static native void SetNextWindowSize(float width, float height); /*
|
|
ImGui::SetNextWindowSize(ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
|
|
*/
|
|
public static native void SetNextWindowSize(float width, float height, int imGuiCond); /*
|
|
ImGui::SetNextWindowSize(ImVec2(width, height), imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Set next window size limits. use -1,-1 on either X/Y axis to preserve the current size. Sizes will be rounded down.
|
|
*/
|
|
public static native void SetNextWindowSizeConstraints(float minWidth, float minHeight, float maxWidth, float maxHeight); /*
|
|
ImGui::SetNextWindowSizeConstraints(ImVec2(minWidth, minHeight), ImVec2(maxWidth, maxHeight));
|
|
*/
|
|
|
|
/**
|
|
* Set next window content size (~ scrollable client area, which enforce the range of scrollbars).
|
|
* Not including window decorations (title bar, menu bar, etc.) nor WindowPadding. set an axis to 0.0f to leave it automatic. call before Begin()
|
|
*/
|
|
public static native void SetNextWindowContentSize(float width, float height); /*
|
|
ImGui::SetNextWindowContentSize(ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Set next window collapsed state. call before Begin()
|
|
*/
|
|
public static native void SetNextWindowCollapsed(boolean collapsed); /*
|
|
ImGui::SetNextWindowCollapsed(collapsed);
|
|
*/
|
|
|
|
/**
|
|
* Set next window collapsed state. call before Begin()
|
|
*/
|
|
public static native void SetNextWindowCollapsed(boolean collapsed, int imGuiCond); /*
|
|
ImGui::SetNextWindowCollapsed(collapsed, imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Set next window to be focused / top-most. call before Begin()
|
|
*/
|
|
public static native void SetNextWindowFocus(); /*
|
|
ImGui::SetNextWindowFocus();
|
|
*/
|
|
|
|
/**
|
|
* Set next window background color alpha. helper to easily modify ImGuiCol_WindowBg/ChildBg/PopupBg.
|
|
* You may also use ImGuiWindowFlags_NoBackground.
|
|
*/
|
|
public static native void SetNextWindowBgAlpha(float alpha); /*
|
|
ImGui::SetNextWindowBgAlpha(alpha);
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window position - call within Begin()/End().
|
|
* Prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
|
|
*/
|
|
public static native void SetWindowPos(float x, float y); /*
|
|
ImGui::SetWindowPos(ImVec2(x, y));
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window position - call within Begin()/End().
|
|
* Prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
|
|
*/
|
|
public static native void SetWindowPos(float x, float y, int imGuiCond); /*
|
|
ImGui::SetWindowPos(ImVec2(x, y), imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0,0) to force an auto-fit.
|
|
* Prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects.
|
|
*/
|
|
public static native void SetWindowSize(float width, float height); /*
|
|
ImGui::SetWindowSize(ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0,0) to force an auto-fit.
|
|
* Prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects.
|
|
*/
|
|
public static native void SetWindowSize(float width, float height, int imGuiCond); /*
|
|
ImGui::SetWindowSize(ImVec2(width, height), imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
|
|
*/
|
|
public static native void SetWindowCollapsed(boolean collapsed); /*
|
|
ImGui::SetWindowCollapsed(collapsed);
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
|
|
*/
|
|
public static native void SetWindowCollapsed(boolean collapsed, int imGuiCond); /*
|
|
ImGui::SetWindowCollapsed(collapsed, imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* (not recommended) set current window to be focused / top-most. prefer using SetNextWindowFocus().
|
|
*/
|
|
public static native void SetWindowFocus(); /*
|
|
ImGui::SetWindowFocus();
|
|
*/
|
|
|
|
/**
|
|
* Set font scale. Adjust IO.FontGlobalScale if you want to scale all windows.
|
|
* This is an old API! For correct scaling, prefer to reload font + rebuild ImFontAtlas + call style.ScaleAllSizes().
|
|
*/
|
|
public native void SetWindowFontScale(float scale); /*
|
|
ImGui::SetWindowFontScale(scale);
|
|
*/
|
|
|
|
/**
|
|
* Set named window position.
|
|
*/
|
|
public static native void SetWindowPos(String name, float x, float y); /*
|
|
ImGui::SetWindowPos(name, ImVec2(x, y));
|
|
*/
|
|
|
|
/**
|
|
* Set named window position.
|
|
*/
|
|
public static native void SetWindowPos(String name, float x, float y, int imGuiCond); /*
|
|
ImGui::SetWindowPos(name, ImVec2(x, y), imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Set named window size. set axis to 0.0f to force an auto-fit on this axis.
|
|
*/
|
|
public static native void SetWindowSize(String name, float x, float y); /*
|
|
ImGui::SetWindowSize(name, ImVec2(x, y));
|
|
*/
|
|
|
|
/**
|
|
* Set named window size. set axis to 0.0f to force an auto-fit on this axis.
|
|
*/
|
|
public static native void SetWindowSize(String name, float x, float y, int imGuiCond); /*
|
|
ImGui::SetWindowSize(name, ImVec2(x, y), imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Set named window collapsed state
|
|
*/
|
|
public static native void SetWindowCollapsed(String name, boolean collapsed); /*
|
|
ImGui::SetWindowCollapsed(name, collapsed);
|
|
*/
|
|
|
|
/**
|
|
* Set named window collapsed state
|
|
*/
|
|
public static native void SetWindowCollapsed(String name, boolean collapsed, int imGuiCond); /*
|
|
ImGui::SetWindowCollapsed(name, collapsed, imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Set named window to be focused / top-most. Use NULL to remove focus.
|
|
*/
|
|
public static native void SetWindowFocus(String name); /*MANUAL
|
|
if (obj_name == NULL)
|
|
ImGui::SetWindowFocus(NULL);
|
|
else {
|
|
char* name = (char*)env->GetStringUTFChars(obj_name, JNI_FALSE);
|
|
ImGui::SetWindowFocus(name);
|
|
env->ReleaseStringUTFChars(obj_name, name);
|
|
}
|
|
*/
|
|
|
|
// Content region
|
|
// - Those functions are bound to be redesigned soon (they are confusing, incomplete and return values in local window coordinates which increases confusion)
|
|
|
|
/**
|
|
* Current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
|
|
*/
|
|
public static native void GetContentRegionMax(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetContentRegionMax(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* == GetContentRegionMax() - GetCursorPos()
|
|
*/
|
|
public static native void GetContentRegionAvail(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetContentRegionAvail(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Content boundaries min (roughly (0,0)-Scroll), in window coordinates
|
|
*/
|
|
public static native float GetContentRegionAvailWidth(); /*
|
|
return ImGui::GetContentRegionAvailWidth();
|
|
*/
|
|
|
|
/**
|
|
* Content boundaries max (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
|
|
*/
|
|
public static native void GetWindowContentRegionMin(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetWindowContentRegionMin(), dstImVec2);
|
|
*/
|
|
|
|
public static native void GetWindowContentRegionMax(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetWindowContentRegionMax(), dstImVec2);
|
|
*/
|
|
|
|
// Windows Scrolling
|
|
|
|
/**
|
|
* Get scrolling amount [0..GetScrollMaxX()]
|
|
*/
|
|
public static native float GetScrollX(); /*
|
|
return ImGui::GetScrollX();
|
|
*/
|
|
|
|
/**
|
|
* Get scrolling amount [0..GetScrollMaxY()]
|
|
*/
|
|
public static native float GetScrollY(); /*
|
|
return ImGui::GetScrollY();
|
|
*/
|
|
|
|
/**
|
|
* Get maximum scrolling amount ~~ ContentSize.X - WindowSize.X
|
|
*/
|
|
public static native float GetScrollMaxX(); /*
|
|
return ImGui::GetScrollMaxX();
|
|
*/
|
|
|
|
/**
|
|
* Get maximum scrolling amount ~~ ContentSize.Y - WindowSize.Y
|
|
*/
|
|
public static native float GetScrollMaxY(); /*
|
|
return ImGui::GetScrollMaxY();
|
|
*/
|
|
|
|
/**
|
|
* Set scrolling amount [0..GetScrollMaxX()]
|
|
*/
|
|
public static native void SetScrollX(float scrollX); /*
|
|
ImGui::SetScrollX(scrollX);
|
|
*/
|
|
|
|
/**
|
|
* Set scrolling amount [0..GetScrollMaxY()]
|
|
*/
|
|
public static native void SetScrollY(float scrollY); /*
|
|
ImGui::SetScrollY(scrollY);
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make current cursor position visible. center_x_ratio=0.0: left, 0.5: center, 1.0: right.
|
|
* When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
|
|
*/
|
|
public static native void SetScrollHereX(); /*
|
|
ImGui::SetScrollHereX();
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make current cursor position visible. center_x_ratio=0.0: left, 0.5: center, 1.0: right.
|
|
* When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
|
|
*/
|
|
public static native void SetScrollHereX(float centerXRatio); /*
|
|
ImGui::SetScrollHereX(centerXRatio);
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom.
|
|
* When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
|
|
*/
|
|
public static native void SetScrollHereY(); /*
|
|
ImGui::SetScrollHereY();
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom.
|
|
* When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
|
|
*/
|
|
public static native void SetScrollHereY(float centerYRatio); /*
|
|
ImGui::SetScrollHereY(centerYRatio);
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
|
|
*/
|
|
public static native void SetScrollFromPosX(float localX); /*
|
|
ImGui::SetScrollFromPosX(localX);
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
|
|
*/
|
|
public static native void SetScrollFromPosX(float localX, float centerXRatio); /*
|
|
ImGui::SetScrollFromPosX(localX, centerXRatio);
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
|
|
*/
|
|
public static native void SetScrollFromPosY(float localY); /*
|
|
ImGui::SetScrollFromPosY(localY);
|
|
*/
|
|
|
|
/**
|
|
* Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
|
|
*/
|
|
public static native void SetScrollFromPosY(float localY, float centerYRatio); /*
|
|
ImGui::SetScrollFromPosY(localY, centerYRatio);
|
|
*/
|
|
|
|
// Parameters stacks (shared)
|
|
|
|
// TODO void PushFont(ImFont* font);
|
|
|
|
public static native void PopFont(); /*
|
|
ImGui::PopFont();
|
|
*/
|
|
|
|
public static native void PushStyleColor(int imGuiCol, long col); /*
|
|
ImGui::PushStyleColor(imGuiCol, col);
|
|
*/
|
|
|
|
public static native void PushStyleColor(int imGuiCol, float r, float g, float b, float a); /*
|
|
ImGui::PushStyleColor(imGuiCol, ImVec4(r, g, b, a));
|
|
*/
|
|
|
|
public static native void PopStyleColor(); /*
|
|
ImGui::PopStyleColor();
|
|
*/
|
|
|
|
public static native void PopStyleColor(int count); /*
|
|
ImGui::PopStyleColor(count);
|
|
*/
|
|
|
|
public static native void PushStyleVar(int imGuiStyleVar, float val); /*
|
|
ImGui::PushStyleVar(imGuiStyleVar, val);
|
|
*/
|
|
|
|
public static native void PushStyleVar(int imGuiStyleVar, float val_x, float val_y); /*
|
|
ImGui::PushStyleVar(imGuiStyleVar, ImVec2(val_x, val_y));
|
|
*/
|
|
|
|
public static native void PopStyleVar(); /*
|
|
ImGui::PopStyleVar();
|
|
*/
|
|
|
|
public static native void PopStyleVar(int count); /*
|
|
ImGui::PopStyleVar(count);
|
|
*/
|
|
|
|
/**
|
|
* Retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(),
|
|
* otherwise use GetColorU32() to get style color with style alpha baked in.
|
|
*/
|
|
public static native void GetStyleColorVec4(int imGuiStyleVar, ImVec4 dstImVec4); /*
|
|
Jni::ImVec4Cpy(env, ImGui::GetStyleColorVec4(imGuiStyleVar), dstImVec4);
|
|
*/
|
|
|
|
// TODO ImFont* GetFont();
|
|
|
|
/**
|
|
* Get current font size (= height in pixels) of current font with current scale applied
|
|
*/
|
|
public static native int GetFontSize(); /*
|
|
return ImGui::GetFontSize();
|
|
*/
|
|
|
|
/**
|
|
* Get UV coordinate for a while pixel, useful to draw custom shapes via the ImDrawList API
|
|
*/
|
|
public static native void GetFontTexUvWhitePixel(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetFontTexUvWhitePixel(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Retrieve given style color with style alpha applied and optional extra alpha multiplier
|
|
*/
|
|
public static native long GetColorU32(int imGuiCol); /*
|
|
return ImGui::GetColorU32((ImGuiCol)imGuiCol);
|
|
*/
|
|
|
|
/**
|
|
* Retrieve given style color with style alpha applied and optional extra alpha multiplier
|
|
*/
|
|
public static native long GetColorU32(int imGuiCol, float alpha_mul); /*
|
|
return ImGui::GetColorU32(imGuiCol, alpha_mul);
|
|
*/
|
|
|
|
/**
|
|
* Retrieve given color with style alpha applied
|
|
*/
|
|
public static native long GetColorU32(float col_r, float col_g, float col_b, float col_a); /*
|
|
return ImGui::GetColorU32(ImVec4(col_r, col_g, col_b, col_a));
|
|
*/
|
|
|
|
/**
|
|
* Retrieve given color with style alpha applied
|
|
*/
|
|
public static native long GetColorU32(long col); /*
|
|
return ImGui::GetColorU32((ImU32)col);
|
|
*/
|
|
|
|
// Parameters stacks (current window)
|
|
|
|
/**
|
|
* Set width of items for common large "item+label" widgets. >0.0f: width in pixels,
|
|
* <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side). 0.0f = default to ~2/3 of windows width,
|
|
*/
|
|
public static native void PushItemWidth(float item_width); /*
|
|
ImGui::PushItemWidth(item_width);
|
|
*/
|
|
|
|
public static native void PopItemWidth(); /*
|
|
ImGui::PopItemWidth();
|
|
*/
|
|
|
|
/**
|
|
* Set width of the _next_ common large "item+label" widget. >0.0f: width in pixels,
|
|
* <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side)
|
|
*/
|
|
public static native void SetNextItemWidth(float item_width); /*
|
|
ImGui::SetNextItemWidth(item_width);
|
|
*/
|
|
|
|
/**
|
|
* Width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions.
|
|
*/
|
|
public static native float CalcItemWidth(); /*
|
|
return ImGui::CalcItemWidth();
|
|
*/
|
|
|
|
/**
|
|
* Word-wrapping for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x'
|
|
* position in window local space
|
|
*/
|
|
public static native void PushTextWrapPos(); /*
|
|
ImGui::PushTextWrapPos();
|
|
*/
|
|
|
|
/**
|
|
* Word-wrapping for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x'
|
|
* position in window local space
|
|
*/
|
|
public static native void PushTextWrapPos(float wrap_local_pos_x); /*
|
|
ImGui::PushTextWrapPos(wrap_local_pos_x);
|
|
*/
|
|
|
|
public static native void PopTextWrapPos(); /*
|
|
ImGui::PopTextWrapPos();
|
|
*/
|
|
|
|
/**
|
|
* Allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets
|
|
*/
|
|
public static native void PushAllowKeyboardFocus(boolean allow_keyboard_focus); /*
|
|
ImGui::PushAllowKeyboardFocus(allow_keyboard_focus);
|
|
*/
|
|
|
|
public static native void PopAllowKeyboardFocus(); /*
|
|
ImGui::PopAllowKeyboardFocus();
|
|
*/
|
|
|
|
/**
|
|
* In 'repeat' mode, Button*() functions return repeated true in a typematic manner (using io.KeyRepeatDelay/io.KeyRepeatRate setting).
|
|
* Note that you can call IsItemActive() after any Button() to tell if the button is held in the current frame.
|
|
*/
|
|
public static native void PushButtonRepeat(boolean repeat); /*
|
|
ImGui::PushButtonRepeat(repeat);
|
|
*/
|
|
|
|
public static native void PopButtonRepeat(); /*
|
|
ImGui::PopButtonRepeat();
|
|
*/
|
|
|
|
// Cursor / Layout
|
|
// - By "cursor" we mean the current output position.
|
|
// - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down.
|
|
// - You can call SameLine() between widgets to undo the last carriage return and output at the right of the preceeding widget.
|
|
|
|
/**
|
|
* Separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.
|
|
*/
|
|
public static native void Separator(); /*
|
|
ImGui::Separator();
|
|
*/
|
|
|
|
/**
|
|
* Call between widgets or groups to layout them horizontally. X position given in window coordinates.
|
|
*/
|
|
public static native void SameLine(); /*
|
|
ImGui::SameLine();
|
|
*/
|
|
|
|
/**
|
|
* Call between widgets or groups to layout them horizontally. X position given in window coordinates.
|
|
*/
|
|
public static native void SameLine(float offsetFromStartX); /*
|
|
ImGui::SameLine(offsetFromStartX);
|
|
*/
|
|
|
|
/**
|
|
* Call between widgets or groups to layout them horizontally. X position given in window coordinates.
|
|
*/
|
|
public static native void SameLine(float offsetFromStartX, float spacing); /*
|
|
ImGui::SameLine(offsetFromStartX, spacing);
|
|
*/
|
|
|
|
/**
|
|
* Undo a SameLine() or force a new line when in an horizontal-layout context.
|
|
*/
|
|
public static native void NewLine(); /*
|
|
ImGui::NewLine();
|
|
*/
|
|
|
|
/**
|
|
* Add vertical spacing.
|
|
*/
|
|
public static native void Spacing(); /*
|
|
ImGui::Spacing();
|
|
*/
|
|
|
|
/**
|
|
* Add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into.
|
|
*/
|
|
public static native void Dummy(float width, float height); /*
|
|
ImGui::Dummy(ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Move content position toward the right, by style.IndentSpacing or indent_w if != 0
|
|
*/
|
|
public static native void Indent(); /*
|
|
ImGui::Indent();
|
|
*/
|
|
|
|
/**
|
|
* Move content position toward the right, by style.IndentSpacing or indent_w if != 0
|
|
*/
|
|
public static native void Indent(float indentW); /*
|
|
ImGui::Indent(indentW);
|
|
*/
|
|
|
|
/**
|
|
* Move content position back to the left, by style.IndentSpacing or indent_w if != 0
|
|
*/
|
|
public static native void Unindent(); /*
|
|
ImGui::Unindent();
|
|
*/
|
|
|
|
/**
|
|
* Move content position back to the left, by style.IndentSpacing or indent_w if != 0
|
|
*/
|
|
public static native void Unindent(float indentW); /*
|
|
ImGui::Unindent(indentW);
|
|
*/
|
|
|
|
/**
|
|
* Lock horizontal starting position
|
|
*/
|
|
public static native void BeginGroup(); /*
|
|
ImGui::BeginGroup();
|
|
*/
|
|
|
|
/**
|
|
* Unlock horizontal starting position + capture the whole group bounding box into one "item" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.)
|
|
*/
|
|
public static native void EndGroup(); /*
|
|
ImGui::EndGroup();
|
|
*/
|
|
|
|
// (some functions are using window-relative coordinates, such as: GetCursorPos, GetCursorStartPos, GetContentRegionMax, GetWindowContentRegion* etc.
|
|
// other functions such as GetCursorScreenPos or everything in ImDrawList::
|
|
// are using the main, absolute coordinate system.
|
|
// GetWindowPos() + GetCursorPos() == GetCursorScreenPos() etc.)
|
|
|
|
/**
|
|
* Cursor position in window coordinates (relative to window position)
|
|
*/
|
|
public static native void GetCursorPos(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetCursorPos(), dstImVec2);
|
|
*/
|
|
|
|
public static native float GetCursorPosX(); /*
|
|
return ImGui::GetCursorPosX();
|
|
*/
|
|
|
|
public static native float GetCursorPosY(); /*
|
|
return ImGui::GetCursorPosY();
|
|
*/
|
|
|
|
public static native void SetCursorPos(float x, float y); /*
|
|
ImGui::SetCursorPos(ImVec2(x, y));
|
|
*/
|
|
|
|
public static native void SetCursorPosX(float x); /*
|
|
ImGui::SetCursorPosX(x);
|
|
*/
|
|
|
|
public static native void SetCursorPosY(float y); /*
|
|
ImGui::SetCursorPosY(y);
|
|
*/
|
|
|
|
/**
|
|
* Initial cursor position in window coordinates
|
|
*/
|
|
public static native void GetCursorStartPos(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetCursorStartPos(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Cursor position in absolute screen coordinates [0..io.DisplaySize] (useful to work with ImDrawList API)
|
|
*/
|
|
public static native void GetCursorScreenPos(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetCursorScreenPos(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Cursor position in absolute screen coordinates [0..io.DisplaySize]
|
|
*/
|
|
public static native void SetCursorScreenPos(float x, float y); /*
|
|
ImGui::SetCursorScreenPos(ImVec2(x, y));
|
|
*/
|
|
|
|
/**
|
|
* Vertically align upcoming text baseline to FramePadding.y so that it will align properly to regularly framed items (call if you have text on a line before a framed item)
|
|
*/
|
|
public static native void AlignTextToFramePadding(); /*
|
|
ImGui::AlignTextToFramePadding();
|
|
*/
|
|
|
|
/**
|
|
* ~ FontSize
|
|
*/
|
|
public static native float GetTextLineHeight(); /*
|
|
return ImGui::GetTextLineHeight();
|
|
*/
|
|
|
|
/**
|
|
* ~ FontSize + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of text)
|
|
*/
|
|
public static native float GetTextLineHeightWithSpacing(); /*
|
|
return ImGui::GetTextLineHeightWithSpacing();
|
|
*/
|
|
|
|
/**
|
|
* ~ FontSize + style.FramePadding.y * 2
|
|
*/
|
|
public static native float GetFrameHeight(); /*
|
|
return ImGui::GetFrameHeight();
|
|
*/
|
|
|
|
/**
|
|
* ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets)
|
|
*/
|
|
public static native float GetFrameHeightWithSpacing(); /*
|
|
return ImGui::GetFrameHeightWithSpacing();
|
|
*/
|
|
|
|
// ID stack/scopes
|
|
// - Read the FAQ for more details about how ID are handled in dear imgui. If you are creating widgets in a loop you most
|
|
// likely want to push a unique identifier (e.g. object pointer, loop index) to uniquely differentiate them.
|
|
// - The resulting ID are hashes of the entire stack.
|
|
// - You can also use the "Label##foobar" syntax within widget label to distinguish them from each others.
|
|
// - In this header file we use the "label"/"name" terminology to denote a string that will be displayed and used as an ID,
|
|
// whereas "str_id" denote a string that is only used as an ID and not normally displayed.
|
|
|
|
/**
|
|
* Push string into the ID stack (will hash string).
|
|
*/
|
|
public static native void PushID(String str_id); /*
|
|
ImGui::PushID(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Push string into the ID stack (will hash string).
|
|
*/
|
|
public static native void PushID(String str_id_begin, String str_id_end); /*
|
|
ImGui::PushID(str_id_begin, str_id_end);
|
|
*/
|
|
|
|
/**
|
|
* Push pointer into the ID stack (will hash pointer).
|
|
*/
|
|
public static native void PushID(long ptr_id); /*
|
|
ImGui::PushID((void*)ptr_id);
|
|
*/
|
|
|
|
/**
|
|
* Push integer into the ID stack (will hash integer).
|
|
*/
|
|
public static native void PushID(int int_id); /*
|
|
ImGui::PushID(int_id);
|
|
*/
|
|
|
|
/**
|
|
* Pop from the ID stack.
|
|
*/
|
|
public static native void PopID(); /*
|
|
ImGui::PopID();
|
|
*/
|
|
|
|
/**
|
|
* Calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
|
|
*/
|
|
public static native long GetID(String str_id); /*
|
|
return ImGui::GetID(str_id);
|
|
*/
|
|
|
|
public static native long GetID(String str_id_begin, String str_id_end); /*
|
|
return ImGui::GetID(str_id_begin, str_id_end);
|
|
*/
|
|
|
|
public static native long GetID(long ptr_id); /*
|
|
return ImGui::GetID((void*)ptr_id);
|
|
*/
|
|
|
|
// Widgets: Text
|
|
|
|
/**
|
|
* Raw text without formatting. Roughly equivalent to Text("%s", text) but:
|
|
* A) doesn't require null terminated string if 'text_end' is specified,
|
|
* B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.
|
|
*/
|
|
public static native void TextUnformatted(String text); /*
|
|
ImGui::TextUnformatted(text);
|
|
*/
|
|
|
|
/**
|
|
* Raw text without formatting. Roughly equivalent to Text("%s", text) but:
|
|
* A) doesn't require null terminated string if 'text_end' is specified,
|
|
* B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.
|
|
*/
|
|
public static native void TextUnformatted(String text, String text_end); /*
|
|
ImGui::TextUnformatted(text, text_end);
|
|
*/
|
|
|
|
/**
|
|
* Formatted text
|
|
* BINDING NOTICE: Since all text formatting could be done on Java side, this call is equal to {@link ImGui#TextUnformatted(String)}.
|
|
*/
|
|
public static native void Text(String text); /*
|
|
ImGui::TextUnformatted(text);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
|
|
*/
|
|
public static native void TextColored(float r, float g, float b, float a, String text); /*
|
|
ImGui::TextColored(ImVec4(r, g, b, a), text);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();
|
|
*/
|
|
public static native void TextDisabled(String text); /*
|
|
ImGui::TextDisabled(text);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();.
|
|
* Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width,
|
|
* yoy may need to set a size using SetNextWindowSize().
|
|
*/
|
|
public static native void TextWrapped(String text); /*
|
|
ImGui::TextWrapped(text);
|
|
*/
|
|
|
|
/**
|
|
* Display text+label aligned the same way as value+label widgets
|
|
*/
|
|
public static native void LabelText(String label, String text); /*
|
|
ImGui::LabelText(label, text);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut for Bullet()+Text()
|
|
*/
|
|
public static native void BulletText(String text); /*
|
|
ImGui::BulletText(text);
|
|
*/
|
|
|
|
// Widgets: Main
|
|
// - Most widgets return true when the value has been changed or when pressed/selected
|
|
// - You may also use one of the many IsItemXXX functions (e.g. IsItemActive, IsItemHovered, etc.) to query widget state.
|
|
|
|
/**
|
|
* Button
|
|
*/
|
|
public static native boolean Button(String label); /*
|
|
return ImGui::Button(label);
|
|
*/
|
|
|
|
/**
|
|
* Button
|
|
*/
|
|
public static native boolean Button(String label, float width, float height); /*
|
|
return ImGui::Button(label, ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Button with FramePadding=(0,0) to easily embed within text
|
|
*/
|
|
public static native boolean SmallButton(String label); /*
|
|
return ImGui::SmallButton(label);
|
|
*/
|
|
|
|
/**
|
|
* Button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
|
|
*/
|
|
public static native boolean InvisibleButton(String strId, float width, float height); /*
|
|
return ImGui::InvisibleButton(strId, ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Square button with an arrow shape
|
|
*/
|
|
public static native boolean ArrowButton(String strId, int dir); /*
|
|
return ImGui::ArrowButton(strId, dir);
|
|
*/
|
|
|
|
public static native void Image(int textureID, float sizeX, float sizeY); /*
|
|
ImGui::Image((ImTextureID)textureID, ImVec2(sizeX, sizeY));
|
|
*/
|
|
|
|
public static native void Image(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y); /*
|
|
ImGui::Image((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y));
|
|
*/
|
|
|
|
public static native void Image(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, float tint_color_r, float tint_color_g, float tint_color_b, float tint_color_a, float border_col_r, float border_col_g, float border_col_b, float border_col_a); /*
|
|
ImGui::Image((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y), ImVec4(tint_color_r, tint_color_g, tint_color_b, tint_color_a), ImVec4(border_col_r, border_col_g, border_col_b, border_col_a));
|
|
*/
|
|
|
|
/**
|
|
* <0 frame_padding uses default frame padding settings. 0 for no padding
|
|
*/
|
|
public static native boolean ImageButton(int textureID, float sizeX, float sizeY); /*
|
|
return ImGui::ImageButton((ImTextureID)textureID, ImVec2(sizeX, sizeY));
|
|
*/
|
|
|
|
/**
|
|
* <0 frame_padding uses default frame padding settings. 0 for no padding
|
|
*/
|
|
public static native boolean ImageButton(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, int frame_padding); /*
|
|
return ImGui::ImageButton((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y), frame_padding);
|
|
*/
|
|
|
|
/**
|
|
* <0 frame_padding uses default frame padding settings. 0 for no padding
|
|
*/
|
|
public static native boolean ImageButton(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, int frame_padding, float bg_color_r, float bg_color_g, float bg_color_b, float bg_color_a, float tint_col_r, float tint_col_g, float tint_col_b, float tint_col_a); /*
|
|
return ImGui::ImageButton((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y), frame_padding, ImVec4(bg_color_r, bg_color_g, bg_color_b, bg_color_a), ImVec4(tint_col_r, tint_col_g, tint_col_b, tint_col_a));
|
|
*/
|
|
|
|
public static boolean Checkbox(String label, ImBool active) {
|
|
return nCheckbox(label, active.data);
|
|
}
|
|
|
|
private static native boolean nCheckbox(String label, boolean[] data); /*
|
|
return ImGui::Checkbox(label, &data[0]);
|
|
*/
|
|
|
|
public static boolean CheckboxFlags(String label, ImInt v, int flagsValue) {
|
|
return nCheckboxFlags(label, v.data, flagsValue);
|
|
}
|
|
|
|
private static native boolean nCheckboxFlags(String label, int[] data, int flagsValue); /*
|
|
return ImGui::CheckboxFlags(label, (unsigned int*)&data[0], flagsValue);
|
|
*/
|
|
|
|
/**
|
|
* Use with e.g. if (RadioButton("one", my_value==1)) { my_value = 1; }
|
|
*/
|
|
public static native boolean RadioButton(String label, boolean active); /*
|
|
return ImGui::RadioButton(label, active);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut to handle the above pattern when value is an integer
|
|
*/
|
|
public static boolean RadioButton(String label, ImInt v, int v_button) {
|
|
return nRadioButton(label, v.data, v_button);
|
|
}
|
|
|
|
private static native boolean nRadioButton(String label, int[] data, int v_button); /*
|
|
return ImGui::RadioButton(label, &data[0], v_button);
|
|
*/
|
|
|
|
public static native void ProgressBar(float fraction); /*
|
|
ImGui::ProgressBar(fraction);
|
|
*/
|
|
|
|
public static native void ProgressBar(float fraction, float size_arg_x, float size_arg_y); /*
|
|
ImGui::ProgressBar(fraction, ImVec2(size_arg_x, size_arg_y));
|
|
*/
|
|
|
|
public static native void ProgressBar(float fraction, float size_arg_x, float size_arg_y, String overlay); /*
|
|
ImGui::ProgressBar(fraction, ImVec2(size_arg_x, size_arg_y), overlay);
|
|
*/
|
|
|
|
/**
|
|
* Draw a small circle and keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
|
|
*/
|
|
public static native void Bullet(); /*
|
|
ImGui::Bullet();
|
|
*/
|
|
|
|
// Widgets: Combo Box
|
|
// - The BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() items.
|
|
// - The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose.
|
|
|
|
public static native boolean BeginCombo(String label, String preview_value); /*
|
|
return ImGui::BeginCombo(label, preview_value);
|
|
*/
|
|
|
|
public static native boolean BeginCombo(String label, String preview_value, int imGuiComboFlags); /*
|
|
return ImGui::BeginCombo(label, preview_value, imGuiComboFlags);
|
|
*/
|
|
|
|
/**
|
|
* Only call EndCombo() if BeginCombo() returns true!
|
|
*/
|
|
public static native void EndCombo(); /*
|
|
ImGui::EndCombo();
|
|
*/
|
|
|
|
public static boolean Combo(String label, ImInt current_item, String[] items, int items_count) {
|
|
return nCombo(label, current_item.data, items, items_count, -1);
|
|
}
|
|
|
|
public static boolean Combo(String label, ImInt current_item, String[] items, int items_count, int popup_max_height_in_items) {
|
|
return nCombo(label, current_item.data, items, items_count, popup_max_height_in_items);
|
|
}
|
|
|
|
private static native boolean nCombo(String label, int[] current_item, String[] items, int items_count, int popup_max_height_in_items); /*
|
|
const char* listbox_items[items_count];
|
|
for(int i = 0; i < items_count; i++) {
|
|
jstring string = (jstring)env->GetObjectArrayElement(items, i);
|
|
const char* rawString = env->GetStringUTFChars(string, 0);
|
|
listbox_items[i] = rawString;
|
|
}
|
|
return ImGui::Combo(label, ¤t_item[0], listbox_items, items_count, popup_max_height_in_items);
|
|
*/
|
|
|
|
/**
|
|
* Separate items with \0 within a string, end item-list with \0\0. e.g. "One\0Two\0Three\0"
|
|
*/
|
|
public static boolean Combo(String label, ImInt current_item, String items_separated_by_zeros) {
|
|
return nCombo(label, current_item.data, items_separated_by_zeros, -1);
|
|
}
|
|
|
|
public static boolean Combo(String label, ImInt current_item, String items_separated_by_zeros, int popup_max_height_in_items) {
|
|
return nCombo(label, current_item.data, items_separated_by_zeros, popup_max_height_in_items);
|
|
}
|
|
|
|
private static native boolean nCombo(String label, int[] current_item, String items_separated_by_zeros, int popup_max_height_in_items); /*
|
|
return ImGui::Combo(label, ¤t_item[0], items_separated_by_zeros, popup_max_height_in_items);
|
|
*/
|
|
|
|
// Widgets: Drags
|
|
// - CTRL+Click on any drag box to turn them into an input box. Manually input values aren't clamped and can go off-bounds.
|
|
// - For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x
|
|
// - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
|
|
// - Speed are per-pixel of mouse movement (v_speed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision).
|
|
// - Use v_min < v_max to clamp edits to given limits. Note that CTRL+Click manual input can override those limits.
|
|
// - Use v_min > v_max to lock edits.
|
|
|
|
public static native boolean DragFloat(String label, float[] v); /*
|
|
return ImGui::DragFloat(label, &v[0]);
|
|
*/
|
|
|
|
public static native boolean DragFloat(String label, float[] v, float v_speed); /*
|
|
return ImGui::DragFloat(label, &v[0], v_speed);
|
|
*/
|
|
|
|
/**
|
|
* If v_min >= v_max we have no bound
|
|
*/
|
|
public static native boolean DragFloat(String label, float[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragFloat(label, &v[0], v_speed, v_min, v_max);
|
|
*/
|
|
|
|
/**
|
|
* If v_min >= v_max we have no bound
|
|
*/
|
|
public static native boolean DragFloat(String label, float[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragFloat(label, &v[0], v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
/**
|
|
* If v_min >= v_max we have no bound
|
|
*/
|
|
public static native boolean DragFloat(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::DragFloat(label, &v[0], v_speed, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean DragFloat2(String label, float[] v); /*
|
|
return ImGui::DragFloat2(label, v);
|
|
*/
|
|
|
|
public static native boolean DragFloat2(String label, float[] v, float v_speed); /*
|
|
return ImGui::DragFloat2(label, v, v_speed);
|
|
*/
|
|
|
|
public static native boolean DragFloat2(String label, float[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragFloat2(label, v, v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragFloat2(String label, float[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragFloat2(label, v, v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragFloat2(String label, float[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragFloat2(label, v, v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragFloat2(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::DragFloat2(label, v, v_speed, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean DragFloat3(String label, float[] v); /*
|
|
return ImGui::DragFloat3(label, v);
|
|
*/
|
|
|
|
public static native boolean DragFloat3(String label, float[] v, float v_speed); /*
|
|
return ImGui::DragFloat3(label, v, v_speed);
|
|
*/
|
|
|
|
public static native boolean DragFloat3(String label, float[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragFloat3(label, v, v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragFloat3(String label, float[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragFloat3(label, v, v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragFloat3(String label, float[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragFloat3(label, v, v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragFloat3(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::DragFloat3(label, v, v_speed, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean DragFloat4(String label, float[] v); /*
|
|
return ImGui::DragFloat4(label, v);
|
|
*/
|
|
|
|
public static native boolean DragFloat4(String label, float[] v, float v_speed); /*
|
|
return ImGui::DragFloat4(label, v, v_speed);
|
|
*/
|
|
|
|
public static native boolean DragFloat4(String label, float[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragFloat4(label, v, v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragFloat4(String label, float[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragFloat4(label, v, v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragFloat4(String label, float[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragFloat4(label, v, v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragFloat4(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::DragFloat4(label, v, v_speed, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0]);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max, float v_speed); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max, float v_speed, float v_min); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max, float v_speed, float v_min, float v_max, String format, String format_max); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format, format_max);
|
|
*/
|
|
|
|
public static native boolean DragFloatRange2(String label, float[] v_current_min, float[] v_current_max, float v_speed, float v_min, float v_max, String format, String format_max, float power); /*
|
|
return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format, format_max, power);
|
|
*/
|
|
|
|
public static native boolean DragInt(String label, int[] v); /*
|
|
return ImGui::DragInt(label, &v[0]);
|
|
*/
|
|
|
|
public static native boolean DragInt(String label, int[] v, float v_speed); /*
|
|
return ImGui::DragInt(label, &v[0], v_speed);
|
|
*/
|
|
|
|
public static native boolean DragInt(String label, int[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragInt(label, &v[0], v_speed, v_min);
|
|
*/
|
|
|
|
/**
|
|
* If v_min >= v_max we have no bound
|
|
*/
|
|
public static native boolean DragInt(String label, int[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragInt(label, &v[0], v_speed, v_min, v_max);
|
|
*/
|
|
|
|
/**
|
|
* If v_min >= v_max we have no bound
|
|
*/
|
|
public static native boolean DragInt(String label, int[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragInt(label, &v[0], v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragInt2(String label, int[] v); /*
|
|
return ImGui::DragInt2(label, v);
|
|
*/
|
|
|
|
public static native boolean DragInt2(String label, int[] v, float v_speed); /*
|
|
return ImGui::DragInt2(label, v, v_speed);
|
|
*/
|
|
|
|
public static native boolean DragInt2(String label, int[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragInt2(label, v, v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragInt2(String label, int[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragInt2(label, v, v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragInt2(String label, int[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragInt3(String label, int[] v); /*
|
|
return ImGui::DragInt2(label, v);
|
|
*/
|
|
|
|
public static native boolean DragInt3(String label, int[] v, float v_speed); /*
|
|
return ImGui::DragInt2(label, v, v_speed);
|
|
*/
|
|
|
|
public static native boolean DragInt3(String label, int[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragInt2(label, v, v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragInt3(String label, int[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragInt2(label, v, v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragInt3(String label, int[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragInt4(String label, int[] v); /*
|
|
return ImGui::DragInt4(label, v);
|
|
*/
|
|
|
|
public static native boolean DragInt4(String label, int[] v, float v_speed); /*
|
|
return ImGui::DragInt4(label, v, v_speed);
|
|
*/
|
|
|
|
public static native boolean DragInt4(String label, int[] v, float v_speed, float v_min); /*
|
|
return ImGui::DragInt4(label, v, v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragInt4(String label, int[] v, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragInt4(label, v, v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragInt4(String label, int[] v, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragInt4(label, v, v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragIntRange2(String label, int[] v_current_min, int[] v_current_max); /*
|
|
return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0]);
|
|
*/
|
|
|
|
public static native boolean DragIntRange2(String label, int[] v_current_min, int[] v_current_max, float v_speed); /*
|
|
return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0], v_speed);
|
|
*/
|
|
|
|
public static native boolean DragIntRange2(String label, int[] v_current_min, int[] v_current_max, float v_speed, float v_min); /*
|
|
return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min);
|
|
*/
|
|
|
|
public static native boolean DragIntRange2(String label, int[] v_current_min, int[] v_current_max, float v_speed, float v_min, float v_max); /*
|
|
return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean DragIntRange2(String label, int[] v_current_min, int[] v_current_max, float v_speed, float v_min, float v_max, String format); /*
|
|
return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean DragIntRange2(String label, int[] v_current_min, int[] v_current_max, float v_speed, float v_min, float v_max, String format, String format_max); /*
|
|
return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format, format_max);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImInt p_data, float v_speed) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, int[] p_data, float v_speed); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImInt p_data, float v_speed, int p_min) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, int[] p_data, float v_speed, int p_min); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImInt p_data, float v_speed, int p_min, int p_max) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, int[] p_data, float v_speed, int p_min, int p_max); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImInt p_data, float v_speed, int p_min, int p_max, String format) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImInt p_data, float v_speed, int p_min, int p_max, String format, float power) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, int[] p_data, float v_speed, int p_min, int p_max, String format, float power); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImFloat p_data, float v_speed) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, float[] p_data, float v_speed); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImFloat p_data, float v_speed, float p_min) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, float[] p_data, float v_speed, float p_min); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImFloat p_data, float v_speed, float p_min, float p_max) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, float[] p_data, float v_speed, float p_min, float p_max); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImFloat p_data, float v_speed, float p_min, float p_max, String format) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImFloat p_data, float v_speed, float p_min, float p_max, String format, float power) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, float[] p_data, float v_speed, float p_min, float p_max, String format, float power); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImDouble p_data, float v_speed) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, double[] p_data, float v_speed); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImDouble p_data, float v_speed, double p_min) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, double[] p_data, float v_speed, double p_min); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImDouble p_data, float v_speed, double p_min, double p_max) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, double[] p_data, float v_speed, double p_min, double p_max); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImDouble p_data, float v_speed, double p_min, double p_max, String format) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImDouble p_data, float v_speed, double p_min, double p_max, String format, float power) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, double[] p_data, float v_speed, double p_min, double p_max, String format, float power); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImLong p_data, float v_speed) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, long[] p_data, float v_speed); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImLong p_data, float v_speed, long p_min) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, long[] p_data, float v_speed, long p_min); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImLong p_data, float v_speed, long p_min, long p_max) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, long[] p_data, float v_speed, long p_min, long p_max); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImLong p_data, float v_speed, long p_min, long p_max, String format) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImLong p_data, float v_speed, long p_min, long p_max, String format, float power) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, long[] p_data, float v_speed, long p_min, long p_max, String format, float power); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImShort p_data, float v_speed) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, short[] p_data, float v_speed); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImShort p_data, float v_speed, short p_min) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, short[] p_data, float v_speed, short p_min); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImShort p_data, float v_speed, short p_min, short p_max) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, short[] p_data, float v_speed, short p_min, short p_max); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImShort p_data, float v_speed, short p_min, short p_max, String format) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalar(String label, int data_type, ImShort p_data, float v_speed, short p_min, short p_max, String format, float power) {
|
|
return nDragScalar(label, data_type, p_data.data, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalar(String label, int data_type, short[] p_data, float v_speed, short p_min, short p_max, String format, float power); /*
|
|
return ImGui::DragScalar(label, data_type, &p_data[0], v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImInt p_data, int components, float v_speed) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, int[] p_data, int components, float v_speed); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImInt p_data, int components, float v_speed, int p_min) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, int[] p_data, int components, float v_speed, int p_min); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImInt p_data, int components, float v_speed, int p_min, int p_max) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, int[] p_data, int components, float v_speed, int p_min, int p_max); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImInt p_data, int components, float v_speed, int p_min, int p_max, String format) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImInt p_data, int components, float v_speed, int p_min, int p_max, String format, float power) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, int[] p_data, int components, float v_speed, int p_min, int p_max, String format, float power); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImFloat p_data, int components, float v_speed) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, float[] p_data, int components, float v_speed); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImFloat p_data, int components, float v_speed, float p_min) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, float[] p_data, int components, float v_speed, float p_min); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImFloat p_data, int components, float v_speed, float p_min, float p_max) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, float[] p_data, int components, float v_speed, float p_min, float p_max); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImFloat p_data, int components, float v_speed, float p_min, float p_max, String format) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImFloat p_data, int components, float v_speed, float p_min, float p_max, String format, float power) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, float[] p_data, int components, float v_speed, float p_min, float p_max, String format, float power); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImDouble p_data, int components, float v_speed) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, double[] p_data, int components, float v_speed); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImDouble p_data, int components, float v_speed, double p_min) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, double[] p_data, int components, float v_speed, double p_min); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImDouble p_data, int components, float v_speed, double p_min, double p_max) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, double[] p_data, int components, float v_speed, double p_min, double p_max); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImDouble p_data, int components, float v_speed, double p_min, double p_max, String format) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImDouble p_data, int components, float v_speed, double p_min, double p_max, String format, float power) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, double[] p_data, int components, float v_speed, double p_min, double p_max, String format, float power); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImLong p_data, int components, float v_speed) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, long[] p_data, int components, float v_speed); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImLong p_data, int components, float v_speed, long p_min) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, long[] p_data, int components, float v_speed, long p_min); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImLong p_data, int components, float v_speed, long p_min, long p_max) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, long[] p_data, int components, float v_speed, long p_min, long p_max); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImLong p_data, int components, float v_speed, long p_min, long p_max, String format) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImLong p_data, int components, float v_speed, long p_min, long p_max, String format, float power) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, long[] p_data, int components, float v_speed, long p_min, long p_max, String format, float power); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImShort p_data, int components, float v_speed) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, short[] p_data, int components, float v_speed); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImShort p_data, int components, float v_speed, short p_min) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, short[] p_data, int components, float v_speed, short p_min); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImShort p_data, int components, float v_speed, short p_min, short p_max) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, short[] p_data, int components, float v_speed, short p_min, short p_max); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max);
|
|
*/
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImShort p_data, int components, float v_speed, short p_min, short p_max, String format) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean DragScalarN(String label, int data_type, ImShort p_data, int components, float v_speed, short p_min, short p_max, String format, float power) {
|
|
return nDragScalarN(label, data_type, p_data.data, components, v_speed, p_min, p_max, format, power);
|
|
}
|
|
|
|
private static native boolean nDragScalarN(String label, int data_type, short[] p_data, int components, float v_speed, short p_min, short p_max, String format, float power); /*
|
|
return ImGui::DragScalarN(label, data_type, &p_data[0], components, v_speed, &p_min, &p_max, format, power);
|
|
*/
|
|
|
|
// Widgets: Sliders
|
|
// - CTRL+Click on any slider to turn them into an input box. Manually input values aren't clamped and can go off-bounds.
|
|
// - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
|
|
|
|
/**
|
|
* Adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display. Use power!=1.0 for power curve sliders
|
|
*/
|
|
public static native boolean SliderFloat(String label, float[] v, float v_min, float v_max); /*
|
|
return ImGui::SliderFloat(label, &v[0],v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderFloat(String label, float[] v, float v_min, float v_max, String format); /*
|
|
return ImGui::SliderFloat(label, &v[0], v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderFloat(String label, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::SliderFloat(label, &v[0], v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean SliderFloat2(String label, float[] v, float v_min, float v_max); /*
|
|
return ImGui::SliderFloat2(label, v, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderFloat2(String label, float[] v, float v_min, float v_max, String format); /*
|
|
return ImGui::SliderFloat2(label, v, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderFloat2(String label, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::SliderFloat2(label, v, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean SliderFloat3(String label, float[] v, float v_min, float v_max); /*
|
|
return ImGui::SliderFloat3(label, v, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderFloat3(String label, float[] v, float v_min, float v_max, String format); /*
|
|
return ImGui::SliderFloat3(label, v, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderFloat3(String label, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::SliderFloat3(label, v, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean SliderFloat4(String label, float[] v, float v_min, float v_max); /*
|
|
return ImGui::SliderFloat4(label, v, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderFloat4(String label, float[] v, float v_min, float v_max, String format); /*
|
|
return ImGui::SliderFloat4(label, v, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderFloat4(String label, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::SliderFloat4(label, v, v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean SliderAngle(String label, float[] v_rad); /*
|
|
return ImGui::SliderAngle(label, &v_rad[0]);
|
|
*/
|
|
|
|
public static native boolean SliderAngle(String label, float[] v_rad, float v_degrees_min); /*
|
|
return ImGui::SliderAngle(label, &v_rad[0], v_degrees_min);
|
|
*/
|
|
|
|
public static native boolean SliderAngle(String label, float[] v_rad, float v_degrees_min, float v_degrees_max); /*
|
|
return ImGui::SliderAngle(label, &v_rad[0], v_degrees_min, v_degrees_max);
|
|
*/
|
|
|
|
public static native boolean SliderAngle(String label, float[] v_rad, float v_degrees_min, float v_degrees_max, String format); /*
|
|
return ImGui::SliderAngle(label, &v_rad[0], v_degrees_min, v_degrees_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderInt(String label, int[] v, int v_min, int v_max); /*
|
|
return ImGui::SliderInt(label, &v[0], v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderInt(String label, int[] v, int v_min, int v_max, String format); /*
|
|
return ImGui::SliderInt(label, &v[0], v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderInt2(String label, int[] v, int v_min, int v_max); /*
|
|
return ImGui::SliderInt2(label, v, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderInt2(String label, int[] v, int v_min, int v_max, String format); /*
|
|
return ImGui::SliderInt2(label, v, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderInt3(String label, int[] v, int v_min, int v_max); /*
|
|
return ImGui::SliderInt3(label, v, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderInt3(String label, int[] v, int v_min, int v_max, String format); /*
|
|
return ImGui::SliderInt3(label, v, v_min, v_max, format);
|
|
*/
|
|
|
|
public static native boolean SliderInt4(String label, int[] v, int v_min, int v_max); /*
|
|
return ImGui::SliderInt4(label, v, v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean SliderInt4(String label, int[] v, int v_min, int v_max, String format); /*
|
|
return ImGui::SliderInt4(label, v, v_min, v_max, format);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImInt v, int v_min, int v_max) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, int[] v, int v_min, int v_max); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImInt v, int v_min, int v_max, String format) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImInt v, int v_min, int v_max, String format, float power) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, int[] v, int v_min, int v_max, String format, float power); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImFloat v, float v_min, float v_max) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, float[] v, float v_min, float v_max); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImFloat v, float v_min, float v_max, String format) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImFloat v, float v_min, float v_max, String format, float power) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImLong v, long v_min, long v_max) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, long[] v, long v_min, long v_max); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImLong v, long v_min, long v_max, String format) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImLong v, long v_min, long v_max, String format, float power) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, long[] v, long v_min, long v_max, String format, float power); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImDouble v, double v_min, double v_max) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, double[] v, double v_min, double v_max); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImDouble v, double v_min, double v_max, String format) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImDouble v, double v_min, double v_max, String format, float power) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, double[] v, double v_min, double v_max, String format, float power); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImShort v, short v_min, short v_max) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, short[] v, short v_min, short v_max); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImShort v, short v_min, short v_max, String format) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalar(String label, int data_type, ImShort v, short v_min, short v_max, String format, float power) {
|
|
return nSliderScalar(label, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalar(String label, int data_type, short[] v, short v_min, short v_max, String format, float power); /*
|
|
return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImInt v, int v_min, int v_max) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, int[] v, int v_min, int v_max); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImInt v, int v_min, int v_max, String format) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImInt v, int v_min, int v_max, String format, float power) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, int[] v, int v_min, int v_max, String format, float power); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImFloat v, float v_min, float v_max) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, float[] v, float v_min, float v_max); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImFloat v, float v_min, float v_max, String format) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImFloat v, float v_min, float v_max, String format, float power) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImLong v, long v_min, long v_max) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, long[] v, long v_min, long v_max); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImLong v, long v_min, long v_max, String format) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImLong v, long v_min, long v_max, String format, float power) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, long[] v, long v_min, long v_max, String format, float power); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImDouble v, double v_min, double v_max) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, double[] v, double v_min, double v_max); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImDouble v, double v_min, double v_max, String format) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImDouble v, double v_min, double v_max, String format, float power) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, double[] v, double v_min, double v_max, String format, float power); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImShort v, short v_min, short v_max) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, short[] v, short v_min, short v_max); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImShort v, short v_min, short v_max, String format) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean SliderScalarN(String label, int data_type, int components, ImShort v, short v_min, short v_max, String format, float power) {
|
|
return nSliderScalarN(label, data_type, components, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nSliderScalarN(String label, int data_type, int components, short[] v, short v_min, short v_max, String format, float power); /*
|
|
return ImGui::SliderScalarN(label, data_type, &v[0], components, &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean VSliderFloat(String label, float sizeX, float sizeY, float[] v, float v_min, float v_max); /*
|
|
return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean VSliderFloat(String label, float sizeX, float sizeY, float[] v, float v_min, float v_max, String format); /*
|
|
return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean VSliderFloat(String label, float sizeX, float sizeY, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max, format, power);
|
|
*/
|
|
|
|
public static native boolean VSliderInt(String label, float sizeX, float sizeY, int[] v, int v_min, int v_max); /*
|
|
return ImGui::VSliderInt(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max);
|
|
*/
|
|
|
|
public static native boolean VSliderInt(String label, float sizeX, float sizeY, int[] v, int v_min, int v_max, String format); /*
|
|
return ImGui::VSliderInt(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max, format);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImInt v, int v_min, int v_max) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, int[] v, int v_min, int v_max); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImInt v, int v_min, int v_max, String format) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImInt v, int v_min, int v_max, String format, float power) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, int[] v, int v_min, int v_max, String format, float power); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImFloat v, float v_min, float v_max) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, float[] v, float v_min, float v_max); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImFloat v, float v_min, float v_max, String format) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImFloat v, float v_min, float v_max, String format, float power) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, float[] v, float v_min, float v_max, String format, float power); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImLong v, long v_min, long v_max) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, long[] v, long v_min, long v_max); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImLong v, long v_min, long v_max, String format) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImLong v, long v_min, long v_max, String format, float power) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, long[] v, long v_min, long v_max, String format, float power); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImDouble v, double v_min, double v_max) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, double[] v, double v_min, double v_max); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImDouble v, double v_min, double v_max, String format) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImDouble v, double v_min, double v_max, String format, float power) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, double[] v, double v_min, double v_max, String format, float power); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImShort v, short v_min, short v_max) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, short[] v, short v_min, short v_max); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max);
|
|
*/
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImShort v, short v_min, short v_max, String format) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, 1.0f);
|
|
}
|
|
|
|
public static boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, ImShort v, short v_min, short v_max, String format, float power) {
|
|
return nVSliderScalar(label, sizeX, sizeY, data_type, v.data, v_min, v_max, format, power);
|
|
}
|
|
|
|
private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int data_type, short[] v, short v_min, short v_max, String format, float power); /*
|
|
return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power);
|
|
*/
|
|
|
|
// Widgets: Input with Keyboard
|
|
// - If you want to use InputText() with a dynamic string type such as std::string or your own, see misc/cpp/imgui_stdlib.h
|
|
// - Most of the ImGuiInputTextFlags flags are only useful for InputText() and not for InputFloatX, InputIntX, InputDouble etc.
|
|
|
|
/*JNI
|
|
jfieldID imTextInputDataSizeID;
|
|
jfieldID imTextInputDataIsDirtyID;
|
|
|
|
struct InputTextCallback_UserData {
|
|
jobject* textInputData;
|
|
JNIEnv* env;
|
|
int maxChar;
|
|
char* allowedChar;
|
|
int allowedCharLength;
|
|
int maxSize;
|
|
int curSize;
|
|
};
|
|
|
|
static int TextEditCallbackStub(ImGuiInputTextCallbackData* data) {
|
|
InputTextCallback_UserData* userData = (InputTextCallback_UserData*)data->UserData;
|
|
|
|
if (data->EventFlag == ImGuiInputTextFlags_CallbackCharFilter) {
|
|
if(userData->allowedCharLength > 0) {
|
|
bool found = false;
|
|
for(int i = 0; i < userData->allowedCharLength; i++) {
|
|
if(userData->allowedChar[i] == data->EventChar) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
return found ? 0 : 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
private static native void nInitInputTextData(); /*
|
|
jclass jImInputTextDataClass = env->FindClass("imgui/ImGuiInputTextData");
|
|
imTextInputDataSizeID = env->GetFieldID(jImInputTextDataClass, "size", "I");
|
|
imTextInputDataIsDirtyID = env->GetFieldID(jImInputTextDataClass, "isDirty", "Z");
|
|
*/
|
|
|
|
public static boolean InputText(String label, ImString text) {
|
|
return nInputText(label, text.data, text.data.length, 0, text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length());
|
|
}
|
|
|
|
public static boolean InputText(String label, ImString text, int imGuiInputTextFlags) {
|
|
return nInputText(label, text.data, text.data.length, imGuiInputTextFlags, text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length());
|
|
}
|
|
|
|
private static native boolean nInputText(String label, byte[] buff, int maxSize, int flags, ImGuiInputTextData textInputData, int maxChar, String allowedChar, int allowedCharLength); /*
|
|
int size = (int)strlen(buff);
|
|
|
|
InputTextCallback_UserData cb_user_data;
|
|
cb_user_data.textInputData = &textInputData;
|
|
cb_user_data.env = env;
|
|
cb_user_data.curSize = size;
|
|
cb_user_data.maxSize = maxSize;
|
|
cb_user_data.maxChar = maxChar;
|
|
cb_user_data.allowedChar = allowedChar;
|
|
cb_user_data.allowedCharLength = allowedCharLength;
|
|
|
|
char tempArray[maxSize];
|
|
|
|
memset(tempArray, 0, sizeof(tempArray));
|
|
memcpy(tempArray, buff, size);
|
|
|
|
if(maxChar >= 0 && maxChar < maxSize) {
|
|
maxSize = maxChar;
|
|
}
|
|
|
|
bool flag = ImGui::InputText(label, tempArray, maxSize, flags | ImGuiInputTextFlags_CallbackCharFilter, &TextEditCallbackStub, &cb_user_data);
|
|
|
|
if (flag) {
|
|
size = (int)strlen(tempArray);
|
|
env->SetIntField(textInputData, imTextInputDataSizeID, size);
|
|
env->SetBooleanField(textInputData, imTextInputDataIsDirtyID, true);
|
|
memset(buff, 0, maxSize);
|
|
memcpy(buff, tempArray, size);
|
|
}
|
|
|
|
return flag;
|
|
*/
|
|
|
|
public static boolean InputTextMultiline(String label, ImString text) {
|
|
return nInputTextMultiline(label, text.data, text.data.length, 0, 0, 0, text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length());
|
|
}
|
|
|
|
public static boolean InputTextMultiline(String label, ImString text, float width, float height) {
|
|
return nInputTextMultiline(label, text.data, text.data.length, width, height, 0, text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length());
|
|
}
|
|
|
|
public static boolean InputTextMultiline(String label, ImString text, float width, float height, int imGuiInputTextFlags) {
|
|
return nInputTextMultiline(label, text.data, text.data.length, width, height, imGuiInputTextFlags, text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length());
|
|
}
|
|
|
|
private static native boolean nInputTextMultiline(String label, byte[] buff, int maxSize, float width, float height, int flags, ImGuiInputTextData textInputData, int maxChar, String allowedChar, int allowedCharLength); /*
|
|
int size = (int)strlen(buff);
|
|
|
|
InputTextCallback_UserData cb_user_data;
|
|
cb_user_data.textInputData = &textInputData;
|
|
cb_user_data.env = env;
|
|
cb_user_data.curSize = size;
|
|
cb_user_data.maxSize = maxSize;
|
|
cb_user_data.maxChar = maxChar;
|
|
cb_user_data.allowedChar = allowedChar;
|
|
cb_user_data.allowedCharLength = allowedCharLength;
|
|
|
|
char tempArray[maxSize];
|
|
|
|
memset(tempArray, 0, sizeof(tempArray));
|
|
memcpy(tempArray, buff, size);
|
|
|
|
if(maxChar >= 0 && maxChar < maxSize) {
|
|
maxSize = maxChar;
|
|
}
|
|
|
|
bool flag = ImGui::InputTextMultiline(label, tempArray, maxSize, ImVec2(width, height), flags | ImGuiInputTextFlags_CallbackCharFilter, &TextEditCallbackStub, &cb_user_data);
|
|
|
|
if (flag) {
|
|
size = (int)strlen(tempArray);
|
|
env->SetIntField(textInputData, imTextInputDataSizeID, size);
|
|
env->SetBooleanField(textInputData, imTextInputDataIsDirtyID, true);
|
|
memset(buff, 0, maxSize);
|
|
memcpy(buff, tempArray, size);
|
|
}
|
|
|
|
return flag;
|
|
*/
|
|
|
|
public static boolean InputFloat(String label, ImFloat v) {
|
|
return nInputFloat(label, v.data, 0, 0, "%.3f", 0);
|
|
}
|
|
|
|
public static boolean InputFloat(String label, ImFloat v, float step) {
|
|
return nInputFloat(label, v.data, step, 0, "%.3f", 0);
|
|
}
|
|
|
|
public static boolean InputFloat(String label, ImFloat v, float step, float step_fast) {
|
|
return nInputFloat(label, v.data, step, step_fast, "%.3f", 0);
|
|
}
|
|
|
|
public static boolean InputFloat(String label, ImFloat v, float step, float step_fast, String format) {
|
|
return nInputFloat(label, v.data, step, step_fast, format, 0);
|
|
}
|
|
|
|
public static boolean InputFloat(String label, ImFloat v, float step, float step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputFloat(label, v.data, step, step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputFloat(String label, float[] v, float step, float step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputFloat(label, &v[0], step, step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static native boolean InputFloat2(String label, float[] v); /*
|
|
return ImGui::InputFloat2(label, v, "%.3f", 0);
|
|
*/
|
|
|
|
public static native boolean InputFloat2(String label, float[] v, String format); /*
|
|
return ImGui::InputFloat2(label, v, format, 0);
|
|
*/
|
|
|
|
public static native boolean InputFloat2(String label, float[] v, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputFloat2(label, v, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static native boolean InputFloat3(String label, float[] v); /*
|
|
return ImGui::InputFloat2(label, v, "%.3f", 0);
|
|
*/
|
|
|
|
public static native boolean InputFloat3(String label, float[] v, String format); /*
|
|
return ImGui::InputFloat2(label, v, format, 0);
|
|
*/
|
|
|
|
public static native boolean InputFloat3(String label, float[] v, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputFloat2(label, v, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static native boolean InputFloat4(String label, float[] v); /*
|
|
return ImGui::InputFloat2(label, v, "%.3f", 0);
|
|
*/
|
|
|
|
public static native boolean InputFloat4(String label, float[] v, String format); /*
|
|
return ImGui::InputFloat2(label, v, format, 0);
|
|
*/
|
|
|
|
public static native boolean InputFloat4(String label, float[] v, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputFloat2(label, v, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputInt(String label, ImInt v) {
|
|
return nInputInt(label, v.data, 1, 100, 0);
|
|
}
|
|
|
|
public static boolean InputInt(String label, ImInt v, int step) {
|
|
return nInputInt(label, v.data, step, 100, 0);
|
|
}
|
|
|
|
public static boolean InputInt(String label, ImInt v, int step, int step_fast) {
|
|
return nInputInt(label, v.data, step, step_fast, 0);
|
|
}
|
|
|
|
public static boolean InputInt(String label, ImInt v, int step, int step_fast, int imGuiInputTextFlags) {
|
|
return nInputInt(label, v.data, step, step_fast, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputInt(String label, int[] v, int step, int step_fast, int imGuiInputTextFlags); /*
|
|
return ImGui::InputInt(label, &v[0], step, step_fast, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static native boolean InputInt2(String label, int[] v); /*
|
|
return ImGui::InputInt2(label, v, 0);
|
|
*/
|
|
|
|
public static native boolean InputInt2(String label, int[] v, int imGuiInputTextFlags); /*
|
|
return ImGui::InputInt2(label, v, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static native boolean InputInt3(String label, int[] v); /*
|
|
return ImGui::InputInt2(label, v, 0);
|
|
*/
|
|
|
|
public static native boolean InputInt3(String label, int[] v, int imGuiInputTextFlags); /*
|
|
return ImGui::InputInt2(label, v, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static native boolean InputInt4(String label, int[] v); /*
|
|
return ImGui::InputInt2(label, v, 0);
|
|
*/
|
|
|
|
public static native boolean InputInt4(String label, int[] v, int imGuiInputTextFlags); /*
|
|
return ImGui::InputInt2(label, v, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputDouble(String label, ImDouble v) {
|
|
return nInputDouble(label, v.data, 0, 0, "%.6f", 0);
|
|
}
|
|
|
|
public static boolean InputDouble(String label, ImDouble v, double step) {
|
|
return nInputDouble(label, v.data, step, 0, "%.6f", 0);
|
|
}
|
|
|
|
public static boolean InputDouble(String label, ImDouble v, double step, double step_fast) {
|
|
return nInputDouble(label, v.data, step, step_fast, "%.6f", 0);
|
|
}
|
|
|
|
public static boolean InputDouble(String label, ImDouble v, double step, double step_fast, String format) {
|
|
return nInputDouble(label, v.data, step, step_fast, format, 0);
|
|
}
|
|
|
|
public static boolean InputDouble(String label, ImDouble v, double step, double step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputDouble(label, v.data, step, step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputDouble(String label, double[] v, double step, double step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputDouble(label, &v[0], step, step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImInt p_data) {
|
|
return nInputScalar(label, data_type, p_data.data);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, int[] p_data); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0]);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImInt p_data, int p_step) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, int[] p_data, int p_step); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImInt p_data, int p_step, int p_step_fast) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, int[] p_data, int p_step, int p_step_fast); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImInt p_data, int p_step, int p_step_fast, String format) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, int[] p_data, int p_step, int p_step_fast, String format); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImInt p_data, int p_step, int p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, int[] p_data, int p_step, int p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImFloat p_data) {
|
|
return nInputScalar(label, data_type, p_data.data);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, float[] p_data); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0]);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImFloat p_data, float p_step) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, float[] p_data, float p_step); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImFloat p_data, float p_step, float p_step_fast) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, float[] p_data, float p_step, float p_step_fast); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImFloat p_data, float p_step, float p_step_fast, String format) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, float[] p_data, float p_step, float p_step_fast, String format); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImFloat p_data, float p_step, float p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, float[] p_data, float p_step, float p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImLong p_data) {
|
|
return nInputScalar(label, data_type, p_data.data);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, long[] p_data); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0]);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImLong p_data, long p_step) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, long[] p_data, long p_step); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImLong p_data, long p_step, long p_step_fast) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, long[] p_data, long p_step, long p_step_fast); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImLong p_data, long p_step, long p_step_fast, String format) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, long[] p_data, long p_step, long p_step_fast, String format); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImLong p_data, long p_step, long p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, long[] p_data, long p_step, long p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImDouble p_data) {
|
|
return nInputScalar(label, data_type, p_data.data);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, double[] p_data); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0]);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImDouble p_data, double p_step) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, double[] p_data, double p_step); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImDouble p_data, double p_step, double p_step_fast) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, double[] p_data, double p_step, double p_step_fast); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImDouble p_data, double p_step, double p_step_fast, String format) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, double[] p_data, double p_step, double p_step_fast, String format); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImDouble p_data, double p_step, double p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, double[] p_data, double p_step, double p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImShort p_data) {
|
|
return nInputScalar(label, data_type, p_data.data);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, short[] p_data); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0]);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImShort p_data, short p_step) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, short[] p_data, short p_step); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImShort p_data, short p_step, short p_step_fast) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, short[] p_data, short p_step, short p_step_fast); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImShort p_data, short p_step, short p_step_fast, String format) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, short[] p_data, short p_step, short p_step_fast, String format); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalar(String label, int data_type, ImShort p_data, short p_step, short p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalar(label, data_type, p_data.data, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalar(String label, int data_type, short[] p_data, short p_step, short p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalar(label, data_type, &p_data[0], &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImInt p_data, int components) {
|
|
return nInputScalarN(label, data_type, p_data.data, components);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, int[] p_data, int components); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImInt p_data, int components, int p_step) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, int[] p_data, int components, int p_step); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImInt p_data, int components, int p_step, int p_step_fast) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, int[] p_data, int components, int p_step, int p_step_fast); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImInt p_data, int components, int p_step, int p_step_fast, String format) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, int[] p_data, int components, int p_step, int p_step_fast, String format); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImInt p_data, int components, int p_step, int p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, int[] p_data, int components, int p_step, int p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImFloat p_data, int components) {
|
|
return nInputScalarN(label, data_type, p_data.data, components);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, float[] p_data, int components); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImFloat p_data, int components, float p_step) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, float[] p_data, int components, float p_step); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImFloat p_data, int components, float p_step, float p_step_fast) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, float[] p_data, int components, float p_step, float p_step_fast); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImFloat p_data, int components, float p_step, float p_step_fast, String format) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, float[] p_data, int components, float p_step, float p_step_fast, String format); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImFloat p_data, int components, float p_step, float p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, float[] p_data, int components, float p_step, float p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImLong p_data, int components) {
|
|
return nInputScalarN(label, data_type, p_data.data, components);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, long[] p_data, int components); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImLong p_data, int components, long p_step) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, long[] p_data, int components, long p_step); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImLong p_data, int components, long p_step, long p_step_fast) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, long[] p_data, int components, long p_step, long p_step_fast); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImLong p_data, int components, long p_step, long p_step_fast, String format) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, long[] p_data, int components, long p_step, long p_step_fast, String format); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImLong p_data, int components, long p_step, long p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, long[] p_data, int components, long p_step, long p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImDouble p_data, int components) {
|
|
return nInputScalarN(label, data_type, p_data.data, components);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, double[] p_data, int components); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImDouble p_data, int components, double p_step) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, double[] p_data, int components, double p_step); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImDouble p_data, int components, double p_step, double p_step_fast) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, double[] p_data, int components, double p_step, double p_step_fast); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImDouble p_data, int components, double p_step, double p_step_fast, String format) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, double[] p_data, int components, double p_step, double p_step_fast, String format); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImDouble p_data, int components, double p_step, double p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, double[] p_data, int components, double p_step, double p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImShort p_data, int components) {
|
|
return nInputScalarN(label, data_type, p_data.data, components);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, short[] p_data, int components); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImShort p_data, int components, short p_step) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, short[] p_data, int components, short p_step); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImShort p_data, int components, short p_step, short p_step_fast) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, short[] p_data, int components, short p_step, short p_step_fast); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImShort p_data, int components, short p_step, short p_step_fast, String format) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, short[] p_data, int components, short p_step, short p_step_fast, String format); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format);
|
|
*/
|
|
|
|
public static boolean InputScalarN(String label, int data_type, ImShort p_data, int components, short p_step, short p_step_fast, String format, int imGuiInputTextFlags) {
|
|
return nInputScalarN(label, data_type, p_data.data, components, p_step, p_step_fast, format, imGuiInputTextFlags);
|
|
}
|
|
|
|
private static native boolean nInputScalarN(String label, int data_type, short[] p_data, int components, short p_step, short p_step_fast, String format, int imGuiInputTextFlags); /*
|
|
return ImGui::InputScalarN(label, data_type, &p_data[0], components, &p_step, &p_step_fast, format, imGuiInputTextFlags);
|
|
*/
|
|
|
|
// Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little colored preview square that can be left-clicked to open a picker, and right-clicked to open an option menu.)
|
|
// - Note that in C++ a 'float v[X]' function argument is the _same_ as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible.
|
|
// - You can pass the address of a first float element out of a contiguous structure, e.g. &myvector.x
|
|
|
|
public native static boolean ColorEdit3(String label, float[] col); /*
|
|
return ImGui::ColorEdit3(label, col);
|
|
*/
|
|
|
|
public native static boolean ColorEdit3(String label, float[] col, int imGuiColorEditFlags); /*
|
|
return ImGui::ColorEdit3(label, col, imGuiColorEditFlags);
|
|
*/
|
|
|
|
public native static boolean ColorEdit4(String label, float[] col); /*
|
|
return ImGui::ColorEdit4(label, col);
|
|
*/
|
|
|
|
public native static boolean ColorEdit4(String label, float[] col, int imGuiColorEditFlags); /*
|
|
return ImGui::ColorEdit4(label, col, imGuiColorEditFlags);
|
|
*/
|
|
|
|
public native static boolean ColorPicker3(String label, float[] col); /*
|
|
return ImGui::ColorPicker3(label, col);
|
|
*/
|
|
|
|
public native static boolean ColorPicker3(String label, float[] col, int imGuiColorEditFlags); /*
|
|
return ImGui::ColorPicker3(label, col, imGuiColorEditFlags);
|
|
*/
|
|
|
|
public native static boolean ColorPicker4(String label, float[] col); /*
|
|
return ImGui::ColorPicker4(label, col);
|
|
*/
|
|
|
|
public native static boolean ColorPicker4(String label, float[] col, int imGuiColorEditFlags); /*
|
|
return ImGui::ColorPicker4(label, col, imGuiColorEditFlags);
|
|
*/
|
|
|
|
public native static boolean ColorPicker4(String label, float[] col, int imGuiColorEditFlags, float ref_col); /*
|
|
return ImGui::ColorPicker4(label, col, imGuiColorEditFlags, &ref_col);
|
|
*/
|
|
|
|
/**
|
|
* Display a colored square/button, hover for details, return true when pressed.
|
|
*/
|
|
public native static boolean ColorButton(String desc_id, float[] col); /*
|
|
return ImGui::ColorButton(desc_id, ImVec4(col[0], col[1], col[2], col[3]));
|
|
*/
|
|
|
|
/**
|
|
* Display a colored square/button, hover for details, return true when pressed.
|
|
*/
|
|
public native static boolean ColorButton(String desc_id, float[] col, int imGuiColorEditFlags); /*
|
|
return ImGui::ColorButton(desc_id, ImVec4(col[0], col[1], col[2], col[3]), imGuiColorEditFlags);
|
|
*/
|
|
|
|
/**
|
|
* Display a colored square/button, hover for details, return true when pressed.
|
|
*/
|
|
public native static boolean ColorButton(String desc_id, float[] col, int imGuiColorEditFlags, float width, float height); /*
|
|
return ImGui::ColorButton(desc_id, ImVec4(col[0], col[1], col[2], col[3]), imGuiColorEditFlags, ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Initialize current options (generally on application startup) if you want to select a default format,
|
|
* picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls.
|
|
*/
|
|
public native static void SetColorEditOptions(int imGuiColorEditFlags); /*
|
|
ImGui::SetColorEditOptions(imGuiColorEditFlags);
|
|
*/
|
|
|
|
// Widgets: Trees
|
|
// - TreeNode functions return true when the node is open, in which case you need to also call TreePop() when you are finished displaying the tree node contents.
|
|
|
|
public static native boolean TreeNode(String label); /*
|
|
return ImGui::TreeNode(label);
|
|
*/
|
|
|
|
/**
|
|
* Helper variation to easily decorelate the id from the displayed string.
|
|
* Read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
|
|
*/
|
|
public static native boolean TreeNode(String str_id, String label); /*
|
|
return ImGui::TreeNode(str_id, label);
|
|
*/
|
|
|
|
public static native boolean TreeNode(long ptr_id, String label); /*
|
|
return ImGui::TreeNode((void*)ptr_id, label);
|
|
*/
|
|
|
|
public static native boolean TreeNodeEx(String label); /*
|
|
return ImGui::TreeNodeEx(label);
|
|
*/
|
|
|
|
public static native boolean TreeNodeEx(String label, int imGuiTreeNodeFlags); /*
|
|
return ImGui::TreeNodeEx(label, imGuiTreeNodeFlags);
|
|
*/
|
|
|
|
public static native boolean TreeNodeEx(String str_id, int imGuiTreeNodeFlags, String label); /*
|
|
return ImGui::TreeNodeEx(str_id, imGuiTreeNodeFlags, label);
|
|
*/
|
|
|
|
public static native boolean TreeNodeEx(int ptr_id, int imGuiTreeNodeFlags, String label); /*
|
|
return ImGui::TreeNodeEx((void*)(intptr_t)ptr_id, imGuiTreeNodeFlags, label);
|
|
*/
|
|
|
|
/**
|
|
* ~ Indent()+PushId(). Already called by TreeNode() when returning true, but you can call TreePush/TreePop yourself if desired.
|
|
*/
|
|
public static native void TreePush(); /*
|
|
ImGui::TreePush();
|
|
*/
|
|
|
|
public static native void TreePush(String str_id); /*
|
|
ImGui::TreePush(str_id);
|
|
*/
|
|
|
|
public static native void TreePush(long ptr_id); /*
|
|
ImGui::TreePush((void*)(intptr_t)ptr_id);
|
|
*/
|
|
|
|
/**
|
|
* ~ Unindent()+PopId()
|
|
*/
|
|
public static native void TreePop(); /*
|
|
ImGui::TreePop();
|
|
*/
|
|
|
|
public static native void TreeAdvanceToLabelPos(); /*
|
|
ImGui::TreeAdvanceToLabelPos();
|
|
*/
|
|
|
|
/**
|
|
* Horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode
|
|
*/
|
|
public static native float GetTreeNodeToLabelSpacing(); /*
|
|
return ImGui::GetTreeNodeToLabelSpacing();
|
|
*/
|
|
|
|
/**
|
|
* If returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
|
|
*/
|
|
public static native boolean CollapsingHeader(String label); /*
|
|
return ImGui::CollapsingHeader(label);
|
|
*/
|
|
|
|
/**
|
|
* If returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
|
|
*/
|
|
public static native boolean CollapsingHeader(String label, int imGuiTreeNodeFlags); /*
|
|
return ImGui::CollapsingHeader(label, imGuiTreeNodeFlags);
|
|
*/
|
|
|
|
/**
|
|
* When 'p_open' isn't NULL, display an additional small close button on upper right of the header
|
|
*/
|
|
public static boolean CollapsingHeader(String label, ImBool p_open) {
|
|
return nCollapsingHeader(label, p_open.data, 0);
|
|
}
|
|
|
|
/**
|
|
* When 'p_open' isn't NULL, display an additional small close button on upper right of the header
|
|
*/
|
|
public static boolean CollapsingHeader(String label, ImBool p_open, int imGuiTreeNodeFlags) {
|
|
return nCollapsingHeader(label, p_open.data, imGuiTreeNodeFlags);
|
|
}
|
|
|
|
private static native boolean nCollapsingHeader(String label, boolean[] p_open, int imGuiTreeNodeFlags); /*
|
|
return ImGui::CollapsingHeader(label, p_open, imGuiTreeNodeFlags);
|
|
*/
|
|
|
|
/**
|
|
* Set next TreeNode/CollapsingHeader open state.
|
|
*/
|
|
public static native void SetNextItemOpen(boolean is_open); /*
|
|
ImGui::SetNextItemOpen(is_open);
|
|
*/
|
|
|
|
/**
|
|
* Set next TreeNode/CollapsingHeader open state.
|
|
*/
|
|
public static native void SetNextItemOpen(boolean is_open, int cond); /*
|
|
ImGui::SetNextItemOpen(is_open, cond);
|
|
*/
|
|
|
|
// Widgets: Selectables
|
|
// - A selectable highlights when hovered, and can display another color when selected.
|
|
// - Neighbors selectable extend their highlight bounds in order to leave no gap between them.
|
|
|
|
public static native boolean Selectable(String label); /*
|
|
return ImGui::Selectable(label);
|
|
*/
|
|
|
|
public static native boolean Selectable(String label, boolean selected); /*
|
|
return ImGui::Selectable(label, selected);
|
|
*/
|
|
|
|
public static native boolean Selectable(String label, boolean selected, int imGuiSelectableFlags); /*
|
|
return ImGui::Selectable(label, selected, imGuiSelectableFlags);
|
|
*/
|
|
|
|
public static native boolean Selectable(String label, boolean selected, int imGuiSelectableFlags, float sizeX, float sizeY); /*
|
|
return ImGui::Selectable(label, selected, imGuiSelectableFlags, ImVec2(sizeX, sizeY));
|
|
*/
|
|
|
|
public static boolean Selectable(String label, ImBool selected) {
|
|
return nSelectable(label, selected.data, 0, 0, 0);
|
|
}
|
|
|
|
public static boolean Selectable(String label, ImBool selected, int imGuiSelectableFlags) {
|
|
return nSelectable(label, selected.data, imGuiSelectableFlags, 0, 0);
|
|
}
|
|
|
|
public static boolean Selectable(String label, ImBool selected, int imGuiSelectableFlags, float sizeX, float sizeY) {
|
|
return nSelectable(label, selected.data, imGuiSelectableFlags, sizeX, sizeY);
|
|
}
|
|
|
|
private static native boolean nSelectable(String label, boolean[] selected, int imGuiSelectableFlags, float sizeX, float sizeY); /*
|
|
return ImGui::Selectable(label, &selected[0], imGuiSelectableFlags, ImVec2(sizeX, sizeY));
|
|
*/
|
|
|
|
// Widgets: List Boxes
|
|
// - FIXME: To be consistent with all the newer API, ListBoxHeader/ListBoxFooter should in reality be called BeginListBox/EndListBox. Will rename them.
|
|
|
|
public static void ListBox(String label, ImInt current_item, String[] items, int items_count) {
|
|
nListBox(label, current_item.data, items, items_count, -1);
|
|
}
|
|
|
|
public static void ListBox(String label, ImInt current_item, String[] items, int items_count, int height_in_items) {
|
|
nListBox(label, current_item.data, items, items_count, height_in_items);
|
|
}
|
|
|
|
private static native boolean nListBox(String label, int[] current_item, String [] items, int items_count, int height_in_items); /*
|
|
const char* listbox_items[items_count];
|
|
|
|
for(int i = 0; i < items_count; i++) {
|
|
jstring string = (jstring)env->GetObjectArrayElement(items, i);
|
|
const char *rawString = env->GetStringUTFChars(string, 0);
|
|
listbox_items[i] = rawString;
|
|
}
|
|
|
|
return ImGui::ListBox(label, ¤t_item[0], listbox_items, items_count, height_in_items);
|
|
*/
|
|
|
|
/**
|
|
* Use if you want to reimplement ListBox() will custom data or interactions.
|
|
* If the function return true, you can output elements then call ListBoxFooter() afterwards.
|
|
*/
|
|
public static native boolean ListBoxHeader(String label); /*
|
|
return ImGui::ListBoxHeader(label);
|
|
*/
|
|
|
|
/**
|
|
* Use if you want to reimplement ListBox() will custom data or interactions.
|
|
* If the function return true, you can output elements then call ListBoxFooter() afterwards.
|
|
*/
|
|
public static native boolean ListBoxHeader(String label, float sizeX, float sizeY); /*
|
|
return ImGui::ListBoxHeader(label, ImVec2(sizeX, sizeY));
|
|
*/
|
|
|
|
public static native boolean ListBoxHeader(String label, int items_count); /*
|
|
return ImGui::ListBoxHeader(label, items_count);
|
|
*/
|
|
|
|
public static native boolean ListBoxHeader(String label, int items_count, int height_in_items); /*
|
|
return ImGui::ListBoxHeader(label, items_count, height_in_items);
|
|
*/
|
|
|
|
/**
|
|
* Terminate the scrolling region. Only call ListBoxFooter() if ListBoxHeader() returned true!
|
|
*/
|
|
public static native void ListBoxFooter(); /*
|
|
ImGui::ListBoxFooter();
|
|
*/
|
|
|
|
// Widgets: Data Plotting
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count); /*
|
|
ImGui::PlotLines(label, &values[0], values_count);
|
|
*/
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count, int values_offset); /*
|
|
ImGui::PlotLines(label, &values[0], values_count, values_offset);
|
|
*/
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count, int values_offset, String overlay_text); /*
|
|
ImGui::PlotLines(label, &values[0], values_count, values_offset, overlay_text);
|
|
*/
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min); /*
|
|
ImGui::PlotLines(label, &values[0], values_count, values_offset, overlay_text, scale_min);
|
|
*/
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min, float scale_max); /*
|
|
ImGui::PlotLines(label, &values[0], values_count, values_offset, overlay_text, scale_min, scale_max);
|
|
*/
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min, float scale_max, float graph_width, float graph_height); /*
|
|
ImGui::PlotLines(label, &values[0], values_count, values_offset, overlay_text, scale_min, scale_max, ImVec2(graph_width, graph_height));
|
|
*/
|
|
|
|
public static native void PlotLines(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min, float scale_max, float graph_width, float graph_height, int stride); /*
|
|
ImGui::PlotLines(label, &values[0], values_count, values_offset, overlay_text, scale_min, scale_max, ImVec2(graph_width, graph_height), stride);
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count);
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count, int values_offset); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count, values_offset);
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count, int values_offset, String overlay_text); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count, values_offset, overlay_text);
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count, values_offset, overlay_text, scale_min);
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min, float scale_max); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count, values_offset, overlay_text, scale_min, scale_max);
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min, float scale_max, float graph_width, float graph_height); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count, values_offset, overlay_text, scale_min, scale_max, ImVec2(graph_width, graph_height));
|
|
*/
|
|
|
|
public static native void PlotHistogram(String label, float[] values, int values_count, int values_offset, String overlay_text, float scale_min, float scale_max, float graph_width, float graph_height, int stride); /*
|
|
ImGui::PlotHistogram(label, &values[0], values_count, values_offset, overlay_text, scale_min, scale_max, ImVec2(graph_width, graph_height), stride);
|
|
*/
|
|
|
|
// Widgets: Value() Helpers.
|
|
// - Those are merely shortcut to calling Text() with a format string. Output single value in "name: value" format (tip: freely declare more in your code to handle your types. you can add functions to the ImGui namespace)
|
|
|
|
public static native void Value(String prefix, boolean b); /*
|
|
ImGui::Value(prefix, b);
|
|
*/
|
|
|
|
public static native void Value(String prefix, int v); /*
|
|
ImGui::Value(prefix, (int)v);
|
|
*/
|
|
|
|
public static native void Value(String prefix, long v); /*
|
|
ImGui::Value(prefix, (unsigned int)v);
|
|
*/
|
|
|
|
public static native void Value(String prefix, float f); /*
|
|
ImGui::Value(prefix, f);
|
|
*/
|
|
|
|
public static native void Value(String prefix, float f, String float_format); /*
|
|
ImGui::Value(prefix, f, float_format);
|
|
*/
|
|
|
|
// Widgets: Menus
|
|
// - Use BeginMenuBar() on a window ImGuiWindowFlags_MenuBar to append to its menu bar.
|
|
// - Use BeginMainMenuBar() to create a menu bar at the top of the screen.
|
|
|
|
/**
|
|
* Append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window).
|
|
*/
|
|
public static native boolean BeginMenuBar(); /*
|
|
return ImGui::BeginMenuBar();
|
|
*/
|
|
|
|
/**
|
|
* Only call EndMenuBar() if BeginMenuBar() returns true!
|
|
*/
|
|
public static native void EndMenuBar(); /*
|
|
ImGui::EndMenuBar();
|
|
*/
|
|
|
|
/**
|
|
* Create and append to a full screen menu-bar.
|
|
*/
|
|
public static native boolean BeginMainMenuBar(); /*
|
|
return ImGui::BeginMainMenuBar();
|
|
*/
|
|
|
|
/**
|
|
* Only call EndMainMenuBar() if BeginMainMenuBar() returns true!
|
|
*/
|
|
public static native void EndMainMenuBar(); /*
|
|
ImGui::EndMainMenuBar();
|
|
*/
|
|
|
|
/**
|
|
* Create a sub-menu entry. only call EndMenu() if this returns true!
|
|
*/
|
|
public static native boolean BeginMenu(String label); /*
|
|
return ImGui::BeginMenu(label);
|
|
*/
|
|
|
|
/**
|
|
* Create a sub-menu entry. only call EndMenu() if this returns true!
|
|
*/
|
|
public static native boolean BeginMenu(String label, boolean enabled); /*
|
|
return ImGui::BeginMenu(label, enabled);
|
|
*/
|
|
|
|
/**
|
|
* Only call EndMenu() if BeginMenu() returns true!
|
|
*/
|
|
public static native void EndMenu(); /*
|
|
ImGui::EndMenu();
|
|
*/
|
|
|
|
/**
|
|
* Return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
|
|
*/
|
|
public static native boolean MenuItem(String label); /*
|
|
return ImGui::MenuItem(label);
|
|
*/
|
|
|
|
/**
|
|
* Return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
|
|
*/
|
|
public static native boolean MenuItem(String label, String shortcut); /*
|
|
return ImGui::MenuItem(label, shortcut);
|
|
*/
|
|
|
|
/**
|
|
* Return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
|
|
*/
|
|
public static native boolean MenuItem(String label, String shortcut, boolean selected); /*
|
|
return ImGui::MenuItem(label, shortcut, selected);
|
|
*/
|
|
|
|
/**
|
|
* Return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
|
|
*/
|
|
public static native boolean MenuItem(String label, String shortcut, boolean selected, boolean enabled); /*
|
|
return ImGui::MenuItem(label, shortcut, selected, enabled);
|
|
*/
|
|
|
|
/**
|
|
* Return true when activated + toggle (*p_selected) if p_selected != NULL
|
|
*/
|
|
public static boolean MenuItem(String label, String shortcut, ImBool p_selected) {
|
|
return nMenuItem(label, shortcut, p_selected.data, true);
|
|
}
|
|
|
|
/**
|
|
* Return true when activated + toggle (*p_selected) if p_selected != NULL
|
|
*/
|
|
public static boolean MenuItem(String label, String shortcut, ImBool p_selected, boolean enabled) {
|
|
return nMenuItem(label, shortcut, p_selected.data, enabled);
|
|
}
|
|
|
|
/**
|
|
* Return true when activated + toggle (*p_selected) if p_selected != NULL
|
|
*/
|
|
private static native boolean nMenuItem(String label, String shortcut, boolean[] p_selected, boolean enabled); /*
|
|
return ImGui::MenuItem(label, shortcut, &p_selected[0], enabled);
|
|
*/
|
|
|
|
// Tooltips
|
|
// - Tooltip are windows following the mouse which do not take focus away.
|
|
|
|
/**
|
|
* Begin/append a tooltip window. to create full-featured tooltip (with any kind of items).
|
|
*/
|
|
public static native void BeginTooltip(); /*
|
|
ImGui::BeginTooltip();
|
|
*/
|
|
|
|
public static native void EndTooltip(); /*
|
|
ImGui::EndTooltip();
|
|
*/
|
|
|
|
/**
|
|
* Set a text-only tooltip, typically use with ImGui::IsItemHovered(). override any previous call to SetTooltip().
|
|
*/
|
|
public static native void SetTooltip(String text); /*
|
|
ImGui::SetTooltip(text);
|
|
*/
|
|
|
|
// Popups, Modals
|
|
// The properties of popups windows are:
|
|
// - They block normal mouse hovering detection outside them. (*)
|
|
// - Unless modal, they can be closed by clicking anywhere outside them, or by pressing ESCAPE.
|
|
// - Their visibility state (~bool) is held internally by imgui instead of being held by the programmer as we are used to with regular Begin() calls.
|
|
// User can manipulate the visibility state by calling OpenPopup().
|
|
// (*) You can use IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup) to bypass it and detect hovering even when normally blocked by a popup.
|
|
// Those three properties are connected. The library needs to hold their visibility state because it can close popups at any time.
|
|
|
|
/**
|
|
* Call to mark popup as open (don't call every frame!).
|
|
* Popups are closed when user click outside, or if CloseCurrentPopup() is called within a BeginPopup()/EndPopup() block.
|
|
* By default, Selectable()/MenuItem() are calling CloseCurrentPopup().
|
|
* Popup identifiers are relative to the current ID-stack (so OpenPopup and BeginPopup needs to be at the same level).
|
|
*/
|
|
public static native void OpenPopup(String str_id); /*
|
|
ImGui::OpenPopup(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Return true if the popup is open, and you can start outputting to it. only call EndPopup() if BeginPopup() returns true!
|
|
*/
|
|
public static native boolean BeginPopup(String str_id); /*
|
|
return ImGui::BeginPopup(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Return true if the popup is open, and you can start outputting to it. only call EndPopup() if BeginPopup() returns true!
|
|
*/
|
|
public static native boolean BeginPopup(String str_id, int imGuiWindowFlags); /*
|
|
return ImGui::BeginPopup(str_id, imGuiWindowFlags);
|
|
*/
|
|
|
|
/**
|
|
* helper to open and begin popup when clicked on last item. if you can pass a NULL str_id only if the previous item had an id.
|
|
* If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!
|
|
*/
|
|
public static native boolean BeginPopupContextItem(); /*
|
|
return ImGui::BeginPopupContextItem();
|
|
*/
|
|
|
|
/**
|
|
* helper to open and begin popup when clicked on last item. if you can pass a NULL str_id only if the previous item had an id.
|
|
* If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!
|
|
*/
|
|
public static native boolean BeginPopupContextItem(String str_id); /*
|
|
return ImGui::BeginPopupContextItem(str_id);
|
|
*/
|
|
|
|
/**
|
|
* helper to open and begin popup when clicked on last item. if you can pass a NULL str_id only if the previous item had an id.
|
|
* If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!
|
|
*/
|
|
public static native boolean BeginPopupContextItem(String str_id, int mouse_button); /*
|
|
return ImGui::BeginPopupContextItem(str_id, mouse_button);
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked on current window.
|
|
*/
|
|
public static native boolean BeginPopupContextWindow(); /*
|
|
return ImGui::BeginPopupContextWindow();
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked on current window.
|
|
*/
|
|
public static native boolean BeginPopupContextWindow(String str_id); /*
|
|
return ImGui::BeginPopupContextWindow(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked on current window.
|
|
*/
|
|
public static native boolean BeginPopupContextWindow(String str_id, int mouse_button); /*
|
|
return ImGui::BeginPopupContextWindow(str_id, mouse_button);
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked on current window.
|
|
*/
|
|
public static native boolean BeginPopupContextWindow(String str_id, int mouse_button, boolean also_over_items); /*
|
|
return ImGui::BeginPopupContextWindow(str_id, mouse_button, also_over_items);
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked in void (where there are no imgui windows).
|
|
*/
|
|
public static native boolean BeginPopupContextVoid(); /*
|
|
return ImGui::BeginPopupContextVoid();
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked in void (where there are no imgui windows).
|
|
*/
|
|
public static native boolean BeginPopupContextVoid(String str_id); /*
|
|
return ImGui::BeginPopupContextVoid(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Helper to open and begin popup when clicked in void (where there are no imgui windows).
|
|
*/
|
|
public static native boolean BeginPopupContextVoid(String str_id, int mouse_button); /*
|
|
return ImGui::BeginPopupContextVoid(str_id, mouse_button);
|
|
*/
|
|
|
|
/**
|
|
* Modal dialog (regular window with title bar, block interactions behind the modal window, can't close the modal window by clicking outside)
|
|
*/
|
|
public static native boolean BeginPopupModal(String name); /*
|
|
return ImGui::BeginPopupModal(name);
|
|
*/
|
|
|
|
/**
|
|
* Modal dialog (regular window with title bar, block interactions behind the modal window, can't close the modal window by clicking outside)
|
|
*/
|
|
public static boolean BeginPopupModal(String name, ImBool p_open) {
|
|
return nBeginPopupModal(name, p_open.data, 0);
|
|
}
|
|
|
|
/**
|
|
* Modal dialog (regular window with title bar, block interactions behind the modal window, can't close the modal window by clicking outside)
|
|
*/
|
|
public static boolean BeginPopupModal(String name, ImBool p_open, int imGuiWindowFlags) {
|
|
return nBeginPopupModal(name, p_open.data, imGuiWindowFlags);
|
|
}
|
|
|
|
private static native boolean nBeginPopupModal(String name, boolean[] p_open, int imGuiWindowFlags); /*
|
|
return ImGui::BeginPopupModal(name, &p_open[0], imGuiWindowFlags);
|
|
*/
|
|
|
|
/**
|
|
* only call EndPopup() if BeginPopupXXX() returns true!
|
|
*/
|
|
public static native void EndPopup(); /*
|
|
ImGui::EndPopup();
|
|
*/
|
|
|
|
/**
|
|
* Helper to open popup when clicked on last item (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors).
|
|
* return true when just opened.
|
|
*/
|
|
public static native boolean OpenPopupOnItemClick(); /*
|
|
return ImGui::OpenPopupOnItemClick();
|
|
*/
|
|
|
|
/**
|
|
* Helper to open popup when clicked on last item (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors).
|
|
* return true when just opened.
|
|
*/
|
|
public static native boolean OpenPopupOnItemClick(String str_id); /*
|
|
return ImGui::OpenPopupOnItemClick(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Helper to open popup when clicked on last item (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors).
|
|
* return true when just opened.
|
|
*/
|
|
public static native boolean OpenPopupOnItemClick(String str_id, int mouse_button); /*
|
|
return ImGui::OpenPopupOnItemClick(str_id, mouse_button);
|
|
*/
|
|
|
|
/**
|
|
* Return true if the popup is open at the current begin-ed level of the popup stack.
|
|
*/
|
|
public static native boolean IsPopupOpen(String str_id); /*
|
|
return ImGui::IsPopupOpen(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Close the popup we have begin-ed into. clicking on a MenuItem or Selectable automatically close the current popup.
|
|
*/
|
|
public static native void CloseCurrentPopup(); /*
|
|
ImGui::CloseCurrentPopup();
|
|
*/
|
|
|
|
// Columns
|
|
// - You can also use SameLine(pos_x) to mimic simplified columns.
|
|
// - The columns API is work-in-progress and rather lacking (columns are arguably the worst part of dear imgui at the moment!)
|
|
// - By end of the 2019 we will expose a new 'Table' api which will replace columns.
|
|
|
|
public static native void Columns(); /*
|
|
ImGui::Columns();
|
|
*/
|
|
|
|
public static native void Columns(int count); /*
|
|
ImGui::Columns(count);
|
|
*/
|
|
|
|
public static native void Columns(int count, String id); /*
|
|
ImGui::Columns(count, id);
|
|
*/
|
|
|
|
public static native void Columns(int count, String id, boolean border); /*
|
|
ImGui::Columns(count, id, border);
|
|
*/
|
|
|
|
/**
|
|
* Next column, defaults to current row or next row if the current row is finished
|
|
*/
|
|
public static native void NextColumn(); /*
|
|
ImGui::NextColumn();
|
|
*/
|
|
|
|
/**
|
|
* Get current column index
|
|
*/
|
|
public static native int GetColumnIndex(); /*
|
|
return ImGui::GetColumnIndex();
|
|
*/
|
|
|
|
/**
|
|
* Get column width (in pixels). pass -1 to use current column
|
|
*/
|
|
public static native float GetColumnWidth(); /*
|
|
return ImGui::GetColumnWidth();
|
|
*/
|
|
|
|
/**
|
|
* Get column width (in pixels). pass -1 to use current column
|
|
*/
|
|
public static native float GetColumnWidth(int column_index); /*
|
|
return ImGui::GetColumnWidth(column_index);
|
|
*/
|
|
|
|
/**
|
|
* Set column width (in pixels). pass -1 to use current column
|
|
*/
|
|
public static native void SetColumnWidth(int column_index, float width); /*
|
|
ImGui::SetColumnWidth(column_index, width);
|
|
*/
|
|
|
|
/**
|
|
* Get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f
|
|
*/
|
|
public static native float GetColumnOffset(); /*
|
|
return ImGui::GetColumnOffset();
|
|
*/
|
|
|
|
/**
|
|
* Get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f
|
|
*/
|
|
public static native float GetColumnOffset(int column_index); /*
|
|
return ImGui::GetColumnOffset(column_index);
|
|
*/
|
|
|
|
/**
|
|
* Set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column
|
|
*/
|
|
public static native void SetColumnOffset(int column_index, float offset_x); /*
|
|
ImGui::SetColumnOffset(column_index, offset_x);
|
|
*/
|
|
|
|
public static native int GetColumnsCount(); /*
|
|
return ImGui::GetColumnsCount();
|
|
*/
|
|
|
|
// Tab Bars, Tabs
|
|
|
|
/**
|
|
* Create and append into a TabBar
|
|
*/
|
|
public static native boolean BeginTabBar(String str_id); /*
|
|
return ImGui::BeginTabBar(str_id);
|
|
*/
|
|
|
|
/**
|
|
* Create and append into a TabBar
|
|
*/
|
|
public static native boolean BeginTabBar(String str_id, int imGuiTabBarFlags); /*
|
|
return ImGui::BeginTabBar(str_id, imGuiTabBarFlags);
|
|
*/
|
|
|
|
/**
|
|
* Only call EndTabBar() if BeginTabBar() returns true!
|
|
*/
|
|
public static native void EndTabBar(); /*
|
|
ImGui::EndTabBar();
|
|
*/
|
|
|
|
/**
|
|
* Create a Tab. Returns true if the Tab is selected.
|
|
*/
|
|
public static native boolean BeginTabItem(String label); /*
|
|
return ImGui::BeginTabItem(label);
|
|
*/
|
|
|
|
/**
|
|
* Create a Tab. Returns true if the Tab is selected.
|
|
*/
|
|
public static boolean BeginTabItem(String label, ImBool p_open) {
|
|
return nBeginTabItem(label, p_open.data, 0);
|
|
}
|
|
|
|
/**
|
|
* Create a Tab. Returns true if the Tab is selected.
|
|
*/
|
|
public static boolean BeginTabItem(String label, ImBool p_open, int imGuiTabBarFlags) {
|
|
return nBeginTabItem(label, p_open.data, imGuiTabBarFlags);
|
|
}
|
|
|
|
private static native boolean nBeginTabItem(String label, boolean[] p_open, int imGuiTabBarFlags); /*
|
|
return ImGui::BeginTabItem(label, &p_open[0], imGuiTabBarFlags);
|
|
*/
|
|
|
|
/**
|
|
* Only call EndTabItem() if BeginTabItem() returns true!
|
|
*/
|
|
public static native void EndTabItem(); /*
|
|
ImGui::EndTabItem();
|
|
*/
|
|
|
|
/**
|
|
* Notify TabBar or Docking system of a closed tab/window ahead (useful to reduce visual flicker on reorderable tab bars).
|
|
* For tab-bar: call after BeginTabBar() and before Tab submissions. Otherwise call with a window name.
|
|
*/
|
|
public static native void SetTabItemClosed(String tab_or_docked_window_label); /*
|
|
ImGui::SetTabItemClosed(tab_or_docked_window_label);
|
|
*/
|
|
|
|
// Logging/Capture
|
|
// - All text output from the interface can be captured into tty/file/clipboard. By default, tree nodes are automatically opened during logging.
|
|
|
|
/**
|
|
* Start logging to tty (stdout)
|
|
*/
|
|
public static native void LogToTTY(); /*
|
|
ImGui::LogToTTY();
|
|
*/
|
|
|
|
/**
|
|
* Start logging to tty (stdout)
|
|
*/
|
|
public static native void LogToTTY(int auto_open_depth); /*
|
|
ImGui::LogToTTY(auto_open_depth);
|
|
*/
|
|
|
|
/**
|
|
* Start logging to file
|
|
*/
|
|
public static native void LogToFile(); /*
|
|
ImGui::LogToFile();
|
|
*/
|
|
|
|
/**
|
|
* Start logging to file
|
|
*/
|
|
public static native void LogToFile(int auto_open_depth); /*
|
|
ImGui::LogToFile(auto_open_depth);
|
|
*/
|
|
|
|
/**
|
|
* Start logging to file
|
|
*/
|
|
public static native void LogToFile(int auto_open_depth, String filename); /*
|
|
ImGui::LogToFile(auto_open_depth, filename);
|
|
*/
|
|
|
|
/**
|
|
* Start logging to OS clipboard
|
|
*/
|
|
public static native void LogToClipboard(); /*
|
|
ImGui::LogToClipboard();
|
|
*/
|
|
|
|
|
|
/**
|
|
* Start logging to OS clipboard
|
|
*/
|
|
public static native void LogToClipboard(int auto_open_depth); /*
|
|
ImGui::LogToClipboard(auto_open_depth);
|
|
*/
|
|
|
|
/**
|
|
* Stop logging (close file, etc.)
|
|
*/
|
|
public static native void LogFinish(); /*
|
|
ImGui::LogFinish();
|
|
*/
|
|
|
|
/**
|
|
* Helper to display buttons for logging to tty/file/clipboard
|
|
*/
|
|
public static native void LogButtons(); /*
|
|
ImGui::LogButtons();
|
|
*/
|
|
|
|
/**
|
|
* Pass text data straight to log (without being displayed)
|
|
*/
|
|
public static native void LogText(String text); /*
|
|
ImGui::LogText(text);
|
|
*/
|
|
|
|
// Drag and Drop
|
|
// [BETA API] API may evolve!
|
|
|
|
/**
|
|
* Call when the current item is active. If this return true, you can call SetDragDropPayload() + EndDragDropSource()
|
|
*/
|
|
public static native boolean BeginDragDropSource(); /*
|
|
return ImGui::BeginDragDropSource();
|
|
*/
|
|
|
|
/**
|
|
* Call when the current item is active. If this return true, you can call SetDragDropPayload() + EndDragDropSource()
|
|
*/
|
|
public static native boolean BeginDragDropSource(int imGuiDragDropFlags); /*
|
|
return ImGui::BeginDragDropSource(imGuiDragDropFlags);
|
|
*/
|
|
|
|
/**
|
|
* Type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types.
|
|
* Data is copied and held by imgui.
|
|
*/
|
|
public static native boolean SetDragDropPayload(String type, byte[] data, int sz); /*
|
|
return ImGui::SetDragDropPayload(type, &data[0], sz);
|
|
*/
|
|
|
|
/**
|
|
* Type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types.
|
|
* Data is copied and held by imgui.
|
|
*/
|
|
public static native boolean SetDragDropPayload(String type, byte[] data, int sz, int imGuiCond); /*
|
|
return ImGui::SetDragDropPayload(type, &data[0], sz, imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Only call EndDragDropSource() if BeginDragDropSource() returns true!
|
|
*/
|
|
public static native void EndDragDropSource(); /*
|
|
ImGui::EndDragDropSource();
|
|
*/
|
|
|
|
/**
|
|
* Call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget()
|
|
*/
|
|
public static native boolean BeginDragDropTarget(); /*
|
|
return ImGui::BeginDragDropTarget();
|
|
*/
|
|
|
|
/**
|
|
* Accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.
|
|
*/
|
|
public static byte[] AcceptDragDropPayload(String type) {
|
|
return nAcceptDragDropPayload(type, 0);
|
|
}
|
|
|
|
/**
|
|
* Accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.
|
|
*/
|
|
public static byte[] AcceptDragDropPayload(String type, int imGuiDragDropFlags) {
|
|
return nAcceptDragDropPayload(type, imGuiDragDropFlags);
|
|
}
|
|
|
|
private static native byte[] nAcceptDragDropPayload(String type, int imGuiDragDropFlags); /*
|
|
if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(type, imGuiDragDropFlags)) {
|
|
jbyteArray array = env->NewByteArray(payload->DataSize);
|
|
env->SetByteArrayRegion(array, 0, payload->DataSize, (jbyte*)payload->Data);
|
|
return array;
|
|
}
|
|
return NULL;
|
|
*/
|
|
|
|
/**
|
|
* Only call EndDragDropTarget() if BeginDragDropTarget() returns true!
|
|
*/
|
|
public static native void EndDragDropTarget(); /*
|
|
ImGui::EndDragDropTarget();
|
|
*/
|
|
|
|
/**
|
|
* Peek directly into the current payload from anywhere. May return NULL. use ImGuiPayload::IsDataType() to test for the payload type.
|
|
* TODO implement ImGuiPayload class
|
|
*/
|
|
public static native byte[] GetDragDropPayload(); /*
|
|
if (const ImGuiPayload* payload = ImGui::GetDragDropPayload()) {
|
|
jbyteArray array = env->NewByteArray(payload->DataSize);
|
|
env->SetByteArrayRegion(array, 0, payload->DataSize, (jbyte*)payload->Data);
|
|
return array;
|
|
}
|
|
return NULL;
|
|
*/
|
|
|
|
// Clipping
|
|
|
|
public static native void PushClipRect(float clip_rect_min_x, float clip_rect_min_y, float clip_rect_max_x, float clip_rect_max_y, boolean intersect_with_current_clip_rect); /*
|
|
ImGui::PushClipRect(ImVec2(clip_rect_min_x, clip_rect_min_y), ImVec2(clip_rect_max_x, clip_rect_max_y), intersect_with_current_clip_rect);
|
|
*/
|
|
|
|
public static native void PopClipRect(); /*
|
|
ImGui::PopClipRect();
|
|
*/
|
|
|
|
// Focus, Activation
|
|
// - Prefer using "SetItemDefaultFocus()" over "if (IsWindowAppearing()) SetScrollHereY()" when applicable to signify "this is the default item"
|
|
|
|
/**
|
|
* Make last item the default focused item of a window.
|
|
*/
|
|
public static native void SetItemDefaultFocus(); /*
|
|
ImGui::SetItemDefaultFocus();
|
|
*/
|
|
|
|
/**
|
|
* Focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.
|
|
*/
|
|
public static native void SetKeyboardFocusHere(); /*
|
|
ImGui::SetKeyboardFocusHere();
|
|
*/
|
|
|
|
/**
|
|
* Focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.
|
|
*/
|
|
public static native void SetKeyboardFocusHere(int offset); /*
|
|
ImGui::SetKeyboardFocusHere(offset);
|
|
*/
|
|
|
|
// Item/Widgets Utilities
|
|
// - Most of the functions are referring to the last/previous item we submitted.
|
|
// - See Demo Window under "Widgets->Querying Status" for an interactive visualization of most of those functions.
|
|
|
|
/**
|
|
* Is the last item hovered? (and usable, aka not blocked by a popup, etc.). See ImGuiHoveredFlags for more options.
|
|
*/
|
|
public static native boolean IsItemHovered(); /*
|
|
return ImGui::IsItemHovered();
|
|
*/
|
|
|
|
/**
|
|
* Is the last item hovered? (and usable, aka not blocked by a popup, etc.). See ImGuiHoveredFlags for more options.
|
|
*/
|
|
public static native boolean IsItemHovered(int imGuiHoveredFlags); /*
|
|
return ImGui::IsItemHovered(imGuiHoveredFlags);
|
|
*/
|
|
|
|
/**
|
|
* Is the last item active? (e.g. button being held, text field being edited.
|
|
* This will continuously return true while holding mouse button on an item.
|
|
* Items that don't interact will always return false)
|
|
*/
|
|
public static native boolean IsItemActive(); /*
|
|
return ImGui::IsItemActive();
|
|
*/
|
|
|
|
/**
|
|
* Is the last item focused for keyboard/gamepad navigation?
|
|
*/
|
|
public static native boolean IsItemFocused(); /*
|
|
return ImGui::IsItemFocused();
|
|
*/
|
|
|
|
/**
|
|
* Is the last item clicked? (e.g. button/node just clicked on) == IsMouseClicked(mouse_button) && IsItemHovered()
|
|
*/
|
|
public static native boolean IsItemClicked(); /*
|
|
return ImGui::IsItemClicked();
|
|
*/
|
|
|
|
/**
|
|
* Is the last item clicked? (e.g. button/node just clicked on) == IsMouseClicked(mouse_button) && IsItemHovered()
|
|
*/
|
|
public static native boolean IsItemClicked(int mouse_button); /*
|
|
return ImGui::IsItemClicked(mouse_button);
|
|
*/
|
|
|
|
/**
|
|
* Is the last item visible? (items may be out of sight because of clipping/scrolling)
|
|
*/
|
|
public static native boolean IsItemVisible(); /*
|
|
return ImGui::IsItemVisible();
|
|
*/
|
|
|
|
/**
|
|
* Did the last item modify its underlying value this frame? or was pressed? This is generally the same as the "bool" return value of many widgets.
|
|
*/
|
|
public static native boolean IsItemEdited(); /*
|
|
return ImGui::IsItemEdited();
|
|
*/
|
|
|
|
/**
|
|
* Was the last item just made active (item was previously inactive).
|
|
*/
|
|
public static native boolean IsItemActivated(); /*
|
|
return ImGui::IsItemActivated();
|
|
*/
|
|
|
|
/**
|
|
* Was the last item just made inactive (item was previously active). Useful for Undo/Redo patterns with widgets that requires continuous editing.
|
|
*/
|
|
public static native boolean IsItemDeactivated(); /*
|
|
return ImGui::IsItemDeactivated();
|
|
*/
|
|
|
|
/**
|
|
* Was the last item just made inactive and made a value change when it was active? (e.g. Slider/Drag moved).
|
|
* Useful for Undo/Redo patterns with widgets that requires continuous editing.
|
|
* Note that you may get false positives (some widgets such as Combo()/ListBox()/Selectable() will return true even when clicking an already selected item).
|
|
*/
|
|
public static native boolean IsItemDeactivatedAfterEdit(); /*
|
|
return ImGui::IsItemDeactivatedAfterEdit();
|
|
*/
|
|
|
|
/**
|
|
* Was the last item open state toggled? set by TreeNode().
|
|
*/
|
|
public static native boolean IsItemToggledOpen(); /*
|
|
return ImGui::IsItemToggledOpen();
|
|
*/
|
|
|
|
/**
|
|
* Is any item hovered?
|
|
*/
|
|
public static native boolean IsAnyItemHovered(); /*
|
|
return ImGui::IsAnyItemHovered();
|
|
*/
|
|
|
|
/**
|
|
* Is any item active?
|
|
*/
|
|
public static native boolean IsAnyItemActive(); /*
|
|
return ImGui::IsAnyItemActive();
|
|
*/
|
|
|
|
/**
|
|
* Is any item focused?
|
|
*/
|
|
public static native boolean IsAnyItemFocused(); /*
|
|
return ImGui::IsAnyItemFocused();
|
|
*/
|
|
|
|
/**
|
|
* Get upper-left bounding rectangle of the last item (screen space)
|
|
*/
|
|
public static native void GetItemRectMin(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetItemRectMin(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Get lower-right bounding rectangle of the last item (screen space)
|
|
*/
|
|
public static native void GetItemRectMax(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetItemRectMax(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Get size of last item
|
|
*/
|
|
public static native void GetItemRectSize(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetItemRectSize(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Allow last item to be overlapped by a subsequent item. sometimes useful with invisible buttons, selectables, etc. to catch unused area.
|
|
*/
|
|
public static native void SetItemAllowOverlap(); /*
|
|
ImGui::SetItemAllowOverlap();
|
|
*/
|
|
|
|
// Miscellaneous Utilities
|
|
|
|
/**
|
|
* Test if rectangle (of given size, starting from cursor position) is visible / not clipped.
|
|
*/
|
|
public static native boolean IsRectVisible(float width, float height); /*
|
|
return ImGui::IsRectVisible(ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.
|
|
*/
|
|
public static native boolean IsRectVisible(float min_x, float min_y, float max_x, float max_y); /*
|
|
return ImGui::IsRectVisible(ImVec2(min_x, min_y), ImVec2(max_x, max_y));
|
|
*/
|
|
|
|
/**
|
|
* Get global imgui time. incremented by io.DeltaTime every frame.
|
|
*/
|
|
public static native double GetTime(); /*
|
|
return ImGui::GetTime();
|
|
*/
|
|
|
|
/**
|
|
* Get global imgui frame count. incremented by 1 every frame.
|
|
*/
|
|
public static native int GetFrameCount(); /*
|
|
return ImGui::GetFrameCount();
|
|
*/
|
|
|
|
/**
|
|
* This draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
|
|
*/
|
|
public static ImDrawList GetBackgroundDrawList() {
|
|
return IM_DRAW_LIST_BACKGROUND;
|
|
}
|
|
|
|
/**
|
|
* This draw list will be the last rendered one. Useful to quickly draw shapes/text over dear imgui contents.
|
|
*/
|
|
public static ImDrawList GetForegroundDrawList() {
|
|
return IM_DRAW_LIST_FOREGROUND;
|
|
}
|
|
|
|
// TODO GetDrawListSharedData
|
|
|
|
/**
|
|
* Get a string corresponding to the enum value (for display, saving, etc.).
|
|
*/
|
|
public static native String GetStyleColorName(int imGuiCol); /*
|
|
return env->NewStringUTF(ImGui::GetStyleColorName(imGuiCol));
|
|
*/
|
|
|
|
// TODO SetStateStorage, GetStateStorage
|
|
|
|
public static native void CalcTextSize(ImVec2 dstImVec2, String text); /*
|
|
ImVec2 src = ImGui::CalcTextSize(text);
|
|
Jni::ImVec2Cpy(env, src, dstImVec2);
|
|
*/
|
|
|
|
public static native void CalcTextSize(ImVec2 dstImVec2, String text, String text_end); /*
|
|
ImVec2 src = ImGui::CalcTextSize(text, text_end);
|
|
Jni::ImVec2Cpy(env, src, dstImVec2);
|
|
*/
|
|
|
|
public static native void CalcTextSize(ImVec2 dstImVec2, String text, String text_end, boolean hide_text_after_double_has); /*
|
|
ImVec2 src = ImGui::CalcTextSize(text, text_end, hide_text_after_double_has);
|
|
Jni::ImVec2Cpy(env, src, dstImVec2);
|
|
*/
|
|
|
|
public static native void CalcTextSize(ImVec2 dstImVec2, String text, String text_end, boolean hide_text_after_double_has, float wrap_width); /*
|
|
ImVec2 src = ImGui::CalcTextSize(text, text_end, hide_text_after_double_has, wrap_width);
|
|
Jni::ImVec2Cpy(env, src, dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Calculate coarse clipping for large list of evenly sized items. Prefer using the ImGuiListClipper higher-level helper if you can.
|
|
*/
|
|
public static native void CalcListClipping(int item_count, float items_height, int[] out_items_display_start, int[] out_items_display_end); /*
|
|
ImGui::CalcListClipping(item_count, items_height, &out_items_display_start[0], &out_items_display_end[0]);
|
|
*/
|
|
|
|
/**
|
|
* Helper to create a child window / scrolling region that looks like a normal widget frame
|
|
*/
|
|
public static native boolean BeginChildFrame(int id, float width, float height); /*
|
|
return ImGui::BeginChildFrame(id, ImVec2(width, height));
|
|
*/
|
|
|
|
/**
|
|
* Helper to create a child window / scrolling region that looks like a normal widget frame
|
|
*/
|
|
public static native boolean BeginChildFrame(int id, float width, float height, int imGuiWindowFlags); /*
|
|
return ImGui::BeginChildFrame(id, ImVec2(width, height), imGuiWindowFlags);
|
|
*/
|
|
|
|
/**
|
|
* Always call EndChildFrame() regardless of BeginChildFrame() return values (which indicates a collapsed/clipped window)
|
|
*/
|
|
public static native void EndChildFrame(); /*
|
|
ImGui::EndChildFrame();
|
|
*/
|
|
|
|
// Color Utilities
|
|
|
|
public static native void ColorConvertU32ToFloat4(long in, ImVec4 dstImVec4); /*
|
|
Jni::ImVec4Cpy(env, ImGui::ColorConvertU32ToFloat4(in), dstImVec4);
|
|
*/
|
|
|
|
public static native long ColorConvertFloat4ToU32(float r, float g, float b, float a); /*
|
|
return ImGui::ColorConvertFloat4ToU32(ImVec4(r, g, b, a));
|
|
*/
|
|
|
|
public static native void ColorConvertRGBtoHSV(float[] rgb, float[] hsv); /*
|
|
ImGui::ColorConvertRGBtoHSV(rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]);
|
|
*/
|
|
|
|
public static native void ColorConvertHSVtoRGB(float[] hsv, float[] rgb); /*
|
|
ImGui::ColorConvertHSVtoRGB(hsv[0], hsv[1], hsv[2], rgb[0], rgb[1], rgb[2]);
|
|
*/
|
|
|
|
// Inputs Utilities
|
|
|
|
/**
|
|
* Map ImGuiKey_* values into user's key index. == io.KeyMap[key]
|
|
*/
|
|
public static native int GetKeyIndex(int imgui_key); /*
|
|
return ImGui::GetKeyIndex(imgui_key);
|
|
*/
|
|
|
|
/**
|
|
* Is key being held. == io.KeysDown[user_key_index]. note that imgui doesn't know the semantic of each entry of io.KeysDown[].
|
|
* Use your own indices/enums according to how your backend/engine stored them into io.KeysDown[]!
|
|
*/
|
|
public static native boolean IsKeyDown(int user_key_index); /*
|
|
return ImGui::IsKeyDown(user_key_index);
|
|
*/
|
|
|
|
/**
|
|
* Was key pressed (went from !Down to Down). if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
|
|
*/
|
|
public static native boolean IsKeyPressed(int user_key_index); /*
|
|
return ImGui::IsKeyPressed(user_key_index);
|
|
*/
|
|
|
|
/**
|
|
* Was key pressed (went from !Down to Down). if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
|
|
*/
|
|
public static native boolean IsKeyPressed(int user_key_index, boolean repeat); /*
|
|
return ImGui::IsKeyPressed(user_key_index, repeat);
|
|
*/
|
|
|
|
/**
|
|
* Was key released (went from Down to !Down)..
|
|
*/
|
|
public static native boolean IsKeyReleased(int user_key_index); /*
|
|
return ImGui::IsKeyReleased(user_key_index);
|
|
*/
|
|
|
|
/**
|
|
* uUses provided repeat rate/delay. return a count, most often 0 or 1 but might be >1 if RepeatRate is small enough that DeltaTime > RepeatRate
|
|
*/
|
|
public static native boolean GetKeyPressedAmount(int key_index, float repeat_delay, float rate); /*
|
|
return ImGui::GetKeyPressedAmount(key_index, repeat_delay, rate);
|
|
*/
|
|
|
|
/**
|
|
* Is mouse button held (0=left, 1=right, 2=middle)
|
|
*/
|
|
public static native boolean IsMouseDown(int button); /*
|
|
return ImGui::IsMouseDown(button);
|
|
*/
|
|
|
|
/**
|
|
* Is any mouse button held
|
|
*/
|
|
public static native boolean IsAnyMouseDown(); /*
|
|
return ImGui::IsAnyMouseDown();
|
|
*/
|
|
|
|
/**
|
|
* Did mouse button clicked (went from !Down to Down) (0=left, 1=right, 2=middle)
|
|
*/
|
|
public static native boolean IsMouseClicked(int button); /*
|
|
return ImGui::IsMouseClicked(button);
|
|
*/
|
|
|
|
public static native boolean IsMouseClicked(int button, boolean repeat); /*
|
|
return ImGui::IsMouseClicked(button, repeat);
|
|
*/
|
|
|
|
/**
|
|
* Did mouse button double-clicked. a double-click returns false in IsMouseClicked(). uses io.MouseDoubleClickTime.
|
|
*/
|
|
public static native boolean IsMouseDoubleClicked(int button); /*
|
|
return ImGui::IsMouseDoubleClicked(button);
|
|
*/
|
|
|
|
/**
|
|
* Did mouse button released (went from Down to !Down)
|
|
*/
|
|
public static native boolean IsMouseReleased(int button); /*
|
|
return ImGui::IsMouseReleased(button);
|
|
*/
|
|
|
|
/**
|
|
* Is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
|
|
*/
|
|
public static native boolean IsMouseDragging(); /*
|
|
return ImGui::IsMouseDragging();
|
|
*/
|
|
|
|
/**
|
|
* Is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
|
|
*/
|
|
public static native boolean IsMouseDragging(int button); /*
|
|
return ImGui::IsMouseDragging(button);
|
|
*/
|
|
|
|
/**
|
|
* Is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
|
|
*/
|
|
public static native boolean IsMouseDragging(int button, float lock_threshold); /*
|
|
return ImGui::IsMouseDragging(button, lock_threshold);
|
|
*/
|
|
|
|
/**
|
|
* Is mouse hovering given bounding rect (in screen space). clipped by current clipping settings, but disregarding of other consideration of focus/window ordering/popup-block.
|
|
*/
|
|
public static native boolean IsMouseHoveringRect(float minX, float minY, float maxX, float maxY); /*
|
|
return ImGui::IsMouseHoveringRect(ImVec2(minX, minY), ImVec2(maxX, maxY));
|
|
*/
|
|
|
|
/**
|
|
* Is mouse hovering given bounding rect (in screen space). clipped by current clipping settings, but disregarding of other consideration of focus/window ordering/popup-block.
|
|
*/
|
|
public static native boolean IsMouseHoveringRect(float minX, float minY, float maxX, float maxY, boolean clip); /*
|
|
return ImGui::IsMouseHoveringRect(ImVec2(minX, minY), ImVec2(maxX, maxY), clip);
|
|
*/
|
|
|
|
/**
|
|
* By convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse
|
|
*/
|
|
public static native boolean IsMousePosValid(); /*
|
|
return ImGui::IsMousePosValid();
|
|
*/
|
|
|
|
/**
|
|
* By convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse
|
|
*/
|
|
public static native boolean IsMousePosValid(float mouse_pos_x, float mouse_pos_y); /*
|
|
ImVec2 pos = ImVec2(mouse_pos_x, mouse_pos_y);
|
|
return ImGui::IsMousePosValid(&pos);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
|
|
*/
|
|
public static native void GetMousePos(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetMousePos(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Retrieve backup of mouse position at the time of opening popup we have BeginPopup() into
|
|
*/
|
|
public static native void GetMousePosOnOpeningCurrentPopup(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetMousePosOnOpeningCurrentPopup(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Return the delta from the initial clicking position while the mouse button is pressed or was just released.
|
|
* This is locked and return 0.0f until the mouse moves past a distance threshold at least once. If lock_threshold < -1.0f uses io.MouseDraggingThreshold.
|
|
*/
|
|
public static native void GetMouseDragDelta(ImVec2 dstImVec2); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetMouseDragDelta(), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Return the delta from the initial clicking position while the mouse button is pressed or was just released.
|
|
* This is locked and return 0.0f until the mouse moves past a distance threshold at least once. If lock_threshold < -1.0f uses io.MouseDraggingThreshold.
|
|
*/
|
|
public static native void GetMouseDragDelta(ImVec2 dstImVec2, int button); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetMouseDragDelta(button), dstImVec2);
|
|
*/
|
|
|
|
/**
|
|
* Return the delta from the initial clicking position while the mouse button is pressed or was just released.
|
|
* This is locked and return 0.0f until the mouse moves past a distance threshold at least once. If lock_threshold < -1.0f uses io.MouseDraggingThreshold.
|
|
*/
|
|
public static native void GetMouseDragDelta(ImVec2 dstImVec2, int button, float lock_threshold); /*
|
|
Jni::ImVec2Cpy(env, ImGui::GetMouseDragDelta(button, lock_threshold), dstImVec2);
|
|
*/
|
|
|
|
public static native void ResetMouseDragDelta(); /*
|
|
ImGui::ResetMouseDragDelta();
|
|
*/
|
|
|
|
public static native void ResetMouseDragDelta(int button); /*
|
|
ImGui::ResetMouseDragDelta(button);
|
|
*/
|
|
|
|
/**
|
|
* Get desired cursor type, reset in ImGui::NewFrame(), this is updated during the frame. valid before Render().
|
|
* If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you
|
|
*/
|
|
public static native int GetMouseCursor(); /*
|
|
return ImGui::GetMouseCursor();
|
|
*/
|
|
|
|
/**
|
|
* Set desired cursor type
|
|
*/
|
|
public static native void SetMouseCursor(int type); /*
|
|
ImGui::SetMouseCursor(type);
|
|
*/
|
|
|
|
/**
|
|
* Attention: misleading name! manually override io.WantCaptureKeyboard flag next frame (said flag is entirely left for your application to handle).
|
|
* e.g. force capture keyboard when your widget is being hovered.
|
|
* This is equivalent to setting "io.WantCaptureKeyboard = want_capture_keyboard_value"; after the next NewFrame() call.
|
|
*/
|
|
public static native void CaptureKeyboardFromApp(); /*
|
|
ImGui::CaptureKeyboardFromApp();
|
|
*/
|
|
|
|
/**
|
|
* Attention: misleading name! manually override io.WantCaptureKeyboard flag next frame (said flag is entirely left for your application to handle).
|
|
* e.g. force capture keyboard when your widget is being hovered.
|
|
* This is equivalent to setting "io.WantCaptureKeyboard = want_capture_keyboard_value"; after the next NewFrame() call.
|
|
*/
|
|
public static native void CaptureKeyboardFromApp(boolean want_capture_keyboard_value); /*
|
|
ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
|
|
*/
|
|
|
|
/**
|
|
* Attention: misleading name! manually override io.WantCaptureMouse flag next frame (said flag is entirely left for your application to handle).
|
|
* This is equivalent to setting "io.WantCaptureMouse = want_capture_mouse_value;" after the next NewFrame() call.
|
|
*/
|
|
public static native void CaptureMouseFromApp(); /*
|
|
ImGui::CaptureMouseFromApp();
|
|
*/
|
|
|
|
/**
|
|
* Attention: misleading name! manually override io.WantCaptureMouse flag next frame (said flag is entirely left for your application to handle).
|
|
* This is equivalent to setting "io.WantCaptureMouse = want_capture_mouse_value;" after the next NewFrame() call.
|
|
*/
|
|
public static native void CaptureMouseFromApp(boolean want_capture_mouse_value); /*
|
|
ImGui::CaptureMouseFromApp(want_capture_mouse_value);
|
|
*/
|
|
|
|
// Settings/.Ini Utilities
|
|
// - The disk functions are automatically called if io.IniFilename != NULL (default is "imgui.ini").
|
|
// - Set io.IniFilename to NULL to load/save manually. Read io.WantSaveIniSettings description about handling .ini saving manually.
|
|
|
|
/**
|
|
* Call after CreateContext() and before the first call to NewFrame(). NewFrame() automatically calls LoadIniSettingsFromDisk(io.IniFilename).
|
|
*/
|
|
public static native void LoadIniSettingsFromDisk(String ini_filename); /*
|
|
ImGui::LoadIniSettingsFromDisk(ini_filename);
|
|
*/
|
|
|
|
/**
|
|
* Call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source.
|
|
*/
|
|
public static native void LoadIniSettingsFromMemory(String ini_data); /*
|
|
ImGui::LoadIniSettingsFromMemory(ini_data);
|
|
*/
|
|
|
|
/**
|
|
* Call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source.
|
|
*/
|
|
public static native void LoadIniSettingsFromMemory(String ini_data, int ini_size); /*
|
|
ImGui::LoadIniSettingsFromMemory(ini_data, ini_size);
|
|
*/
|
|
|
|
/**
|
|
* This is automatically called (if io.IniFilename is not empty) a few seconds after any modification that should be reflected in the .ini file (and also by DestroyContext).
|
|
*/
|
|
public static native void SaveIniSettingsToDisk(String ini_filename); /*
|
|
ImGui::SaveIniSettingsToDisk(ini_filename);
|
|
*/
|
|
|
|
/**
|
|
* Return a zero-terminated string with the .ini data which you can save by your own mean.
|
|
* Call when io.WantSaveIniSettings is set, then save data by your own mean and clear io.WantSaveIniSettings.
|
|
*/
|
|
public static native String SaveIniSettingsToMemory(); /*
|
|
return env->NewStringUTF(ImGui::SaveIniSettingsToMemory());
|
|
*/
|
|
|
|
/**
|
|
* Return a zero-terminated string with the .ini data which you can save by your own mean.
|
|
* Call when io.WantSaveIniSettings is set, then save data by your own mean and clear io.WantSaveIniSettings.
|
|
*/
|
|
public static native String SaveIniSettingsToMemory(long out_ini_size); /*
|
|
return env->NewStringUTF(ImGui::SaveIniSettingsToMemory((size_t*)&out_ini_size));
|
|
*/
|
|
}
|