2839 lines
122 KiB
Java
2839 lines
122 KiB
Java
package imgui;
|
|
|
|
import imgui.assertion.ImAssertCallback;
|
|
import imgui.binding.annotation.ArgValue;
|
|
import imgui.binding.annotation.ArgVariant;
|
|
import imgui.binding.annotation.BindingMethod;
|
|
import imgui.binding.annotation.BindingSource;
|
|
import imgui.binding.annotation.OptArg;
|
|
import imgui.binding.annotation.ReturnValue;
|
|
import imgui.callback.ImGuiInputTextCallback;
|
|
import imgui.flag.ImGuiDragDropFlags;
|
|
import imgui.flag.ImGuiInputTextFlags;
|
|
import imgui.internal.ImGuiContext;
|
|
import imgui.type.ImBoolean;
|
|
import imgui.type.ImDouble;
|
|
import imgui.type.ImFloat;
|
|
import imgui.type.ImInt;
|
|
import imgui.type.ImLong;
|
|
import imgui.type.ImShort;
|
|
import imgui.type.ImString;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.UncheckedIOException;
|
|
import java.lang.ref.WeakReference;
|
|
import java.nio.file.AccessDeniedException;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.nio.file.StandardCopyOption;
|
|
import java.util.Optional;
|
|
import java.util.Properties;
|
|
|
|
@BindingSource
|
|
@SuppressWarnings({"unused", "UnusedReturnValue"})
|
|
public class ImGui {
|
|
private static final String LIB_PATH_PROP = "imgui.library.path";
|
|
private static final String LIB_NAME_PROP = "imgui.library.name";
|
|
private static final String LIB_NAME_DEFAULT = "imgui-java64";
|
|
private static final String LIB_TMP_DIR_PREFIX = "imgui-java-natives";
|
|
|
|
static {
|
|
final String libPath = System.getProperty(LIB_PATH_PROP);
|
|
final String libName = System.getProperty(LIB_NAME_PROP, LIB_NAME_DEFAULT);
|
|
final String fullLibName = resolveFullLibName();
|
|
|
|
if (libPath != null) {
|
|
System.load(Paths.get(libPath).resolve(fullLibName).toAbsolutePath().toString());
|
|
} else {
|
|
try {
|
|
System.loadLibrary(libName);
|
|
} catch (Exception | Error e) {
|
|
final String extractedLibAbsPath = tryLoadFromClasspath(fullLibName);
|
|
if (extractedLibAbsPath != null) {
|
|
System.load(extractedLibAbsPath);
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
nInitJni();
|
|
ImFontAtlas.nInit();
|
|
ImGuiPlatformIO.init();
|
|
nInitInputTextData();
|
|
|
|
setAssertCallback(new ImAssertCallback() {
|
|
@Override
|
|
public void imAssertCallback(String assertion, int line, String file) {
|
|
System.err.println("Dear ImGui Assertion Failed: " + assertion);
|
|
System.err.println("Assertion Located At: " + file + ":" + line);
|
|
Thread.dumpStack();
|
|
}
|
|
});
|
|
}
|
|
|
|
private static String resolveFullLibName() {
|
|
final boolean isWin = System.getProperty("os.name").toLowerCase().contains("win");
|
|
final boolean isMac = System.getProperty("os.name").toLowerCase().contains("mac");
|
|
final String libPrefix;
|
|
final String libSuffix;
|
|
|
|
if (isWin) {
|
|
libPrefix = "";
|
|
libSuffix = ".dll";
|
|
} else if (isMac) {
|
|
libPrefix = "lib";
|
|
libSuffix = ".dylib";
|
|
} else {
|
|
libPrefix = "lib";
|
|
libSuffix = ".so";
|
|
}
|
|
|
|
return System.getProperty(LIB_NAME_PROP, libPrefix + LIB_NAME_DEFAULT + libSuffix);
|
|
}
|
|
|
|
// This method tries to unpack the library binary from classpath into the temp dir.
|
|
private static String tryLoadFromClasspath(final String fullLibName) {
|
|
try (InputStream is = ImGui.class.getClassLoader().getResourceAsStream("io/imgui/java/native-bin/" + fullLibName)) {
|
|
if (is == null) {
|
|
return null;
|
|
}
|
|
|
|
final String version = getVersionString().orElse("undefined");
|
|
final Path tmpDir = Paths.get(System.getProperty("java.io.tmpdir")).resolve(LIB_TMP_DIR_PREFIX).resolve(version);
|
|
if (!Files.exists(tmpDir)) {
|
|
Files.createDirectories(tmpDir);
|
|
}
|
|
|
|
final Path libBin = tmpDir.resolve(fullLibName);
|
|
try {
|
|
Files.copy(is, libBin, StandardCopyOption.REPLACE_EXISTING);
|
|
} catch (AccessDeniedException e) {
|
|
if (!Files.exists(libBin)) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
return libBin.toAbsolutePath().toString();
|
|
} catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
}
|
|
|
|
private static Optional<String> getVersionString() {
|
|
final Properties properties = new Properties();
|
|
try (InputStream is = ImGui.class.getResourceAsStream("/imgui/imgui-java.properties")) {
|
|
if (is != null) {
|
|
properties.load(is);
|
|
return Optional.of(properties.get("imgui.java.version").toString());
|
|
}
|
|
} catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
return Optional.empty();
|
|
}
|
|
|
|
/**
|
|
* For internal usage.
|
|
* Method is used to initiate static instantiation (loading of the native libraries etc.).
|
|
* Otherwise, native libraries will be loaded on demand and natively mapped objects won't work.
|
|
*/
|
|
public static void init() {
|
|
}
|
|
|
|
/*JNI
|
|
#include "_common.h"
|
|
*/
|
|
|
|
private static native void nInitJni(); /*
|
|
Jni::InitJvm(env);
|
|
Jni::InitCommon(env);
|
|
Jni::InitAssertion(env);
|
|
Jni::InitCallbacks(env);
|
|
Jni::InitBindingStruct(env);
|
|
*/
|
|
|
|
/**
|
|
* Set a custom assertion callback for ImGui assertions.
|
|
* Take note: Any custom assertion callback SHOULD NOT throw any exception.
|
|
* After any callback the application will be terminated, any attempt to bypass this behavior
|
|
* will result in a EXCEPTION_ACCESS_VIOLATION from within the native layer.
|
|
*
|
|
* @param callback The custom ImGui assertion callback
|
|
*/
|
|
public static native void setAssertCallback(ImAssertCallback callback); /*
|
|
Jni::SetAssertionCallback(callback);
|
|
*/
|
|
|
|
// 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.
|
|
|
|
@BindingMethod
|
|
public static native ImGuiContext CreateContext(@OptArg ImFontAtlas sharedFontAtlas);
|
|
|
|
@BindingMethod
|
|
public static native void DestroyContext(@OptArg ImGuiContext ctx);
|
|
|
|
@BindingMethod
|
|
public static native ImGuiContext GetCurrentContext();
|
|
|
|
@BindingMethod
|
|
public static native void SetCurrentContext(ImGuiContext ctx);
|
|
|
|
// Main
|
|
|
|
/**
|
|
* Access the IO structure (mouse/keyboard/gamepad inputs, time, various configuration options/flags).
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true, callPrefix = "&")
|
|
public static native ImGuiIO GetIO();
|
|
|
|
/**
|
|
* Access the Style structure (colors, sizes). Always use PushStyleCol(), PushStyleVar() to modify style mid-frame!
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true, callPrefix = "&")
|
|
public static native ImGuiStyle GetStyle();
|
|
|
|
/**
|
|
* Start a new Dear ImGui frame, you can submit any command from this point until Render()/EndFrame().
|
|
*/
|
|
@BindingMethod
|
|
public static native void NewFrame();
|
|
|
|
/**
|
|
* Ends the Dear ImGui frame. automatically called by Render(). If you don't need to render data (skipping rendering) you may call EndFrame() without
|
|
* Render()... but you'll have wasted CPU already! If you don't need to render, better to not create any windows and not call NewFrame() at all!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndFrame();
|
|
|
|
/**
|
|
* Ends the Dear ImGui frame, finalize the draw data. You can then get call GetDrawData().
|
|
*/
|
|
@BindingMethod
|
|
public static native void Render();
|
|
|
|
/**
|
|
* Valid after Render() and until the next call to NewFrame(). this is what you have to render.
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true)
|
|
public static native ImDrawData GetDrawData();
|
|
|
|
// Demo, Debug, Information
|
|
|
|
/**
|
|
* Create Demo window. Demonstrate most ImGui features. Call this to learn about the library!
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowDemoWindow(@OptArg ImBoolean pOpen);
|
|
|
|
/**
|
|
* Create Metrics/Debugger window. display Dear ImGui internals: windows, draw commands, various internal state, etc.
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowMetricsWindow(@OptArg ImBoolean pOpen);
|
|
|
|
/**
|
|
* Create Stack Tool window. hover items with mouse to query information about the source of their unique ID.
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowStackToolWindow(@OptArg ImBoolean pOpen);
|
|
|
|
/**
|
|
* Create About window. display Dear ImGui version, credits and build/system information.
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowAboutWindow(@OptArg ImBoolean pOpen);
|
|
|
|
/**
|
|
* 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)
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowStyleEditor(@OptArg ImGuiStyle ref);
|
|
|
|
/**
|
|
* Add style selector block (not a window), essentially a combo listing the default styles.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ShowStyleSelector(String label);
|
|
|
|
/**
|
|
* Add font selector block (not a window), essentially a combo listing the loaded fonts.
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowFontSelector(String label);
|
|
|
|
/**
|
|
* Add basic help/info block (not a window): how to manipulate ImGui as a end-user (mouse/keyboard controls).
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowUserGuide();
|
|
|
|
/**
|
|
* Get the compiled version string e.g. "1.80 WIP" (essentially the value for IMGUI_VERSION from the compiled version of imgui.cpp)
|
|
*/
|
|
@BindingMethod
|
|
public static native String GetVersion();
|
|
|
|
// Styles
|
|
|
|
/**
|
|
* New, recommended style (default)
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsDark(@OptArg ImGuiStyle style);
|
|
|
|
/**
|
|
* Best used with borders and a custom, thicker font
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsLight(@OptArg ImGuiStyle style);
|
|
|
|
/**
|
|
* Classic imgui style
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsClassic(@OptArg ImGuiStyle style);
|
|
|
|
// 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.
|
|
// - You may append multiple times to the same window during the same frame by calling Begin()/End() pairs multiple times.
|
|
// Some information such as 'flags' or 'p_open' will only be considered by the first call to Begin().
|
|
// - 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".
|
|
|
|
@BindingMethod
|
|
public static native boolean Begin(String title, @OptArg(callValue = "NULL") ImBoolean pOpen, @OptArg int imGuiWindowFlags);
|
|
|
|
@BindingMethod
|
|
public static native void 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.
|
|
// [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.]
|
|
|
|
@BindingMethod
|
|
public static native boolean BeginChild(String strId, @OptArg(callValue = "ImVec2(0,0)") ImVec2 size, @OptArg(callValue = "false") boolean border, @OptArg int imGuiWindowFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean BeginChild(int imGuiID, @OptArg(callValue = "ImVec2(0,0)") ImVec2 size, @OptArg(callValue = "false") boolean border, @OptArg int imGuiWindowFlags);
|
|
|
|
@BindingMethod
|
|
public static native void 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.
|
|
|
|
@BindingMethod
|
|
public static native boolean IsWindowAppearing();
|
|
|
|
@BindingMethod
|
|
public static native boolean IsWindowCollapsed();
|
|
|
|
/**
|
|
* Is current window focused? or its root/child, depending on flags. see flags for options.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsWindowFocused(@OptArg int 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!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsWindowHovered(@OptArg int imGuiHoveredFlags);
|
|
|
|
/**
|
|
* Get draw list associated to the current window, to append your own drawing primitives
|
|
*/
|
|
@BindingMethod
|
|
public static native ImDrawList GetWindowDrawList();
|
|
|
|
/**
|
|
* Get DPI scale currently associated to the current window's viewport.
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetWindowDpiScale();
|
|
|
|
/**
|
|
* Get current window position in screen space (useful if you want to do your own drawing via the DrawList API)
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetWindowPos();
|
|
|
|
/**
|
|
* Get current window size
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetWindowSize();
|
|
|
|
/**
|
|
* Get current window width (shortcut for GetWindowSize().x)
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetWindowWidth();
|
|
|
|
/**
|
|
* Get current window height (shortcut for GetWindowSize().y)
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetWindowHeight();
|
|
|
|
/**
|
|
* Get viewport currently associated to the current window.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImGuiViewport GetWindowViewport();
|
|
|
|
// 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowPos(ImVec2 pos, @OptArg(callValue = "ImGuiCond_None") int cond, @OptArg ImVec2 pivot);
|
|
|
|
/**
|
|
* Set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowSize(ImVec2 size, @OptArg int cond);
|
|
|
|
/**
|
|
* Set next window size limits. use -1,-1 on either X/Y axis to preserve the current size. Sizes will be rounded down.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowSizeConstraints(ImVec2 sizeMin, ImVec2 sizeMax);
|
|
|
|
/**
|
|
* 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()
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowContentSize(ImVec2 size);
|
|
|
|
/**
|
|
* Set next window collapsed state. call before Begin()
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowCollapsed(boolean collapsed, @OptArg int cond);
|
|
|
|
/**
|
|
* Set next window to be focused / top-most. call before Begin()
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowFocus();
|
|
|
|
/**
|
|
* Set next window background color alpha. helper to easily override the Alpha component of ImGuiCol_WindowBg/ChildBg/PopupBg.
|
|
* You may also use ImGuiWindowFlags_NoBackground.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowBgAlpha(float alpha);
|
|
|
|
/**
|
|
* Set next window viewport.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowViewport(int viewportId);
|
|
|
|
/**
|
|
* (not recommended) set current window position - call within Begin()/End().
|
|
* Prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowPos(ImVec2 pos, @OptArg int cond);
|
|
|
|
/**
|
|
* (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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowSize(ImVec2 size, @OptArg int cond);
|
|
|
|
/**
|
|
* (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowCollapsed(boolean collapsed, @OptArg int cond);
|
|
|
|
/**
|
|
* (not recommended) set current window to be focused / top-most. prefer using SetNextWindowFocus().
|
|
*/
|
|
@BindingMethod
|
|
public static native void 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().
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowFontScale(float scale);
|
|
|
|
/**
|
|
* Set named window position.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowPos(String name, ImVec2 pos, @OptArg int cond);
|
|
|
|
/**
|
|
* Set named window size. set axis to 0.0f to force an auto-fit on this axis.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowSize(String name, ImVec2 size, @OptArg int cond);
|
|
|
|
/**
|
|
* Set named window collapsed state
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowCollapsed(@ArgValue(callPrefix = "(const char *)") String name, @ArgValue(callPrefix = "(bool)") boolean collapsed, @OptArg int cond);
|
|
|
|
/**
|
|
* Set named window to be focused / top-most. Use NULL to remove focus.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetWindowFocus(String name);
|
|
|
|
// Content region
|
|
// - Retrieve available space from a given point. GetContentRegionAvail() is frequently useful.
|
|
// - Those functions are bound to be redesigned (they are confusing, incomplete and the Min/Max return values are in local window coordinates which increases confusion)
|
|
|
|
/**
|
|
* == GetContentRegionMax() - GetCursorPos()
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetContentRegionAvail();
|
|
|
|
/**
|
|
* Current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetContentRegionMax();
|
|
|
|
/**
|
|
* Content boundaries min for the full window (roughly (0,0)-Scroll), in window coordinates
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetWindowContentRegionMin();
|
|
|
|
/**
|
|
* Content boundaries max for the full window (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetWindowContentRegionMax();
|
|
|
|
// Windows Scrolling
|
|
|
|
/**
|
|
* Get scrolling amount [0 .. GetScrollMaxX()]
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetScrollX();
|
|
|
|
/**
|
|
* Get scrolling amount [0 .. GetScrollMaxY()]
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetScrollY();
|
|
|
|
/**
|
|
* Set scrolling amount [0 .. GetScrollMaxX()]
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetScrollX(float scrollX);
|
|
|
|
/**
|
|
* Set scrolling amount [0..GetScrollMaxY()]
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetScrollY(float scrollY);
|
|
|
|
/**
|
|
* Get maximum scrolling amount ~~ ContentSize.x - WindowSize.x - DecorationsSize.x
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetScrollMaxX();
|
|
|
|
/**
|
|
* Get maximum scrolling amount ~~ ContentSize.y - WindowSize.y - DecorationsSize.y
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetScrollMaxY();
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetScrollHereX(@OptArg float 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetScrollHereY(@OptArg float centerYRatio);
|
|
|
|
/**
|
|
* Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetScrollFromPosX(float localX, @OptArg float centerXRatio);
|
|
|
|
/**
|
|
* Adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetScrollFromPosY(float localY, @OptArg float centerYRatio);
|
|
|
|
// Parameters stacks (shared)
|
|
|
|
@BindingMethod
|
|
public static native void PushFont(ImFont font);
|
|
|
|
@BindingMethod
|
|
public static native void PopFont();
|
|
|
|
/**
|
|
* Modify a style color. always use this if you modify the style after NewFrame().
|
|
*/
|
|
public static native void pushStyleColor(int imGuiCol, int r, int g, int b, int a); /*
|
|
ImGui::PushStyleColor(imGuiCol, (ImU32)ImColor((int)r, (int)g, (int)b, (int)a));
|
|
*/
|
|
|
|
/**
|
|
* Modify a style color. always use this if you modify the style after NewFrame().
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleColor(final int imGuiCol, final ImVec4 col);
|
|
|
|
/**
|
|
* Modify a style color. always use this if you modify the style after NewFrame().
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleColor(int imGuiCol, int col);
|
|
|
|
@BindingMethod
|
|
public static native void PopStyleColor(@OptArg int count);
|
|
|
|
/**
|
|
* Modify a style float variable. always use this if you modify the style after NewFrame().
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleVar(int imGuiStyleVar, float val);
|
|
|
|
/**
|
|
* Modify a style ImVec2 variable. always use this if you modify the style after NewFrame().
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleVar(int imGuiStyleVar, ImVec2 val);
|
|
|
|
@BindingMethod
|
|
public static native void PopStyleVar(@OptArg int count);
|
|
|
|
/**
|
|
* Allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushAllowKeyboardFocus(boolean allowKeyboardFocus);
|
|
|
|
@BindingMethod
|
|
public static native void 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushButtonRepeat(boolean repeat);
|
|
|
|
@BindingMethod
|
|
public static native void PopButtonRepeat();
|
|
|
|
// Parameters stacks (current window)
|
|
|
|
/**
|
|
* Push width of items for common large "item+label" widgets. {@code > 0.0f}: width in pixels,
|
|
* {@code <0.0f} align xx pixels to the right of window (so -1.0f always align width to the right side).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushItemWidth(float itemWidth);
|
|
|
|
@BindingMethod
|
|
public static native void PopItemWidth();
|
|
|
|
/**
|
|
* Set width of the _next_ common large "item+label" widget. {@code > 0.0f}: width in pixels,
|
|
* {@code <0.0f} align xx pixels to the right of window (so -1.0f always align width to the right side)
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextItemWidth(float itemWidth);
|
|
|
|
/**
|
|
* Width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions.
|
|
*/
|
|
@BindingMethod
|
|
public static native float CalcItemWidth();
|
|
|
|
/**
|
|
* Push Word-wrapping positions for Text*() commands. {@code < 0.0f}: no wrapping; 0.0f: wrap to end of window (or column); {@code > 0.0f}: wrap at
|
|
* 'wrap_posX' position in window local space
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushTextWrapPos(@OptArg float wrapLocalPosX);
|
|
|
|
@BindingMethod
|
|
public static native void PopTextWrapPos();
|
|
|
|
// Style read access
|
|
|
|
/**
|
|
* Get current font.
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true)
|
|
public static native ImFont GetFont();
|
|
|
|
/**
|
|
* Get current font size (= height in pixels) of current font with current scale applied
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetFontSize();
|
|
|
|
/**
|
|
* Get UV coordinate for a while pixel, useful to draw custom shapes via the ImDrawList API
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetFontTexUvWhitePixel();
|
|
|
|
/**
|
|
* Retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value suitable for ImDrawList.
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetColorU32(@ArgValue(staticCast = "ImGuiCol") int idx, @OptArg float alphaMul);
|
|
|
|
/**
|
|
* Retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList.
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetColorU32(ImVec4 col);
|
|
|
|
/**
|
|
* Retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList.
|
|
*/
|
|
@BindingMethod(callName = "GetColorU32")
|
|
public static native int GetColorU32i(@ArgValue(staticCast = "ImU32") int col);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec4 GetStyleColorVec4(int imGuiColIdx);
|
|
|
|
// 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 preceding widget.
|
|
// - Attention! We currently have inconsistencies between window-local and absolute positions we will aim to fix with future API:
|
|
// Window-local coordinates: SameLine(), GetCursorPos(), SetCursorPos(), GetCursorStartPos(), GetContentRegionMax(), GetWindowContentRegion*(), PushTextWrapPos()
|
|
// Absolute coordinate: GetCursorScreenPos(), SetCursorScreenPos(), all ImDrawList:: functions.
|
|
|
|
/**
|
|
* Separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Separator();
|
|
|
|
/**
|
|
* Call between widgets or groups to layout them horizontally. X position given in window coordinates.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SameLine(@OptArg float offsetFromStartX, @OptArg float spacing);
|
|
|
|
/**
|
|
* Undo a SameLine() or force a new line when in an horizontal-layout context.
|
|
*/
|
|
@BindingMethod
|
|
public static native void NewLine();
|
|
|
|
/**
|
|
* Add vertical spacing.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Spacing();
|
|
|
|
/**
|
|
* Add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Dummy(ImVec2 size);
|
|
|
|
/**
|
|
* Move content position toward the right, by indent_w, or style.IndentSpacing if indent_w {@code <= 0}.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Indent(@OptArg float indentW);
|
|
|
|
/**
|
|
* Move content position back to the left, by indent_w, or style.IndentSpacing if indent_w {@code <= 0}.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Unindent(@OptArg float indentW);
|
|
|
|
/**
|
|
* Lock horizontal starting position
|
|
*/
|
|
@BindingMethod
|
|
public static native void 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.)
|
|
*/
|
|
@BindingMethod
|
|
public static native void 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)
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetCursorPos();
|
|
|
|
/**
|
|
* Cursor position in window coordinates (relative to window position)
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetCursorPos(ImVec2 pos);
|
|
|
|
/**
|
|
* Cursor position in window coordinates (relative to window position)
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetCursorPosX(float x);
|
|
|
|
/**
|
|
* Cursor position in window coordinates (relative to window position)
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetCursorPosY(float y);
|
|
|
|
/**
|
|
* Initial cursor position in window coordinates
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetCursorStartPos();
|
|
|
|
/**
|
|
* Cursor position in absolute coordinates (useful to work with ImDrawList API).
|
|
* Generally top-left == GetMainViewport().Pos == (0,0) in single viewport mode,
|
|
* and bottom-right == GetMainViewport().Pos+Size == io.DisplaySize in single-viewport mode.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetCursorScreenPos();
|
|
|
|
/**
|
|
* Cursor position in absolute coordinates.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetCursorScreenPos(ImVec2 pos);
|
|
|
|
/**
|
|
* 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)
|
|
*/
|
|
@BindingMethod
|
|
public static native void AlignTextToFramePadding();
|
|
|
|
/**
|
|
* ~ FontSize
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetTextLineHeight();
|
|
|
|
/**
|
|
* ~ FontSize + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of text)
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetTextLineHeightWithSpacing();
|
|
|
|
/**
|
|
* ~ FontSize + style.FramePadding.y * 2
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetFrameHeight();
|
|
|
|
/**
|
|
* ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets)
|
|
*/
|
|
@BindingMethod
|
|
public static native float 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 "strId" denote a string that is only used as an ID and not normally displayed.
|
|
|
|
/**
|
|
* Push string into the ID stack (will hash string).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushID(String strId);
|
|
|
|
/**
|
|
* Push string into the ID stack (will hash string).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushID(String strIdBegin, String strIdEnd);
|
|
|
|
/**
|
|
* Push pointer into the ID stack (will hash pointer).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushID(@ArgValue(callPrefix = "(void*)") long ptrId);
|
|
|
|
/**
|
|
* Push integer into the ID stack (will hash integer).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushID(int intId);
|
|
|
|
/**
|
|
* Pop from the ID stack.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PopID();
|
|
|
|
/**
|
|
* Calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetID(String strId);
|
|
|
|
/**
|
|
* Calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetID(String strIdBegin, String strIdEnd);
|
|
|
|
/**
|
|
* Calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetID(@ArgValue(callPrefix = "(void*)") long ptrId);
|
|
|
|
// Widgets: Text
|
|
|
|
/**
|
|
* Raw text without formatting. Roughly equivalent to Text("%s", text) but:
|
|
* A) doesn't require null terminated string if 'textEnd' is specified,
|
|
* B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.
|
|
*/
|
|
@BindingMethod
|
|
public static native void TextUnformatted(String text, @OptArg String textEnd);
|
|
|
|
/**
|
|
* Formatted text
|
|
*/
|
|
@BindingMethod
|
|
public static native void Text(String text, Void NULL);
|
|
|
|
/**
|
|
* Shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
|
|
*/
|
|
@BindingMethod
|
|
public static native void TextColored(ImVec4 col, String text, Void NULL);
|
|
|
|
/**
|
|
* Shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
|
|
*/
|
|
public static native void textColored(int r, int g, int b, int a, String text); /*
|
|
ImGui::TextColored(ImColor((int)r, (int)g, (int)b, (int)a), text, NULL);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
|
|
*/
|
|
public static native void textColored(int col, String text); /*
|
|
ImGui::TextColored(ImColor(col), text, NULL);
|
|
*/
|
|
|
|
/**
|
|
* Shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();
|
|
*/
|
|
@BindingMethod
|
|
public static native void TextDisabled(String text, Void NULL);
|
|
|
|
/**
|
|
* 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().
|
|
*/
|
|
@BindingMethod
|
|
public static native void TextWrapped(String text, Void NULL);
|
|
|
|
/**
|
|
* Display text+label aligned the same way as value+label widgets
|
|
*/
|
|
@BindingMethod
|
|
public static native void LabelText(String label, String text, Void NULL);
|
|
|
|
/**
|
|
* Shortcut for Bullet()+Text()
|
|
*/
|
|
@BindingMethod
|
|
public static native void BulletText(String text, Void NULL);
|
|
|
|
// 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
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean Button(String label, @OptArg ImVec2 size);
|
|
|
|
/**
|
|
* Button with FramePadding=(0,0) to easily embed within text
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean SmallButton(String label);
|
|
|
|
/**
|
|
* Flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean InvisibleButton(String strId, ImVec2 size, @OptArg int imGuiButtonFlags);
|
|
|
|
/**
|
|
* Square button with an arrow shape
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ArrowButton(String strId, int dir);
|
|
|
|
@BindingMethod
|
|
public static native void Image(@ArgValue(callPrefix = "(ImTextureID)(uintptr_t)") long userTextureId, ImVec2 size, @OptArg ImVec2 uv0, @OptArg ImVec2 uv1, @OptArg ImVec4 tintCol, @OptArg ImVec4 borderCol);
|
|
|
|
/**
|
|
* {@code <0} framePadding uses default frame padding settings. 0 for no padding
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ImageButton(@ArgValue(callPrefix = "(ImTextureID)(uintptr_t)") long userTextureId, ImVec2 size, @OptArg ImVec2 uv0, @OptArg ImVec2 uv1, @OptArg(callValue = "-1") int framePadding, @OptArg ImVec4 bgCol, @OptArg ImVec4 tintCol);
|
|
|
|
public static boolean checkbox(String label, boolean active) {
|
|
return nCheckbox(label, active);
|
|
}
|
|
|
|
private static native boolean nCheckbox(String label, boolean active); /*
|
|
bool flag = (bool)active;
|
|
return ImGui::Checkbox(label, &flag);
|
|
*/
|
|
|
|
@BindingMethod
|
|
public static native boolean Checkbox(String label, ImBoolean data);
|
|
|
|
@BindingMethod
|
|
public static native boolean CheckboxFlags(String label, ImInt flags, int flagsValue);
|
|
|
|
/**
|
|
* Use with e.g. if (RadioButton("one", my_value==1)) { my_value = 1; }
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean RadioButton(String label, boolean active);
|
|
|
|
/**
|
|
* Shortcut to handle the above pattern when value is an integer
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean RadioButton(String label, ImInt v, int vButton);
|
|
|
|
@BindingMethod
|
|
public static native void ProgressBar(float fraction, @OptArg(callValue = "ImVec2(-FLT_MIN,0)") ImVec2 size, @OptArg String overlay);
|
|
|
|
/**
|
|
* Draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
|
|
*/
|
|
@BindingMethod
|
|
public static native void 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.
|
|
|
|
@BindingMethod
|
|
public static native boolean BeginCombo(String label, String previewValue, @OptArg int imGuiComboFlags);
|
|
|
|
/**
|
|
* Only call EndCombo() if BeginCombo() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndCombo();
|
|
|
|
@BindingMethod
|
|
public static native boolean Combo(String label, ImInt currentItem, String[] items, Void itemsCount, @OptArg int popupMaxHeightInItems);
|
|
|
|
/**
|
|
* Separate items with \0 within a string, end item-list with \0\0. e.g. "One\0Two\0Three\0"
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean Combo(String label, ImInt currentItem, String itemsSeparatedByZeros, @OptArg int popupMaxHeightInItems);
|
|
|
|
// Widgets: Drag Sliders
|
|
// - 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.
|
|
// - Format string may also be set to NULL or use the default format ("%f" or "%d").
|
|
// - Speed are per-pixel of mouse movement (vSpeed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(vSpeed, minimum_step_at_given_precision).
|
|
// - Use vMin < vMax to clamp edits to given limits. Note that CTRL+Click manual input can override those limits.
|
|
// - Use v_max = FLT_MAX / INT_MAX etc to avoid clamping to a maximum, same with v_min = -FLT_MAX / INT_MIN to avoid clamping to a minimum.
|
|
// - Use vMin > vMax to lock edits.
|
|
// - We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.
|
|
// - Legacy: Pre-1.78 there are DragXXX() function signatures that takes a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.
|
|
// If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361
|
|
|
|
/**
|
|
* If {@code vMin >= vMax} we have no bound
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean DragFloat(String label, float[] v, @OptArg float vSpeed, @OptArg float vMin, @OptArg float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragFloat2(String label, float[] v, @OptArg float vSpeed, @OptArg float vMin, @OptArg float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragFloat3(String label, float[] v, @OptArg float vSpeed, @OptArg float vMin, @OptArg float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragFloat4(String label, float[] v, @OptArg float vSpeed, @OptArg float vMin, @OptArg float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragFloatRange2(String label, float[] vCurrentMin, float[] vCurrentMax, float vSpeed, @OptArg float vMin, @OptArg float vMax, @OptArg String format, @OptArg String formatMax, @OptArg int imGuiSliderFlags);
|
|
|
|
/**
|
|
* If {@code vMin >= vMax} we have no bound
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean DragInt(String label, int[] v, @OptArg float vSpeed, @OptArg int vMin, @OptArg int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragInt2(String label, int[] v, @OptArg float vSpeed, @OptArg int vMin, @OptArg int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragInt3(String label, int[] v, @OptArg float vSpeed, @OptArg int vMin, @OptArg int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragInt4(String label, int[] v, @OptArg float vSpeed, @OptArg int vMin, @OptArg int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragIntRange2(String label, int[] vCurrentMin, int[] vCurrentMax, @OptArg float vSpeed, @OptArg int vMin, @OptArg int vMax, @OptArg String format, @OptArg String formatMax, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalar(String label, Void ImGuiDataType_S16, short[] pData, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") short pMin, @OptArg @ArgValue(callPrefix = "&") short pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalar(String label, Void ImGuiDataType_S32, int[] pData, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") int pMin, @OptArg @ArgValue(callPrefix = "&") int pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalar(String label, Void ImGuiDataType_S64, long[] pData, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") long pMin, @OptArg @ArgValue(callPrefix = "&") long pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalar(String label, Void ImGuiDataType_Float, float[] pData, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") float pMin, @OptArg @ArgValue(callPrefix = "&") float pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalar(String label, Void ImGuiDataType_Double, double[] pData, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") double pMin, @OptArg @ArgValue(callPrefix = "&") double pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalarN(String label, Void ImGuiDataType_S16, short[] pData, int components, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") short pMin, @OptArg @ArgValue(callPrefix = "&") short pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalarN(String label, Void ImGuiDataType_S32, int[] pData, int components, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") int pMin, @OptArg @ArgValue(callPrefix = "&") int pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalarN(String label, Void ImGuiDataType_S64, long[] pData, int components, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") long pMin, @OptArg @ArgValue(callPrefix = "&") long pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalarN(String label, Void ImGuiDataType_Float, float[] pData, int components, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") float pMin, @OptArg @ArgValue(callPrefix = "&") float pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean DragScalarN(String label, Void ImGuiDataType_Double, double[] pData, int components, @OptArg float vSpeed, @OptArg @ArgValue(callPrefix = "&") double pMin, @OptArg @ArgValue(callPrefix = "&") double pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
// Widgets: Regular 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.
|
|
// - Format string may also be set to NULL or use the default format ("%f" or "%d").
|
|
// - Legacy: Pre-1.78 there are SliderXXX() function signatures that takes a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.
|
|
// If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361
|
|
|
|
/**
|
|
* Adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean SliderFloat(String label, float[] v, float vMin, float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderFloat2(String label, float[] v, float vMin, float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderFloat3(String label, float[] v, float vMin, float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderFloat4(String label, float[] v, float vMin, float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderAngle(String label, float[] vRad, @OptArg float vDegreesMin, @OptArg float vDegreesMax, @OptArg(callValue = "\"%.0f deg\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderInt(String label, int[] v, int vMin, int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderInt2(String label, int[] v, int vMin, int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderInt3(String label, int[] v, int vMin, int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderInt4(String label, int[] v, int vMin, int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalar(String label, Void ImGuiDataType_S16, short[] pData, @ArgValue(callPrefix = "&") short pMin, @ArgValue(callPrefix = "&") short pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalar(String label, Void ImGuiDataType_S32, int[] pData, @ArgValue(callPrefix = "&") int pMin, @ArgValue(callPrefix = "&") int pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalar(String label, Void ImGuiDataType_S64, long[] pData, @ArgValue(callPrefix = "&") long pMin, @ArgValue(callPrefix = "&") long pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalar(String label, Void ImGuiDataType_Float, float[] pData, @ArgValue(callPrefix = "&") float pMin, @ArgValue(callPrefix = "&") float pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalar(String label, Void ImGuiDataType_Double, double[] pData, @ArgValue(callPrefix = "&") double pMin, @ArgValue(callPrefix = "&") double pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalarN(String label, Void ImGuiDataType_S16, short[] pData, int components, @ArgValue(callPrefix = "&") short pMin, @ArgValue(callPrefix = "&") short pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalarN(String label, Void ImGuiDataType_S32, int[] pData, int components, @ArgValue(callPrefix = "&") int pMin, @ArgValue(callPrefix = "&") int pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalarN(String label, Void ImGuiDataType_S64, long[] pData, int components, @ArgValue(callPrefix = "&") long pMin, @ArgValue(callPrefix = "&") long pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalarN(String label, Void ImGuiDataType_Float, float[] pData, int components, @ArgValue(callPrefix = "&") float pMin, @ArgValue(callPrefix = "&") float pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean SliderScalarN(String label, Void ImGuiDataType_Double, double[] pData, int components, @ArgValue(callPrefix = "&") double pMin, @ArgValue(callPrefix = "&") double pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderFloat(String label, ImVec2 size, float[] v, float vMin, float vMax, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderInt(String label, ImVec2 size, int[] v, int vMin, int vMax, @OptArg(callValue = "\"%d\"") String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderScalar(String label, ImVec2 size, Void ImGuiDataType_S16, short[] pData, @ArgValue(callPrefix = "&") short pMin, @ArgValue(callPrefix = "&") short pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderScalar(String label, ImVec2 size, Void ImGuiDataType_S32, int[] pData, @ArgValue(callPrefix = "&") int pMin, @ArgValue(callPrefix = "&") int pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderScalar(String label, ImVec2 size, Void ImGuiDataType_S64, long[] pData, @ArgValue(callPrefix = "&") long pMin, @ArgValue(callPrefix = "&") long pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderScalar(String label, ImVec2 size, Void ImGuiDataType_Float, float[] pData, @ArgValue(callPrefix = "&") float pMin, @ArgValue(callPrefix = "&") float pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean VSliderScalar(String label, ImVec2 size, Void ImGuiDataType_Double, double[] pData, @ArgValue(callPrefix = "&") double pMin, @ArgValue(callPrefix = "&") double pMax, @OptArg String format, @OptArg int imGuiSliderFlags);
|
|
|
|
// Widgets: Input with Keyboard
|
|
// - If you want to use InputText() with std::string or any custom dynamic string type, see misc/cpp/imgui_stdlib.h and comments in imgui_demo.cpp.
|
|
// - Most of the ImGuiInputTextFlags flags are only useful for InputText() and not for InputFloatX, InputIntX, InputDouble etc.
|
|
|
|
/*JNI
|
|
jmethodID jImStringResizeInternalMID;
|
|
jmethodID jInputTextCallbackMID;
|
|
|
|
jfieldID inputDataSizeID;
|
|
jfieldID inputDataIsDirtyID;
|
|
jfieldID inputDataIsResizedID;
|
|
|
|
struct InputTextCallbackUserData {
|
|
JNIEnv* env;
|
|
jobject* imString;
|
|
int maxSize;
|
|
jbyteArray jResizedBuf;
|
|
char* resizedBuf;
|
|
jobject* textInputData;
|
|
char* allowedChars;
|
|
jobject* handler;
|
|
};
|
|
|
|
static int TextEditCallbackStub(ImGuiInputTextCallbackData* data) {
|
|
InputTextCallbackUserData* userData = (InputTextCallbackUserData*)data->UserData;
|
|
|
|
if (data->EventFlag == ImGuiInputTextFlags_CallbackCharFilter) {
|
|
int allowedCharLength = strlen(userData->allowedChars);
|
|
if(allowedCharLength > 0) {
|
|
bool found = false;
|
|
for(int i = 0; i < allowedCharLength; i++) {
|
|
if(userData->allowedChars[i] == data->EventChar) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
return found ? 0 : 1;
|
|
}
|
|
} else if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) {
|
|
int newSize = data->BufTextLen;
|
|
if (newSize >= userData->maxSize) {
|
|
JNIEnv* env = userData->env;
|
|
|
|
jbyteArray newBufArr = (jbyteArray)env->CallObjectMethod(*userData->imString, jImStringResizeInternalMID, newSize);
|
|
char* newBuf = (char*)env->GetPrimitiveArrayCritical(newBufArr, 0);
|
|
|
|
data->Buf = newBuf;
|
|
|
|
userData->jResizedBuf = newBufArr;
|
|
userData->resizedBuf = newBuf;
|
|
}
|
|
}
|
|
|
|
if (userData->handler != NULL) {
|
|
JNIEnv* env = userData->env;
|
|
env->CallObjectMethod(*userData->handler, jInputTextCallbackMID, data);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
private static native void nInitInputTextData(); /*
|
|
jclass jInputDataClass = env->FindClass("imgui/type/ImString$InputData");
|
|
inputDataSizeID = env->GetFieldID(jInputDataClass, "size", "I");
|
|
inputDataIsDirtyID = env->GetFieldID(jInputDataClass, "isDirty", "Z");
|
|
inputDataIsResizedID = env->GetFieldID(jInputDataClass, "isResized", "Z");
|
|
|
|
jclass jImString = env->FindClass("imgui/type/ImString");
|
|
jImStringResizeInternalMID = env->GetMethodID(jImString, "resizeInternal", "(I)[B");
|
|
|
|
jclass jCallback = env->FindClass("imgui/callback/ImGuiInputTextCallback");
|
|
jInputTextCallbackMID = env->GetMethodID(jCallback, "accept", "(J)V");
|
|
*/
|
|
|
|
public static boolean inputText(final String label, final ImString text) {
|
|
return preInputText(false, label, null, text);
|
|
}
|
|
|
|
public static boolean inputText(final String label, final ImString text, final int imGuiInputTextFlags) {
|
|
return preInputText(false, label, null, text, 0, 0, imGuiInputTextFlags);
|
|
}
|
|
|
|
public static boolean inputText(final String label, final ImString text, final int imGuiInputTextFlags, final ImGuiInputTextCallback callback) {
|
|
return preInputText(false, label, null, text, 0, 0, imGuiInputTextFlags, callback);
|
|
}
|
|
|
|
public static boolean inputTextMultiline(final String label, final ImString text) {
|
|
return preInputText(true, label, null, text);
|
|
}
|
|
|
|
public static boolean inputTextMultiline(final String label, final ImString text, final float width, final float height) {
|
|
return preInputText(true, label, null, text, width, height);
|
|
}
|
|
|
|
public static boolean inputTextMultiline(final String label, final ImString text, final int imGuiInputTextFlags) {
|
|
return preInputText(true, label, null, text, 0, 0, imGuiInputTextFlags);
|
|
}
|
|
|
|
public static boolean inputTextMultiline(final String label, final ImString text, final int imGuiInputTextFlags, final ImGuiInputTextCallback callback) {
|
|
return preInputText(true, label, null, text, 0, 0, imGuiInputTextFlags, callback);
|
|
}
|
|
|
|
public static boolean inputTextMultiline(final String label, final ImString text, final float width, final float height, final int imGuiInputTextFlags) {
|
|
return preInputText(true, label, null, text, width, height, imGuiInputTextFlags);
|
|
}
|
|
|
|
public static boolean inputTextMultiline(final String label, final ImString text, final float width, final float height, final int imGuiInputTextFlags, final ImGuiInputTextCallback callback) {
|
|
return preInputText(true, label, null, text, width, height, imGuiInputTextFlags, callback);
|
|
}
|
|
|
|
public static boolean inputTextWithHint(final String label, final String hint, final ImString text) {
|
|
return preInputText(false, label, hint, text);
|
|
}
|
|
|
|
public static boolean inputTextWithHint(final String label, final String hint, final ImString text, final int imGuiInputTextFlags) {
|
|
return preInputText(false, label, hint, text, 0, 0, imGuiInputTextFlags);
|
|
}
|
|
|
|
public static boolean inputTextWithHint(final String label, final String hint, final ImString text, final int imGuiInputTextFlags, final ImGuiInputTextCallback callback) {
|
|
return preInputText(false, label, hint, text, 0, 0, imGuiInputTextFlags, callback);
|
|
}
|
|
|
|
private static boolean preInputText(final boolean multiline, final String label, final String hint, final ImString text) {
|
|
return preInputText(multiline, label, hint, text, 0, 0);
|
|
}
|
|
|
|
private static boolean preInputText(final boolean multiline, final String label, final String hint, final ImString text, final float width, final float height) {
|
|
return preInputText(multiline, label, hint, text, width, height, ImGuiInputTextFlags.None);
|
|
}
|
|
|
|
private static boolean preInputText(final boolean multiline, final String label, final String hint, final ImString text, final float width, final float height, final int flags) {
|
|
return preInputText(multiline, label, hint, text, width, height, flags, null);
|
|
}
|
|
|
|
private static boolean preInputText(final boolean multiline, final String label, final String hint, final ImString text, final float width, final float height, final int flagsV, final ImGuiInputTextCallback callback) {
|
|
final ImString.InputData inputData = text.inputData;
|
|
int flags = flagsV;
|
|
|
|
if (inputData.isResizable) {
|
|
flags |= ImGuiInputTextFlags.CallbackResize;
|
|
}
|
|
|
|
if (!inputData.allowedChars.isEmpty()) {
|
|
flags |= ImGuiInputTextFlags.CallbackCharFilter;
|
|
}
|
|
|
|
String hintLabel = hint;
|
|
if (hintLabel == null) {
|
|
hintLabel = "";
|
|
}
|
|
|
|
return nInputText(multiline, hint != null, label, hintLabel, text, text.getData(), text.getData().length, width, height, flags, inputData, inputData.allowedChars, callback);
|
|
}
|
|
|
|
private static native boolean nInputText(boolean multiline, boolean hint, String label, String hintLabel, ImString imString, byte[] buf, int maxSize, float width, float height, int flags, ImString.InputData textInputData, String allowedChars, ImGuiInputTextCallback callback); /*
|
|
InputTextCallbackUserData userData;
|
|
userData.imString = &imString;
|
|
userData.maxSize = maxSize;
|
|
userData.jResizedBuf = NULL;
|
|
userData.resizedBuf = NULL;
|
|
userData.textInputData = &textInputData;
|
|
userData.env = env;
|
|
userData.allowedChars = allowedChars;
|
|
userData.handler = callback != NULL ? &callback : NULL;
|
|
|
|
bool valueChanged;
|
|
|
|
if (multiline) {
|
|
valueChanged = ImGui::InputTextMultiline(label, buf, maxSize, ImVec2(width, height), flags, &TextEditCallbackStub, &userData);
|
|
} else if (hint) {
|
|
valueChanged = ImGui::InputTextWithHint(label, hintLabel, buf, maxSize, flags, &TextEditCallbackStub, &userData);
|
|
} else {
|
|
valueChanged = ImGui::InputText(label, buf, maxSize, flags, &TextEditCallbackStub, &userData);
|
|
}
|
|
|
|
if (valueChanged) {
|
|
int size;
|
|
|
|
if (userData.jResizedBuf != NULL) {
|
|
size = strlen(userData.resizedBuf);
|
|
env->ReleasePrimitiveArrayCritical(userData.jResizedBuf, userData.resizedBuf, 0);
|
|
} else {
|
|
size = strlen(buf);
|
|
}
|
|
|
|
env->SetIntField(textInputData, inputDataSizeID, size);
|
|
env->SetBooleanField(textInputData, inputDataIsDirtyID, true);
|
|
}
|
|
|
|
return valueChanged;
|
|
*/
|
|
|
|
@BindingMethod
|
|
public static native boolean InputFloat(String label, ImFloat v, @OptArg float step, @OptArg float stepFast, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputFloat2(String label, float[] v, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputFloat3(String label, float[] v, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputFloat4(String label, float[] v, @OptArg(callValue = "\"%.3f\"") String format, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputInt(String label, ImInt v, @OptArg int step, @OptArg int stepFast, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputInt2(String label, int[] v, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputInt3(String label, int[] v, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputInt4(String label, int[] v, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputDouble(String label, ImDouble v, @OptArg double step, @OptArg double stepFast, @OptArg(callValue = "\"%.6f\"") String format, @OptArg int imGuiInputTextFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputScalar(String label,
|
|
@ArgVariant(name = {"ImGuiDataType_S16", "ImGuiDataType_S32", "ImGuiDataType_S64", "ImGuiDataType_Float", "ImGuiDataType_Double"}) Void __,
|
|
@ArgVariant(type = {"ImShort", "ImInt", "ImLong", "ImFloat", "ImDouble"}) Void pData,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStep,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStepFast,
|
|
@OptArg String format,
|
|
@OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputScalar(String label,
|
|
int dataType,
|
|
@ArgVariant(type = {"ImShort", "ImInt", "ImLong", "ImFloat", "ImDouble"}) Void pData,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStep,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStepFast,
|
|
@OptArg String format,
|
|
@OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputScalarN(String label,
|
|
@ArgVariant(name = {"ImGuiDataType_S16", "ImGuiDataType_S32", "ImGuiDataType_S64", "ImGuiDataType_Float", "ImGuiDataType_Double"}) Void __,
|
|
@ArgVariant(type = {"short[]", "int[]", "long[]", "float[]", "double[]"}) Void pData,
|
|
int components,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStep,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStepFast,
|
|
@OptArg String format,
|
|
@OptArg int imGuiSliderFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean InputScalarN(String label,
|
|
int dataType,
|
|
@ArgVariant(type = {"short[]", "int[]", "long[]", "float[]", "double[]"}) Void pData,
|
|
int components,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStep,
|
|
@ArgVariant(type = {"short", "int", "long", "float", "double"}) @OptArg @ArgValue(callPrefix = "&") Void pStepFast,
|
|
@OptArg String format,
|
|
@OptArg int imGuiSliderFlags);
|
|
|
|
// Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little color 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
|
|
|
|
@BindingMethod
|
|
public static native boolean ColorEdit3(String label, float[] col, @OptArg int imGuiColorEditFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean ColorEdit4(String label, float[] col, @OptArg int imGuiColorEditFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean ColorPicker3(String label, float[] col, @OptArg int imGuiColorEditFlags);
|
|
|
|
@BindingMethod
|
|
public static native boolean ColorPicker4(String label, float[] col, @OptArg(callValue = "0") int imGuiColorEditFlags, @OptArg float[] refCol);
|
|
|
|
/**
|
|
* Display a colored square/button, hover for details, return true when pressed.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ColorButton(String descId, ImVec4 col, @OptArg(callValue = "0") int imGuiColorEditFlags, @OptArg ImVec2 size);
|
|
|
|
/**
|
|
* Display a colored square/button, hover for details, return true when pressed.
|
|
*
|
|
* @deprecated use {@link #colorButton(String, ImVec4)} or {@link #colorButton(String, float, float, float, float)} instead
|
|
*/
|
|
@Deprecated
|
|
@BindingMethod
|
|
public static native boolean ColorButton(String descId, @ArgValue(callValue = "ImVec4(col[0], col[1], col[2], col[3])") float[] col, @OptArg(callValue = "0") int imGuiColorEditFlags, @OptArg ImVec2 size);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetColorEditOptions(int 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.
|
|
|
|
@BindingMethod
|
|
public static native boolean TreeNode(String 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().
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean TreeNode(String strId, String label, Void NULL);
|
|
|
|
@BindingMethod
|
|
public static native boolean TreeNode(@ArgValue(callPrefix = "(void*)") long ptrId, String label, Void NULL);
|
|
|
|
@BindingMethod
|
|
public static native boolean TreeNodeEx(String label, @OptArg int flags);
|
|
|
|
@BindingMethod
|
|
public static native boolean TreeNodeEx(String strId, int flags, String label, Void NULL);
|
|
|
|
@BindingMethod
|
|
public static native boolean TreeNodeEx(@ArgValue(callPrefix = "(void*)") long ptrId, int flags, String label, Void NULL);
|
|
|
|
/**
|
|
* ~ Indent()+PushId(). Already called by TreeNode() when returning true, but you can call TreePush/TreePop yourself if desired.
|
|
*/
|
|
@BindingMethod
|
|
public static native void TreePush(String strId);
|
|
|
|
/**
|
|
* ~ Indent()+PushId(). Already called by TreeNode() when returning true, but you can call TreePush/TreePop yourself if desired.
|
|
*/
|
|
@BindingMethod
|
|
public static native void TreePush(@OptArg @ArgValue(callPrefix = "(void*)") long ptrId);
|
|
|
|
/**
|
|
* ~ Unindent()+PopId()
|
|
*/
|
|
@BindingMethod
|
|
public static native void TreePop();
|
|
|
|
/**
|
|
* Horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetTreeNodeToLabelSpacing();
|
|
|
|
/**
|
|
* If returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean CollapsingHeader(String label, @OptArg int imGuiTreeNodeFlags);
|
|
|
|
/**
|
|
* When 'p_visible != NULL': if '*p_visible==true' display an additional small close button on upper right of the header which will set the bool
|
|
* to false when clicked, if '*p_visible==false' don't display the header.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean CollapsingHeader(String label, ImBoolean pVisible, @OptArg int imGuiTreeNodeFlags);
|
|
|
|
/**
|
|
* Set next TreeNode/CollapsingHeader open state.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextItemOpen(boolean isOpen, @OptArg int 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.
|
|
|
|
@BindingMethod
|
|
public static native boolean Selectable(String label, @OptArg(callValue = "false") boolean selected, @OptArg(callValue = "0") int imGuiSelectableFlags, @OptArg ImVec2 size);
|
|
|
|
@BindingMethod
|
|
public static native boolean Selectable(String label, ImBoolean pSelected, @OptArg(callValue = "0") int imGuiSelectableFlags, @OptArg ImVec2 size);
|
|
|
|
// Widgets: List Boxes
|
|
// - This is essentially a thin wrapper to using BeginChild/EndChild with some stylistic changes.
|
|
// - The BeginListBox()/EndListBox() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() or any items.
|
|
// - The simplified/old ListBox() api are helpers over BeginListBox()/EndListBox() which are kept available for convenience purpose. This is analoguous to how Combos are created.
|
|
// - Choose frame width: size.x > 0.0f: custom / size.x < 0.0f or -FLT_MIN: right-align / size.x = 0.0f (default): use current ItemWidth
|
|
// - Choose frame height: size.y > 0.0f: custom / size.y < 0.0f or -FLT_MIN: bottom-align / size.y = 0.0f (default): arbitrary default height which can fit ~7 items
|
|
|
|
/**
|
|
* Open a framed scrolling region.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginListBox(String label, @OptArg ImVec2 size);
|
|
|
|
/**
|
|
* Only call EndListBox() if BeginListBox() returned true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndListBox();
|
|
|
|
@BindingMethod
|
|
public static native void ListBox(String label, ImInt currentItem, String[] items, Void itemsCount, @OptArg int heightInItems);
|
|
|
|
// Widgets: Data Plotting
|
|
// - Consider using ImPlot (https://github.com/epezent/implot)
|
|
|
|
@BindingMethod
|
|
public static native void PlotLines(String label, float[] values, int valuesCount, @OptArg(callValue = "0") int valuesOffset, @OptArg(callValue = "NULL") String overlayText, @OptArg float scaleMin, @OptArg float scaleMax, @OptArg(callValue = "ImVec2(0,0)") ImVec2 graphSize, @OptArg int stride);
|
|
|
|
@BindingMethod
|
|
public static native void PlotHistogram(String label, float[] values, int valuesCount, @OptArg(callValue = "0") int valuesOffset, @OptArg(callValue = "NULL") String overlayText, @OptArg float scaleMin, @OptArg float scaleMax, @OptArg(callValue = "ImVec2(0,0)") ImVec2 graphSize, @OptArg int 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 void value(final String prefix, final Number value) {
|
|
nValue(prefix, value.toString());
|
|
}
|
|
|
|
public static void value(final String prefix, final float value, String floatFormat) {
|
|
nValue(prefix, String.format(floatFormat, value));
|
|
}
|
|
|
|
private static native void nValue(String prefix, String value); /*
|
|
ImGui::Value(prefix, value);
|
|
*/
|
|
|
|
// 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 and append to it.
|
|
// - Use BeginMenu() to create a menu. You can call BeginMenu() multiple time with the same identifier to append more items to it.
|
|
|
|
/**
|
|
* Append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window).
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginMenuBar();
|
|
|
|
/**
|
|
* Only call EndMenuBar() if BeginMenuBar() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndMenuBar();
|
|
|
|
/**
|
|
* Create and append to a full screen menu-bar.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginMainMenuBar();
|
|
|
|
/**
|
|
* Only call EndMainMenuBar() if BeginMainMenuBar() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndMainMenuBar();
|
|
|
|
/**
|
|
* Create a sub-menu entry. only call EndMenu() if this returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginMenu(String label, @OptArg boolean enabled);
|
|
|
|
/**
|
|
* Only call EndMenu() if BeginMenu() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndMenu();
|
|
|
|
/**
|
|
* Return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean MenuItem(String label, Void NULL, @OptArg boolean selected, @OptArg boolean enabled);
|
|
|
|
/**
|
|
* Return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean MenuItem(String label, String shortcut, @OptArg boolean selected, @OptArg boolean enabled);
|
|
|
|
/**
|
|
* Return true when activated + toggle (*pSelected) if pSelected != NULL
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean MenuItem(String label, String shortcut, ImBoolean pSelected, @OptArg boolean enabled);
|
|
|
|
// Tooltips
|
|
// - Tooltip are windows following the mouse. They do not take focus away.
|
|
|
|
/**
|
|
* Begin/append a tooltip window. to create full-featured tooltip (with any kind of items).
|
|
*/
|
|
@BindingMethod
|
|
public static native void BeginTooltip();
|
|
|
|
@BindingMethod
|
|
public static native void EndTooltip();
|
|
|
|
/**
|
|
* Set a text-only tooltip, typically use with ImGui::IsItemHovered(). override any previous call to SetTooltip().
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetTooltip(String text, Void NULL);
|
|
|
|
// Popups, Modals
|
|
// - They block normal mouse hovering detection (and therefore most mouse interactions) behind them.
|
|
// - If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.
|
|
// - Their visibility state (~bool) is held internally instead of being held by the programmer as we are used to with regular Begin*() calls.
|
|
// - The 3 properties above are related: we need to retain popup visibility state in the library because popups may be closed as any time.
|
|
// - You can bypass the hovering restriction by using ImGuiHoveredFlags_AllowWhenBlockedByPopup when calling IsItemHovered() or IsWindowHovered().
|
|
// - IMPORTANT: Popup identifiers are relative to the current ID stack, so OpenPopup and BeginPopup generally needs to be at the same level of the stack.
|
|
// This is sometimes leading to confusing mistakes. May rework this in the future.
|
|
// Popups: begin/end functions
|
|
// - BeginPopup(): query popup state, if open start appending into the window. Call EndPopup() afterwards. ImGuiWindowFlags are forwarded to the window.
|
|
// - BeginPopupModal(): block every interactions behind the window, cannot be closed by user, add a dimming background, has a title bar.
|
|
|
|
/**
|
|
* Return true if the popup is open, and you can start outputting to it.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginPopup(String strId, @OptArg int imGuiWindowFlags);
|
|
|
|
/**
|
|
* Return true if the popup is open, and you can start outputting to it.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginPopupModal(String name, @OptArg(callValue = "NULL") ImBoolean pOpen, @OptArg int imGuiWindowFlags);
|
|
|
|
/**
|
|
* Only call EndPopup() if BeginPopupXXX() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndPopup();
|
|
|
|
// Popups: open/close functions
|
|
// - OpenPopup(): set popup state to open. ImGuiPopupFlags are available for opening options.
|
|
// - If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.
|
|
// - CloseCurrentPopup(): use inside the BeginPopup()/EndPopup() scope to close manually.
|
|
// - CloseCurrentPopup() is called by default by Selectable()/MenuItem() when activated (FIXME: need some options).
|
|
// - Use ImGuiPopupFlags_NoOpenOverExistingPopup to avoid opening a popup if there's already one at the same level. This is equivalent to e.g. testing for !IsAnyPopupOpen() prior to OpenPopup().
|
|
|
|
/**
|
|
* Call to mark popup as open (don't call every frame!).
|
|
*/
|
|
@BindingMethod
|
|
public static native void OpenPopup(String strId, @OptArg int imGuiPopupFlags);
|
|
|
|
/**
|
|
* Id overload to facilitate calling from nested stacks.
|
|
*/
|
|
@BindingMethod
|
|
public static native void OpenPopup(@ArgValue(callPrefix = "(ImGuiID)") int id, @OptArg int imGuiPopupFlags);
|
|
|
|
/**
|
|
* Helper to open popup when clicked on last item. return true when just opened. (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors)
|
|
*/
|
|
@BindingMethod
|
|
public static native void OpenPopupOnItemClick(@OptArg(callValue = "NULL") String strId, @OptArg int imGuiPopupFlags);
|
|
|
|
/**
|
|
* Manually close the popup we have begin-ed into.
|
|
*/
|
|
@BindingMethod
|
|
public static native void CloseCurrentPopup();
|
|
|
|
// Popups: open+begin combined functions helpers
|
|
// - Helpers to do OpenPopup+BeginPopup where the Open action is triggered by e.g. hovering an item and right-clicking.
|
|
// - They are convenient to easily create context menus, hence the name.
|
|
// - IMPORTANT: Notice that BeginPopupContextXXX takes ImGuiPopupFlags just like OpenPopup() and unlike BeginPopup(). For full consistency, we may add ImGuiWindowFlags to the BeginPopupContextXXX functions in the future.
|
|
// - IMPORTANT: we exceptionally default their flags to 1 (== ImGuiPopupFlags_MouseButtonRight) for backward compatibility with older API taking 'int mouse_button = 1' parameter, so if you add other flags remember to re-add the ImGuiPopupFlags_MouseButtonRight.
|
|
|
|
/**
|
|
* Open+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!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginPopupContextItem(@OptArg(callValue = "NULL") String strId, @OptArg int imGuiPopupFlags);
|
|
|
|
/**
|
|
* Open+begin popup when clicked on current window.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginPopupContextWindow(@OptArg(callValue = "NULL") String strId, @OptArg int imGuiPopupFlags);
|
|
|
|
/**
|
|
* Open+begin popup when clicked in void (where there are no windows).
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginPopupContextVoid(@OptArg(callValue = "NULL") String strId, @OptArg int imGuiPopupFlags);
|
|
|
|
// Popups: test function
|
|
// - IsPopupOpen(): return true if the popup is open at the current BeginPopup() level of the popup stack.
|
|
// - IsPopupOpen() with ImGuiPopupFlags_AnyPopupId: return true if any popup is open at the current BeginPopup() level of the popup stack.
|
|
// - IsPopupOpen() with ImGuiPopupFlags_AnyPopupId + ImGuiPopupFlags_AnyPopupLevel: return true if any popup is open.
|
|
|
|
/**
|
|
* Return true if the popup is open.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsPopupOpen(String strId, @OptArg int imGuiPopupFlags);
|
|
|
|
// Tables
|
|
// [BETA API] API may evolve slightly! If you use this, please update to the next version when it comes out!
|
|
// - Full-featured replacement for old Columns API.
|
|
// - See Demo->Tables for demo code.
|
|
// - See top of imgui_tables.cpp for general commentary.
|
|
// - See ImGuiTableFlags_ and ImGuiTableColumnFlags_ enums for a description of available flags.
|
|
// The typical call flow is:
|
|
// - 1. Call BeginTable().
|
|
// - 2. Optionally call TableSetupColumn() to submit column name/flags/defaults.
|
|
// - 3. Optionally call TableSetupScrollFreeze() to request scroll freezing of columns/rows.
|
|
// - 4. Optionally call TableHeadersRow() to submit a header row. Names are pulled from TableSetupColumn() data.
|
|
// - 5. Populate contents:
|
|
// - In most situations you can use TableNextRow() + TableSetColumnIndex(N) to start appending into a column.
|
|
// - If you are using tables as a sort of grid, where every columns is holding the same type of contents,
|
|
// you may prefer using TableNextColumn() instead of TableNextRow() + TableSetColumnIndex().
|
|
// TableNextColumn() will automatically wrap-around into the next row if needed.
|
|
// - IMPORTANT: Comparatively to the old Columns() API, we need to call TableNextColumn() for the first column!
|
|
// - Summary of possible call flow:
|
|
// --------------------------------------------------------------------------------------------------------
|
|
// TableNextRow() -> TableSetColumnIndex(0) -> Text("Hello 0") -> TableSetColumnIndex(1) -> Text("Hello 1") // OK
|
|
// TableNextRow() -> TableNextColumn() -> Text("Hello 0") -> TableNextColumn() -> Text("Hello 1") // OK
|
|
// TableNextColumn() -> Text("Hello 0") -> TableNextColumn() -> Text("Hello 1") // OK: TableNextColumn() automatically gets to next row!
|
|
// TableNextRow() -> Text("Hello 0") // Not OK! Missing TableSetColumnIndex() or TableNextColumn()! Text will not appear!
|
|
// --------------------------------------------------------------------------------------------------------
|
|
// - 5. Call EndTable()
|
|
|
|
@BindingMethod
|
|
public static native boolean BeginTable(String id, int column, @OptArg(callValue = "0") int imGuiTableFlags, @OptArg(callValue = "ImVec2(0,0)") ImVec2 outerSize, @OptArg float innerWidth);
|
|
|
|
/**
|
|
* Only call EndTable() if BeginTable() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndTable();
|
|
|
|
/**
|
|
* Append into the first cell of a new row.
|
|
*/
|
|
@BindingMethod
|
|
public static native void TableNextRow(@OptArg(callValue = "0") int imGuiTableRowFlags, @OptArg float minRowHeight);
|
|
|
|
/**
|
|
* Append into the next column (or first column of next row if currently in last column). Return true when column is visible.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean TableNextColumn();
|
|
|
|
/**
|
|
* Append into the specified column. Return true when column is visible.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean TableSetColumnIndex(int columnN);
|
|
|
|
// Tables: Headers & Columns declaration
|
|
// - Use TableSetupColumn() to specify label, resizing policy, default width/weight, id, various other flags etc.
|
|
// - Use TableHeadersRow() to create a header row and automatically submit a TableHeader() for each column.
|
|
// Headers are required to perform: reordering, sorting, and opening the context menu.
|
|
// The context menu can also be made available in columns body using ImGuiTableFlags_ContextMenuInBody.
|
|
// - You may manually submit headers using TableNextRow() + TableHeader() calls, but this is only useful in
|
|
// some advanced use cases (e.g. adding custom widgets in header row).
|
|
// - Use TableSetupScrollFreeze() to lock columns/rows so they stay visible when scrolled.
|
|
|
|
@BindingMethod
|
|
public static native void TableSetupColumn(String label, @OptArg(callValue = "0") int imGuiTableColumnFlags, @OptArg(callValue = "0.0f") float initWidthOrWeight, @OptArg int userId);
|
|
|
|
/**
|
|
* Lock columns/rows so they stay visible when scrolled.
|
|
*/
|
|
@BindingMethod
|
|
public static native void TableSetupScrollFreeze(int cols, int rows);
|
|
|
|
/**
|
|
* Submit all headers cells based on data provided to TableSetupColumn() + submit context menu
|
|
*/
|
|
@BindingMethod
|
|
public static native void TableHeadersRow();
|
|
|
|
/**
|
|
* Submit one header cell manually (rarely used)
|
|
*/
|
|
@BindingMethod
|
|
public static native void TableHeader(String label);
|
|
|
|
// Tables: Sorting
|
|
// - Call TableGetSortSpecs() to retrieve latest sort specs for the table. NULL when not sorting.
|
|
// - When 'SpecsDirty == true' you should sort your data. It will be true when sorting specs have changed
|
|
// since last call, or the first time. Make sure to set 'SpecsDirty = false' after sorting, else you may
|
|
// wastefully sort your data every frame!
|
|
// - Lifetime: don't hold on this pointer over multiple frames or past any subsequent call to BeginTable().
|
|
|
|
@BindingMethod
|
|
public static native ImGuiTableSortSpecs TableGetSortSpecs();
|
|
|
|
// Tables: Miscellaneous functions
|
|
// - Functions args 'int column_n' treat the default value of -1 as the same as passing the current column index.
|
|
|
|
/**
|
|
* Return number of columns (value passed to BeginTable).
|
|
*/
|
|
@BindingMethod
|
|
public static native int TableGetColumnCount();
|
|
|
|
/**
|
|
* Return current column index.
|
|
*/
|
|
@BindingMethod
|
|
public static native int TableGetColumnIndex();
|
|
|
|
/**
|
|
* Return current row index.
|
|
*/
|
|
@BindingMethod
|
|
public static native int TableGetRowIndex();
|
|
|
|
/**
|
|
* Return "" if column didn't have a name declared by TableSetupColumn(). Pass -1 to use current column.
|
|
*/
|
|
@BindingMethod
|
|
public static native String TableGetColumnName(@OptArg int columnN);
|
|
|
|
/**
|
|
* Return column flags, so you can query their Enabled/Visible/Sorted/Hovered status flags. Pass -1 to use current column.
|
|
*/
|
|
@BindingMethod
|
|
public static native int TableGetColumnFlags(@OptArg int columnN);
|
|
|
|
/**
|
|
* change user accessible enabled/disabled state of a column. Set to false to hide the column.
|
|
* User can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)
|
|
*/
|
|
@BindingMethod
|
|
public static native void TableSetColumnEnabled(int columnN, boolean value);
|
|
|
|
/**
|
|
* Change the color of a cell, row, or column. See ImGuiTableBgTarget_ flags for details.
|
|
*/
|
|
@BindingMethod
|
|
public static native void TableSetBgColor(int imGuiTableBgTarget, int color, @OptArg int columnN);
|
|
|
|
// Legacy Columns API (2020: prefer using Tables!)
|
|
// Columns
|
|
// - You can also use SameLine(posX) to mimic simplified columns.
|
|
|
|
@BindingMethod
|
|
public static native void Columns(@OptArg(callValue = "1") int count, @OptArg(callValue = "NULL") String id, @OptArg boolean border);
|
|
|
|
/**
|
|
* Next column, defaults to current row or next row if the current row is finished
|
|
*/
|
|
@BindingMethod
|
|
public static native void NextColumn();
|
|
|
|
/**
|
|
* Get current column index
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetColumnIndex();
|
|
|
|
/**
|
|
* Get column width (in pixels). pass -1 to use current column
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetColumnWidth(@OptArg int columnIndex);
|
|
|
|
/**
|
|
* Set column width (in pixels). pass -1 to use current column
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetColumnWidth(int columnIndex, float 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
|
|
*/
|
|
@BindingMethod
|
|
public static native float GetColumnOffset(@OptArg int columnIndex);
|
|
|
|
/**
|
|
* Set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetColumnOffset(int columnIndex, float offsetX);
|
|
|
|
@BindingMethod
|
|
public static native int GetColumnsCount();
|
|
|
|
// Tab Bars, Tabs
|
|
// Note: Tabs are automatically created by the docking system. Use this to create tab bars/tabs yourself without docking being involved.
|
|
|
|
/**
|
|
* Create and append into a TabBar
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginTabBar(String strId, @OptArg int imGuiTabBarFlags);
|
|
|
|
/**
|
|
* Only call EndTabBar() if BeginTabBar() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndTabBar();
|
|
|
|
/**
|
|
* Create a Tab. Returns true if the Tab is selected.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginTabItem(String label, @OptArg(callValue = "NULL") ImBoolean pOpen, @OptArg int imGuiTabItemFlags);
|
|
|
|
/**
|
|
* Only call EndTabItem() if BeginTabItem() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndTabItem();
|
|
|
|
/**
|
|
* Create a Tab behaving like a button. return true when clicked. cannot be selected in the tab bar.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean TabItemButton(String label, @OptArg int imGuiTabItemFlags);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetTabItemClosed(String tabOrDockedWindowLabel);
|
|
|
|
// Docking
|
|
// [BETA API] Enable with io.ConfigFlags |= ImGuiConfigFlags_DockingEnable.
|
|
// Note: You can use most Docking facilities without calling any API. You DO NOT need to call DockSpace() to use Docking!
|
|
// - To dock windows: if io.ConfigDockingWithShift == false (default) drag window from their title bar.
|
|
// - To dock windows: if io.ConfigDockingWithShift == true: hold SHIFT anywhere while moving windows.
|
|
// About DockSpace:
|
|
// - Use DockSpace() to create an explicit dock node _within_ an existing window. See Docking demo for details.
|
|
// - DockSpace() needs to be submitted _before_ any window they can host. If you use a dockspace, submit it early in your app.
|
|
|
|
@BindingMethod
|
|
public static native int DockSpace(int imGuiID, @OptArg(callValue = "ImVec2(0,0)") ImVec2 size, @OptArg(callValue = "0") int imGuiDockNodeFlags, @OptArg ImGuiWindowClass windowClass);
|
|
|
|
@BindingMethod
|
|
public static native int DockSpaceOverViewport(@OptArg ImGuiViewport viewport, @OptArg(callValue = "0") int imGuiDockNodeFlags, @OptArg ImGuiWindowClass windowClass);
|
|
|
|
/**
|
|
* Set next window dock id
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowDockID(int dockId, @OptArg int imGuiCond);
|
|
|
|
/**
|
|
* set next window class (rare/advanced uses: provide hints to the platform backend via altered viewport flags and parent/child info)
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextWindowClass(ImGuiWindowClass windowClass);
|
|
|
|
@BindingMethod
|
|
public static native int GetWindowDockID();
|
|
|
|
/**
|
|
* Is current window docked into another window?
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsWindowDocked();
|
|
|
|
// 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)
|
|
*/
|
|
@BindingMethod
|
|
public static native void LogToTTY(@OptArg int autoOpenDepth);
|
|
|
|
/**
|
|
* Start logging to file
|
|
*/
|
|
@BindingMethod
|
|
public static native void LogToFile(@OptArg(callValue = "-1") int autoOpenDepth, @OptArg String filename);
|
|
|
|
/**
|
|
* Start logging to OS clipboard
|
|
*/
|
|
@BindingMethod
|
|
public static native void LogToClipboard(@OptArg int autoOpenDepth);
|
|
|
|
/**
|
|
* Stop logging (close file, etc.)
|
|
*/
|
|
@BindingMethod
|
|
public static native void LogFinish();
|
|
|
|
/**
|
|
* Helper to display buttons for logging to tty/file/clipboard
|
|
*/
|
|
@BindingMethod
|
|
public static native void LogButtons();
|
|
|
|
/**
|
|
* Pass text data straight to log (without being displayed)
|
|
*/
|
|
@BindingMethod
|
|
public static native void LogText(String text, Void NULL);
|
|
|
|
// Drag and Drop
|
|
// - If you stop calling BeginDragDropSource() the payload is preserved however it won't have a preview tooltip (we currently display a fallback "..." tooltip as replacement)
|
|
|
|
/**
|
|
* Call when the current item is active. If this return true, you can call SetDragDropPayload() + EndDragDropSource()
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropSource(@OptArg int imGuiDragDropFlags);
|
|
|
|
private static WeakReference<Object> payloadRef = null;
|
|
private static final byte[] PAYLOAD_PLACEHOLDER_DATA = new byte[1];
|
|
|
|
/**
|
|
* Type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types.
|
|
* <p>
|
|
* BINDING NOTICE:
|
|
* Method adopted for Java, so objects are used instead of raw bytes.
|
|
* Binding stores a reference to the object in a form of {@link WeakReference}.
|
|
*/
|
|
public static boolean setDragDropPayload(final String dataType, final Object payload) {
|
|
return setDragDropPayload(dataType, payload, 0);
|
|
}
|
|
|
|
/**
|
|
* Type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types.
|
|
* <p>
|
|
* BINDING NOTICE:
|
|
* Method adopted for Java, so objects are used instead of raw bytes.
|
|
* Binding stores a reference to the object in a form of {@link WeakReference}.
|
|
*/
|
|
public static boolean setDragDropPayload(final String dataType, final Object payload, final int imGuiCond) {
|
|
if (payloadRef == null || payloadRef.get() != payload) {
|
|
payloadRef = new WeakReference<>(payload);
|
|
}
|
|
return nSetDragDropPayload(dataType, PAYLOAD_PLACEHOLDER_DATA, 1, imGuiCond);
|
|
}
|
|
|
|
/**
|
|
* Binding alternative for {@link #setDragDropPayload(String, Object)}, which uses payload class as a unique identifier.
|
|
*/
|
|
public static boolean setDragDropPayload(final Object payload) {
|
|
return setDragDropPayload(payload, 0);
|
|
}
|
|
|
|
/**
|
|
* Binding alternative for {@link #setDragDropPayload(String, Object, int)}, which uses payload class as a unique identifier.
|
|
*/
|
|
public static boolean setDragDropPayload(final Object payload, final int imGuiCond) {
|
|
return setDragDropPayload(String.valueOf(payload.getClass().hashCode()), payload, imGuiCond);
|
|
}
|
|
|
|
private static native boolean nSetDragDropPayload(String dataType, byte[] data, int sz, int imGuiCond); /*
|
|
return ImGui::SetDragDropPayload(dataType, &data[0], sz, imGuiCond);
|
|
*/
|
|
|
|
/**
|
|
* Only call EndDragDropSource() if BeginDragDropSource() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndDragDropSource();
|
|
|
|
/**
|
|
* Call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget()
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean 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 <T> T acceptDragDropPayload(final String dataType) {
|
|
return acceptDragDropPayload(dataType, ImGuiDragDropFlags.None);
|
|
}
|
|
|
|
/**
|
|
* Type safe alternative for {@link #acceptDragDropPayload(String)}, since it checks assignability of the accepted class.
|
|
*/
|
|
public static <T> T acceptDragDropPayload(final String dataType, final Class<T> aClass) {
|
|
return acceptDragDropPayload(dataType, ImGuiDragDropFlags.None, aClass);
|
|
}
|
|
|
|
/**
|
|
* 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 <T> T acceptDragDropPayload(final String dataType, final int imGuiDragDropFlags) {
|
|
return acceptDragDropPayload(dataType, imGuiDragDropFlags, null);
|
|
}
|
|
|
|
/**
|
|
* Type safe alternative for {@link #acceptDragDropPayload(String, int)}, since it checks assignability of the accepted class.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static <T> T acceptDragDropPayload(final String dataType, final int imGuiDragDropFlags, final Class<T> aClass) {
|
|
if (payloadRef != null && nAcceptDragDropPayload(dataType, imGuiDragDropFlags)) {
|
|
final Object rawPayload = payloadRef.get();
|
|
if (rawPayload != null) {
|
|
if (aClass == null || rawPayload.getClass().isAssignableFrom(aClass)) {
|
|
return (T) rawPayload;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Binding alternative for {@link #acceptDragDropPayload(String)}, which uses payload class as a unique identifier.
|
|
*/
|
|
public static <T> T acceptDragDropPayload(final Class<T> aClass) {
|
|
return acceptDragDropPayload(String.valueOf(aClass.hashCode()), ImGuiDragDropFlags.None, aClass);
|
|
}
|
|
|
|
/**
|
|
* Binding alternative for {@link #acceptDragDropPayload(String, int)}, which uses payload class as a unique identifier.
|
|
*/
|
|
public static <T> T acceptDragDropPayload(final Class<T> aClass, final int imGuiDragDropFlags) {
|
|
return acceptDragDropPayload(String.valueOf(aClass.hashCode()), imGuiDragDropFlags, aClass);
|
|
}
|
|
|
|
private static native boolean nAcceptDragDropPayload(String dataType, int imGuiDragDropFlags); /*
|
|
return ImGui::AcceptDragDropPayload(dataType, imGuiDragDropFlags) != NULL;
|
|
*/
|
|
|
|
/**
|
|
* Only call EndDragDropTarget() if BeginDragDropTarget() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndDragDropTarget();
|
|
|
|
/**
|
|
* Peek directly into the current payload from anywhere. May return NULL.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static <T> T getDragDropPayload() {
|
|
if (payloadRef != null && nHasDragDropPayload()) {
|
|
final Object rawPayload = payloadRef.get();
|
|
if (rawPayload != null) {
|
|
return (T) rawPayload;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Peek directly into the current payload from anywhere. May return NULL. Checks if payload has the same type as provided.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static <T> T getDragDropPayload(final String dataType) {
|
|
if (payloadRef != null && nHasDragDropPayload(dataType)) {
|
|
final Object rawPayload = payloadRef.get();
|
|
if (rawPayload != null) {
|
|
return (T) rawPayload;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Binding alternative for {@link #getDragDropPayload(String)}, which uses payload class as a unique identifier.
|
|
*/
|
|
public static <T> T getDragDropPayload(final Class<T> aClass) {
|
|
return getDragDropPayload(String.valueOf(aClass.hashCode()));
|
|
}
|
|
|
|
private static native boolean nHasDragDropPayload(); /*
|
|
const ImGuiPayload* payload = ImGui::GetDragDropPayload();
|
|
return payload != NULL && payload->Data != NULL;
|
|
*/
|
|
|
|
private static native boolean nHasDragDropPayload(String dataType); /*
|
|
const ImGuiPayload* payload = ImGui::GetDragDropPayload();
|
|
return payload != NULL && payload->IsDataType(dataType);
|
|
*/
|
|
|
|
/**
|
|
* Disable all user interactions and dim items visuals (applying style.DisabledAlpha over current colors)
|
|
* BeginDisabled(false) essentially does nothing useful but is provided to facilitate use of boolean expressions.
|
|
* If you can avoid calling BeginDisabled(False)/EndDisabled() best to avoid it.
|
|
*/
|
|
@BindingMethod
|
|
public static native void BeginDisabled(@OptArg boolean disabled);
|
|
|
|
@BindingMethod
|
|
public static native void EndDisabled();
|
|
|
|
// Clipping
|
|
// - Mouse hovering is affected by ImGui::PushClipRect() calls, unlike direct calls to ImDrawList::PushClipRect() which are render only.
|
|
|
|
@BindingMethod
|
|
public static native void PushClipRect(ImVec2 clipRectMin, ImVec2 clipRectMax, boolean intersectWithCurrentClipRect);
|
|
|
|
@BindingMethod
|
|
public static native void 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetKeyboardFocusHere(@OptArg int 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemHovered(@OptArg int 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)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemActive();
|
|
|
|
/**
|
|
* Is the last item focused for keyboard/gamepad navigation?
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemFocused();
|
|
|
|
/**
|
|
* Is the last item clicked? (e.g. button/node just clicked on) == {@code IsMouseClicked(mouseButton) && IsItemHovered()}
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemClicked(@OptArg int mouseButton);
|
|
|
|
/**
|
|
* Is the last item visible? (items may be out of sight because of clipping/scrolling)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemEdited();
|
|
|
|
/**
|
|
* Was the last item just made active (item was previously inactive).
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemActivated();
|
|
|
|
/**
|
|
* Was the last item just made inactive (item was previously active). Useful for Undo/Redo patterns with widgets that requires continuous editing.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean 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).
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemDeactivatedAfterEdit();
|
|
|
|
/**
|
|
* Was the last item open state toggled? set by TreeNode().
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsItemToggledOpen();
|
|
|
|
/**
|
|
* Is any item hovered?
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsAnyItemHovered();
|
|
|
|
/**
|
|
* Is any item active?
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsAnyItemActive();
|
|
/**
|
|
* Is any item focused?
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsAnyItemFocused();
|
|
|
|
/**
|
|
* Get upper-left bounding rectangle of the last item (screen space)
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetItemRectMin();
|
|
|
|
/**
|
|
* Get lower-right bounding rectangle of the last item (screen space)
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetItemRectMax();
|
|
|
|
/**
|
|
* Get size of last item
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetItemRectSize();
|
|
|
|
/**
|
|
* Allow last item to be overlapped by a subsequent item. sometimes useful with invisible buttons, selectables, etc. to catch unused area.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetItemAllowOverlap();
|
|
|
|
// Viewports
|
|
// - Currently represents the Platform Window created by the application which is hosting our Dear ImGui windows.
|
|
// - In 'docking' branch with multi-viewport enabled, we extend this concept to have multiple active viewports.
|
|
// - In the future we will extend this concept further to also represent Platform Monitor and support a "no main platform window" operation mode.
|
|
|
|
/**
|
|
* Return primary/default viewport.
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true)
|
|
public static native ImGuiViewport GetMainViewport();
|
|
|
|
// Miscellaneous Utilities
|
|
|
|
/**
|
|
* Test if rectangle (of given size, starting from cursor position) is visible / not clipped.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsRectVisible(ImVec2 size);
|
|
|
|
/**
|
|
* Test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsRectVisible(ImVec2 rectMin, ImVec2 rectMax);
|
|
|
|
/**
|
|
* Get global imgui time. incremented by io.DeltaTime every frame.
|
|
*/
|
|
@BindingMethod
|
|
public static native double GetTime();
|
|
|
|
/**
|
|
* Get global imgui frame count. incremented by 1 every frame.
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetFrameCount();
|
|
|
|
/**
|
|
* Get background draw list for the viewport associated to the current window.
|
|
* This draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImDrawList GetBackgroundDrawList(@OptArg ImGuiViewport viewport);
|
|
|
|
/**
|
|
* Get foreground draw list for the viewport associated to the current window.
|
|
* This draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImDrawList GetForegroundDrawList(@OptArg ImGuiViewport viewport);
|
|
|
|
// TODO GetDrawListSharedData
|
|
|
|
/**
|
|
* Get a string corresponding to the enum value (for display, saving, etc.).
|
|
*/
|
|
@BindingMethod
|
|
public static native String GetStyleColorName(int imGuiColIdx);
|
|
|
|
/**
|
|
* Replace current window storage with our own (if you want to manipulate it yourself, typically clear subsection of it).
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetStateStorage(final ImGuiStorage storage);
|
|
|
|
@BindingMethod
|
|
public static native ImGuiStorage GetStateStorage();
|
|
|
|
/**
|
|
* Helper to create a child window / scrolling region that looks like a normal widget frame
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginChildFrame(int id, ImVec2 size, @OptArg int imGuiWindowFlags);
|
|
|
|
/**
|
|
* Always call EndChildFrame() regardless of BeginChildFrame() return values (which indicates a collapsed/clipped window)
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndChildFrame();
|
|
|
|
// Text Utilities
|
|
|
|
@BindingMethod
|
|
public static native ImVec2 CalcTextSize(String text, Void NULL, @OptArg(callValue = "false") boolean hideTextAfterDoubleHash, @OptArg float wrapWidth);
|
|
|
|
// Color Utilities
|
|
|
|
@BindingMethod
|
|
public static native ImVec4 ColorConvertU32ToFloat4(final int in);
|
|
|
|
@BindingMethod
|
|
public static native int ColorConvertFloat4ToU32(ImVec4 in);
|
|
|
|
public static void colorConvertRGBtoHSV(float[] rgb, float[] hsv){
|
|
nColorConvertRGBtoHSV(rgb, hsv);
|
|
}
|
|
|
|
public static native void nColorConvertRGBtoHSV(float[] rgb, float[] hsv); /*
|
|
ImGui::ColorConvertRGBtoHSV(rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]);
|
|
*/
|
|
|
|
public static void colorConvertHSVtoRGB(float[] hsv, float[] rgb) {
|
|
nColorConvertHSVtoRGB(hsv, rgb);
|
|
}
|
|
|
|
public static native void nColorConvertHSVtoRGB(float[] hsv, float[] rgb); /*
|
|
ImGui::ColorConvertHSVtoRGB(hsv[0], hsv[1], hsv[2], rgb[0], rgb[1], rgb[2]);
|
|
*/
|
|
|
|
// Inputs Utilities: Keyboard
|
|
// Without IMGUI_DISABLE_OBSOLETE_KEYIO: (legacy support)
|
|
// - For 'ImGuiKey key' you can still use your legacy native/user indices according to how your backend/engine stored them in io.KeysDown[].
|
|
// With IMGUI_DISABLE_OBSOLETE_KEYIO: (this is the way forward)
|
|
// - Any use of 'ImGuiKey' will assert when key < 512 will be passed, previously reserved as native/user keys indices
|
|
// - GetKeyIndex() is pass-through and therefore deprecated (gone if IMGUI_DISABLE_OBSOLETE_KEYIO is defined)
|
|
|
|
/**
|
|
* Map ImGuiKey_* values into user's key index. == io.KeyMap[key]
|
|
*/
|
|
@BindingMethod
|
|
@Deprecated
|
|
public static native int GetKeyIndex(@ArgValue(staticCast = "ImGuiKey") int key);
|
|
|
|
/**
|
|
* Is key being held. == io.KeysDown[user_key_index].
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsKeyDown(@ArgValue(staticCast = "ImGuiKey") int key);
|
|
|
|
/**
|
|
* Was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsKeyPressed(@ArgValue(staticCast = "ImGuiKey") int key, @OptArg boolean repeat);
|
|
|
|
/**
|
|
* Was key released (went from Down to !Down)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsKeyReleased(@ArgValue(staticCast = "ImGuiKey") int key);
|
|
|
|
/**
|
|
* Uses provided repeat rate/delay.
|
|
* Return a count, most often 0 or 1 but might be {@code >1} if RepeatRate is small enough that {@code DeltaTime > RepeatRate}
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean GetKeyPressedAmount(@ArgValue(staticCast = "ImGuiKey") int key, float repeatDelay, float rate);
|
|
|
|
/**
|
|
* [DEBUG] returns English name of the key. Those names a provided for debugging purpose and are not meant to be saved persistently not compared.
|
|
*/
|
|
@BindingMethod
|
|
public static native String GetKeyName(@ArgValue(staticCast = "ImGuiKey") int key);
|
|
|
|
/**
|
|
* 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 = wantCaptureKeyboardValue"; after the next NewFrame() call.
|
|
*/
|
|
@BindingMethod
|
|
public static native void CaptureKeyboardFromApp(@OptArg boolean wantCaptureKeyboardValue);
|
|
|
|
// Inputs Utilities: Mouse
|
|
// - To refer to a mouse button, you may use named enums in your code e.g. ImGuiMouseButton_Left, ImGuiMouseButton_Right.
|
|
// - You can also use regular integer: it is forever guaranteed that 0=Left, 1=Right, 2=Middle.
|
|
// - Dragging operations are only reported after mouse has moved a certain distance away from the initial clicking position (see 'lock_threshold' and 'io.MouseDraggingThreshold')
|
|
|
|
/**
|
|
* Is mouse button held (0=left, 1=right, 2=middle)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMouseDown(int button);
|
|
|
|
/**
|
|
* Did mouse button clicked (went from !Down to Down) (0=left, 1=right, 2=middle)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMouseClicked(int button, @OptArg boolean repeat);
|
|
|
|
/**
|
|
* Did mouse button released (went from Down to !Down)
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMouseReleased(int button);
|
|
|
|
/**
|
|
* did mouse button double-clicked? (note that a double-click will also report IsMouseClicked() == true).
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMouseDoubleClicked(int button);
|
|
|
|
/**
|
|
* Return the number of successive mouse-clicks at the time where a click happen (otherwise 0).
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetMouseClickedCount(int button);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMouseHoveringRect(ImVec2 rMin, ImVec2 rMax, @OptArg boolean clip);
|
|
|
|
/**
|
|
* By convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMousePosValid(@OptArg @ArgValue(callPrefix = "&") final ImVec2 mousePos);
|
|
|
|
/**
|
|
* Is any mouse button held
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsAnyMouseDown();
|
|
|
|
/**
|
|
* Shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetMousePos();
|
|
|
|
/**
|
|
* Retrieve backup of mouse position at the time of opening popup we have BeginPopup() into
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetMousePosOnOpeningCurrentPopup();
|
|
|
|
/**
|
|
* Is mouse dragging. if lockThreshold {@code < -1.0f} uses io.MouseDraggingThreshold
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsMouseDragging(int button, @OptArg float lockThreshold);
|
|
|
|
/**
|
|
* 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 lockThreshold {@code < -1.0f} uses io.MouseDraggingThreshold.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetMouseDragDelta(@OptArg final int button, @OptArg final float lockThreshold);
|
|
|
|
@BindingMethod
|
|
public static native void ResetMouseDragDelta(@OptArg int 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
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetMouseCursor();
|
|
|
|
/**
|
|
* Set desired cursor type
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetMouseCursor(int type);
|
|
|
|
/**
|
|
* 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 = wantCaptureMouseValue;" after the next NewFrame() call.
|
|
*/
|
|
@BindingMethod
|
|
public static native void CaptureMouseFromApp(@OptArg boolean wantCaptureMouseValue);
|
|
|
|
// Clipboard Utilities
|
|
// - Also see the LogToClipboard() function to capture GUI into clipboard, or easily output text data to the clipboard.
|
|
|
|
@BindingMethod
|
|
public static native String GetClipboardText();
|
|
|
|
@BindingMethod
|
|
public static native void SetClipboardText(String text);
|
|
|
|
// 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).
|
|
*/
|
|
@BindingMethod
|
|
public static native void LoadIniSettingsFromDisk(String iniFilename);
|
|
|
|
/**
|
|
* Call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source.
|
|
*/
|
|
@BindingMethod
|
|
public static native void LoadIniSettingsFromMemory(String iniData, @OptArg int iniSize);
|
|
|
|
/**
|
|
* 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).
|
|
*/
|
|
@BindingMethod
|
|
public static native void SaveIniSettingsToDisk(String iniFilename);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@BindingMethod
|
|
public static native String SaveIniSettingsToMemory(@OptArg @ArgValue(callPrefix = "(size_t*)&") long outIniSize);
|
|
|
|
// Debug Utilities
|
|
// - This is used by the IMGUI_CHECKVERSION() macro.
|
|
|
|
@BindingMethod
|
|
public static native boolean DebugCheckVersionAndDataLayout(String versionStr, int szIo, int szStyle, int szVec2, int szVec4, int szDrawVert, int szDrawIdx);
|
|
|
|
// (Optional) Platform/OS interface for multi-viewport support
|
|
// Read comments around the ImGuiPlatformIO structure for more details.
|
|
// Note: You may use GetWindowViewport() to get the current viewport of the current window.
|
|
|
|
/**
|
|
* Platform/renderer functions, for backend to setup + viewports list.
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true, callPrefix = "&")
|
|
public static native ImGuiPlatformIO GetPlatformIO();
|
|
|
|
/**
|
|
* Call in main loop. Will call CreateWindow/ResizeWindow/etc. Platform functions for each secondary viewport, and DestroyWindow for each inactive viewport.
|
|
*/
|
|
@BindingMethod
|
|
public static native void UpdatePlatformWindows();
|
|
|
|
/**
|
|
* Call in main loop. will call RenderWindow/SwapBuffers platform functions for each secondary viewport which doesn't have the ImGuiViewportFlags_Minimized flag set.
|
|
* May be reimplemented by user for custom rendering needs.
|
|
*/
|
|
@BindingMethod
|
|
public static native void RenderPlatformWindowsDefault();
|
|
|
|
/**
|
|
* Call DestroyWindow platform functions for all viewports.
|
|
* Call from backend Shutdown() if you need to close platform windows before imgui shutdown.
|
|
* Otherwise will be called by DestroyContext().
|
|
*/
|
|
@BindingMethod
|
|
public static native void DestroyPlatformWindows();
|
|
|
|
/**
|
|
* This is a helper for backends.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImGuiViewport FindViewportByID(int imGuiID);
|
|
|
|
/**
|
|
* This is a helper for backends. The type platform_handle is decided by the backend (e.g. HWND, MyWindow*, GLFWwindow* etc.)
|
|
*/
|
|
@BindingMethod
|
|
public static native ImGuiViewport FindViewportByPlatformHandle(@ArgValue(callPrefix = "(void*)") long platformHandle);
|
|
}
|