🚧 up to Aug 22 half

Author: elect86

src/main/kotlin/imgui/Context.kt

@@ -386,9 +386,9 @@ class Context(sharedFontAtlas: FontAtlas? = null) {
         g.drawDataBuilder.clear()
         g.overlayDrawList.clearFreeMemory()
         g.privateClipboard = ""
-        g.inputTextState.text = charArrayOf()
+        g.inputTextState.textW = charArrayOf()
         g.inputTextState.initialText = charArrayOf()
-        g.inputTextState.tempTextBuffer = charArrayOf()
+        g.inputTextState.tempBuffer = charArrayOf()
 
 //        if (g.logFile != null && g.logFile != stdout) { TODO
 //            fclose(g.LogFile)

src/main/kotlin/imgui/TextEditState.kt

@@ -13,11 +13,11 @@ class TextEditState {
     var id: ID = 0
     /** edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer.
      *  So we copy into own buffer.    */
-    var text = CharArray(0)
+    var textW = CharArray(0)
     /** backup of end-user buffer at the time of focus (in UTF-8, unaltered)    */
     var initialText = CharArray(0)
-
-    var tempTextBuffer = CharArray(0)
+    /** temporary buffer for callback and other other operations. size=capacity. */
+    var tempBuffer = CharArray(0)
     /** we need to maintain our buffer length in both UTF-8 and wchar format.   */
     var curLenA = 0
     /** we need to maintain our buffer length in both UTF-8 and wchar format.   */
@@ -37,7 +37,7 @@ class TextEditState {
 
     // Temporarily set when active
     var userFlags: InputTextFlags = 0
-    var userCallback: TextEditCallback? = null
+    var userCallback: InputTextCallback? = null
     var userCallbackData: Any? = null
 
     /** After a user-input the cursor stays on for a while without blinking */
@@ -63,6 +63,7 @@ class TextEditState {
         state.hasPreferredX = false
     }
 
+    /** Cannot be inline because we call in code in stb_textedit.h implementation */
     fun onKeyPressed(key: Int) {
         key(key)
         cursorFollow = true
@@ -79,9 +80,9 @@ class TextEditState {
 
     val stringLen get() = curLenW
 
-    fun getChar(idx: Int) = text[idx]
+    fun getChar(idx: Int) = textW[idx]
     fun getWidth(lineStartIdx: Int, charIdx: Int): Float {
-        val c = text[lineStartIdx + charIdx]
+        val c = textW[lineStartIdx + charIdx]
         return if (c == '\n') -1f else g.font.getCharAdvance(c) * (g.fontSize / g.font.fontSize)
     }
 
@@ -92,7 +93,7 @@ class TextEditState {
 
     fun layout(r: Row, lineStartIdx: Int) {
 
-        val size = inputTextCalcTextSizeW(text, lineStartIdx, curLenW, ::textRemaining, null, true)
+        val size = inputTextCalcTextSizeW(textW, lineStartIdx, curLenW, ::textRemaining, null, true)
         with(r) {
             r.x0 = 0f
             r.x1 = size.x
@@ -107,7 +108,7 @@ class TextEditState {
         get() = isBlankW || this == ',' || this == ';' || this == '(' || this == ')' ||
                 this == '{' || this == '}' || this == '[' || this == ']' || this == '|'
 
-    fun isWordBoundaryFromRight(idx: Int) = if (idx > 0) text[idx - 1].isSeparator && !text[idx].isSeparator else true
+    fun isWordBoundaryFromRight(idx: Int) = if (idx > 0) textW[idx - 1].isSeparator && !textW[idx].isSeparator else true
 
     fun moveWordLeft(idx_: Int): Int {
         var idx = idx_ - 1
@@ -131,9 +132,9 @@ class TextEditState {
         curLenW -= n
 
         // Offset remaining text
-        for (c in pos + n until text.size)
-            text[dst++] = text[c]
-        text[dst] = NUL
+        for (c in pos + n until textW.size)
+            textW[dst++] = textW[c]
+        textW[dst] = NUL
     }
 
     fun insertChars(pos: Int, newText: CharArray, ptr: Int, newTextLen: Int): Boolean {
@@ -147,22 +148,22 @@ class TextEditState {
         if (!isResizable && newTextLenUtf8 + curLenA > bufCapacityA) return false
 
         // Grow internal buffer if needed
-        if (newTextLen + textLen > text.size)        {
+        if (newTextLen + textLen > textW.size) {
             if (!isResizable)
                 return false
-            assert(textLen < text.size)
+            assert(textLen < textW.size)
             val tmp = CharArray(textLen + glm.clamp(newTextLen * 4, 32, max(256, newTextLen)))
-            System.arraycopy(text, 0, tmp, 0, text.size)
-            text = tmp
+            System.arraycopy(textW, 0, tmp, 0, textW.size)
+            textW = tmp
         }
 
         if (pos != textLen)
-            for (i in 0 until textLen - pos) text[textLen - 1 + newTextLen - i] = text[textLen - 1 - i]
-        for (i in 0 until newTextLen) text[pos + i] = newText[ptr + i]
+            for (i in 0 until textLen - pos) textW[textLen - 1 + newTextLen - i] = textW[textLen - 1 - i]
+        for (i in 0 until newTextLen) textW[pos + i] = newText[ptr + i]
 
         curLenW += newTextLen
         curLenA += newTextLenUtf8
-        text[curLenW] = NUL
+        textW[curLenW] = NUL
 
         return true
     }
@@ -478,7 +479,7 @@ class TextEditState {
         }
 
         // if the last character is a newline, return that. otherwise return 'after' the last character
-        return if (text[i + r.numChars - 1] == '\n') i + r.numChars - 1 else i + r.numChars
+        return if (textW[i + r.numChars - 1] == '\n') i + r.numChars - 1 else i + r.numChars
     }
 
     /** API click: on mouse down, move the cursor to the clicked location, and reset the selection  */
@@ -797,7 +798,7 @@ class TextEditState {
         clamp()
         deleteSelection()
         // try to insert the characters
-        if (insertChars(state.cursor, text, 0, len)) {
+        if (insertChars(state.cursor, textW, 0, len)) {
             makeundoInsert(state.cursor, len)
             state.cursor += len
             state.hasPreferredX = true

src/main/kotlin/imgui/enums.kt

@@ -127,7 +127,7 @@ enum class InputTextFlag(val i: Int) {
     /** Allow 0123456789.+-* /eE (Scientific notation input) */
     CharsScientific(1 shl 17),
     /** Allow buffer capacity resize + notify when the string wants to be resized
-     *  (for string types which hold a cache of their Size) */
+     *  (for string types which hold a cache of their Size) (see misc/stl/imgui_stl.h for an example of using this) */
     CallbackResize(1 shl 18),
 
     // [Internal]

src/main/kotlin/imgui/font.kt

@@ -1195,7 +1195,7 @@ class Font {
     }
 
     //    const ImVec4& clipRect, const char* text, const char* textEnd, float wrapWidth = 0.0f, bool cpuFineClip = false) const;
-    fun renderText(drawList: DrawList, size: Float, pos: Vec2, col: Int, clipRect: Vec4, text: CharArray, textEnd: Int = text.size,
+    fun renderText(drawList: DrawList, size: Float, pos: Vec2, col: Int, clipRect: Vec4, text: CharArray, textEnd_: Int = text.size, // TODO return it also?
                    wrapWidth: Float = 0f, cpuFineClip: Boolean = false) {
 
         // Align to be pixel perfect
@@ -1209,11 +1209,32 @@ class Font {
         val wordWrapEnabled = wrapWidth > 0f
         var wordWrapEol = 0
 
-        // Skip non-visible lines
+        // Fast-forward to first visible line
         var s = 0
-        if (!wordWrapEnabled && y + lineHeight < clipRect.y)
-            while (s < textEnd && text[s] != '\n')  // Fast-forward to next line
-                s++
+        if (y + lineHeight < clipRect.y && !wordWrapEnabled)
+            while (y + lineHeight < clipRect.y) {
+                while (s < textEnd_)
+                    if (text[s++] == '\n')
+                        break
+                y += lineHeight
+            }
+
+        /*  For large text, scan for the last visible line in order to avoid over-reserving in the call to PrimReserve()
+            Note that very large horizontal line will still be affected by the issue (e.g. a one megabyte string buffer without a newline will likely crash atm)         */
+        var textEnd = textEnd_
+        if (textEnd - s > 10000 && !wordWrapEnabled)        {
+            var sEnd = s
+            var yEnd = y
+            while (yEnd < clipRect.w)            {
+                while (sEnd < textEnd)
+                    if (text[sEnd++] == '\n')
+                        break
+                yEnd += lineHeight
+            }
+            textEnd = sEnd
+        }
+
+
 
         // Reserve vertices for remaining worse case (over-reserving is useful and easily amortized)
         val vtxCountMax = (textEnd - s) * 4
@@ -1274,12 +1295,8 @@ class Font {
                 if (c == '\n') {
                     x = pos.x
                     y += lineHeight
-
-                    if (y > clipRect.w) break
-
-                    if (!wordWrapEnabled && y + lineHeight < clipRect.y)
-                        while (s < textEnd && text[s] != '\n')  // Fast-forward to next line
-                            s++
+                    if (y > clipRect.w)
+                        break // break out of main loop
                     continue
                 }
                 if (c == '\r') continue

src/main/kotlin/imgui/helpers.kt

@@ -14,7 +14,9 @@ import imgui.ImGui.inputText
 import imgui.ImGui.popItemWidth
 import imgui.ImGui.pushItemWidth
 import imgui.ImGui.style
+import imgui.internal.strlen
 import java.nio.ByteBuffer
+import kotlin.math.max
 
 /** Helper: Execute a block of code at maximum once a frame. Convenient if you want to quickly create an UI within
  *  deep-nested code that runs multiple times every frame.
@@ -139,14 +141,18 @@ class Storage {
     fun setAllInt(value: Int) = data.replaceAll { _, _ -> value }
 }
 
-/** Shared state of InputText(), passed to callback when a ImGuiInputTextFlags_Callback* flag is used and the corresponding callback is triggered.
+/** Shared state of InputText(), passed as an argument to your callback when a ImGuiInputTextFlags_Callback* flag is used.
  *  The callback function should return 0 by default.
  *  Special processing:
  *  - InputTextFlag.CallbackCharFilter:  return 1 if the character is not allowed. You may also set 'EventChar=0'
  *                                       as any character replacement are allowed.
- *  - InputTextFlag.CallbackResize:      BufTextLen is set to the new desired string length so you can allocate or update known size.
- *                                       No need to initialize new characters or zero-terminator as InputText will do it. */
-class TextEditCallbackData {
+ *  - InputTextFlag.CallbackResize:      notified by InputText() when the string is resized.
+ *                                       BufTextLen is set to the new desired string length so you can allocate or update known size.
+ *                                       No need to initialize new characters or zero-terminator as InputText will do it.
+ *
+ *  Helper functions for text manipulation.
+ *  Use those function to benefit from the CallbackResize behaviors. Calling those function reset the selection. */
+class InputTextCallbackData {
 
     /** One ImGuiInputTextFlags_Callback*    // Read-only */
     var eventFlag: InputTextFlags = 0
@@ -156,19 +162,20 @@ class TextEditCallbackData {
     var userData: Any? = null
 
     /*  Arguments for the different callback events
-     *  (If you modify the 'buf' contents make sure you update 'BufTextLen' and set 'BufDirty' to true!) */
+     *  - To modify the text buffer in a callback, prefer using the InsertChars() / DeleteChars() function. InsertChars() will take care of calling the resize callback if necessary.
+     *  - If you know your edits are not going to resize the underlying buffer allocation, you may modify the contents of 'Buf[]' directly. You need to update 'BufTextLen' accordingly (0 <= BufTextLen < BufSize) and set 'BufDirty'' to true so InputText can update its internal state. */
 
     /** Character input                     Read-write   [CharFilter] Replace character or set to zero. return 1 is equivalent to setting EventChar=0; */
     var eventChar = NUL
     /** Key pressed (Up/Down/TAB)           Read-only    [Completion,History] */
     var eventKey = Key.Tab
-    /** Current text buffer                 Read-write   [Resize] Can replace pointer / [Completion,History,Always] Only write to pointed data, don't replace the actual pointer! */
+    /** Text buffer                 Read-write   [Resize] Can replace pointer / [Completion,History,Always] Only write to pointed data, don't replace the actual pointer! */
     var buf = CharArray(0)
     /** JVM custom, current buf pointer */
     var bufPtr = 0
-    /** Current text length in bytes        Read-write   [Resize,Completion,History,Always] */
+    /** Text length in bytes        Read-write   [Resize,Completion,History,Always] */
     var bufTextLen = 0
-    /** Capacity + 1 (max text length + 1)  Read-only    [Resize,Completion,History,Always] */
+    /** Buffer capacity in bytes    Read-only    [Resize,Completion,History,Always] */
     var bufSize = 0
     /** Set if you modify Buf/BufTextLen!!  Write        [Completion,History,Always] */
     var bufDirty = false
@@ -180,10 +187,65 @@ class TextEditCallbackData {
     var selectionEnd = 0
 
 
-//    IMGUI_API void      DeleteChars(int pos, int bytes_count);
-//    IMGUI_API void      InsertChars(int pos, const char* text, const char* text_end = NULL);
+    /** Public API to manipulate UTF-8 text
+     *  We expose UTF-8 to the user (unlike the STB_TEXTEDIT_* functions which are manipulating wchar)
+     *  FIXME: The existence of this rarely exercised code path is a bit of a nuisance. */
+    fun deleteChars(pos: Int, bytesCount: Int) {
+        assert(pos + bytesCount <= bufTextLen)
+        var dst = pos
+        var src = pos + bytesCount
+        var c = buf[src++]
+        while (c != NUL) {
+            buf[dst++] = c
+            c = buf.getOrElse(src++) { NUL }
+        }
+        if (cursorPos + bytesCount >= pos)
+            cursorPos -= bytesCount
+        else if (cursorPos >= pos)
+            cursorPos = pos
+        selectionEnd = cursorPos
+        selectionStart = cursorPos
+        bufDirty = true
+        bufTextLen -= bytesCount
+    }
+
+    fun insertChars(pos: Int, newText: CharArray, ptr: Int, newTextEnd: Int? = null) {
+
+        val isResizable = flags has InputTextFlag.CallbackResize
+        val newTextLen = newTextEnd ?: newText.strlen
+        if (newTextLen + bufTextLen >= bufSize) {
+
+            if (!isResizable) return
+
+            // Contrary to STB_TEXTEDIT_INSERTCHARS() this is working in the UTF8 buffer, hence the midly similar code (until we remove the U16 buffer alltogether!)
+            val editState = g.inputTextState
+            assert(editState.id != 0 && g.activeId == editState.id)
+            assert(buf === editState.tempBuffer)
+            val newBufSize = bufTextLen + glm.clamp(newTextLen * 4, 32, max(256, newTextLen))
+            val t = CharArray(newBufSize)
+            System.arraycopy(editState.tempBuffer, 0, t, 0, editState.tempBuffer.size)
+            editState.tempBuffer = t
+            buf = editState.tempBuffer
+            editState.bufCapacityA = newBufSize
+            bufSize = newBufSize
+        }
+
+        if (bufTextLen != pos)
+            for (i in 0 until bufTextLen - pos)
+                buf[pos + newTextLen + i] = buf[pos + i]
+        for (i in 0 until newTextLen)
+            buf[pos + i] = newText[i]
+
+        if (cursorPos >= pos)
+            cursorPos += newTextLen
+        selectionEnd = cursorPos
+        selectionStart = cursorPos
+        bufDirty = true
+        bufTextLen += newTextLen
+    }
+
     val hasSelection: Boolean
-    get() = selectionStart != selectionEnd
+        get() = selectionStart != selectionEnd
 }
 
 class SizeCallbackData(

src/main/kotlin/imgui/imgui.kt

@@ -154,7 +154,7 @@ typealias TreeNodeFlags = Int
 /** flags: for Begin*()                      // enum WindowFlag */
 typealias WindowFlags = Int
 
-typealias TextEditCallback = (TextEditCallbackData) -> Int
+typealias InputTextCallback = (InputTextCallbackData) -> Int
 typealias SizeCallback = (SizeCallbackData) -> Unit
 
 // dummy main

src/main/kotlin/imgui/imgui/demo/showExampleApp/Console.kt

@@ -162,14 +162,15 @@ object Console {
 //            bool reclaim_focus = false;
 //            if (ImGui::InputText("Input", InputBuf, IM_ARRAYSIZE(InputBuf), ImGuiInputTextFlags_EnterReturnsTrue|ImGuiInputTextFlags_CallbackCompletion|ImGuiInputTextFlags_CallbackHistory, &TextEditCallbackStub, (void*)this))
 //            {
-//                Strtrim(InputBuf);
-//                if (InputBuf[0])
-//                    ExecCommand(InputBuf);
-//                strcpy(InputBuf, "");
+//                char* s = InputBuf;
+//                Strtrim(s);
+//                if (s[0])
+//                    ExecCommand(s);
+//                strcpy(s, "");
 //                reclaim_focus = true;
 //            }
 //
-//            // Demonstrate keeping focus on the input box
+//            // Auto-focus on window apparition
 //            ImGui::SetItemDefaultFocus();
 //            if (reclaim_focus)
 //                ImGui::SetKeyboardFocusHere(-1); // Auto focus previous widget
@@ -218,10 +219,10 @@ object Console {
 //        static int TextEditCallbackStub(ImGuiTextEditCallbackData* data) // In C++11 you are better off using lambdas for this sort of forwarding callbacks
 //        {
 //            ExampleAppConsole* console = (ExampleAppConsole*)data->UserData;
-//            return console->TextEditCallback(data);
+//            return console->InputTextCallback(data);
 //        }
 //
-//        int     TextEditCallback(ImGuiTextEditCallbackData* data)
+//        int     InputTextCallback(ImGuiTextEditCallbackData* data)
 //        {
 //            //AddLog("cursor: %d, selection: %d-%d", data->CursorPos, data->SelectionStart, data->SelectionEnd);
 //            switch (data->EventFlag)
@@ -312,9 +313,9 @@ object Console {
 //                    // A better implementation would preserve the data on the current input line along with cursor position.
 //                    if (prev_history_pos != HistoryPos)
 //                        {
-//                            int sz = (int)snprintf(data->Buf, (size_t)data->BufSize, "%s", (HistoryPos >= 0) ? History[HistoryPos] : "");
-//                            data->CursorPos = data->SelectionStart = data->SelectionEnd = data->BufTextLen = sz;
-//                            data->BufDirty = true;
+//                          const char* history_str = (HistoryPos >= 0) ? History[HistoryPos] : "";
+//                          data->DeleteChars(0, data->BufTextLen);
+//                          data->InsertChars(0, history_str);
 //                        }
 //                }
 //            }