feat(api): Dear ImGui v1.87 + ImPlot v0.13 (#252)

* build(deps): bump Dear ImGui from 1.86 to 1.87

* build(deps): bump implot from 0.12 to 0.13

* feat(api,binding): adapt API to Dear ImGui v1.87

* feat(api,binding): adapt API to implot v0.13

* build: generate API for latest changes

* chore(binding): add missing super call for ImGuiStructDestroyable constructor

* chore: minor code style

* feat: adapt ImGuiImplGlfw to 1.87

* feat: adapt ImGuiImplGl3 to 1.87

* feat: adapt imgui-app module to 1.87

* fix: javadoc for updated imgui-binding

* fix: loosing data when setting struct field of char* type

Since we manually release chars, to store them in field we need to do a local copy.

* fix: invalid methods to check program linking in OpenGL

* chore: remove dedicated method to check GLFW version

* fix: add missing include

imgui-binding/src/generated/java/imgui/ImFont.java

@@ -8,6 +8,7 @@ import imgui.binding.ImGuiStructDestroyable;
  */
 public final class ImFont extends ImGuiStructDestroyable {
     public ImFont() {
+        super();
     }
 
     public ImFont(final long ptr) {

imgui-binding/src/generated/java/imgui/ImFontAtlas.java

@@ -30,6 +30,7 @@ public final class ImFontAtlas extends ImGuiStructDestroyable {
     private ByteBuffer rgba32pixels = null;
 
     public ImFontAtlas() {
+        super();
     }
 
     public ImFontAtlas(final long ptr) {

imgui-binding/src/generated/java/imgui/ImFontGlyph.java

@@ -8,6 +8,7 @@ import imgui.binding.ImGuiStructDestroyable;
  */
 public final class ImFontGlyph extends ImGuiStructDestroyable {
     public ImFontGlyph() {
+        super();
     }
 
     public ImFontGlyph(final long ptr) {

imgui-binding/src/generated/java/imgui/ImGui.java

@@ -11927,73 +11927,89 @@ public class ImGui {
     */
 
     // Inputs Utilities: Keyboard
-    // - For 'int user_key_index' you can use your own indices/enums according to how your backend/engine stored them in io.KeysDown[].
-    // - We don't know the meaning of those value. You can use GetKeyIndex() to map a ImGuiKey_ value into the user index.
+    // Without IMGUI_DISABLE_OBSOLETE_KEYIO: (legacy support)
+    //   - For 'ImGuiKey key' you can still use your legacy native/user indices according to how your backend/engine stored them in io.KeysDown[].
+    // With IMGUI_DISABLE_OBSOLETE_KEYIO: (this is the way forward)
+    //   - Any use of 'ImGuiKey' will assert when key < 512 will be passed, previously reserved as native/user keys indices
+    //   - GetKeyIndex() is pass-through and therefore deprecated (gone if IMGUI_DISABLE_OBSOLETE_KEYIO is defined)
 
     /**
      * Map ImGuiKey_* values into user's key index. == io.KeyMap[key]
      */
-    public static int getKeyIndex(final int imguiKey) {
-        return nGetKeyIndex(imguiKey);
+    @Deprecated
+    public static int getKeyIndex(final int key) {
+        return nGetKeyIndex(key);
     }
 
-    private static native int nGetKeyIndex(int imguiKey); /*
-        return ImGui::GetKeyIndex(imguiKey);
+    private static native int nGetKeyIndex(int key); /*
+        return ImGui::GetKeyIndex(static_cast<ImGuiKey>(key));
     */
+
     /**
      * Is key being held. == io.KeysDown[user_key_index].
      */
-    public static boolean isKeyDown(final int userKeyIndex) {
-        return nIsKeyDown(userKeyIndex);
+    public static boolean isKeyDown(final int key) {
+        return nIsKeyDown(key);
     }
 
-    private static native boolean nIsKeyDown(int userKeyIndex); /*
-        return ImGui::IsKeyDown(userKeyIndex);
+    private static native boolean nIsKeyDown(int key); /*
+        return ImGui::IsKeyDown(static_cast<ImGuiKey>(key));
     */
 
     /**
      * Was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
      */
-    public static boolean isKeyPressed(final int userKeyIndex) {
-        return nIsKeyPressed(userKeyIndex);
+    public static boolean isKeyPressed(final int key) {
+        return nIsKeyPressed(key);
     }
 
     /**
      * Was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
      */
-    public static boolean isKeyPressed(final int userKeyIndex, final boolean repeat) {
-        return nIsKeyPressed(userKeyIndex, repeat);
+    public static boolean isKeyPressed(final int key, final boolean repeat) {
+        return nIsKeyPressed(key, repeat);
     }
 
-    private static native boolean nIsKeyPressed(int userKeyIndex); /*
-        return ImGui::IsKeyPressed(userKeyIndex);
+    private static native boolean nIsKeyPressed(int key); /*
+        return ImGui::IsKeyPressed(static_cast<ImGuiKey>(key));
     */
 
-    private static native boolean nIsKeyPressed(int userKeyIndex, boolean repeat); /*
-        return ImGui::IsKeyPressed(userKeyIndex, repeat);
+    private static native boolean nIsKeyPressed(int key, boolean repeat); /*
+        return ImGui::IsKeyPressed(static_cast<ImGuiKey>(key), repeat);
     */
 
     /**
-     * Was key released (went from Down to !Down)..
+     * Was key released (went from Down to !Down)
      */
-    public static boolean isKeyReleased(final int userKeyIndex) {
-        return nIsKeyReleased(userKeyIndex);
+    public static boolean isKeyReleased(final int key) {
+        return nIsKeyReleased(key);
     }
 
-    private static native boolean nIsKeyReleased(int userKeyIndex); /*
-        return ImGui::IsKeyReleased(userKeyIndex);
+    private static native boolean nIsKeyReleased(int key); /*
+        return ImGui::IsKeyReleased(static_cast<ImGuiKey>(key));
     */
 
     /**
      * Uses provided repeat rate/delay.
      * Return a count, most often 0 or 1 but might be {@code >1} if RepeatRate is small enough that {@code DeltaTime > RepeatRate}
      */
-    public static boolean getKeyPressedAmount(final int keyIndex, final float repeatDelay, final float rate) {
-        return nGetKeyPressedAmount(keyIndex, repeatDelay, rate);
+    public static boolean getKeyPressedAmount(final int key, final float repeatDelay, final float rate) {
+        return nGetKeyPressedAmount(key, repeatDelay, rate);
     }
 
-    private static native boolean nGetKeyPressedAmount(int keyIndex, float repeatDelay, float rate); /*
-        return ImGui::GetKeyPressedAmount(keyIndex, repeatDelay, rate);
+    private static native boolean nGetKeyPressedAmount(int key, float repeatDelay, float rate); /*
+        return ImGui::GetKeyPressedAmount(static_cast<ImGuiKey>(key), repeatDelay, rate);
+    */
+
+    /**
+     * [DEBUG] returns English name of the key. Those names a provided for debugging purpose and are not meant to be saved persistently not compared.
+     */
+    public static String getKeyName(final int key) {
+        return nGetKeyName(key);
+    }
+
+    private static native String nGetKeyName(int key); /*
+        return env->NewStringUTF(ImGui::GetKeyName(static_cast<ImGuiKey>(key)));
     */
 
     /**

imgui-binding/src/generated/java/imgui/ImGuiInputTextCallbackData.java

@@ -116,7 +116,7 @@ public class ImGuiInputTextCallbackData extends ImGuiStruct {
 
     private native void nSetBuf(String value); /*MANUAL
         auto value = obj_value == NULL ? NULL : (char*)env->GetStringUTFChars(obj_value, JNI_FALSE);
-        THIS->Buf = value;
+        SET_STRING_FIELD(THIS->Buf, value);
         if (value != NULL) env->ReleaseStringUTFChars(obj_value, value);
     */
 

imgui-binding/src/generated/java/imgui/ImGuiKeyData.java

@@ -0,0 +1,123 @@
+package imgui;
+
+import imgui.binding.ImGuiStructDestroyable;
+
+/**
+ * [Internal] Storage used by IsKeyDown(), IsKeyPressed() etc functions.
+ * If prior to 1.87 you used io.KeysDownDuration[] (which was marked as internal), you should use GetKeyData(key).DownDuration and not io.KeysData[key].DownDuration.
+ */
+public final class ImGuiKeyData extends ImGuiStructDestroyable {
+    public ImGuiKeyData() {
+        super();
+    }
+
+    public ImGuiKeyData(final long ptr) {
+        super(ptr);
+    }
+
+    @Override
+    protected long create() {
+        return nCreate();
+    }
+
+    /*JNI
+        #include "_common.h"
+        #define THIS ((ImGuiKeyData*)STRUCT_PTR)
+     */
+
+    private native long nCreate(); /*
+        return (intptr_t)(new ImGuiKeyData());
+    */
+
+    /**
+     * True for if key is down
+     */
+    public boolean getDown() {
+        return nGetDown();
+    }
+
+    /**
+     * True for if key is down
+     */
+    public void setDown(final boolean value) {
+        nSetDown(value);
+    }
+
+    private native boolean nGetDown(); /*
+        return THIS->Down;
+    */
+
+    private native void nSetDown(boolean value); /*
+        THIS->Down = value;
+    */
+
+    /**
+     * Duration the key has been down ({@code <}0.0f: not pressed, 0.0f: just pressed, {@code >}0.0f: time held)
+     */
+    public float getDownDuration() {
+        return nGetDownDuration();
+    }
+
+    /**
+     * Duration the key has been down ({@code <}0.0f: not pressed, 0.0f: just pressed, {@code >}0.0f: time held)
+     */
+    public void setDownDuration(final float value) {
+        nSetDownDuration(value);
+    }
+
+    private native float nGetDownDuration(); /*
+        return THIS->DownDuration;
+    */
+
+    private native void nSetDownDuration(float value); /*
+        THIS->DownDuration = value;
+    */
+
+    /**
+     * Last frame duration the key has been down
+     */
+    public float getDownDurationPrev() {
+        return nGetDownDurationPrev();
+    }
+
+    /**
+     * Last frame duration the key has been down
+     */
+    public void setDownDurationPrev(final float value) {
+        nSetDownDurationPrev(value);
+    }
+
+    private native float nGetDownDurationPrev(); /*
+        return THIS->DownDurationPrev;
+    */
+
+    private native void nSetDownDurationPrev(float value); /*
+        THIS->DownDurationPrev = value;
+    */
+
+    /**
+     * 0.0f..1.0f for gamepad values
+     */
+    public float getAnalogValue() {
+        return nGetAnalogValue();
+    }
+
+    /**
+     * 0.0f..1.0f for gamepad values
+     */
+    public void setAnalogValue(final float value) {
+        nSetAnalogValue(value);
+    }
+
+    private native float nGetAnalogValue(); /*
+        return THIS->AnalogValue;
+    */
+
+    private native void nSetAnalogValue(float value); /*
+        THIS->AnalogValue = value;
+    */
+
+    /*JNI
+        #undef THIS
+     */
+}

imgui-binding/src/generated/java/imgui/ImGuiStorage.java

@@ -14,6 +14,7 @@ import imgui.binding.ImGuiStructDestroyable;
  */
 public final class ImGuiStorage extends ImGuiStructDestroyable {
     public ImGuiStorage() {
+        super();
     }
 
     public ImGuiStorage(final long ptr) {

imgui-binding/src/generated/java/imgui/ImGuiStyle.java

@@ -9,6 +9,7 @@ import imgui.binding.ImGuiStructDestroyable;
  */
 public final class ImGuiStyle extends ImGuiStructDestroyable {
     public ImGuiStyle() {
+        super();
     }
 
     public ImGuiStyle(final long ptr) {

imgui-binding/src/generated/java/imgui/ImGuiTableSortSpecs.java

@@ -9,7 +9,6 @@ import imgui.binding.ImGuiStruct;
  * Make sure to set 'SpecsDirty = false' after sorting, else you may wastefully sort your data every frame!
  */
 public final class ImGuiTableSortSpecs extends ImGuiStruct {
-
     public ImGuiTableSortSpecs(final long ptr) {
         super(ptr);
     }
@@ -23,8 +22,8 @@ public final class ImGuiTableSortSpecs extends ImGuiStruct {
      * Pointer to sort spec array.
      */
     public ImGuiTableColumnSortSpecs[] getSpecs() {
-        long[] specsPointers = nGetSpecs();
-        ImGuiTableColumnSortSpecs[] specs = new ImGuiTableColumnSortSpecs[specsPointers.length];
+        final long[] specsPointers = nGetSpecs();
+        final ImGuiTableColumnSortSpecs[] specs = new ImGuiTableColumnSortSpecs[specsPointers.length];
         for (int i = 0; i < specsPointers.length; i++) {
             specs[i] = new ImGuiTableColumnSortSpecs(specsPointers[i]);
         }
@@ -45,7 +44,7 @@ public final class ImGuiTableSortSpecs extends ImGuiStruct {
     */
 
     /**
-     * Sort spec count. Most often 1. May be {@code > } 1 when ImGuiTableFlags_SortMulti is enabled. May be == 0 when ImGuiTableFlags_SortTristate is enabled.
+     * Sort spec count. Most often 1. May be {@code >} 1 when ImGuiTableFlags_SortMulti is enabled. May be == 0 when ImGuiTableFlags_SortTristate is enabled.
      */
     public int getSpecsCount() {
         return nGetSpecsCount();

imgui-binding/src/generated/java/imgui/ImGuiWindowClass.java

@@ -13,6 +13,7 @@ import imgui.binding.ImGuiStructDestroyable;
  */
 public final class ImGuiWindowClass extends ImGuiStructDestroyable {
     public ImGuiWindowClass() {
+        super();
     }
 
     public ImGuiWindowClass(final long ptr) {

imgui-binding/src/generated/java/imgui/extension/implot/ImPlotInputMap.java

@@ -0,0 +1,307 @@
+package imgui.extension.implot;
+
+import imgui.binding.ImGuiStructDestroyable;
+
+public final class ImPlotInputMap extends ImGuiStructDestroyable {
+    public ImPlotInputMap() {
+        super();
+    }
+
+    public ImPlotInputMap(final long ptr) {
+        super(ptr);
+    }
+
+    @Override
+    protected long create() {
+        return nCreate();
+    }
+
+    /*JNI
+        #include "_implot.h"
+        #define THIS ((ImPlotInputMap*)STRUCT_PTR)
+     */
+
+    private native long nCreate(); /*
+        return (intptr_t)(new ImPlotInputMap());
+    */
+
+    /**
+     * LMB enables panning when held
+     */
+    public int getPan() {
+        return nGetPan();
+    }
+
+    /**
+     * LMB enables panning when held
+     */
+    public void setPan(final int value) {
+        nSetPan(value);
+    }
+
+    private native int nGetPan(); /*
+        return THIS->Pan;
+    */
+
+    private native void nSetPan(int value); /*
+        THIS->Pan = value;
+    */
+
+    /**
+     * Optional modifier that must be held for panning/fitting
+     */
+    public int getPanMod() {
+        return nGetPanMod();
+    }
+
+    /**
+     * Optional modifier that must be held for panning/fitting
+     */
+    public void setPanMod(final int value) {
+        nSetPanMod(value);
+    }
+
+    private native int nGetPanMod(); /*
+        return THIS->PanMod;
+    */
+
+    private native void nSetPanMod(int value); /*
+        THIS->PanMod = value;
+    */
+
+    /**
+     * LMB initiates fit when double clicked
+     */
+    public int getFit() {
+        return nGetFit();
+    }
+
+    /**
+     * LMB initiates fit when double clicked
+     */
+    public void setFit(final int value) {
+        nSetFit(value);
+    }
+
+    private native int nGetFit(); /*
+        return THIS->Fit;
+    */
+
+    private native void nSetFit(int value); /*
+        THIS->Fit = value;
+    */
+
+    /**
+     * RMB begins box selection when pressed and confirms
+     * selection when released
+     */
+    public int getSelect() {
+        return nGetSelect();
+    }
+
+    /**
+     * RMB begins box selection when pressed and confirms
+     * selection when released
+     */
+    public void setSelect(final int value) {
+        nSetSelect(value);
+    }
+
+    private native int nGetSelect(); /*
+        return THIS->Select;
+    */
+
+    private native void nSetSelect(int value); /*
+        THIS->Select = value;
+    */
+
+    /**
+     * LMB cancels active box selection when pressed;
+     * cannot be the same as Select
+     */
+    public int getSelectCancel() {
+        return nGetSelectCancel();
+    }
+
+    /**
+     * LMB cancels active box selection when pressed;
+     * cannot be the same as Select
+     */
+    public void setSelectCancel(final int value) {
+        nSetSelectCancel(value);
+    }
+
+    private native int nGetSelectCancel(); /*
+        return THIS->SelectCancel;
+    */
+
+    private native void nSetSelectCancel(int value); /*
+        THIS->SelectCancel = value;
+    */
+
+    /**
+     * Optional modifier that must be held for box selection
+     */
+    public int getSelectMod() {
+        return nGetSelectMod();
+    }
+
+    /**
+     * Optional modifier that must be held for box selection
+     */
+    public void setSelectMod(final int value) {
+        nSetSelectMod(value);
+    }
+
+    private native int nGetSelectMod(); /*
+        return THIS->SelectMod;
+    */
+
+    private native void nSetSelectMod(int value); /*
+        THIS->SelectMod = value;
+    */
+
+    /**
+     * Alt expands active box selection horizontally
+     * to plot edge when held
+     */
+    public int getSelectHorzMod() {
+        return nGetSelectHorzMod();
+    }
+
+    /**
+     * Alt expands active box selection horizontally
+     * to plot edge when held
+     */
+    public void setSelectHorzMod(final int value) {
+        nSetSelectHorzMod(value);
+    }
+
+    private native int nGetSelectHorzMod(); /*
+        return THIS->SelectHorzMod;
+    */
+
+    private native void nSetSelectHorzMod(int value); /*
+        THIS->SelectHorzMod = value;
+    */
+
+    /**
+     * Shift expands active box selection vertically
+     * to plot edge when held
+     */
+    public int getSelectVertMod() {
+        return nGetSelectVertMod();
+    }
+
+    /**
+     * Shift expands active box selection vertically
+     * to plot edge when held
+     */
+    public void setSelectVertMod(final int value) {
+        nSetSelectVertMod(value);
+    }
+
+    private native int nGetSelectVertMod(); /*
+        return THIS->SelectVertMod;
+    */
+
+    private native void nSetSelectVertMod(int value); /*
+        THIS->SelectVertMod = value;
+    */
+
+    /**
+     * RMB opens context menus (if enabled) when clicked
+     */
+    public int getMenu() {
+        return nGetMenu();
+    }
+
+    /**
+     * RMB opens context menus (if enabled) when clicked
+     */
+    public void setMenu(final int value) {
+        nSetMenu(value);
+    }
+
+    private native int nGetMenu(); /*
+        return THIS->Menu;
+    */
+
+    private native void nSetMenu(int value); /*
+        THIS->Menu = value;
+    */
+
+    /**
+     * Ctrl when held, all input is ignored;
+     * used to enable axis/plots as DND sources
+     */
+    public int getOverrideMod() {
+        return nGetOverrideMod();
+    }
+
+    /**
+     * Ctrl when held, all input is ignored;
+     * used to enable axis/plots as DND sources
+     */
+    public void setOverrideMod(final int value) {
+        nSetOverrideMod(value);
+    }
+
+    private native int nGetOverrideMod(); /*
+        return THIS->OverrideMod;
+    */
+
+    private native void nSetOverrideMod(int value); /*
+        THIS->OverrideMod = value;
+    */
+
+    /**
+     * Optional modifier that must be held for scroll wheel zooming
+     */
+    public int getZoomMod() {
+        return nGetZoomMod();
+    }
+
+    /**
+     * Optional modifier that must be held for scroll wheel zooming
+     */
+    public void setZoomMod(final int value) {
+        nSetZoomMod(value);
+    }
+
+    private native int nGetZoomMod(); /*
+        return THIS->ZoomMod;
+    */
+
+    private native void nSetZoomMod(int value); /*
+        THIS->ZoomMod = value;
+    */
+
+    /**
+     * Zoom rate for scroll (e.g. 0.1f = 10% plot range every scroll click);
+     * make negative to invert
+     */
+    public float getZoomRate() {
+        return nGetZoomRate();
+    }
+
+    /**
+     * Zoom rate for scroll (e.g. 0.1f = 10% plot range every scroll click);
+     * make negative to invert
+     */
+    public void setZoomRate(final float value) {
+        nSetZoomRate(value);
+    }
+
+    private native float nGetZoomRate(); /*
+        return THIS->ZoomRate;
+    */
+
+    private native void nSetZoomRate(float value); /*
+        THIS->ZoomRate = value;
+    */
+
+    /*JNI
+        #undef THIS
+     */
+}

imgui-binding/src/generated/java/imgui/extension/implot/ImPlotRange.java

@@ -25,6 +25,10 @@ public final class ImPlotRange implements Cloneable {
         return max - min;
     }
 
+    public double clamp(final double value) {
+        return Math.max(min, Math.min(max, value));
+    }
+
     public ImPlotRange set(final double min, final double max) {
         this.min = min;
         this.max = max;

imgui-binding/src/generated/java/imgui/extension/implot/ImPlotRect.java

@@ -4,22 +4,22 @@ import imgui.ImVec2;
 
 import java.util.Objects;
 
-public final class ImPlotLimits implements Cloneable {
+public final class ImPlotRect implements Cloneable {
     public final ImPlotRange x = new ImPlotRange();
     public final ImPlotRange y = new ImPlotRange();
 
-    public ImPlotLimits() {
+    public ImPlotRect() {
     }
 
-    public ImPlotLimits(final double xMin, final double yMin, final double xMax, final double yMax) {
+    public ImPlotRect(final double xMin, final double yMin, final double xMax, final double yMax) {
         set(xMin, yMin, xMax, yMax);
     }
 
-    public ImPlotLimits(final ImVec2 min, final ImVec2 max) {
+    public ImPlotRect(final ImVec2 min, final ImVec2 max) {
         set(min, max);
     }
 
-    public ImPlotLimits(final ImPlotLimits value) {
+    public ImPlotRect(final ImPlotRect value) {
         set(value);
     }
 
@@ -31,6 +31,18 @@ public final class ImPlotLimits implements Cloneable {
         return contains(value.x, value.y);
     }
 
+    public ImPlotPoint size() {
+        return new ImPlotPoint(x.size(), y.size());
+    }
+
+    public ImPlotPoint clamp(final double x, final double y) {
+        return new ImPlotPoint(this.x.clamp(x), this.y.clamp(y));
+    }
+
+    public ImPlotPoint clamp(ImPlotPoint p) {
+        return clamp(p.x, p.y);
+    }
+
     public ImPlotPoint min() {
         return new ImPlotPoint(x.min, y.min);
     }
@@ -54,13 +66,13 @@ public final class ImPlotLimits implements Cloneable {
         set(x.min, y.min, x.max, y.max);
     }
 
-    public void set(final ImPlotLimits value) {
+    public void set(final ImPlotRect value) {
         set(value.x, value.y);
     }
 
     @Override
     public String toString() {
-        return "ImPlotLimits{"
+        return "ImPlotRect{"
             + "x=" + x
             + ", y=" + y
             + '}';
@@ -76,8 +88,8 @@ public final class ImPlotLimits implements Cloneable {
             return false;
         }
 
-        final ImPlotLimits imPlotLimits = (ImPlotLimits) o;
-        return Objects.equals(x, imPlotLimits.x) && Objects.equals(y, imPlotLimits.y);
+        final ImPlotRect imPlotRect = (ImPlotRect) o;
+        return Objects.equals(x, imPlotRect.x) && Objects.equals(y, imPlotRect.y);
     }
 
     @Override
@@ -87,7 +99,7 @@ public final class ImPlotLimits implements Cloneable {
 
     @Override
     @SuppressWarnings("MethodDoesntCallSuperMethod")
-    public ImPlotLimits clone() {
-        return new ImPlotLimits(this);
+    public ImPlotRect clone() {
+        return new ImPlotRect(this);
     }
 }

imgui-binding/src/generated/java/imgui/extension/implot/ImPlotStyle.java

@@ -6,6 +6,7 @@ import imgui.binding.ImGuiStructDestroyable;
 
 public final class ImPlotStyle extends ImGuiStructDestroyable {
     public ImPlotStyle() {
+        super();
     }
 
     public ImPlotStyle(final long ptr) {

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotAxis.java

@@ -0,0 +1,44 @@
+package imgui.extension.implot.flag;
+
+
+public final class ImPlotAxis {
+    private ImPlotAxis() {
+    }
+
+    /**
+     * enabled by default
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int X1 = 0;
+
+    /**
+     * disabled by default
+     */
+    public static final int X2 = 1;
+
+    /**
+     * disabled by default
+     */
+    public static final int X3 = 2;
+
+    /**
+     * enabled by default
+     */
+    public static final int Y1 = 3;
+
+    /**
+     * disabled by default
+     */
+    public static final int Y2 = 4;
+
+    /**
+     * disabled by default
+     */
+    public static final int Y3 = 5;
+
+    /**
+     * bookeeping
+     */
+    public static final int COUNT = 6;
+}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotAxisFlags.java

@@ -41,75 +41,94 @@ public final class ImPlotAxisFlags {
     public static final int NoTickLabels = 8;
 
     /**
-     * grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background
+     * axis will not be initially fit to data extents on the first rendered frame
      *
      * <p>Definition: {@code 1 << 4}
      */
-    public static final int Foreground = 16;
+    public static final int NoInitialFit = 16;
+
+    /**
+     * the user will not be able to open context menus with right-click
+     *
+     * <p>Definition: {@code 1 << 5}
+     */
+    public static final int NoMenus = 32;
+
+    /**
+     * axis ticks and labels will be rendered on conventionally opposite side (i.e, right or top)
+     *
+     * <p>Definition: {@code 1 << 6}
+     */
+    public static final int Opposite = 64;
+
+    /**
+     * grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background
+     *
+     * <p>Definition: {@code 1 << 7}
+     */
+    public static final int Foreground = 128;
 
     /**
      * a logartithmic (base 10) axis scale will be used (mutually exclusive with ImPlotAxisFlags_Time)
      *
-     * <p>Definition: {@code 1 << 5}
+     * <p>Definition: {@code 1 << 8}
      */
-    public static final int LogScale = 32;
+    public static final int LogScale = 256;
 
     /**
      * axis will display date/time formatted labels (mutually exclusive with ImPlotAxisFlags_LogScale)
      *
-     * <p>Definition: {@code 1 << 6}
+     * <p>Definition: {@code 1 << 9}
      */
-    public static final int Time = 64;
+    public static final int Time = 512;
 
     /**
      * the axis will be inverted
      *
-     * <p>Definition: {@code 1 << 7}
+     * <p>Definition: {@code 1 << 10}
      */
-    public static final int Invert = 128;
-
-    /**
-     * axis will not be initially fit to data extents on the first rendered frame (also the case if SetNextPlotLimits explicitly called)
-     *
-     * <p>Definition: {@code 1 << 8}
-     */
-    public static final int NoInitialFit = 256;
+    public static final int Invert = 1024;
 
     /**
      * axis will be auto-fitting to data extents
      *
-     * <p>Definition: {@code 1 << 9}
+     * <p>Definition: {@code 1 << 11}
      */
-    public static final int AutoFit = 512;
+    public static final int AutoFit = 2048;
 
     /**
-     * axis will only fit points if the point is in the visible range of the **orthoganol** axis
+     * axis will only fit points if the point is in the visible range of the **orthogonal** axis
      *
-     * <p>Definition: {@code 1 << 10}
+     * <p>Definition: {@code 1 << 12}
      */
-    public static final int RangeFit = 1024;
+    public static final int RangeFit = 4096;
 
     /**
      * the axis minimum value will be locked when panning/zooming
      *
-     * <p>Definition: {@code 1 << 11}
+     * <p>Definition: {@code 1 << 13}
      */
-    public static final int LockMin = 2048;
+    public static final int LockMin = 8192;
 
     /**
      * the axis maximum value will be locked when panning/zooming
      *
-     * <p>Definition: {@code 1 << 12}
+     * <p>Definition: {@code 1 << 14}
      */
-    public static final int LockMax = 4096;
+    public static final int LockMax = 16384;
 
     /**
      * Definition: {@code ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax}
      */
-    public static final int Lock = 6144;
+    public static final int Lock = 24576;
 
     /**
      * Definition: {@code ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels}
      */
     public static final int NoDecorations = 15;
+
+    /**
+     * Definition: {@code ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_Opposite}
+     */
+    public static final int AuxDefault = 66;
 }

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotBarGroupsFlags.java

@@ -0,0 +1,21 @@
+package imgui.extension.implot.flag;
+
+
+public final class ImPlotBarGroupsFlags {
+    private ImPlotBarGroupsFlags() {
+    }
+
+    /**
+     * default
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int None = 0;
+
+    /**
+     * items in a group will be stacked on top of each other
+     *
+     * <p>Definition: {@code 1 << 0}
+     */
+    public static final int Stacked = 1;
+}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotCol.java

@@ -71,59 +71,44 @@ public final class ImPlotCol {
     public static final int InlayText = 12;
 
     /**
-     * x-axis label and tick lables color (defaults to ImGuiCol_Text)
+     * axis label and tick lables color (defaults to ImGuiCol_Text)
      */
-    public static final int XAxis = 13;
+    public static final int AxisText = 13;
 
     /**
-     * x-axis grid color (defaults to 25% ImPlotCol_XAxis)
+     * axis grid color (defaults to 25% ImPlotCol_AxisText)
      */
-    public static final int XAxisGrid = 14;
+    public static final int AxisGrid = 14;
 
     /**
-     * y-axis label and tick labels color (defaults to ImGuiCol_Text)
+     * axis tick color (defaults to AxisGrid)
      */
-    public static final int YAxis = 15;
+    public static final int AxisTick = 15;
 
     /**
-     * y-axis grid color (defaults to 25% ImPlotCol_YAxis)
+     * background color of axis hover region (defaults to transparent)
      */
-    public static final int YAxisGrid = 16;
+    public static final int AxisBg = 16;
 
     /**
-     * 2nd y-axis label and tick labels color (defaults to ImGuiCol_Text)
+     * axis hover color (defaults to ImGuiCol_ButtonHovered)
      */
-    public static final int YAxis2 = 17;
+    public static final int AxisBgHovered = 17;
 
     /**
-     * 2nd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis2)
+     * axis active color (defaults to ImGuiCol_ButtonActive)
      */
-    public static final int YAxisGrid2 = 18;
-
-    /**
-     * 3rd y-axis label and tick labels color (defaults to ImGuiCol_Text)
-     */
-    public static final int YAxis3 = 19;
-
-    /**
-     * 3rd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis3)
-     */
-    public static final int YAxisGrid3 = 20;
+    public static final int AxisBgActive = 18;
 
     /**
      * box-selection color (defaults to yellow)
      */
-    public static final int Selection = 21;
-
-    /**
-     * box-query color (defaults to green)
-     */
-    public static final int Query = 22;
+    public static final int Selection = 19;
 
     /**
      * crosshairs color (defaults to ImPlotCol_PlotBorder)
      */
-    public static final int Crosshairs = 23;
+    public static final int Crosshairs = 20;
 
-    public static final int COUNT = 24;
+    public static final int COUNT = 21;
 }

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotCond.java

@@ -0,0 +1,22 @@
+package imgui.extension.implot.flag;
+
+
+public final class ImPlotCond {
+    private ImPlotCond() {
+    }
+
+    /**
+     * No condition (always set the variable), same as _Always
+     */
+    public static final int None = 0;
+
+    /**
+     * No condition (always set the variable)
+     */
+    public static final int Always = 1;
+
+    /**
+     * Set the variable once per runtime session (only the first call will succeed)
+     */
+    public static final int Once = 2;
+}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotDragToolFlags.java

@@ -0,0 +1,42 @@
+package imgui.extension.implot.flag;
+
+
+public final class ImPlotDragToolFlags {
+    private ImPlotDragToolFlags() {
+    }
+
+    /**
+     * default
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int None = 0;
+
+    /**
+     * drag tools won't change cursor icons when hovered or held
+     *
+     * <p>Definition: {@code 1 << 0}
+     */
+    public static final int NoCursors = 1;
+
+    /**
+     * the drag tool won't be considered for plot fits
+     *
+     * <p>Definition: {@code 1 << 1}
+     */
+    public static final int NoFit = 2;
+
+    /**
+     * lock the tool from user inputs
+     *
+     * <p>Definition: {@code 1 << 2}
+     */
+    public static final int NoInputs = 4;
+
+    /**
+     * tool rendering will be delayed one frame; useful when applying position-constraints
+     *
+     * <p>Definition: {@code 1 << 3}
+     */
+    public static final int Delayed = 8;
+}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotFlags.java

@@ -27,32 +27,32 @@ public final class ImPlotFlags {
     public static final int NoLegend = 2;
 
     /**
-     * the user will not be able to open context menus with right-click
+     * the mouse position, in plot coordinates, will not be displayed inside of the plot
      *
      * <p>Definition: {@code 1 << 2}
      */
-    public static final int NoMenus = 4;
+    public static final int NoMouseText = 4;
 
     /**
-     * the user will not be able to box-select with right-click drag
+     * the user will not be able to interact with the plot
      *
      * <p>Definition: {@code 1 << 3}
      */
-    public static final int NoBoxSelect = 8;
+    public static final int NoInputs = 8;
 
     /**
-     * the mouse position, in plot coordinates, will not be displayed inside of the plot
+     * the user will not be able to open context menus
      *
      * <p>Definition: {@code 1 << 4}
      */
-    public static final int NoMousePos = 16;
+    public static final int NoMenus = 16;
 
     /**
-     * plot items will not be highlighted when their legend entry is hovered
+     * the user will not be able to box-select
      *
      * <p>Definition: {@code 1 << 5}
      */
-    public static final int NoHighlight = 32;
+    public static final int NoBoxSelect = 32;
 
     /**
      * a child window region will not be used to capture mouse scroll (can boost performance for single ImGui window applications)
@@ -62,49 +62,35 @@ public final class ImPlotFlags {
     public static final int NoChild = 64;
 
     /**
-     * primary x and y axes will be constrained to have the same units/pixel (does not apply to auxiliary y-axes)
+     * the ImGui frame will not be rendered
      *
      * <p>Definition: {@code 1 << 7}
      */
-    public static final int Equal = 128;
+    public static final int NoFrame = 128;
 
     /**
-     * enable a 2nd y-axis on the right side
+     * x and y axes pairs will be constrained to have the same units/pixel
      *
      * <p>Definition: {@code 1 << 8}
      */
-    public static final int YAxis2 = 256;
-
-    /**
-     * enable a 3rd y-axis on the right side
-     *
-     * <p>Definition: {@code 1 << 9}
-     */
-    public static final int YAxis3 = 512;
-
-    /**
-     * the user will be able to draw query rects with middle-mouse or CTRL + right-click drag
-     *
-     * <p>Definition: {@code 1 << 10}
-     */
-    public static final int Query = 1024;
+    public static final int Equal = 256;
 
     /**
      * the default mouse cursor will be replaced with a crosshair when hovered
      *
-     * <p>Definition: {@code 1 << 11}
+     * <p>Definition: {@code 1 << 9}
      */
-    public static final int Crosshairs = 2048;
+    public static final int Crosshairs = 512;
 
     /**
-     * plot lines will be software anti-aliased (not recommended for high density plots, prefer MSAA)
+     * plot items will be software anti-aliased (not recommended for high density plots, prefer MSAA)
      *
-     * <p>Definition: {@code 1 << 12}
+     * <p>Definition: {@code 1 << 10}
      */
-    public static final int AntiAliased = 4096;
+    public static final int AntiAliased = 1024;
 
     /**
-     * Definition: {@code ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMousePos}
+     * Definition: {@code ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMouseText}
      */
-    public static final int CanvasOnly = 31;
+    public static final int CanvasOnly = 55;
 }

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotLegendFlags.java

@@ -0,0 +1,56 @@
+package imgui.extension.implot.flag;
+
+
+public final class ImPlotLegendFlags {
+    private ImPlotLegendFlags() {
+    }
+
+    /**
+     * default
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int None = 0;
+
+    /**
+     * legend icons will not function as hide/show buttons
+     *
+     * <p>Definition: {@code 1 << 0}
+     */
+    public static final int NoButtons = 1;
+
+    /**
+     * plot items will not be highlighted when their legend entry is hovered
+     *
+     * <p>Definition: {@code 1 << 1}
+     */
+    public static final int NoHighlightItem = 2;
+
+    /**
+     * axes will not be highlighted when legend entries are hovered (only relevant if x/y-axis count{@code >}1)
+     *
+     * <p>Definition: {@code 1 << 2}
+     */
+    public static final int NoHighlightAxis = 4;
+
+    /**
+     * the user will not be able to open context menus with right-click
+     *
+     * <p>Definition: {@code 1 << 3}
+     */
+    public static final int NoMenus = 8;
+
+    /**
+     * legend will be rendered outside of the plot area
+     *
+     * <p>Definition: {@code 1 << 4}
+     */
+    public static final int Outside = 16;
+
+    /**
+     * legend entries will be displayed horizontally
+     *
+     * <p>Definition: {@code 1 << 5}
+     */
+    public static final int Horizontal = 32;
+}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotMouseTextFlags.java

@@ -0,0 +1,35 @@
+package imgui.extension.implot.flag;
+
+
+public final class ImPlotMouseTextFlags {
+    private ImPlotMouseTextFlags() {
+    }
+
+    /**
+     * default
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int None = 0;
+
+    /**
+     * only show the mouse position for primary axes
+     *
+     * <p>Definition: {@code 1 << 0}
+     */
+    public static final int NoAuxAxes = 1;
+
+    /**
+     * axes label formatters won't be used to render text
+     *
+     * <p>Definition: {@code 1 << 1}
+     */
+    public static final int NoFormat = 2;
+
+    /**
+     * always display mouse position even if plot not hovered
+     *
+     * <p>Definition: {@code 1 << 2}
+     */
+    public static final int ShowAlways = 4;
+}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotOrientation.java

@@ -1,17 +0,0 @@
-package imgui.extension.implot.flag;
-
-
-public final class ImPlotOrientation {
-    private ImPlotOrientation() {
-    }
-
-    /**
-     * left/right
-     */
-    public static final int Horizontal = 0;
-
-    /**
-     * up/down
-     */
-    public static final int Vertical = 1;
-}

imgui-binding/src/generated/java/imgui/extension/implot/flag/ImPlotYAxis.java

@@ -1,28 +0,0 @@
-package imgui.extension.implot.flag;
-
-
-public final class ImPlotYAxis {
-    private ImPlotYAxis() {
-    }
-
-    /**
-     * left (default)
-     *
-     * <p>Definition: {@code 0}
-     */
-    public static final int YAxis_1 = 0;
-
-    /**
-     * first on right side
-     *
-     * <p>Definition: {@code 1}
-     */
-    public static final int YAxis_2 = 1;
-
-    /**
-     * second on right side
-     *
-     * <p>Definition: {@code 2}
-     */
-    public static final int YAxis_3 = 2;
-}

imgui-binding/src/generated/java/imgui/extension/memedit/MemoryEditor.java

@@ -8,6 +8,7 @@ import imgui.binding.ImGuiStructDestroyable;
  */
 public final class MemoryEditor extends ImGuiStructDestroyable {
     public MemoryEditor() {
+        super();
     }
 
     public MemoryEditor(final long ptr) {

imgui-binding/src/generated/java/imgui/extension/memedit/MemoryEditorSizes.java

@@ -4,6 +4,7 @@ import imgui.binding.ImGuiStructDestroyable;
 
 public final class MemoryEditorSizes extends ImGuiStructDestroyable {
     public MemoryEditorSizes() {
+        super();
     }
 
     public MemoryEditorSizes(final long ptr) {

imgui-binding/src/generated/java/imgui/extension/nodeditor/NodeEditorConfig.java

@@ -31,7 +31,7 @@ public final class NodeEditorConfig extends ImGuiStructDestroyable {
 
     private native void nSetSettingsFile(String value); /*MANUAL
         auto value = obj_value == NULL ? NULL : (char*)env->GetStringUTFChars(obj_value, JNI_FALSE);
-        THIS->SettingsFile = value;
+        SET_STRING_FIELD(THIS->SettingsFile, value);
         if (value != NULL) env->ReleaseStringUTFChars(obj_value, value);
     */
 

imgui-binding/src/generated/java/imgui/extension/texteditor/TextEditor.java

@@ -7,6 +7,7 @@ import java.util.Map;
 
 public final class TextEditor extends ImGuiStructDestroyable {
     public TextEditor() {
+        super();
     }
 
     public TextEditor(final long ptr) {

imgui-binding/src/generated/java/imgui/extension/texteditor/TextEditorLanguageDefinition.java

@@ -6,6 +6,7 @@ import java.util.Map;
 
 public final class TextEditorLanguageDefinition extends ImGuiStructDestroyable {
     public TextEditorLanguageDefinition() {
+        super();
     }
 
     public TextEditorLanguageDefinition(final long ptr) {

imgui-binding/src/generated/java/imgui/flag/ImGuiBackendFlags.java

@@ -49,7 +49,7 @@ public final class ImGuiBackendFlags {
     public static final int PlatformHasViewports = 1024;
 
     /**
-     * Backend Platform supports setting io.MouseHoveredViewport to the viewport directly under the mouse _IGNORING_ viewports with the ImGuiViewportFlags_NoInputs flag and _REGARDLESS_ of whether another viewport is focused and may be capturing the mouse. This information is _NOT EASY_ to provide correctly with most high-level engines! Don't set this without studying _carefully_ how the backends handle ImGuiViewportFlags_NoInputs!
+     * Backend Platform supports calling io.AddMouseViewportEvent() with the viewport under the mouse. IF POSSIBLE, ignore viewports with the ImGuiViewportFlags_NoInputs flag (Win32 backend, GLFW 3.30+ backend can do this, SDL backend cannot). If this cannot be done, Dear ImGui needs to use a flawed heuristic to find the viewport under.
      *
      * <p>Definition: {@code 1 << 11}
      */

imgui-binding/src/generated/java/imgui/flag/ImGuiColorEditFlags.java

@@ -208,25 +208,4 @@ public final class ImGuiColorEditFlags {
      * <p>Definition: {@code ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_InputHSV}
      */
     public static final int InputMask_ = 402653184;
-
-    /**
-     * [renamed in 1.69]
-     *
-     * <p>Definition: {@code ImGuiColorEditFlags_DisplayRGB}
-     */
-    public static final int RGB = 1048576;
-
-    /**
-     * [renamed in 1.69]
-     *
-     * <p>Definition: {@code ImGuiColorEditFlags_DisplayHSV}
-     */
-    public static final int HSV = 2097152;
-
-    /**
-     * [renamed in 1.69]
-     *
-     * <p>Definition: {@code ImGuiColorEditFlags_DisplayHex}
-     */
-    public static final int HEX = 4194304;
 }

imgui-binding/src/generated/java/imgui/flag/ImGuiConfigFlags.java

@@ -14,7 +14,7 @@ public final class ImGuiConfigFlags {
     public static final int None = 0;
 
     /**
-     * Master keyboard navigation enable flag. NewFrame() will automatically fill io.NavInputs[] based on io.KeysDown[].
+     * Master keyboard navigation enable flag. NewFrame() will automatically fill io.NavInputs[] based on io.AddKeyEvent() calls
      *
      * <p>Definition: {@code 1 << 0}
      */

imgui-binding/src/generated/java/imgui/flag/ImGuiKey.java

@@ -8,67 +8,445 @@ public final class ImGuiKey {
     private ImGuiKey() {
     }
 
-    public static final int Tab = 0;
-
-    public static final int LeftArrow = 1;
-
-    public static final int RightArrow = 2;
-
-    public static final int UpArrow = 3;
-
-    public static final int DownArrow = 4;
-
-    public static final int PageUp = 5;
-
-    public static final int PageDown = 6;
-
-    public static final int Home = 7;
-
-    public static final int End = 8;
-
-    public static final int Insert = 9;
-
-    public static final int Delete = 10;
-
-    public static final int Backspace = 11;
-
-    public static final int Space = 12;
-
-    public static final int Enter = 13;
-
-    public static final int Escape = 14;
-
-    public static final int KeyPadEnter = 15;
+    /**
+     * Keyboard
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int None = 0;
 
     /**
-     * for text edit CTRL+A: select all
+     * == ImGuiKey_NamedKey_BEGIN
+     *
+     * <p>Definition: {@code 512}
      */
-    public static final int A = 16;
+    public static final int Tab = 512;
+
+    public static final int LeftArrow = 513;
+
+    public static final int RightArrow = 514;
+
+    public static final int UpArrow = 515;
+
+    public static final int DownArrow = 516;
+
+    public static final int PageUp = 517;
+
+    public static final int PageDown = 518;
+
+    public static final int Home = 519;
+
+    public static final int End = 520;
+
+    public static final int Insert = 521;
+
+    public static final int Delete = 522;
+
+    public static final int Backspace = 523;
+
+    public static final int Space = 524;
+
+    public static final int Enter = 525;
+
+    public static final int Escape = 526;
+
+    public static final int LeftCtrl = 527;
+
+    public static final int LeftShift = 528;
+
+    public static final int LeftAlt = 529;
+
+    public static final int LeftSuper = 530;
+
+    public static final int RightCtrl = 531;
+
+    public static final int RightShift = 532;
+
+    public static final int RightAlt = 533;
+
+    public static final int RightSuper = 534;
+
+    public static final int Menu = 535;
+
+    public static final int _0 = 536;
+
+    public static final int _1 = 537;
+
+    public static final int _2 = 538;
+
+    public static final int _3 = 539;
+
+    public static final int _4 = 540;
+
+    public static final int _5 = 541;
+
+    public static final int _6 = 542;
+
+    public static final int _7 = 543;
+
+    public static final int _8 = 544;
+
+    public static final int _9 = 545;
+
+    public static final int A = 546;
+
+    public static final int B = 547;
+
+    public static final int C = 548;
+
+    public static final int D = 549;
+
+    public static final int E = 550;
+
+    public static final int F = 551;
+
+    public static final int G = 552;
+
+    public static final int H = 553;
+
+    public static final int I = 554;
+
+    public static final int J = 555;
+
+    public static final int K = 556;
+
+    public static final int L = 557;
+
+    public static final int M = 558;
+
+    public static final int N = 559;
+
+    public static final int O = 560;
+
+    public static final int P = 561;
+
+    public static final int Q = 562;
+
+    public static final int R = 563;
+
+    public static final int S = 564;
+
+    public static final int T = 565;
+
+    public static final int U = 566;
+
+    public static final int V = 567;
+
+    public static final int W = 568;
+
+    public static final int X = 569;
+
+    public static final int Y = 570;
+
+    public static final int Z = 571;
+
+    public static final int F1 = 572;
+
+    public static final int F2 = 573;
+
+    public static final int F3 = 574;
+
+    public static final int F4 = 575;
+
+    public static final int F5 = 576;
+
+    public static final int F6 = 577;
+
+    public static final int F7 = 578;
+
+    public static final int F8 = 579;
+
+    public static final int F9 = 580;
+
+    public static final int F10 = 581;
+
+    public static final int F11 = 582;
+
+    public static final int F12 = 583;
 
     /**
-     * for text edit CTRL+C: copy
+     * '
      */
-    public static final int C = 17;
+    public static final int Apostrophe = 584;
 
     /**
-     * for text edit CTRL+V: paste
+     * ,
      */
-    public static final int V = 18;
+    public static final int Comma = 585;
 
     /**
-     * for text edit CTRL+X: cut
+     * -
      */
-    public static final int X = 19;
+    public static final int Minus = 586;
 
     /**
-     * for text edit CTRL+Y: redo
+     * .
      */
-    public static final int Y = 20;
+    public static final int Period = 587;
 
     /**
-     * for text edit CTRL+Z: undo
+     * /
      */
-    public static final int Z = 21;
+    public static final int Slash = 588;
 
-    public static final int COUNT = 22;
+    /**
+     * ;
+     */
+    public static final int Semicolon = 589;
+
+    /**
+     * =
+     */
+    public static final int Equal = 590;
+
+    /**
+     * [
+     */
+    public static final int LeftBracket = 591;
+
+    /**
+     * \ (this text inhibit multiline comment caused by backslash)
+     */
+    public static final int Backslash = 592;
+
+    /**
+     * ]
+     */
+    public static final int RightBracket = 593;
+
+    /**
+     * `
+     */
+    public static final int GraveAccent = 594;
+
+    public static final int CapsLock = 595;
+
+    public static final int ScrollLock = 596;
+
+    public static final int NumLock = 597;
+
+    public static final int PrintScreen = 598;
+
+    public static final int Pause = 599;
+
+    public static final int Keypad0 = 600;
+
+    public static final int Keypad1 = 601;
+
+    public static final int Keypad2 = 602;
+
+    public static final int Keypad3 = 603;
+
+    public static final int Keypad4 = 604;
+
+    public static final int Keypad5 = 605;
+
+    public static final int Keypad6 = 606;
+
+    public static final int Keypad7 = 607;
+
+    public static final int Keypad8 = 608;
+
+    public static final int Keypad9 = 609;
+
+    public static final int KeypadDecimal = 610;
+
+    public static final int KeypadDivide = 611;
+
+    public static final int KeypadMultiply = 612;
+
+    public static final int KeypadSubtract = 613;
+
+    public static final int KeypadAdd = 614;
+
+    public static final int KeypadEnter = 615;
+
+    public static final int KeypadEqual = 616;
+
+    /**
+     * Menu (Xbox)          + (Switch)   Start/Options (PS) // --
+     */
+    public static final int GamepadStart = 617;
+
+    /**
+     * View (Xbox)          - (Switch)   Share (PS)         // --
+     */
+    public static final int GamepadBack = 618;
+
+    /**
+     * Y (Xbox)             X (Switch)   Triangle (PS)      // {@code ->} ImGuiNavInput_Input
+     */
+    public static final int GamepadFaceUp = 619;
+
+    /**
+     * A (Xbox)             B (Switch)   Cross (PS)         // {@code ->} ImGuiNavInput_Activate
+     */
+    public static final int GamepadFaceDown = 620;
+
+    /**
+     * X (Xbox)             Y (Switch)   Square (PS)        // {@code ->} ImGuiNavInput_Menu
+     */
+    public static final int GamepadFaceLeft = 621;
+
+    /**
+     * B (Xbox)             A (Switch)   Circle (PS)        // {@code ->} ImGuiNavInput_Cancel
+     */
+    public static final int GamepadFaceRight = 622;
+
+    /**
+     * D-pad Up                                             // {@code ->} ImGuiNavInput_DpadUp
+     */
+    public static final int GamepadDpadUp = 623;
+
+    /**
+     * D-pad Down                                           // {@code ->} ImGuiNavInput_DpadDown
+     */
+    public static final int GamepadDpadDown = 624;
+
+    /**
+     * D-pad Left                                           // {@code ->} ImGuiNavInput_DpadLeft
+     */
+    public static final int GamepadDpadLeft = 625;
+
+    /**
+     * D-pad Right                                          // {@code ->} ImGuiNavInput_DpadRight
+     */
+    public static final int GamepadDpadRight = 626;
+
+    /**
+     * L Bumper (Xbox)      L (Switch)   L1 (PS)            // {@code ->} ImGuiNavInput_FocusPrev + ImGuiNavInput_TweakSlow
+     */
+    public static final int GamepadL1 = 627;
+
+    /**
+     * R Bumper (Xbox)      R (Switch)   R1 (PS)            // {@code ->} ImGuiNavInput_FocusNext + ImGuiNavInput_TweakFast
+     */
+    public static final int GamepadR1 = 628;
+
+    /**
+     * L Trigger (Xbox)     ZL (Switch)  L2 (PS) [Analog]
+     */
+    public static final int GamepadL2 = 629;
+
+    /**
+     * R Trigger (Xbox)     ZR (Switch)  R2 (PS) [Analog]
+     */
+    public static final int GamepadR2 = 630;
+
+    /**
+     * L Thumbstick (Xbox)  L3 (Switch)  L3 (PS)
+     */
+    public static final int GamepadL3 = 631;
+
+    /**
+     * R Thumbstick (Xbox)  R3 (Switch)  R3 (PS)
+     */
+    public static final int GamepadR3 = 632;
+
+    /**
+     * [Analog]                                             // {@code ->} ImGuiNavInput_LStickUp
+     */
+    public static final int GamepadLStickUp = 633;
+
+    /**
+     * [Analog]                                             // {@code ->} ImGuiNavInput_LStickDown
+     */
+    public static final int GamepadLStickDown = 634;
+
+    /**
+     * [Analog]                                             // {@code ->} ImGuiNavInput_LStickLeft
+     */
+    public static final int GamepadLStickLeft = 635;
+
+    /**
+     * [Analog]                                             // {@code ->} ImGuiNavInput_LStickRight
+     */
+    public static final int GamepadLStickRight = 636;
+
+    /**
+     * [Analog]
+     */
+    public static final int GamepadRStickUp = 637;
+
+    /**
+     * [Analog]
+     */
+    public static final int GamepadRStickDown = 638;
+
+    /**
+     * [Analog]
+     */
+    public static final int GamepadRStickLeft = 639;
+
+    /**
+     * [Analog]
+     */
+    public static final int GamepadRStickRight = 640;
+
+    /**
+     * Keyboard Modifiers - This is mirroring the data also written to io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper, in a format allowing them to be accessed via standard key API, allowing calls such as IsKeyPressed(), IsKeyReleased(), querying duration etc. - Code polling every keys (e.g. an interface to detect a key press for input mapping) might want to ignore those and prefer using the real keys (e.g. ImGuiKey_LeftCtrl, ImGuiKey_RightCtrl instead of ImGuiKey_ModCtrl). - In theory the value of keyboard modifiers should be roughly equivalent to a logical or of the equivalent left/right keys. In practice: it's complicated; mods are often provided from different sources. Keyboard layout, IME, sticky keys and backends tend to interfere and break that equivalence. The safer decision is to relay that ambiguity down to the end-user...
+     */
+    public static final int ModCtrl = 641;
+
+    /**
+     * Keyboard Modifiers - This is mirroring the data also written to io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper, in a format allowing them to be accessed via standard key API, allowing calls such as IsKeyPressed(), IsKeyReleased(), querying duration etc. - Code polling every keys (e.g. an interface to detect a key press for input mapping) might want to ignore those and prefer using the real keys (e.g. ImGuiKey_LeftCtrl, ImGuiKey_RightCtrl instead of ImGuiKey_ModCtrl). - In theory the value of keyboard modifiers should be roughly equivalent to a logical or of the equivalent left/right keys. In practice: it's complicated; mods are often provided from different sources. Keyboard layout, IME, sticky keys and backends tend to interfere and break that equivalence. The safer decision is to relay that ambiguity down to the end-user...
+     */
+    public static final int ModShift = 642;
+
+    /**
+     * Keyboard Modifiers - This is mirroring the data also written to io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper, in a format allowing them to be accessed via standard key API, allowing calls such as IsKeyPressed(), IsKeyReleased(), querying duration etc. - Code polling every keys (e.g. an interface to detect a key press for input mapping) might want to ignore those and prefer using the real keys (e.g. ImGuiKey_LeftCtrl, ImGuiKey_RightCtrl instead of ImGuiKey_ModCtrl). - In theory the value of keyboard modifiers should be roughly equivalent to a logical or of the equivalent left/right keys. In practice: it's complicated; mods are often provided from different sources. Keyboard layout, IME, sticky keys and backends tend to interfere and break that equivalence. The safer decision is to relay that ambiguity down to the end-user...
+     */
+    public static final int ModAlt = 643;
+
+    /**
+     * Keyboard Modifiers - This is mirroring the data also written to io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper, in a format allowing them to be accessed via standard key API, allowing calls such as IsKeyPressed(), IsKeyReleased(), querying duration etc. - Code polling every keys (e.g. an interface to detect a key press for input mapping) might want to ignore those and prefer using the real keys (e.g. ImGuiKey_LeftCtrl, ImGuiKey_RightCtrl instead of ImGuiKey_ModCtrl). - In theory the value of keyboard modifiers should be roughly equivalent to a logical or of the equivalent left/right keys. In practice: it's complicated; mods are often provided from different sources. Keyboard layout, IME, sticky keys and backends tend to interfere and break that equivalence. The safer decision is to relay that ambiguity down to the end-user...
+     */
+    public static final int ModSuper = 644;
+
+    /**
+     * No valid ImGuiKey is ever greater than this value
+     */
+    public static final int COUNT = 645;
+
+    /**
+     * [Internal] Prior to 1.87 we required user to fill io.KeysDown[512] using their own native index + a io.KeyMap[] array. We are ditching this method but keeping a legacy path for user code doing e.g. IsKeyPressed(MY_NATIVE_KEY_CODE)
+     *
+     * <p>Definition: {@code 512}
+     */
+    public static final int NamedKey_BEGIN = 512;
+
+    /**
+     * [Internal] Prior to 1.87 we required user to fill io.KeysDown[512] using their own native index + a io.KeyMap[] array. We are ditching this method but keeping a legacy path for user code doing e.g. IsKeyPressed(MY_NATIVE_KEY_CODE)
+     *
+     * <p>Definition: {@code ImGuiKey_COUNT}
+     */
+    public static final int NamedKey_END = 645;
+
+    /**
+     * [Internal] Prior to 1.87 we required user to fill io.KeysDown[512] using their own native index + a io.KeyMap[] array. We are ditching this method but keeping a legacy path for user code doing e.g. IsKeyPressed(MY_NATIVE_KEY_CODE)
+     *
+     * <p>Definition: {@code ImGuiKey_NamedKey_END - ImGuiKey_NamedKey_BEGIN}
+     */
+    public static final int NamedKey_COUNT = 133;
+
+    /**
+     * Size of KeysData[]: hold legacy 0..512 keycodes + named keys
+     *
+     * <p>Definition: {@code ImGuiKey_COUNT}
+     */
+    public static final int KeysData_SIZE = 645;
+
+    /**
+     * First key stored in KeysData[0]
+     *
+     * <p>Definition: {@code 0}
+     */
+    public static final int KeysData_OFFSET = 0;
+
+    /**
+     * Renamed in 1.87
+     *
+     * <p>Definition: {@code ImGuiKey_KeypadEnter}
+     */
+    public static final int KeyPadEnter = 615;
 }

imgui-binding/src/generated/java/imgui/flag/ImGuiKeyModFlags.java

@@ -29,7 +29,9 @@ public final class ImGuiKeyModFlags {
     public static final int Alt = 4;
 
     /**
-     * Definition: {@code 1 << 3}
+     * Cmd/Super/Windows key
+     *
+     * <p>Definition: {@code 1 << 3}
      */
     public static final int Super = 8;
 }

imgui-binding/src/generated/java/imgui/flag/ImGuiNavInput.java

@@ -15,27 +15,27 @@ public final class ImGuiNavInput {
     }
 
     /**
-     * activate / open / toggle / tweak value       // e.g. Cross  (PS4), A (Xbox), A (Switch), Space (Keyboard)
+     * Activate / Open / Toggle / Tweak value       // e.g. Cross  (PS4), A (Xbox), A (Switch), Space (Keyboard)
      */
     public static final int Activate = 0;
 
     /**
-     * cancel / close / exit                        // e.g. Circle (PS4), B (Xbox), B (Switch), Escape (Keyboard)
+     * Cancel / Close / Exit                        // e.g. Circle (PS4), B (Xbox), B (Switch), Escape (Keyboard)
      */
     public static final int Cancel = 1;
 
     /**
-     * text input / on-screen keyboard              // e.g. Triang.(PS4), Y (Xbox), X (Switch), Return (Keyboard)
+     * Text input / On-Screen keyboard              // e.g. Triang.(PS4), Y (Xbox), X (Switch), Return (Keyboard)
      */
     public static final int Input = 2;
 
     /**
-     * tap: toggle menu / hold: focus, move, resize // e.g. Square (PS4), X (Xbox), Y (Switch), Alt (Keyboard)
+     * Tap: Toggle menu / Hold: Focus, Move, Resize // e.g. Square (PS4), X (Xbox), Y (Switch), Alt (Keyboard)
      */
     public static final int Menu = 3;
 
     /**
-     * move / tweak / resize window (w/ PadMenu)    // e.g. D-pad Left/Right/Up/Down (Gamepads), Arrow keys (Keyboard)
+     * Move / Tweak / Resize window (w/ PadMenu)    // e.g. D-pad Left/Right/Up/Down (Gamepads), Arrow keys (Keyboard)
      */
     public static final int DpadLeft = 4;
 
@@ -46,7 +46,7 @@ public final class ImGuiNavInput {
     public static final int DpadDown = 7;
 
     /**
-     * scroll / move window (w/ PadMenu)            // e.g. Left Analog Stick Left/Right/Up/Down
+     * Scroll / Move window (w/ PadMenu)            // e.g. Left Analog Stick Left/Right/Up/Down
      */
     public static final int LStickLeft = 8;
 
@@ -57,49 +57,44 @@ public final class ImGuiNavInput {
     public static final int LStickDown = 11;
 
     /**
-     * next window (w/ PadMenu)                     // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
+     * Focus Next window (w/ PadMenu)               // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
      */
     public static final int FocusPrev = 12;
 
     /**
-     * prev window (w/ PadMenu)                     // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
+     * Focus Prev window (w/ PadMenu)               // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
      */
     public static final int FocusNext = 13;
 
     /**
-     * slower tweaks                                // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
+     * Slower tweaks                                // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
      */
     public static final int TweakSlow = 14;
 
     /**
-     * faster tweaks                                // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
+     * Faster tweaks                                // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
      */
     public static final int TweakFast = 15;
 
     /**
-     * move left                                    // = Arrow keys
+     * Move left                                    // = Arrow keys
      */
     public static final int KeyLeft_ = 16;
 
     /**
-     * move right
+     * Move right
      */
     public static final int KeyRight_ = 17;
 
     /**
-     * move up
+     * Move up
      */
     public static final int KeyUp_ = 18;
 
     /**
-     * move down
+     * Move down
      */
     public static final int KeyDown_ = 19;
 
     public static final int COUNT = 20;
-
-    /**
-     * Definition: {@code ImGuiNavInput_KeyLeft_}
-     */
-    public static final int InternalStart_ = 16;
 }

imgui-binding/src/generated/java/imgui/flag/ImGuiTableRowFlags.java

@@ -14,7 +14,7 @@ public final class ImGuiTableRowFlags {
     public static final int None = 0;
 
     /**
-     * Identify header row (set default background color + width of its contents accounted different for auto column width)
+     * Identify header row (set default background color + width of its contents accounted differently for auto column width)
      *
      * <p>Definition: {@code 1 << 0}
      */