SpaiR
8a8cd22ed6
A squash of hundreds of commits with a binding API generator. The API generator works with a hybrid model: 1. We define methods and fields in the code. 2. Mark them with API annotations. 3. For specific use cases, we use the old approach with JNI generation comments. There is also an API to generate an AST tree, which is saved to JSON. This JSON can be used for full API generation by declaring only field/method names. Currently, it is used to generate constants. By eyeballing, 95% of the API has been converted to the new approach. This is sufficient for the current moment. Only edge cases with specific API calls are left. fix: ambiguous call for ImGui::GetColorU32 build: disable checkstyle for imgui-binding module Since the module is heavily generated, checkstyle for it doesn't make sense. build: make buildSrc to use JDK 11 build: make generateApi optional when compiling project Initially generated module was not included to the project VCS. Since it's now in the separate src folder, we don't need to call generator every time. Only when a new generation result is required.
1978 lines
93 KiB
Java
1978 lines
93 KiB
Java
package imgui.extension.implot;
|
|
|
|
import imgui.ImDrawList;
|
|
import imgui.ImVec2;
|
|
import imgui.ImVec4;
|
|
import imgui.binding.annotation.ArgValue;
|
|
import imgui.binding.annotation.BindingMethod;
|
|
import imgui.binding.annotation.BindingSource;
|
|
import imgui.binding.annotation.OptArg;
|
|
import imgui.binding.annotation.ReturnValue;
|
|
import imgui.internal.ImGuiContext;
|
|
import imgui.type.ImBoolean;
|
|
import imgui.type.ImDouble;
|
|
import imgui.type.ImFloat;
|
|
|
|
@BindingSource
|
|
public final class ImPlot {
|
|
private ImPlot() {
|
|
}
|
|
|
|
/*JNI
|
|
#include "_implot.h"
|
|
*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ImPlot Context
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Creates a new ImPlot context. Call this after ImGui.createContext().
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotContext CreateContext();
|
|
|
|
/**
|
|
* Destroys an ImPlot context. Call this before ImGui.destroyContext(). NULL = destroy current context.
|
|
*/
|
|
@BindingMethod
|
|
public static native void DestroyContext(@OptArg ImPlotContext ctx);
|
|
|
|
/**
|
|
* Returns the current ImPlot context. NULL if no context has ben set.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotContext GetCurrentContext();
|
|
|
|
/**
|
|
* Sets the current ImPlot context.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetCurrentContext(ImPlotContext ctx);
|
|
|
|
@BindingMethod
|
|
public static native void SetImGuiContext(ImGuiContext ctx);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Begin/End Plot
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Starts a 2D plotting context. If this function returns true, EndPlot() MUST
|
|
// be called! You are encouraged to use the following convention:
|
|
//
|
|
// if (ImPlot.beginPlot(...)) {
|
|
// ImPlot.plotLine(...);
|
|
// ...
|
|
// ImPlot.endPlot();
|
|
// }
|
|
//
|
|
// Important notes:
|
|
//
|
|
// - #titleID must be unique to the current ImGui ID scope. If you need to avoid ID
|
|
// collisions or don't want to display a title in the plot, use double hashes
|
|
// (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
|
|
// - If #xLabel and/or #yLabel are provided, axes labels will be displayed.
|
|
// - #size is the **frame** size of the plot widget, not the plot area. The default
|
|
// size of plots (i.e. when ImVec2(0,0)) can be modified in your ImPlotStyle
|
|
// (default is 400x300 px).
|
|
// - Auxiliary y-axes must be enabled with ImPlotFlags_YAxis2/3 to be displayed.
|
|
// - See ImPlotFlags and ImPlotAxisFlags for more available options.
|
|
|
|
@BindingMethod
|
|
public static native boolean BeginPlot(String titleID,
|
|
@OptArg String xLabel,
|
|
@OptArg String yLabel,
|
|
@OptArg(callValue = "ImVec2(-1,0)") ImVec2 size,
|
|
@OptArg int flags,
|
|
@OptArg int xFlags,
|
|
@OptArg int yFlags,
|
|
@OptArg int y2Flags,
|
|
@OptArg int y3Flags,
|
|
@OptArg String y2Label,
|
|
@OptArg String y3Label);
|
|
|
|
/**
|
|
* Only call EndPlot() if beginPlot() returns true! Typically called at the end
|
|
* of an if statement conditioned on BeginPlot(). See example in beginPlot().
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndPlot();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Begin/EndSubplots
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Starts a subdivided plotting context. If the function returns true,
|
|
// EndSubplots() MUST be called! Call BeginPlot/EndPlot AT MOST [rows*cols]
|
|
// times in between the begining and end of the subplot context. Plots are
|
|
// added in row major order.
|
|
//
|
|
// Example:
|
|
//
|
|
// if (BeginSubplots("My Subplot",2,3,ImVec2(800,400)) {
|
|
// for (int i = 0; i < 6; ++i) {
|
|
// if (BeginPlot(...)) {
|
|
// ImPlot::PlotLine(...);
|
|
// ...
|
|
// EndPlot();
|
|
// }
|
|
// }
|
|
// EndSubplots();
|
|
// }
|
|
//
|
|
// Produces:
|
|
//
|
|
// [0][1][2]
|
|
// [3][4][5]
|
|
//
|
|
// Important notes:
|
|
//
|
|
// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
|
|
// collisions or don't want to display a title in the plot, use double hashes
|
|
// (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
|
|
// - #rows and #cols must be greater than 0.
|
|
// - #size is the size of the entire grid of subplots, not the individual plots
|
|
// - #row_ratios and #col_ratios must have AT LEAST #rows and #cols elements,
|
|
// respectively. These are the sizes of the rows and columns expressed in ratios.
|
|
// If the user adjusts the dimensions, the arrays are updated with new ratios.
|
|
//
|
|
// Important notes regarding BeginPlot from inside of BeginSubplots:
|
|
//
|
|
// - The #title_id parameter of _BeginPlot_ (see above) does NOT have to be
|
|
// unique when called inside of a subplot context. Subplot IDs are hashed
|
|
// for your convenience so you don't have call PushID or generate unique title
|
|
// strings. Simply pass an empty string to BeginPlot unless you want to title
|
|
// each subplot.
|
|
// - The #size parameter of _BeginPlot_ (see above) is ignored when inside of a
|
|
// subplot context. The actual size of the subplot will be based on the
|
|
// #size value you pass to _BeginSubplots_ and #row/#col_ratios if provided.
|
|
|
|
@BindingMethod
|
|
public static native boolean BeginSubplots(String titleID,
|
|
int rows,
|
|
int cols,
|
|
ImVec2 size,
|
|
@OptArg(callValue = "ImPlotSubplotFlags_None") int flags,
|
|
@OptArg float[] rowRatios,
|
|
@OptArg float[] colRatios);
|
|
|
|
/**
|
|
* Only call EndSubplots() if BeginSubplots() returns true! Typically called at the end
|
|
* of an if statement conditioned on BeginSublots(). See example above.
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndSubplots();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Plot Items
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*JNI
|
|
// For a proper type conversion, since C++ doesn't have a "long" type.
|
|
#define long ImS64
|
|
#define LEN(arg) (int)env->GetArrayLength(obj_##arg)
|
|
*/
|
|
|
|
// The template functions below are explicitly instantiated in implot_items.cpp.
|
|
// They are not intended to be used generically with custom types. You will get
|
|
// a linker error if you try! All functions support the following scalar types:
|
|
//
|
|
// float, double, ImS8, ImU8, ImS16, ImU16, ImS32, ImU32, ImS64, ImU64
|
|
//
|
|
//
|
|
// If you need to plot custom or non-homogenous data you have a few options:
|
|
//
|
|
// 1. If your data is a simple struct/class (e.g. Vector2f), you can use striding.
|
|
// This is the most performant option if applicable.
|
|
//
|
|
// struct Vector2f { float X, Y; };
|
|
// ...
|
|
// Vector2f data[42];
|
|
// ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, sizeof(Vector2f)); // or sizeof(float)*2
|
|
//
|
|
// 2. Write a custom getter C function or C++ lambda and pass it and optionally your data to
|
|
// an ImPlot function post-fixed with a G (e.g. PlotScatterG). This has a slight performance
|
|
// cost, but probably not enough to worry about unless your data is very large. Examples:
|
|
//
|
|
// ImPlotPoint MyDataGetter(void* data, int idx) {
|
|
// MyData* my_data = (MyData*)data;
|
|
// ImPlotPoint p;
|
|
// p.x = my_data->GetTime(idx);
|
|
// p.y = my_data->GetValue(idx);
|
|
// return p
|
|
// }
|
|
// ...
|
|
// auto my_lambda = [](void*, int idx) {
|
|
// double t = idx / 999.0;
|
|
// return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
|
|
// };
|
|
// ...
|
|
// if (ImPlot::BeginPlot("MyPlot")) {
|
|
// MyData my_data;
|
|
// ImPlot::PlotScatterG("scatter", MyDataGetter, &my_data, my_data.Size());
|
|
// ImPlot::PlotLineG("line", my_lambda, nullptr, 1000);
|
|
// ImPlot::EndPlot();
|
|
// }
|
|
//
|
|
// NB: All types are converted to double before plotting. You may lose information
|
|
// if you try plotting extremely large 64-bit integral types. Proceed with caution!
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D line plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotLine(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotScatter(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStairs(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
// xs,ys1,ys2
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, short[] xs, short[] ys1, short[] ys2, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, int[] xs, int[] ys1, int[] ys2, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, long[] xs, long[] ys1, long[] ys2, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, float[] xs, float[] ys1, float[] ys2, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotShaded(String labelId, double[] xs, double[] ys1, double[] ys2, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double width, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double width, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double width, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double width, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double width, @OptArg double shift, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void width, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a vertical bar graph. #width and #shift are in X units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBars(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void width, @OptArg int offset);
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double height, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double height, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double height, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double height, @OptArg double shift, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double height, @OptArg double shift, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, double height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a horizontal bar graph. #height and #shift are in Y units.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotBarsH(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @ArgValue(callValue = "0.67") Void height, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, short[] xs, short[] ys, short[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, int[] xs, int[] ys, int[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, long[] xs, long[] ys, long[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, float[] xs, float[] ys, float[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, double[] xs, double[] ys, double[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, short[] xs, short[] ys, short[] neg, short[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, int[] xs, int[] ys, int[] neg, int[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, long[] xs, long[] ys, long[] neg, long[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, float[] xs, float[] ys, float[] neg, float[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBars(String labelId, double[] xs, double[] ys, double[] neg, double[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, short[] xs, short[] ys, short[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, int[] xs, int[] ys, int[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, long[] xs, long[] ys, long[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, float[] xs, float[] ys, float[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, double[] xs, double[] ys, double[] err, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, short[] xs, short[] ys, short[] neg, short[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, int[] xs, int[] ys, int[] neg, int[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, long[] xs, long[] ys, long[] neg, long[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, float[] xs, float[] ys, float[] neg, float[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotErrorBarsH(String labelId, double[] xs, double[] ys, double[] neg, double[] pos, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
// values
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, short[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, int[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, long[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, float[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, double[] values, @ArgValue(callValue = "LEN(values)") Void count, @OptArg double yRef, @OptArg double xscale, @OptArg double x0, @OptArg int offset);
|
|
|
|
// xs,ys
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots vertical stems.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotStems(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg double yRef, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotVLines(String labelId, short[] xs, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotVLines(String labelId, int[] xs, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotVLines(String labelId, long[] xs, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotVLines(String labelId, float[] xs, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotVLines(String labelId, double[] xs, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHLines(String labelId, short[] ys, @ArgValue(callValue = "LEN(ys)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHLines(String labelId, int[] ys, @ArgValue(callValue = "LEN(ys)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHLines(String labelId, long[] ys, @ArgValue(callValue = "LEN(ys)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHLines(String labelId, float[] ys, @ArgValue(callValue = "LEN(ys)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHLines(String labelId, double[] ys, @ArgValue(callValue = "LEN(ys)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots a pie chart. If the sum of values{@code >}1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotPieChart(String[] labelIds,
|
|
short[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
double x,
|
|
double y,
|
|
double radius,
|
|
@OptArg(callValue = "false") boolean normalize,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg double angle0);
|
|
|
|
/**
|
|
* Plots a pie chart. If the sum of values{@code >}1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotPieChart(String[] labelIds,
|
|
int[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
double x,
|
|
double y,
|
|
double radius,
|
|
@OptArg(callValue = "false") boolean normalize,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg double angle0);
|
|
|
|
/**
|
|
* Plots a pie chart. If the sum of values{@code >}1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotPieChart(String[] labelIds,
|
|
long[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
double x,
|
|
double y,
|
|
double radius,
|
|
@OptArg(callValue = "false") boolean normalize,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg double angle0);
|
|
|
|
/**
|
|
* Plots a pie chart. If the sum of values{@code >}1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotPieChart(String[] labelIds,
|
|
float[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
double x,
|
|
double y,
|
|
double radius,
|
|
@OptArg(callValue = "false") boolean normalize,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg double angle0);
|
|
|
|
/**
|
|
* Plots a pie chart. If the sum of values{@code >}1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotPieChart(String[] labelIds,
|
|
double[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
double x,
|
|
double y,
|
|
double radius,
|
|
@OptArg(callValue = "false") boolean normalize,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg double angle0);
|
|
|
|
/**
|
|
* Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHeatmap(String labelId,
|
|
short[] values,
|
|
int rows,
|
|
int cols,
|
|
@OptArg double scaleMin,
|
|
@OptArg double scaleMax,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg ImPlotPoint boundsMin,
|
|
@OptArg ImPlotPoint boundsMax);
|
|
|
|
/**
|
|
* Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHeatmap(String labelId,
|
|
int[] values,
|
|
int rows,
|
|
int cols,
|
|
@OptArg double scaleMin,
|
|
@OptArg double scaleMax,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg ImPlotPoint boundsMin,
|
|
@OptArg ImPlotPoint boundsMax);
|
|
|
|
/**
|
|
* Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHeatmap(String labelId,
|
|
long[] values,
|
|
int rows,
|
|
int cols,
|
|
@OptArg double scaleMin,
|
|
@OptArg double scaleMax,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg ImPlotPoint boundsMin,
|
|
@OptArg ImPlotPoint boundsMax);
|
|
|
|
/**
|
|
* Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHeatmap(String labelId,
|
|
float[] values,
|
|
int rows,
|
|
int cols,
|
|
@OptArg double scaleMin,
|
|
@OptArg double scaleMax,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg ImPlotPoint boundsMin,
|
|
@OptArg ImPlotPoint boundsMax);
|
|
|
|
/**
|
|
* Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotHeatmap(String labelId,
|
|
double[] values,
|
|
int rows,
|
|
int cols,
|
|
@OptArg double scaleMin,
|
|
@OptArg double scaleMax,
|
|
@OptArg(callValue = "\"%.1f\"") String labelFmt,
|
|
@OptArg ImPlotPoint boundsMin,
|
|
@OptArg ImPlotPoint boundsMax);
|
|
|
|
/**
|
|
* Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
|
|
* If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
|
|
* If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram(String labelId,
|
|
short[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
@OptArg(callValue = "ImPlotBin_Sturges") int bins,
|
|
@OptArg boolean cumulative,
|
|
@OptArg boolean density,
|
|
@OptArg(callValue = "ImPlotRange()") ImPlotRange range,
|
|
@OptArg(callValue = "true") boolean outliers,
|
|
@OptArg double barScale);
|
|
|
|
/**
|
|
* Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
|
|
* If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
|
|
* If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram(String labelId,
|
|
int[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
@OptArg(callValue = "ImPlotBin_Sturges") int bins,
|
|
@OptArg boolean cumulative,
|
|
@OptArg boolean density,
|
|
@OptArg(callValue = "ImPlotRange()") ImPlotRange range,
|
|
@OptArg(callValue = "true") boolean outliers,
|
|
@OptArg double barScale);
|
|
|
|
/**
|
|
* Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
|
|
* If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
|
|
* If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram(String labelId,
|
|
long[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
@OptArg(callValue = "ImPlotBin_Sturges") int bins,
|
|
@OptArg boolean cumulative,
|
|
@OptArg boolean density,
|
|
@OptArg(callValue = "ImPlotRange()") ImPlotRange range,
|
|
@OptArg(callValue = "true") boolean outliers,
|
|
@OptArg double barScale);
|
|
|
|
/**
|
|
* Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
|
|
* If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
|
|
* If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram(String labelId,
|
|
float[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
@OptArg(callValue = "ImPlotBin_Sturges") int bins,
|
|
@OptArg boolean cumulative,
|
|
@OptArg boolean density,
|
|
@OptArg(callValue = "ImPlotRange()") ImPlotRange range,
|
|
@OptArg(callValue = "true") boolean outliers,
|
|
@OptArg double barScale);
|
|
|
|
/**
|
|
* Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
|
|
* If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
|
|
* If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram(String labelId,
|
|
double[] values,
|
|
@ArgValue(callValue = "LEN(values)") Void count,
|
|
@OptArg(callValue = "ImPlotBin_Sturges") int bins,
|
|
@OptArg boolean cumulative,
|
|
@OptArg boolean density,
|
|
@OptArg(callValue = "ImPlotRange()") ImPlotRange range,
|
|
@OptArg(callValue = "true") boolean outliers,
|
|
@OptArg double barScale);
|
|
|
|
/**
|
|
* Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
|
|
* If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
|
|
* However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram2D(String labelId,
|
|
short[] xs,
|
|
short[] ys,
|
|
@ArgValue(callValue = "LEN(xs)") Void count,
|
|
@OptArg int xBins,
|
|
@OptArg int yBins,
|
|
@OptArg(callValue = "false") boolean density,
|
|
@OptArg(callValue = "ImPlotLimits()") ImPlotLimits range,
|
|
@OptArg boolean outliers);
|
|
|
|
/**
|
|
* Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
|
|
* If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
|
|
* However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram2D(String labelId,
|
|
int[] xs,
|
|
int[] ys,
|
|
@ArgValue(callValue = "LEN(xs)") Void count,
|
|
@OptArg int xBins,
|
|
@OptArg int yBins,
|
|
@OptArg(callValue = "false") boolean density,
|
|
@OptArg(callValue = "ImPlotLimits()") ImPlotLimits range,
|
|
@OptArg boolean outliers);
|
|
|
|
/**
|
|
* Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
|
|
* If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
|
|
* However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram2D(String labelId,
|
|
long[] xs,
|
|
long[] ys,
|
|
@ArgValue(callValue = "LEN(xs)") Void count,
|
|
@OptArg int xBins,
|
|
@OptArg int yBins,
|
|
@OptArg(callValue = "false") boolean density,
|
|
@OptArg(callValue = "ImPlotLimits()") ImPlotLimits range,
|
|
@OptArg boolean outliers);
|
|
|
|
/**
|
|
* Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
|
|
* If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
|
|
* However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram2D(String labelId,
|
|
float[] xs,
|
|
float[] ys,
|
|
@ArgValue(callValue = "LEN(xs)") Void count,
|
|
@OptArg int xBins,
|
|
@OptArg int yBins,
|
|
@OptArg(callValue = "false") boolean density,
|
|
@OptArg(callValue = "ImPlotLimits()") ImPlotLimits range,
|
|
@OptArg boolean outliers);
|
|
|
|
/**
|
|
* Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
|
|
* If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
|
|
* However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
|
|
*/
|
|
@BindingMethod
|
|
public static native double PlotHistogram2D(String labelId,
|
|
double[] xs,
|
|
double[] ys,
|
|
@ArgValue(callValue = "LEN(xs)") Void count,
|
|
@OptArg int xBins,
|
|
@OptArg int yBins,
|
|
@OptArg(callValue = "false") boolean density,
|
|
@OptArg(callValue = "ImPlotLimits()") ImPlotLimits range,
|
|
@OptArg boolean outliers);
|
|
|
|
/**
|
|
* Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotDigital(String labelId, short[] xs, short[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotDigital(String labelId, int[] xs, int[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotDigital(String labelId, long[] xs, long[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotDigital(String labelId, float[] xs, float[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotDigital(String labelId, double[] xs, double[] ys, @ArgValue(callValue = "LEN(xs)") Void count, @OptArg int offset);
|
|
|
|
/**
|
|
* Plots an axis-aligned image. #bounds_min/bounds_max are in plot coordinates (y-up) and #uv0/uv1 are in texture coordinates (y-down).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotImage(String labelId, @ArgValue(callPrefix = "(ImTextureID)(intptr_t)") int userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, @OptArg ImVec2 uv0, @OptArg ImVec2 uv1, @OptArg ImVec4 tintCol);
|
|
|
|
/**
|
|
* Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotText(String text, double x, double y, @OptArg(callValue = "false") boolean vertical, @OptArg ImVec2 pixOffset);
|
|
|
|
/**
|
|
* Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
|
|
*/
|
|
@BindingMethod
|
|
public static native void PlotDummy(String labelID);
|
|
|
|
/*JNI
|
|
#undef LEN
|
|
#undef long
|
|
*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Plot Utils
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotLimits(double xMin, double xMax, double yMin, double yMax, @OptArg int cond);
|
|
|
|
/**
|
|
* Set the X axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the X axis limits will be locked.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotLimitsX(double xMin, double xMax, @OptArg int cond);
|
|
|
|
/**
|
|
* Set the Y axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the Y axis limits will be locked.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotLimitsY(double yMin, double yMax, @OptArg int cond);
|
|
|
|
/**
|
|
* Links the next plot limits to external values. Set to NULL for no linkage. The pointer data must remain valid until the matching call to EndPlot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void LinkNextPlotLimits(ImDouble xMin, ImDouble xMax, ImDouble yMin, ImDouble yMax, @OptArg ImDouble yMin2, @OptArg ImDouble yMax2, @OptArg ImDouble yMin3, @OptArg ImDouble yMax3);
|
|
|
|
/**
|
|
* Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks).
|
|
*/
|
|
@BindingMethod
|
|
public static native void FitNextPlotAxes(@OptArg boolean x, @OptArg boolean y, @OptArg boolean y2, @OptArg boolean y3);
|
|
|
|
/**
|
|
* Set the X axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotTicksX(double[] values, int nTicks, @OptArg(callValue = "NULL") String[] labels, @OptArg boolean keepDefault);
|
|
|
|
/**
|
|
* Set the X axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotTicksX(double xMin, double xMax, int nTicks, @OptArg(callValue = "NULL") String[] labels, @OptArg boolean keepDefault);
|
|
|
|
/**
|
|
* Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotTicksY(double[] values, int nTicks, @OptArg(callValue = "NULL") String[] labels, @OptArg(callValue = "false") boolean keepDefault, @OptArg int yAxis);
|
|
|
|
/**
|
|
* Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotTicksY(double yMin, double yMax, int nTicks, @OptArg(callValue = "NULL") String[] labels, @OptArg(callValue = "false") boolean keepDefault, @OptArg int yAxis);
|
|
|
|
/**
|
|
* Set the format for numeric X axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.). Not applicable if ImPlotAxisFlags_Time enabled.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotFormatX(String fmt);
|
|
|
|
/**
|
|
* Set the format for numeric Y axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.).
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextPlotFormatY(String fmt, @OptArg int yAxis);
|
|
|
|
/**
|
|
* Select which Y axis will be used for subsequent plot elements. The default is ImPlotYAxis_1, or the first (left) Y axis. Enable 2nd and 3rd axes with ImPlotFlags_YAxisX.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetPlotYAxis(int yAxis);
|
|
|
|
/**
|
|
* Hides the next plot item. Use ImGuiCond.Always if you need to forcefully set this every frame (default ImGuiCond.Once).
|
|
*/
|
|
@BindingMethod
|
|
public static native void HideNextItem(@OptArg(callValue = "true") boolean hidden, @OptArg int cond);
|
|
|
|
/**
|
|
* Convert pixels to a position in the current plot's coordinate system. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotPoint PixelsToPlot(ImVec2 pix, @OptArg int yAxis);
|
|
|
|
/**
|
|
* Convert a position in the current plot's coordinate system to pixels. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 PlotToPixels(ImPlotPoint plt, @OptArg int yAxis);
|
|
|
|
/**
|
|
* Get the current Plot position (top-left) in pixels.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetPlotPos();
|
|
|
|
/**
|
|
* Get the current Plot size in pixels.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec2 GetPlotSize();
|
|
|
|
/**
|
|
* Returns true if the plot area in the current plot is hovered.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsPlotHovered();
|
|
|
|
/**
|
|
* Returns true if the XAxis plot area in the current plot is hovered.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsPlotXAxisHovered();
|
|
|
|
/**
|
|
* Returns true if the YAxis[n] plot area in the current plot is hovered.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsPlotYAxisHovered(@OptArg int yAxis);
|
|
|
|
/**
|
|
* Returns the mouse position in x,y coordinates of the current plot. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotPoint GetPlotMousePos(@OptArg int yAxis);
|
|
|
|
/**
|
|
* Returns the current plot axis range. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotLimits GetPlotLimits(@OptArg int yAxis);
|
|
|
|
/**
|
|
* Returns true if the current plot is being box selected.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsPlotSelected();
|
|
|
|
/**
|
|
* Returns the current plot box selection bounds.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotLimits GetPlotSelection(@OptArg int yAxis);
|
|
|
|
/**
|
|
* Returns true if the current plot is being queried or has an active query. Query must be enabled with ImPlotFlags_Query.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsPlotQueried();
|
|
|
|
/**
|
|
* Returns the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImPlotLimits GetPlotQuery(@OptArg int yAxis);
|
|
|
|
/**
|
|
* Set the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetPlotQuery(ImPlotLimits query, @OptArg int yAxis);
|
|
|
|
/**
|
|
* Returns true if the bounding frame of a subplot is hovered
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsSubplotsHovered();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Aligned Plots
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Consider using Begin/EndSubplots first. They are more feature rich and
|
|
// accomplish the same behaviour by default. The functions below offer lower
|
|
// level control of plot alignment.
|
|
|
|
/**
|
|
* Align axis padding over multiple plots in a single row or column. If this function returns true, EndAlignedPlots() must be called. #group_id must be unique.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginAlignedPlots(String groupId, @OptArg int orientation);
|
|
|
|
/**
|
|
* Only call EndAlignedPlots() if BeginAlignedPlots() returns true!
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndAlignedPlots();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Plot Tools
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Shows an annotation callout at a chosen point.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Annotate(double x, double y, ImVec2 pixOffset, String fmt, Void NULL);
|
|
|
|
/**
|
|
* Shows an annotation callout at a chosen point.
|
|
*/
|
|
@BindingMethod
|
|
public static native void Annotate(double x, double y, ImVec2 pixOffset, ImVec4 color, String fmt, Void NULL);
|
|
|
|
/**
|
|
* Same as above, but the annotation will always be clamped to stay inside the plot area.
|
|
*/
|
|
@BindingMethod
|
|
public static native void AnnotateClamped(double x, double y, ImVec2 pixOffset, String fmt, Void NULL);
|
|
|
|
/**
|
|
* Same as above, but the annotation will always be clamped to stay inside the plot area.
|
|
*/
|
|
@BindingMethod
|
|
public static native void AnnotateClamped(double x, double y, ImVec2 pixOffset, ImVec4 color, String fmt, Void NULL);
|
|
|
|
/**
|
|
* Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean DragLineX(String id, ImDouble xValue, @OptArg(callValue = "true") boolean showLabel, @OptArg(callValue = "IMPLOT_AUTO_COL") ImVec4 color, @OptArg float thickness);
|
|
|
|
/**
|
|
* Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean DragLineY(String id, ImDouble yValue, @OptArg(callValue = "true") boolean showLabel, @OptArg(callValue = "IMPLOT_AUTO_COL") ImVec4 color, @OptArg float thickness);
|
|
|
|
/**
|
|
* Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean DragPoint(String id, ImDouble x, ImDouble y, @OptArg(callValue = "true") boolean showLabel, @OptArg(callValue = "IMPLOT_AUTO_COL") ImVec4 color, @OptArg float radius);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Legend Utils and Tools
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Set the location of the current plot's legend
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetLegendLocation(int location, @OptArg(callValue = "ImPlotOrientation_Vertical") int orientation, @OptArg boolean outside);
|
|
|
|
/**
|
|
* Set the location of the current plot's mouse position text
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetMousePosLocation(int location);
|
|
|
|
/**
|
|
* Returns true if a plot item legend entry is hovered.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean IsLegendEntryHovered(String labelId);
|
|
|
|
/**
|
|
* Begin a popup for a legend entry.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginLegendPopup(String labelID, @OptArg int mouseButton);
|
|
|
|
/**
|
|
* End a popup for a legend entry.
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndLegendPopup();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Drag and Drop Utils
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropTarget();
|
|
|
|
/**
|
|
* Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropTargetX();
|
|
|
|
/**
|
|
* Turns the current plot's Y-Axis into a drag and drop target. Don't forget to call EndDragDropTarget!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropTargetY(@OptArg int yAxis);
|
|
|
|
/**
|
|
* Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropTargetLegend();
|
|
|
|
/**
|
|
* Ends a drag and drop target.
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndDragDropTarget();
|
|
|
|
// NB: By default, plot and axes drag and drop *sources* require holding the Ctrl modifier to initiate the drag.
|
|
// You can change the modifier if desired. If ImGuiKeyModFlags_None is provided, the axes will be locked from panning.
|
|
|
|
/**
|
|
* Turns the current plot's plotting area into a drag and drop source. Don't forget to call EndDragDropSource!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropSource(@OptArg int keyMods, @OptArg int dragDropFlags);
|
|
|
|
/**
|
|
* Turns the current plot's X-axis into a drag and drop source. Don't forget to call EndDragDropSource!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropSourceX(@OptArg int keyMods, @OptArg int dragDropFlags);
|
|
|
|
/**
|
|
* Turns the current plot's Y-axis into a drag and drop source. Don't forget to call EndDragDropSource!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropSourceY(@OptArg int yAxis, @OptArg int keyMods, @OptArg int dragDropFlags);
|
|
|
|
/**
|
|
* Turns an item in the current plot's legend into drag and drop source. Don't forget to call EndDragDropSource!
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean BeginDragDropSourceItem(String labelID, @OptArg int dragDropFlags);
|
|
|
|
/**
|
|
* Ends a drag and drop source.
|
|
*/
|
|
@BindingMethod
|
|
public static native void EndDragDropSource();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Plot and Item Styling
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Styling colors in ImPlot works similarly to styling colors in ImGui, but
|
|
// with one important difference. Like ImGui, all style colors are stored in an
|
|
// indexable array in ImPlotStyle. You can permanently modify these values through
|
|
// GetStyle().Colors, or temporarily modify them with Push/Pop functions below.
|
|
// However, by default all style colors in ImPlot default to a special color
|
|
// IMPLOT_AUTO_COL. The behavior of this color depends upon the style color to
|
|
// which it as applied:
|
|
//
|
|
// 1) For style colors associated with plot items (e.g. ImPlotCol_Line),
|
|
// IMPLOT_AUTO_COL tells ImPlot to color the item with the next unused
|
|
// color in the current colormap. Thus, every item will have a different
|
|
// color up to the number of colors in the colormap, at which point the
|
|
// colormap will roll over. For most use cases, you should not need to
|
|
// set these style colors to anything but IMPLOT_COL_AUTO; you are
|
|
// probably better off changing the current colormap. However, if you
|
|
// need to explicitly color a particular item you may either Push/Pop
|
|
// the style color around the item in question, or use the SetNextXXXStyle
|
|
// API below. If you permanently set one of these style colors to a specific
|
|
// color, or forget to call Pop, then all subsequent items will be styled
|
|
// with the color you set.
|
|
//
|
|
// 2) For style colors associated with plot styling (e.g. ImPlotCol_PlotBg),
|
|
// IMPLOT_AUTO_COL tells ImPlot to set that color from color data in your
|
|
// **ImGuiStyle**. The ImGuiCol_ that these style colors default to are
|
|
// detailed above, and in general have been mapped to produce plots visually
|
|
// consistent with your current ImGui style. Of course, you are free to
|
|
// manually set these colors to whatever you like, and further can Push/Pop
|
|
// them around individual plots for plot-specific styling (e.g. coloring axes).
|
|
|
|
/**
|
|
* Provides access to plot style structure for permanant modifications to colors, sizes, etc.
|
|
*/
|
|
@BindingMethod
|
|
@ReturnValue(isStatic = true, callPrefix = "&")
|
|
public static native ImPlotStyle GetStyle();
|
|
|
|
/**
|
|
* Style plot colors for current ImGui style (default).
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsAuto(@OptArg ImPlotStyle dst);
|
|
|
|
/**
|
|
* Style plot colors for ImGui "Classic".
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsClassic(@OptArg ImPlotStyle dst);
|
|
|
|
/**
|
|
* Style plot colors for ImGui "Dark".
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsDark(@OptArg ImPlotStyle dst);
|
|
|
|
/**
|
|
* Style plot colors for ImGui "Light".
|
|
*/
|
|
@BindingMethod
|
|
public static native void StyleColorsLight(@OptArg ImPlotStyle dst);
|
|
|
|
// Use PushStyleX to temporarily modify your ImPlotStyle. The modification
|
|
// will last until the matching call to PopStyleX. You MUST call a pop for
|
|
// every push, otherwise you will leak memory! This behaves just like ImGui.
|
|
|
|
/**
|
|
* Temporarily modify a style color. Don't forget to call PopStyleColor!
|
|
*/
|
|
public static native void pushStyleColor(int idx, long col); /*
|
|
ImPlot::PushStyleColor(idx, col);
|
|
*/
|
|
|
|
/**
|
|
* Temporarily modify a style color. Don't forget to call PopStyleColor!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleColor(int idx, @ArgValue(staticCast = "ImU32") int col);
|
|
|
|
/**
|
|
* Temporarily modify a style color. Don't forget to call PopStyleColor!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleColor(int idx, ImVec4 col);
|
|
|
|
@BindingMethod
|
|
public static native void PopStyleColor(@OptArg int count);
|
|
|
|
/**
|
|
* Temporarily modify a style variable of float type. Don't forget to call PopStyleVar!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleVar(int idx, @ArgValue(staticCast = "float") float val);
|
|
|
|
/**
|
|
* Temporarily modify a style variable of int type. Don't forget to call PopStyleVar!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleVar(int idx, @ArgValue(staticCast = "int") int val);
|
|
|
|
/**
|
|
* Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushStyleVar(int idx, ImVec2 val);
|
|
/**
|
|
* Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PopStyleVar(@OptArg int count);
|
|
|
|
/**
|
|
* Set the line color and weight for the next item only.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextLineStyle(@OptArg(callValue = "IMPLOT_AUTO_COL") ImVec4 col, @OptArg float weight);
|
|
|
|
/**
|
|
* Set the fill color for the next item only.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextFillStyle(@OptArg(callValue = "IMPLOT_AUTO_COL") ImVec4 col, @OptArg float alphaMod);
|
|
|
|
/**
|
|
* Set the marker style for the next item only.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextMarkerStyle(@OptArg int marker, @OptArg float size, @OptArg ImVec4 fill, @OptArg(callValue = "IMPLOT_AUTO") float weight, @OptArg ImVec4 outline);
|
|
|
|
/**
|
|
* Set the error bar style for the next item only.
|
|
*/
|
|
@BindingMethod
|
|
public static native void SetNextErrorBarStyle(@OptArg(callValue = "IMPLOT_AUTO_COL") ImVec4 col, @OptArg float size, @OptArg float weight);
|
|
|
|
/**
|
|
* Gets the last item primary color (i.e. its legend icon color)
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec4 GetLastItemColor();
|
|
|
|
/**
|
|
* Returns the string name for an ImPlotCol.
|
|
*/
|
|
@BindingMethod
|
|
public static native String GetStyleColorName(int idx);
|
|
|
|
/**
|
|
* Returns the null terminated string name for an ImPlotMarker.
|
|
*/
|
|
@BindingMethod
|
|
public static native String GetMarkerName(int idx);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Colormaps
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
|
|
// IMPLOT_AUTO_COL (default). Several built-in colormaps are available. You can
|
|
// add and then push/pop your own colormaps as well. To permanently set a colormap,
|
|
// modify the Colormap index member of your ImPlotStyle.
|
|
|
|
// Colormap data will be ignored and a custom color will be used if you have done one of the following:
|
|
// 1) Modified an item style color in your ImPlotStyle to anything other than IMPLOT_AUTO_COL.
|
|
// 2) Pushed an item style color using PushStyleColor().
|
|
// 3) Set the next item style with a SetNextXXXStyle function.
|
|
|
|
// Add a new colormap. The color data will be copied. The colormap can be used by pushing either the returned index or the
|
|
// string name with PushColormap. The colormap name must be unique and the size must be greater than 1. You will receive
|
|
// an assert otherwise! By default colormaps are considered to be qualitative (i.e. discrete). If you want to create a
|
|
// continuous colormap, set #qual=false. This will treat the colors you provide as keys, and ImPlot will build a linearly
|
|
// interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.
|
|
|
|
@BindingMethod
|
|
public static native int AddColormap(String name, ImVec4[] cols, @ArgValue(callValue = "env->GetArrayLength(obj_cols)") Void size, @OptArg boolean qual);
|
|
|
|
@BindingMethod
|
|
public static native int AddColormap(String name, @ArgValue(reinterpretCast = "ImU32*") int[] cols, @ArgValue(callValue = "env->GetArrayLength(obj_cols)") Void size, @OptArg boolean qual);
|
|
|
|
/**
|
|
* Returns the number of available colormaps (i.e. the built-in + user-added count).
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetColormapCount();
|
|
|
|
/**
|
|
* Returns a string name for a colormap given an index.
|
|
*/
|
|
@BindingMethod
|
|
public static native String GetColormapName(int cmap);
|
|
|
|
/**
|
|
* Returns an index number for a colormap given a valid string name. Returns -1 if the name is invalid.
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetColormapIndex(String name);
|
|
|
|
/**
|
|
* Temporarily switch to one of the built-in (i.e. ImPlotColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don't forget to call PopColormap!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushColormap(int cmap);
|
|
|
|
/**
|
|
* Push a colormap by string name. Use built-in names such as "Default", "Deep", "Jet", etc. or a string you provided to AddColormap. Don't forget to call PopColormap!
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushColormap(String name);
|
|
|
|
/**
|
|
* Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PopColormap(@OptArg int count);
|
|
|
|
/**
|
|
* Returns the next color from the current colormap and advances the colormap for the current plot.
|
|
* Can also be used with no return value to skip colors if desired. You need to call this between Begin/EndPlot!
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec4 NextColormapColor();
|
|
|
|
/**
|
|
* Returns the size of a colormap.
|
|
*/
|
|
@BindingMethod
|
|
public static native int GetColormapSize(@OptArg int cmap);
|
|
|
|
/**
|
|
* Returns a color from a colormap given an index {@code >=} 0 (modulo will be performed).
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec4 GetColormapColor(int idx, @OptArg int cmap);
|
|
|
|
/**
|
|
* Sample a color from a colormap given t between 0 and 1
|
|
*/
|
|
@BindingMethod
|
|
public static native ImVec4 SampleColormap(float t, @OptArg int cmap);
|
|
|
|
/**
|
|
* Shows a vertical color scale with linear spaced ticks using the specified color map. Use double hashes to hide label (e.g. "##NoLabel").
|
|
*/
|
|
@BindingMethod
|
|
public static native void ColormapScale(String label, double scaleMin, double scaleMax, @OptArg(callValue = "ImVec2(0,0)") ImVec2 size, @OptArg(callValue = "IMPLOT_AUTO") int cmap, @OptArg String fmt);
|
|
|
|
/**
|
|
* Shows a horizontal slider with a colormap gradient background.
|
|
* TODO: support our argument
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ColormapSlider(String label, ImFloat t, Void NULL, @OptArg(callValue = "\"\"") String format, @OptArg int cmap);
|
|
|
|
/**
|
|
* Shows a button with a colormap gradient brackground.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ColormapButton(String label, @OptArg(callValue = "ImVec2(0,0)") ImVec2 size, @OptArg int cmap);
|
|
|
|
/**
|
|
* When items in a plot sample their color from a colormap, the color is cached and does not change
|
|
* unless explicitly overriden. Therefore, if you change the colormap after the item has already been plotted,
|
|
* item colors will NOT update. If you need item colors to resample the new colormap, then use this
|
|
* function to bust the cached colors. If #plot_title_id is NULL, then every item in EVERY existing plot
|
|
* will be cache busted. Otherwise only the plot specified by #plot_title_id will be busted. For the
|
|
* latter, this function must be called in the same ImGui ID scope that the plot is in. You should rarely if ever
|
|
* need this function, but it is available for applications that require runtime colormap swaps (e.g. Heatmaps demo).
|
|
*/
|
|
@BindingMethod
|
|
public static native void BustColorCache(@OptArg String plotTitleId);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Miscellaneous
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Render icons similar to those that appear in legends (nifty for data lists).
|
|
|
|
@BindingMethod
|
|
public static native void ItemIcon(ImVec4 col);
|
|
|
|
@BindingMethod
|
|
public static native void ItemIcon(@ArgValue(staticCast = "ImU32") int col);
|
|
|
|
@BindingMethod
|
|
public static native void ColormapIcon(int cmap);
|
|
|
|
/**
|
|
* Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot.
|
|
*/
|
|
@BindingMethod
|
|
public static native ImDrawList GetPlotDrawList();
|
|
|
|
/**
|
|
* Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PushPlotClipRect(@OptArg float expand);
|
|
|
|
/**
|
|
* Pop plot clip rect. Call between Begin/EndPlot.
|
|
*/
|
|
@BindingMethod
|
|
public static native void PopPlotClipRect();
|
|
|
|
/**
|
|
* Shows ImPlot style selector dropdown menu.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ShowStyleSelector(String label);
|
|
|
|
/**
|
|
* Shows ImPlot colormap selector dropdown menu.
|
|
*/
|
|
@BindingMethod
|
|
public static native boolean ShowColormapSelector(String label);
|
|
|
|
/**
|
|
* Shows ImPlot style editor block (not a window).
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowStyleEditor(@OptArg ImPlotStyle ref);
|
|
|
|
/**
|
|
* Add basic help/info block for end users (not a window).
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowUserGuide();
|
|
|
|
/**
|
|
* Shows ImPlot metrics/debug information window.
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowMetricsWindow(@OptArg ImBoolean pOpen);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Demo
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Shows the ImPlot demo window.
|
|
*/
|
|
@BindingMethod
|
|
public static native void ShowDemoWindow(@OptArg ImBoolean pOpen);
|
|
}
|