1463 lines
43 KiB
Java
1463 lines
43 KiB
Java
package imgui;
|
|
|
|
import imgui.binding.ImGuiStructDestroyable;
|
|
|
|
/**
|
|
* You may modify the ImGui::GetStyle() main instance during initialization and before NewFrame().
|
|
* During the frame, use ImGui::PushStyleVar(ImGuiStyleVar_XXXX)/PopStyleVar() to alter the main style values,
|
|
* and ImGui::PushStyleColor(ImGuiCol_XXX)/PopStyleColor() for colors.
|
|
*/
|
|
public final class ImGuiStyle extends ImGuiStructDestroyable {
|
|
public ImGuiStyle() {
|
|
super();
|
|
}
|
|
|
|
public ImGuiStyle(final long ptr) {
|
|
super(ptr);
|
|
}
|
|
|
|
@Override
|
|
protected long create() {
|
|
return nCreate();
|
|
}
|
|
|
|
/*JNI
|
|
#include "_common.h"
|
|
#define THIS ((ImGuiStyle*)STRUCT_PTR)
|
|
*/
|
|
|
|
private native long nCreate(); /*
|
|
return (uintptr_t)(new ImGuiStyle());
|
|
*/
|
|
|
|
/**
|
|
* Global alpha applies to everything in Dear ImGui.
|
|
*/
|
|
public float getAlpha() {
|
|
return nGetAlpha();
|
|
}
|
|
|
|
/**
|
|
* Global alpha applies to everything in Dear ImGui.
|
|
*/
|
|
public void setAlpha(final float value) {
|
|
nSetAlpha(value);
|
|
}
|
|
|
|
private native float nGetAlpha(); /*
|
|
return THIS->Alpha;
|
|
*/
|
|
|
|
private native void nSetAlpha(float value); /*
|
|
THIS->Alpha = value;
|
|
*/
|
|
|
|
/**
|
|
* Additional alpha multiplier applied by BeginDisabled(). Multiply over current value of Alpha.
|
|
*/
|
|
public float getDisabledAlpha() {
|
|
return nGetDisabledAlpha();
|
|
}
|
|
|
|
/**
|
|
* Additional alpha multiplier applied by BeginDisabled(). Multiply over current value of Alpha.
|
|
*/
|
|
public void setDisabledAlpha(final float value) {
|
|
nSetDisabledAlpha(value);
|
|
}
|
|
|
|
private native float nGetDisabledAlpha(); /*
|
|
return THIS->DisabledAlpha;
|
|
*/
|
|
|
|
private native void nSetDisabledAlpha(float value); /*
|
|
THIS->DisabledAlpha = value;
|
|
*/
|
|
|
|
/**
|
|
* Padding within a window.
|
|
*/
|
|
public ImVec2 getWindowPadding() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetWindowPadding(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Padding within a window.
|
|
*/
|
|
public float getWindowPaddingX() {
|
|
return nGetWindowPaddingX();
|
|
}
|
|
|
|
/**
|
|
* Padding within a window.
|
|
*/
|
|
public float getWindowPaddingY() {
|
|
return nGetWindowPaddingY();
|
|
}
|
|
|
|
/**
|
|
* Padding within a window.
|
|
*/
|
|
public void getWindowPadding(final ImVec2 dst) {
|
|
nGetWindowPadding(dst);
|
|
}
|
|
|
|
/**
|
|
* Padding within a window.
|
|
*/
|
|
public void setWindowPadding(final ImVec2 value) {
|
|
nSetWindowPadding(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Padding within a window.
|
|
*/
|
|
public void setWindowPadding(final float valueX, final float valueY) {
|
|
nSetWindowPadding(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetWindowPadding(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->WindowPadding, dst);
|
|
*/
|
|
|
|
private native float nGetWindowPaddingX(); /*
|
|
return THIS->WindowPadding.x;
|
|
*/
|
|
|
|
private native float nGetWindowPaddingY(); /*
|
|
return THIS->WindowPadding.y;
|
|
*/
|
|
|
|
private native void nSetWindowPadding(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->WindowPadding = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of window corners rounding. Set to 0.0f to have rectangular windows.
|
|
* Large values tend to lead to variety of artifacts and are not recommended.
|
|
*/
|
|
public float getWindowRounding() {
|
|
return nGetWindowRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of window corners rounding. Set to 0.0f to have rectangular windows.
|
|
* Large values tend to lead to variety of artifacts and are not recommended.
|
|
*/
|
|
public void setWindowRounding(final float value) {
|
|
nSetWindowRounding(value);
|
|
}
|
|
|
|
private native float nGetWindowRounding(); /*
|
|
return THIS->WindowRounding;
|
|
*/
|
|
|
|
private native void nSetWindowRounding(float value); /*
|
|
THIS->WindowRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* Thickness of border around windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public float getWindowBorderSize() {
|
|
return nGetWindowBorderSize();
|
|
}
|
|
|
|
/**
|
|
* Thickness of border around windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public void setWindowBorderSize(final float value) {
|
|
nSetWindowBorderSize(value);
|
|
}
|
|
|
|
private native float nGetWindowBorderSize(); /*
|
|
return THIS->WindowBorderSize;
|
|
*/
|
|
|
|
private native void nSetWindowBorderSize(float value); /*
|
|
THIS->WindowBorderSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
|
|
*/
|
|
public ImVec2 getWindowMinSize() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetWindowMinSize(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
|
|
*/
|
|
public float getWindowMinSizeX() {
|
|
return nGetWindowMinSizeX();
|
|
}
|
|
|
|
/**
|
|
* Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
|
|
*/
|
|
public float getWindowMinSizeY() {
|
|
return nGetWindowMinSizeY();
|
|
}
|
|
|
|
/**
|
|
* Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
|
|
*/
|
|
public void getWindowMinSize(final ImVec2 dst) {
|
|
nGetWindowMinSize(dst);
|
|
}
|
|
|
|
/**
|
|
* Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
|
|
*/
|
|
public void setWindowMinSize(final ImVec2 value) {
|
|
nSetWindowMinSize(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
|
|
*/
|
|
public void setWindowMinSize(final float valueX, final float valueY) {
|
|
nSetWindowMinSize(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetWindowMinSize(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->WindowMinSize, dst);
|
|
*/
|
|
|
|
private native float nGetWindowMinSizeX(); /*
|
|
return THIS->WindowMinSize.x;
|
|
*/
|
|
|
|
private native float nGetWindowMinSizeY(); /*
|
|
return THIS->WindowMinSize.y;
|
|
*/
|
|
|
|
private native void nSetWindowMinSize(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->WindowMinSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
|
|
*/
|
|
public ImVec2 getWindowTitleAlign() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetWindowTitleAlign(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
|
|
*/
|
|
public float getWindowTitleAlignX() {
|
|
return nGetWindowTitleAlignX();
|
|
}
|
|
|
|
/**
|
|
* Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
|
|
*/
|
|
public float getWindowTitleAlignY() {
|
|
return nGetWindowTitleAlignY();
|
|
}
|
|
|
|
/**
|
|
* Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
|
|
*/
|
|
public void getWindowTitleAlign(final ImVec2 dst) {
|
|
nGetWindowTitleAlign(dst);
|
|
}
|
|
|
|
/**
|
|
* Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
|
|
*/
|
|
public void setWindowTitleAlign(final ImVec2 value) {
|
|
nSetWindowTitleAlign(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
|
|
*/
|
|
public void setWindowTitleAlign(final float valueX, final float valueY) {
|
|
nSetWindowTitleAlign(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetWindowTitleAlign(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->WindowTitleAlign, dst);
|
|
*/
|
|
|
|
private native float nGetWindowTitleAlignX(); /*
|
|
return THIS->WindowTitleAlign.x;
|
|
*/
|
|
|
|
private native float nGetWindowTitleAlignY(); /*
|
|
return THIS->WindowTitleAlign.y;
|
|
*/
|
|
|
|
private native void nSetWindowTitleAlign(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->WindowTitleAlign = value;
|
|
*/
|
|
|
|
/**
|
|
* Side of the collapsing/docking button in the title bar (None/Left/Right). Defaults to ImGuiDir_Left.
|
|
*/
|
|
public int getWindowMenuButtonPosition() {
|
|
return nGetWindowMenuButtonPosition();
|
|
}
|
|
|
|
/**
|
|
* Side of the collapsing/docking button in the title bar (None/Left/Right). Defaults to ImGuiDir_Left.
|
|
*/
|
|
public void setWindowMenuButtonPosition(final int value) {
|
|
nSetWindowMenuButtonPosition(value);
|
|
}
|
|
|
|
private native int nGetWindowMenuButtonPosition(); /*
|
|
return THIS->WindowMenuButtonPosition;
|
|
*/
|
|
|
|
private native void nSetWindowMenuButtonPosition(int value); /*
|
|
THIS->WindowMenuButtonPosition = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of child window corners rounding. Set to 0.0f to have rectangular windows.
|
|
*/
|
|
public float getChildRounding() {
|
|
return nGetChildRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of child window corners rounding. Set to 0.0f to have rectangular windows.
|
|
*/
|
|
public void setChildRounding(final float value) {
|
|
nSetChildRounding(value);
|
|
}
|
|
|
|
private native float nGetChildRounding(); /*
|
|
return THIS->ChildRounding;
|
|
*/
|
|
|
|
private native void nSetChildRounding(float value); /*
|
|
THIS->ChildRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* Thickness of border around child windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public float getChildBorderSize() {
|
|
return nGetChildBorderSize();
|
|
}
|
|
|
|
/**
|
|
* Thickness of border around child windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public void setChildBorderSize(final float value) {
|
|
nSetChildBorderSize(value);
|
|
}
|
|
|
|
private native float nGetChildBorderSize(); /*
|
|
return THIS->ChildBorderSize;
|
|
*/
|
|
|
|
private native void nSetChildBorderSize(float value); /*
|
|
THIS->ChildBorderSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of popup window corners rounding. (Note that tooltip windows use WindowRounding)
|
|
*/
|
|
public float getPopupRounding() {
|
|
return nGetPopupRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of popup window corners rounding. (Note that tooltip windows use WindowRounding)
|
|
*/
|
|
public void setPopupRounding(final float value) {
|
|
nSetPopupRounding(value);
|
|
}
|
|
|
|
private native float nGetPopupRounding(); /*
|
|
return THIS->PopupRounding;
|
|
*/
|
|
|
|
private native void nSetPopupRounding(float value); /*
|
|
THIS->PopupRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* Thickness of border around popup/tooltip windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public float getPopupBorderSize() {
|
|
return nGetPopupBorderSize();
|
|
}
|
|
|
|
/**
|
|
* Thickness of border around popup/tooltip windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public void setPopupBorderSize(final float value) {
|
|
nSetPopupBorderSize(value);
|
|
}
|
|
|
|
private native float nGetPopupBorderSize(); /*
|
|
return THIS->PopupBorderSize;
|
|
*/
|
|
|
|
private native void nSetPopupBorderSize(float value); /*
|
|
THIS->PopupBorderSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Padding within a framed rectangle (used by most widgets).
|
|
*/
|
|
public ImVec2 getFramePadding() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetFramePadding(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Padding within a framed rectangle (used by most widgets).
|
|
*/
|
|
public float getFramePaddingX() {
|
|
return nGetFramePaddingX();
|
|
}
|
|
|
|
/**
|
|
* Padding within a framed rectangle (used by most widgets).
|
|
*/
|
|
public float getFramePaddingY() {
|
|
return nGetFramePaddingY();
|
|
}
|
|
|
|
/**
|
|
* Padding within a framed rectangle (used by most widgets).
|
|
*/
|
|
public void getFramePadding(final ImVec2 dst) {
|
|
nGetFramePadding(dst);
|
|
}
|
|
|
|
/**
|
|
* Padding within a framed rectangle (used by most widgets).
|
|
*/
|
|
public void setFramePadding(final ImVec2 value) {
|
|
nSetFramePadding(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Padding within a framed rectangle (used by most widgets).
|
|
*/
|
|
public void setFramePadding(final float valueX, final float valueY) {
|
|
nSetFramePadding(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetFramePadding(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->FramePadding, dst);
|
|
*/
|
|
|
|
private native float nGetFramePaddingX(); /*
|
|
return THIS->FramePadding.x;
|
|
*/
|
|
|
|
private native float nGetFramePaddingY(); /*
|
|
return THIS->FramePadding.y;
|
|
*/
|
|
|
|
private native void nSetFramePadding(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->FramePadding = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
|
|
*/
|
|
public float getFrameRounding() {
|
|
return nGetFrameRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
|
|
*/
|
|
public void setFrameRounding(final float value) {
|
|
nSetFrameRounding(value);
|
|
}
|
|
|
|
private native float nGetFrameRounding(); /*
|
|
return THIS->FrameRounding;
|
|
*/
|
|
|
|
private native void nSetFrameRounding(float value); /*
|
|
THIS->FrameRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public float getFrameBorderSize() {
|
|
return nGetFrameBorderSize();
|
|
}
|
|
|
|
/**
|
|
* Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
|
|
*/
|
|
public void setFrameBorderSize(final float value) {
|
|
nSetFrameBorderSize(value);
|
|
}
|
|
|
|
private native float nGetFrameBorderSize(); /*
|
|
return THIS->FrameBorderSize;
|
|
*/
|
|
|
|
private native void nSetFrameBorderSize(float value); /*
|
|
THIS->FrameBorderSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between widgets/lines.
|
|
*/
|
|
public ImVec2 getItemSpacing() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetItemSpacing(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between widgets/lines.
|
|
*/
|
|
public float getItemSpacingX() {
|
|
return nGetItemSpacingX();
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between widgets/lines.
|
|
*/
|
|
public float getItemSpacingY() {
|
|
return nGetItemSpacingY();
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between widgets/lines.
|
|
*/
|
|
public void getItemSpacing(final ImVec2 dst) {
|
|
nGetItemSpacing(dst);
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between widgets/lines.
|
|
*/
|
|
public void setItemSpacing(final ImVec2 value) {
|
|
nSetItemSpacing(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between widgets/lines.
|
|
*/
|
|
public void setItemSpacing(final float valueX, final float valueY) {
|
|
nSetItemSpacing(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetItemSpacing(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->ItemSpacing, dst);
|
|
*/
|
|
|
|
private native float nGetItemSpacingX(); /*
|
|
return THIS->ItemSpacing.x;
|
|
*/
|
|
|
|
private native float nGetItemSpacingY(); /*
|
|
return THIS->ItemSpacing.y;
|
|
*/
|
|
|
|
private native void nSetItemSpacing(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->ItemSpacing = value;
|
|
*/
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
|
|
*/
|
|
public ImVec2 getItemInnerSpacing() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetItemInnerSpacing(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
|
|
*/
|
|
public float getItemInnerSpacingX() {
|
|
return nGetItemInnerSpacingX();
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
|
|
*/
|
|
public float getItemInnerSpacingY() {
|
|
return nGetItemInnerSpacingY();
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
|
|
*/
|
|
public void getItemInnerSpacing(final ImVec2 dst) {
|
|
nGetItemInnerSpacing(dst);
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
|
|
*/
|
|
public void setItemInnerSpacing(final ImVec2 value) {
|
|
nSetItemInnerSpacing(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
|
|
*/
|
|
public void setItemInnerSpacing(final float valueX, final float valueY) {
|
|
nSetItemInnerSpacing(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetItemInnerSpacing(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->ItemInnerSpacing, dst);
|
|
*/
|
|
|
|
private native float nGetItemInnerSpacingX(); /*
|
|
return THIS->ItemInnerSpacing.x;
|
|
*/
|
|
|
|
private native float nGetItemInnerSpacingY(); /*
|
|
return THIS->ItemInnerSpacing.y;
|
|
*/
|
|
|
|
private native void nSetItemInnerSpacing(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->ItemInnerSpacing = value;
|
|
*/
|
|
|
|
/**
|
|
* Padding within a table cell.
|
|
*/
|
|
public ImVec2 getCellPadding() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetCellPadding(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Padding within a table cell.
|
|
*/
|
|
public float getCellPaddingX() {
|
|
return nGetCellPaddingX();
|
|
}
|
|
|
|
/**
|
|
* Padding within a table cell.
|
|
*/
|
|
public float getCellPaddingY() {
|
|
return nGetCellPaddingY();
|
|
}
|
|
|
|
/**
|
|
* Padding within a table cell.
|
|
*/
|
|
public void getCellPadding(final ImVec2 dst) {
|
|
nGetCellPadding(dst);
|
|
}
|
|
|
|
/**
|
|
* Padding within a table cell.
|
|
*/
|
|
public void setCellPadding(final ImVec2 value) {
|
|
nSetCellPadding(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Padding within a table cell.
|
|
*/
|
|
public void setCellPadding(final float valueX, final float valueY) {
|
|
nSetCellPadding(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetCellPadding(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->CellPadding, dst);
|
|
*/
|
|
|
|
private native float nGetCellPaddingX(); /*
|
|
return THIS->CellPadding.x;
|
|
*/
|
|
|
|
private native float nGetCellPaddingY(); /*
|
|
return THIS->CellPadding.y;
|
|
*/
|
|
|
|
private native void nSetCellPadding(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->CellPadding = value;
|
|
*/
|
|
|
|
/**
|
|
* Expand reactive bounding box for touch-based system where touch position is not accurate enough.
|
|
* Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
|
|
*/
|
|
public ImVec2 getTouchExtraPadding() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetTouchExtraPadding(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Expand reactive bounding box for touch-based system where touch position is not accurate enough.
|
|
* Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
|
|
*/
|
|
public float getTouchExtraPaddingX() {
|
|
return nGetTouchExtraPaddingX();
|
|
}
|
|
|
|
/**
|
|
* Expand reactive bounding box for touch-based system where touch position is not accurate enough.
|
|
* Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
|
|
*/
|
|
public float getTouchExtraPaddingY() {
|
|
return nGetTouchExtraPaddingY();
|
|
}
|
|
|
|
/**
|
|
* Expand reactive bounding box for touch-based system where touch position is not accurate enough.
|
|
* Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
|
|
*/
|
|
public void getTouchExtraPadding(final ImVec2 dst) {
|
|
nGetTouchExtraPadding(dst);
|
|
}
|
|
|
|
/**
|
|
* Expand reactive bounding box for touch-based system where touch position is not accurate enough.
|
|
* Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
|
|
*/
|
|
public void setTouchExtraPadding(final ImVec2 value) {
|
|
nSetTouchExtraPadding(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Expand reactive bounding box for touch-based system where touch position is not accurate enough.
|
|
* Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
|
|
*/
|
|
public void setTouchExtraPadding(final float valueX, final float valueY) {
|
|
nSetTouchExtraPadding(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetTouchExtraPadding(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->TouchExtraPadding, dst);
|
|
*/
|
|
|
|
private native float nGetTouchExtraPaddingX(); /*
|
|
return THIS->TouchExtraPadding.x;
|
|
*/
|
|
|
|
private native float nGetTouchExtraPaddingY(); /*
|
|
return THIS->TouchExtraPadding.y;
|
|
*/
|
|
|
|
private native void nSetTouchExtraPadding(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->TouchExtraPadding = value;
|
|
*/
|
|
|
|
/**
|
|
* Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
|
|
*/
|
|
public float getIndentSpacing() {
|
|
return nGetIndentSpacing();
|
|
}
|
|
|
|
/**
|
|
* Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
|
|
*/
|
|
public void setIndentSpacing(final float value) {
|
|
nSetIndentSpacing(value);
|
|
}
|
|
|
|
private native float nGetIndentSpacing(); /*
|
|
return THIS->IndentSpacing;
|
|
*/
|
|
|
|
private native void nSetIndentSpacing(float value); /*
|
|
THIS->IndentSpacing = value;
|
|
*/
|
|
|
|
/**
|
|
* Minimum horizontal spacing between two columns. Preferably {@code >} (FramePadding.x + 1).
|
|
*/
|
|
public float getColumnsMinSpacing() {
|
|
return nGetColumnsMinSpacing();
|
|
}
|
|
|
|
/**
|
|
* Minimum horizontal spacing between two columns. Preferably {@code >} (FramePadding.x + 1).
|
|
*/
|
|
public void setColumnsMinSpacing(final float value) {
|
|
nSetColumnsMinSpacing(value);
|
|
}
|
|
|
|
private native float nGetColumnsMinSpacing(); /*
|
|
return THIS->ColumnsMinSpacing;
|
|
*/
|
|
|
|
private native void nSetColumnsMinSpacing(float value); /*
|
|
THIS->ColumnsMinSpacing = value;
|
|
*/
|
|
|
|
/**
|
|
* Width of the vertical scrollbar, Height of the horizontal scrollbar.
|
|
*/
|
|
public float getScrollbarSize() {
|
|
return nGetScrollbarSize();
|
|
}
|
|
|
|
/**
|
|
* Width of the vertical scrollbar, Height of the horizontal scrollbar.
|
|
*/
|
|
public void setScrollbarSize(final float value) {
|
|
nSetScrollbarSize(value);
|
|
}
|
|
|
|
private native float nGetScrollbarSize(); /*
|
|
return THIS->ScrollbarSize;
|
|
*/
|
|
|
|
private native void nSetScrollbarSize(float value); /*
|
|
THIS->ScrollbarSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of grab corners for scrollbar.
|
|
*/
|
|
public float getScrollbarRounding() {
|
|
return nGetScrollbarRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of grab corners for scrollbar.
|
|
*/
|
|
public void setScrollbarRounding(final float value) {
|
|
nSetScrollbarRounding(value);
|
|
}
|
|
|
|
private native float nGetScrollbarRounding(); /*
|
|
return THIS->ScrollbarRounding;
|
|
*/
|
|
|
|
private native void nSetScrollbarRounding(float value); /*
|
|
THIS->ScrollbarRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* Minimum width/height of a grab box for slider/scrollbar.
|
|
*/
|
|
public float getGrabMinSize() {
|
|
return nGetGrabMinSize();
|
|
}
|
|
|
|
/**
|
|
* Minimum width/height of a grab box for slider/scrollbar.
|
|
*/
|
|
public void setGrabMinSize(final float value) {
|
|
nSetGrabMinSize(value);
|
|
}
|
|
|
|
private native float nGetGrabMinSize(); /*
|
|
return THIS->GrabMinSize;
|
|
*/
|
|
|
|
private native void nSetGrabMinSize(float value); /*
|
|
THIS->GrabMinSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
|
|
*/
|
|
public float getGrabRounding() {
|
|
return nGetGrabRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
|
|
*/
|
|
public void setGrabRounding(final float value) {
|
|
nSetGrabRounding(value);
|
|
}
|
|
|
|
private native float nGetGrabRounding(); /*
|
|
return THIS->GrabRounding;
|
|
*/
|
|
|
|
private native void nSetGrabRounding(float value); /*
|
|
THIS->GrabRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero.
|
|
*/
|
|
public float getLogSliderDeadzone() {
|
|
return nGetLogSliderDeadzone();
|
|
}
|
|
|
|
/**
|
|
* The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero.
|
|
*/
|
|
public void setLogSliderDeadzone(final float value) {
|
|
nSetLogSliderDeadzone(value);
|
|
}
|
|
|
|
private native float nGetLogSliderDeadzone(); /*
|
|
return THIS->LogSliderDeadzone;
|
|
*/
|
|
|
|
private native void nSetLogSliderDeadzone(float value); /*
|
|
THIS->LogSliderDeadzone = value;
|
|
*/
|
|
|
|
/**
|
|
* Radius of upper corners of a tab. Set to 0.0f to have rectangular tabs.
|
|
*/
|
|
public float getTabRounding() {
|
|
return nGetTabRounding();
|
|
}
|
|
|
|
/**
|
|
* Radius of upper corners of a tab. Set to 0.0f to have rectangular tabs.
|
|
*/
|
|
public void setTabRounding(final float value) {
|
|
nSetTabRounding(value);
|
|
}
|
|
|
|
private native float nGetTabRounding(); /*
|
|
return THIS->TabRounding;
|
|
*/
|
|
|
|
private native void nSetTabRounding(float value); /*
|
|
THIS->TabRounding = value;
|
|
*/
|
|
|
|
/**
|
|
* Thickness of border around tabs.
|
|
*/
|
|
public float getTabBorderSize() {
|
|
return nGetTabBorderSize();
|
|
}
|
|
|
|
/**
|
|
* Thickness of border around tabs.
|
|
*/
|
|
public void setTabBorderSize(final float value) {
|
|
nSetTabBorderSize(value);
|
|
}
|
|
|
|
private native float nGetTabBorderSize(); /*
|
|
return THIS->TabBorderSize;
|
|
*/
|
|
|
|
private native void nSetTabBorderSize(float value); /*
|
|
THIS->TabBorderSize = value;
|
|
*/
|
|
|
|
/**
|
|
* Minimum width for close button to appears on an unselected tab when hovered.
|
|
* Set to 0.0f to always show when hovering, set to FLT_MAX to never show close button unless selected.
|
|
*/
|
|
public float getTabMinWidthForCloseButton() {
|
|
return nGetTabMinWidthForCloseButton();
|
|
}
|
|
|
|
/**
|
|
* Minimum width for close button to appears on an unselected tab when hovered.
|
|
* Set to 0.0f to always show when hovering, set to FLT_MAX to never show close button unless selected.
|
|
*/
|
|
public void setTabMinWidthForCloseButton(final float value) {
|
|
nSetTabMinWidthForCloseButton(value);
|
|
}
|
|
|
|
private native float nGetTabMinWidthForCloseButton(); /*
|
|
return THIS->TabMinWidthForCloseButton;
|
|
*/
|
|
|
|
private native void nSetTabMinWidthForCloseButton(float value); /*
|
|
THIS->TabMinWidthForCloseButton = value;
|
|
*/
|
|
|
|
/**
|
|
* Side of the color button in the ColorEdit4 widget (left/right). Defaults to ImGuiDir_Right.
|
|
*/
|
|
public int getColorButtonPosition() {
|
|
return nGetColorButtonPosition();
|
|
}
|
|
|
|
/**
|
|
* Side of the color button in the ColorEdit4 widget (left/right). Defaults to ImGuiDir_Right.
|
|
*/
|
|
public void setColorButtonPosition(final int value) {
|
|
nSetColorButtonPosition(value);
|
|
}
|
|
|
|
private native int nGetColorButtonPosition(); /*
|
|
return THIS->ColorButtonPosition;
|
|
*/
|
|
|
|
private native void nSetColorButtonPosition(int value); /*
|
|
THIS->ColorButtonPosition = value;
|
|
*/
|
|
|
|
/**
|
|
* Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
|
|
*/
|
|
public ImVec2 getButtonTextAlign() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetButtonTextAlign(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
|
|
*/
|
|
public float getButtonTextAlignX() {
|
|
return nGetButtonTextAlignX();
|
|
}
|
|
|
|
/**
|
|
* Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
|
|
*/
|
|
public float getButtonTextAlignY() {
|
|
return nGetButtonTextAlignY();
|
|
}
|
|
|
|
/**
|
|
* Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
|
|
*/
|
|
public void getButtonTextAlign(final ImVec2 dst) {
|
|
nGetButtonTextAlign(dst);
|
|
}
|
|
|
|
/**
|
|
* Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
|
|
*/
|
|
public void setButtonTextAlign(final ImVec2 value) {
|
|
nSetButtonTextAlign(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
|
|
*/
|
|
public void setButtonTextAlign(final float valueX, final float valueY) {
|
|
nSetButtonTextAlign(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetButtonTextAlign(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->ButtonTextAlign, dst);
|
|
*/
|
|
|
|
private native float nGetButtonTextAlignX(); /*
|
|
return THIS->ButtonTextAlign.x;
|
|
*/
|
|
|
|
private native float nGetButtonTextAlignY(); /*
|
|
return THIS->ButtonTextAlign.y;
|
|
*/
|
|
|
|
private native void nSetButtonTextAlign(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->ButtonTextAlign = value;
|
|
*/
|
|
|
|
/**
|
|
* Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned).
|
|
* It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
|
|
*/
|
|
public ImVec2 getSelectableTextAlign() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetSelectableTextAlign(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned).
|
|
* It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
|
|
*/
|
|
public float getSelectableTextAlignX() {
|
|
return nGetSelectableTextAlignX();
|
|
}
|
|
|
|
/**
|
|
* Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned).
|
|
* It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
|
|
*/
|
|
public float getSelectableTextAlignY() {
|
|
return nGetSelectableTextAlignY();
|
|
}
|
|
|
|
/**
|
|
* Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned).
|
|
* It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
|
|
*/
|
|
public void getSelectableTextAlign(final ImVec2 dst) {
|
|
nGetSelectableTextAlign(dst);
|
|
}
|
|
|
|
/**
|
|
* Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned).
|
|
* It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
|
|
*/
|
|
public void setSelectableTextAlign(final ImVec2 value) {
|
|
nSetSelectableTextAlign(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned).
|
|
* It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
|
|
*/
|
|
public void setSelectableTextAlign(final float valueX, final float valueY) {
|
|
nSetSelectableTextAlign(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetSelectableTextAlign(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->SelectableTextAlign, dst);
|
|
*/
|
|
|
|
private native float nGetSelectableTextAlignX(); /*
|
|
return THIS->SelectableTextAlign.x;
|
|
*/
|
|
|
|
private native float nGetSelectableTextAlignY(); /*
|
|
return THIS->SelectableTextAlign.y;
|
|
*/
|
|
|
|
private native void nSetSelectableTextAlign(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->SelectableTextAlign = value;
|
|
*/
|
|
|
|
/**
|
|
* Window position are clamped to be visible within the display area by at least this amount. Only applies to regular windows.
|
|
*/
|
|
public ImVec2 getDisplayWindowPadding() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetDisplayWindowPadding(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Window position are clamped to be visible within the display area by at least this amount. Only applies to regular windows.
|
|
*/
|
|
public float getDisplayWindowPaddingX() {
|
|
return nGetDisplayWindowPaddingX();
|
|
}
|
|
|
|
/**
|
|
* Window position are clamped to be visible within the display area by at least this amount. Only applies to regular windows.
|
|
*/
|
|
public float getDisplayWindowPaddingY() {
|
|
return nGetDisplayWindowPaddingY();
|
|
}
|
|
|
|
/**
|
|
* Window position are clamped to be visible within the display area by at least this amount. Only applies to regular windows.
|
|
*/
|
|
public void getDisplayWindowPadding(final ImVec2 dst) {
|
|
nGetDisplayWindowPadding(dst);
|
|
}
|
|
|
|
/**
|
|
* Window position are clamped to be visible within the display area by at least this amount. Only applies to regular windows.
|
|
*/
|
|
public void setDisplayWindowPadding(final ImVec2 value) {
|
|
nSetDisplayWindowPadding(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* Window position are clamped to be visible within the display area by at least this amount. Only applies to regular windows.
|
|
*/
|
|
public void setDisplayWindowPadding(final float valueX, final float valueY) {
|
|
nSetDisplayWindowPadding(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetDisplayWindowPadding(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->DisplayWindowPadding, dst);
|
|
*/
|
|
|
|
private native float nGetDisplayWindowPaddingX(); /*
|
|
return THIS->DisplayWindowPadding.x;
|
|
*/
|
|
|
|
private native float nGetDisplayWindowPaddingY(); /*
|
|
return THIS->DisplayWindowPadding.y;
|
|
*/
|
|
|
|
private native void nSetDisplayWindowPadding(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->DisplayWindowPadding = value;
|
|
*/
|
|
|
|
/**
|
|
* If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding.
|
|
* Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
|
|
*/
|
|
public ImVec2 getDisplaySafeAreaPadding() {
|
|
final ImVec2 dst = new ImVec2();
|
|
nGetDisplaySafeAreaPadding(dst);
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding.
|
|
* Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
|
|
*/
|
|
public float getDisplaySafeAreaPaddingX() {
|
|
return nGetDisplaySafeAreaPaddingX();
|
|
}
|
|
|
|
/**
|
|
* If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding.
|
|
* Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
|
|
*/
|
|
public float getDisplaySafeAreaPaddingY() {
|
|
return nGetDisplaySafeAreaPaddingY();
|
|
}
|
|
|
|
/**
|
|
* If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding.
|
|
* Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
|
|
*/
|
|
public void getDisplaySafeAreaPadding(final ImVec2 dst) {
|
|
nGetDisplaySafeAreaPadding(dst);
|
|
}
|
|
|
|
/**
|
|
* If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding.
|
|
* Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
|
|
*/
|
|
public void setDisplaySafeAreaPadding(final ImVec2 value) {
|
|
nSetDisplaySafeAreaPadding(value.x, value.y);
|
|
}
|
|
|
|
/**
|
|
* If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding.
|
|
* Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
|
|
*/
|
|
public void setDisplaySafeAreaPadding(final float valueX, final float valueY) {
|
|
nSetDisplaySafeAreaPadding(valueX, valueY);
|
|
}
|
|
|
|
private native void nGetDisplaySafeAreaPadding(ImVec2 dst); /*
|
|
Jni::ImVec2Cpy(env, THIS->DisplaySafeAreaPadding, dst);
|
|
*/
|
|
|
|
private native float nGetDisplaySafeAreaPaddingX(); /*
|
|
return THIS->DisplaySafeAreaPadding.x;
|
|
*/
|
|
|
|
private native float nGetDisplaySafeAreaPaddingY(); /*
|
|
return THIS->DisplaySafeAreaPadding.y;
|
|
*/
|
|
|
|
private native void nSetDisplaySafeAreaPadding(float valueX, float valueY); /*MANUAL
|
|
ImVec2 value = ImVec2(valueX, valueY);
|
|
THIS->DisplaySafeAreaPadding = value;
|
|
*/
|
|
|
|
/**
|
|
* Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). May be removed later.
|
|
*/
|
|
public float getMouseCursorScale() {
|
|
return nGetMouseCursorScale();
|
|
}
|
|
|
|
/**
|
|
* Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). May be removed later.
|
|
*/
|
|
public void setMouseCursorScale(final float value) {
|
|
nSetMouseCursorScale(value);
|
|
}
|
|
|
|
private native float nGetMouseCursorScale(); /*
|
|
return THIS->MouseCursorScale;
|
|
*/
|
|
|
|
private native void nSetMouseCursorScale(float value); /*
|
|
THIS->MouseCursorScale = value;
|
|
*/
|
|
|
|
/**
|
|
* Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
|
|
*/
|
|
public boolean getAntiAliasedLines() {
|
|
return nGetAntiAliasedLines();
|
|
}
|
|
|
|
/**
|
|
* Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
|
|
*/
|
|
public void setAntiAliasedLines(final boolean value) {
|
|
nSetAntiAliasedLines(value);
|
|
}
|
|
|
|
private native boolean nGetAntiAliasedLines(); /*
|
|
return THIS->AntiAliasedLines;
|
|
*/
|
|
|
|
private native void nSetAntiAliasedLines(boolean value); /*
|
|
THIS->AntiAliasedLines = value;
|
|
*/
|
|
|
|
/**
|
|
* Enable anti-aliased lines/borders using textures where possible.
|
|
* Require backend to render with bilinear filtering (NOT point/nearest filtering).
|
|
* Latched at the beginning of the frame (copied to ImDrawList).
|
|
*/
|
|
public boolean getAntiAliasedLinesUseTex() {
|
|
return nGetAntiAliasedLinesUseTex();
|
|
}
|
|
|
|
/**
|
|
* Enable anti-aliased lines/borders using textures where possible.
|
|
* Require backend to render with bilinear filtering (NOT point/nearest filtering).
|
|
* Latched at the beginning of the frame (copied to ImDrawList).
|
|
*/
|
|
public void setAntiAliasedLinesUseTex(final boolean value) {
|
|
nSetAntiAliasedLinesUseTex(value);
|
|
}
|
|
|
|
private native boolean nGetAntiAliasedLinesUseTex(); /*
|
|
return THIS->AntiAliasedLinesUseTex;
|
|
*/
|
|
|
|
private native void nSetAntiAliasedLinesUseTex(boolean value); /*
|
|
THIS->AntiAliasedLinesUseTex = value;
|
|
*/
|
|
|
|
/**
|
|
* Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.).
|
|
* Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
|
|
*/
|
|
public boolean getAntiAliasedFill() {
|
|
return nGetAntiAliasedFill();
|
|
}
|
|
|
|
/**
|
|
* Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.).
|
|
* Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
|
|
*/
|
|
public void setAntiAliasedFill(final boolean value) {
|
|
nSetAntiAliasedFill(value);
|
|
}
|
|
|
|
private native boolean nGetAntiAliasedFill(); /*
|
|
return THIS->AntiAliasedFill;
|
|
*/
|
|
|
|
private native void nSetAntiAliasedFill(boolean value); /*
|
|
THIS->AntiAliasedFill = value;
|
|
*/
|
|
|
|
/**
|
|
* Tessellation tolerance when using PathBezierCurveTo() without a specific number of segments.
|
|
* Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
|
|
*/
|
|
public float getCurveTessellationTol() {
|
|
return nGetCurveTessellationTol();
|
|
}
|
|
|
|
/**
|
|
* Tessellation tolerance when using PathBezierCurveTo() without a specific number of segments.
|
|
* Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
|
|
*/
|
|
public void setCurveTessellationTol(final float value) {
|
|
nSetCurveTessellationTol(value);
|
|
}
|
|
|
|
private native float nGetCurveTessellationTol(); /*
|
|
return THIS->CurveTessellationTol;
|
|
*/
|
|
|
|
private native void nSetCurveTessellationTol(float value); /*
|
|
THIS->CurveTessellationTol = value;
|
|
*/
|
|
|
|
/**
|
|
* Maximum error (in pixels) allowed when using AddCircle()/AddCircleFilled() or drawing rounded corner rectangles with no explicit segment count specified.
|
|
* Decrease for higher quality but more geometry.
|
|
*/
|
|
public float getCircleTessellationMaxError() {
|
|
return nGetCircleTessellationMaxError();
|
|
}
|
|
|
|
/**
|
|
* Maximum error (in pixels) allowed when using AddCircle()/AddCircleFilled() or drawing rounded corner rectangles with no explicit segment count specified.
|
|
* Decrease for higher quality but more geometry.
|
|
*/
|
|
public void setCircleTessellationMaxError(final float value) {
|
|
nSetCircleTessellationMaxError(value);
|
|
}
|
|
|
|
private native float nGetCircleTessellationMaxError(); /*
|
|
return THIS->CircleTessellationMaxError;
|
|
*/
|
|
|
|
private native void nSetCircleTessellationMaxError(float value); /*
|
|
THIS->CircleTessellationMaxError = value;
|
|
*/
|
|
|
|
public ImVec4[] getColors() {
|
|
return nGetColors();
|
|
}
|
|
|
|
public void setColors(final ImVec4[] value) {
|
|
nSetColors(value);
|
|
}
|
|
|
|
private native ImVec4[] nGetColors(); /*
|
|
return Jni::NewImVec4Array(env, THIS->Colors, ImGuiCol_COUNT);
|
|
*/
|
|
|
|
private native void nSetColors(ImVec4[] value); /*
|
|
Jni::ImVec4ArrayCpy(env, value, THIS->Colors, ImGuiCol_COUNT);
|
|
*/
|
|
|
|
public ImVec4 getColor(final int col) {
|
|
final ImVec4 dst = new ImVec4();
|
|
getColor(col, dst);
|
|
return dst;
|
|
}
|
|
|
|
public native void getColor(int col, ImVec4 dst); /*
|
|
Jni::ImVec4Cpy(env, THIS->Colors[col], dst);
|
|
*/
|
|
|
|
public native void setColor(int col, float r, float g, float b, float a); /*
|
|
THIS->Colors[col] = ImColor((float)r, (float)g, (float)b, (float)a);
|
|
*/
|
|
|
|
public native void setColor(int col, int r, int g, int b, int a); /*
|
|
THIS->Colors[col] = ImColor((int)r, (int)g, (int)b, (int)a);
|
|
*/
|
|
|
|
public native void setColor(int col, int value); /*
|
|
THIS->Colors[col] = ImColor(value);
|
|
*/
|
|
|
|
public void scaleAllSizes(final float scaleFactor) {
|
|
nScaleAllSizes(scaleFactor);
|
|
}
|
|
|
|
private native void nScaleAllSizes(float scaleFactor); /*
|
|
THIS->ScaleAllSizes(scaleFactor);
|
|
*/
|
|
|
|
/*JNI
|
|
#undef THIS
|
|
*/
|
|
}
|