|
|
@@ -0,0 +1,1067 @@
|
|
|
+/*******************************************************************************************
|
|
|
+*
|
|
|
+* Text box extended (cursor positioning and editing)
|
|
|
+*
|
|
|
+* MODULE USAGE:
|
|
|
+* #define GUI_TEXTBOX_EXTENDED_IMPLEMENTATION
|
|
|
+* #include "gui_textbox_extended.h"
|
|
|
+*
|
|
|
+* On game draw call: GuiTextBoxEx(...);
|
|
|
+*
|
|
|
+* LICENSE: zlib/libpng
|
|
|
+*
|
|
|
+* Copyright (c) 2019 Vlad Adrian (@Demizdor) and Ramon Santamaria (@raysan5)
|
|
|
+*
|
|
|
+* This software is provided "as-is", without any express or implied warranty. In no event
|
|
|
+* will the authors be held liable for any damages arising from the use of this software.
|
|
|
+*
|
|
|
+* Permission is granted to anyone to use this software for any purpose, including commercial
|
|
|
+* applications, and to alter it and redistribute it freely, subject to the following restrictions:
|
|
|
+*
|
|
|
+* 1. The origin of this software must not be misrepresented; you must not claim that you
|
|
|
+* wrote the original software. If you use this software in a product, an acknowledgment
|
|
|
+* in the product documentation would be appreciated but is not required.
|
|
|
+*
|
|
|
+* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
|
|
|
+* as being the original software.
|
|
|
+*
|
|
|
+* 3. This notice may not be removed or altered from any source distribution.
|
|
|
+*
|
|
|
+**********************************************************************************************/
|
|
|
+
|
|
|
+#ifndef GUI_TEXTBOX_EXTENDED_H
|
|
|
+#define GUI_TEXTBOX_EXTENDED_H
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Defines and Macros
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+//...
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Types and Structures Definition
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+
|
|
|
+// Text box state data
|
|
|
+typedef struct GuiTextBoxState {
|
|
|
+ int cursor; // Cursor position in text
|
|
|
+ int start; // Text start position (from where we begin drawing the text)
|
|
|
+ int index; // Text start index (index inside the text of `start` always in sync)
|
|
|
+ int select; // Marks position of cursor when selection has started
|
|
|
+} GuiTextBoxState;
|
|
|
+
|
|
|
+#ifdef __cplusplus
|
|
|
+extern "C" { // Prevents name mangling of functions
|
|
|
+#endif
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Module Functions Declaration
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+RAYGUIDEF void GuiTextBoxSetActive(Rectangle bounds); // Sets the active textbox
|
|
|
+RAYGUIDEF Rectangle GuiTextBoxGetActive(void); // Get bounds of active textbox
|
|
|
+
|
|
|
+RAYGUIDEF void GuiTextBoxSetCursor(int cursor); // Set cursor position of active textbox
|
|
|
+RAYGUIDEF int GuiTextBoxGetCursor(void); // Get cursor position of active textbox
|
|
|
+
|
|
|
+RAYGUIDEF void GuiTextBoxSetSelection(int start, int length); // Set selection of active textbox
|
|
|
+RAYGUIDEF Vector2 GuiTextBoxGetSelection(void); // Get selection of active textbox (x - selection start y - selection length)
|
|
|
+
|
|
|
+RAYGUIDEF bool GuiTextBoxIsActive(Rectangle bounds); // Returns true if a textbox control with specified `bounds` is the active textbox
|
|
|
+RAYGUIDEF GuiTextBoxState GuiTextBoxGetState(void); // Get state for the active textbox
|
|
|
+RAYGUIDEF void GuiTextBoxSetState(GuiTextBoxState state); // Set state for the active textbox (state must be valid else things will break)
|
|
|
+
|
|
|
+RAYGUIDEF void GuiTextBoxSelectAll(const char *text); // Select all characters in the active textbox (same as pressing `CTRL` + `A`)
|
|
|
+RAYGUIDEF void GuiTextBoxCopy(const char *text); // Copy selected text to clipboard from the active textbox (same as pressing `CTRL` + `C`)
|
|
|
+RAYGUIDEF void GuiTextBoxPaste(char *text, int textSize); // Paste text from clipboard into the textbox (same as pressing `CTRL` + `V`)
|
|
|
+RAYGUIDEF void GuiTextBoxCut(char *text); // Cut selected text in the active textbox and copy it to clipboard (same as pressing `CTRL` + `X`)
|
|
|
+RAYGUIDEF int GuiTextBoxDelete(char *text, int length, bool before); // Deletes a character or selection before from the active textbox (depending on `before`). Returns bytes deleted.
|
|
|
+RAYGUIDEF int GuiTextBoxGetByteIndex(const char *text, int start, int from, int to); // Get the byte index for a character starting at position `from` with index `start` until position `to`.
|
|
|
+
|
|
|
+RAYGUIDEF bool GuiTextBoxEx(Rectangle bounds, char *text, int textSize, bool editMode);
|
|
|
+
|
|
|
+#ifdef __cplusplus
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+#endif // GUI_TEXTBOX_EXTENDED_H
|
|
|
+
|
|
|
+/***********************************************************************************
|
|
|
+*
|
|
|
+* GUI TEXTBOX EXTENDED IMPLEMENTATION
|
|
|
+*
|
|
|
+************************************************************************************/
|
|
|
+
|
|
|
+#if defined(GUI_TEXTBOX_EXTENDED_IMPLEMENTATION)
|
|
|
+
|
|
|
+#include "raygui.h"
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Defines and Macros
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+//...
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Types and Structures Definition
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Cursor measure mode
|
|
|
+typedef enum {
|
|
|
+ GUI_MEASURE_MODE_CURSOR_END = 0xA,
|
|
|
+ GUI_MEASURE_MODE_CURSOR_POS,
|
|
|
+ GUI_MEASURE_MODE_CURSOR_COORDS
|
|
|
+} GuiMeasureMode;
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Global Variables Definition
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+static Rectangle guiTextBoxActive = { 0 }; // Area of the currently active textbox
|
|
|
+
|
|
|
+static GuiTextBoxState guiTextBoxState = { // Keeps state of the active textbox
|
|
|
+ .cursor = -1,
|
|
|
+ .start = 0,
|
|
|
+ .index = 0,
|
|
|
+ .select = -1
|
|
|
+};
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Module Internal Functions Declaration
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+static int GetPrevCodepoint(const char *text, const char *start, int *prev);
|
|
|
+static int GuiMeasureTextBox(const char *text, int length, Rectangle rec, int *pos, int mode);
|
|
|
+static int GuiMeasureTextBoxRev(const char *text, int length, Rectangle rec, int *pos); // Highly synchronized with calculations in DrawTextRecEx()
|
|
|
+
|
|
|
+static inline int GuiTextBoxGetCursorCoordinates(const char *text, int length, Rectangle rec, int pos); // Calculate cursor coordinates based on the cursor position `pos` inside the `text`.
|
|
|
+static inline int GuiTextBoxGetCursorFromMouse(const char *text, int length, Rectangle rec, int *pos); // Calculate cursor position in textbox based on mouse coordinates.
|
|
|
+static inline int GuiTextBoxMaxCharacters(const char *text, int length, Rectangle rec); // Calculates how many characters is the textbox able to draw inside rec
|
|
|
+static inline unsigned int GuiCountCodepointsUntilNewline(const char *text); // Returns total number of characters(codepoints) in a UTF8 encoded `text` until `\0` or a `\n` is found.
|
|
|
+
|
|
|
+static inline void MoveTextBoxCursorRight(const char *text, int length, Rectangle textRec);
|
|
|
+static inline void MoveTextBoxCursorLeft(const char *text);
|
|
|
+
|
|
|
+static int EncodeCodepoint(unsigned int c, char out[5]);
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Module Functions Definition
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+
|
|
|
+// Sets the active textbox (reseting state of the previous active textbox)
|
|
|
+RAYGUIDEF void GuiTextBoxSetActive(Rectangle bounds)
|
|
|
+{
|
|
|
+ guiTextBoxActive = bounds;
|
|
|
+ guiTextBoxState = (GuiTextBoxState){ .cursor = -1, .start = 0, .index = 0, .select = -1 };
|
|
|
+}
|
|
|
+
|
|
|
+// Gets bounds of active textbox
|
|
|
+RAYGUIDEF Rectangle GuiTextBoxGetActive(void) { return guiTextBoxActive; }
|
|
|
+
|
|
|
+// Set cursor position of active textbox
|
|
|
+RAYGUIDEF void GuiTextBoxSetCursor(int cursor)
|
|
|
+{
|
|
|
+ guiTextBoxState.cursor = (cursor < 0) ? -1 : cursor;
|
|
|
+ guiTextBoxState.start = -1; // Mark this to be recalculated
|
|
|
+}
|
|
|
+
|
|
|
+// Get cursor position of active textbox
|
|
|
+RAYGUIDEF int GuiTextBoxGetCursor(void) { return guiTextBoxState.cursor; }
|
|
|
+
|
|
|
+// Set selection of active textbox
|
|
|
+RAYGUIDEF void GuiTextBoxSetSelection(int start, int length)
|
|
|
+{
|
|
|
+ if (start < 0) start = 0;
|
|
|
+ if (length < 0) length = 0;
|
|
|
+
|
|
|
+ GuiTextBoxSetCursor(start + length);
|
|
|
+ guiTextBoxState.select = start;
|
|
|
+}
|
|
|
+
|
|
|
+// Get selection of active textbox
|
|
|
+RAYGUIDEF Vector2 GuiTextBoxGetSelection(void)
|
|
|
+{
|
|
|
+ if (guiTextBoxState.select == -1 || guiTextBoxState.select == guiTextBoxState.cursor) return RAYGUI_CLITERAL(Vector2){ 0 };
|
|
|
+ else if (guiTextBoxState.cursor > guiTextBoxState.select) return RAYGUI_CLITERAL(Vector2){ guiTextBoxState.select, guiTextBoxState.cursor - guiTextBoxState.select };
|
|
|
+
|
|
|
+ return RAYGUI_CLITERAL(Vector2){ guiTextBoxState.cursor, guiTextBoxState.select - guiTextBoxState.cursor };
|
|
|
+}
|
|
|
+
|
|
|
+// Returns true if a textbox control with specified `bounds` is the active textbox
|
|
|
+RAYGUIDEF bool GuiTextBoxIsActive(Rectangle bounds)
|
|
|
+{
|
|
|
+ return (bounds.x == guiTextBoxActive.x && bounds.y == guiTextBoxActive.y &&
|
|
|
+ bounds.width == guiTextBoxActive.width && bounds.height == guiTextBoxActive.height);
|
|
|
+}
|
|
|
+
|
|
|
+RAYGUIDEF GuiTextBoxState GuiTextBoxGetState(void) { return guiTextBoxState; }
|
|
|
+RAYGUIDEF void GuiTextBoxSetState(GuiTextBoxState state)
|
|
|
+{
|
|
|
+ // NOTE: should we check if state values are valid ?!?
|
|
|
+ guiTextBoxState = state;
|
|
|
+}
|
|
|
+
|
|
|
+RAYGUIDEF int GuiTextBoxGetByteIndex(const char *text, int start, int from, int to)
|
|
|
+{
|
|
|
+ int i = start, k = from;
|
|
|
+
|
|
|
+ while ((text[i] != '\0') && (k < to))
|
|
|
+ {
|
|
|
+ int j = 0;
|
|
|
+ int letter = GetNextCodepoint(&text[i], &j);
|
|
|
+
|
|
|
+ if (letter == 0x3f) j = 1;
|
|
|
+ i += j;
|
|
|
+ ++k;
|
|
|
+ }
|
|
|
+
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+RAYGUIDEF int GuiTextBoxDelete(char *text, int length, bool before)
|
|
|
+{
|
|
|
+ if ((guiTextBoxState.cursor != -1) && (text != NULL))
|
|
|
+ {
|
|
|
+ int startIdx = 0, endIdx = 0;
|
|
|
+ if ((guiTextBoxState.select != -1) && (guiTextBoxState.select != guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ // Delete selection
|
|
|
+ int start = guiTextBoxState.cursor;
|
|
|
+ int end = guiTextBoxState.select;
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor > guiTextBoxState.select)
|
|
|
+ {
|
|
|
+ start = guiTextBoxState.select;
|
|
|
+ end = guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Convert to byte indexes
|
|
|
+ startIdx = GuiTextBoxGetByteIndex(text, 0, 0, start);
|
|
|
+ endIdx = GuiTextBoxGetByteIndex(text, 0, 0, end);
|
|
|
+
|
|
|
+ // Adjust text box state
|
|
|
+ guiTextBoxState.cursor = start; // Always set cursor to start of selection
|
|
|
+ if (guiTextBoxState.select < guiTextBoxState.start) guiTextBoxState.start = -1; // Force to recalculate on the next frame
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (before)
|
|
|
+ {
|
|
|
+ // Delete character before cursor
|
|
|
+ if (guiTextBoxState.cursor != 0)
|
|
|
+ {
|
|
|
+ endIdx = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+ guiTextBoxState.cursor--;
|
|
|
+ startIdx = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor < guiTextBoxState.start) guiTextBoxState.start = -1; // Force to recalculate on the next frame
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Delete character after cursor
|
|
|
+ if (guiTextBoxState.cursor + 1 <= GuiCountCodepointsUntilNewline(text))
|
|
|
+ {
|
|
|
+ startIdx = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+ endIdx = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor+1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ memmove(&text[startIdx], &text[endIdx], length - endIdx);
|
|
|
+ text[length - (endIdx - startIdx)] = '\0';
|
|
|
+ guiTextBoxState.select = -1; // Always deselect
|
|
|
+
|
|
|
+ return (endIdx - startIdx);
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+RAYGUIDEF void GuiTextBoxSelectAll(const char *text)
|
|
|
+{
|
|
|
+ guiTextBoxState.cursor = GuiCountCodepointsUntilNewline(text);
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor > 0)
|
|
|
+ {
|
|
|
+ guiTextBoxState.select = 0;
|
|
|
+ guiTextBoxState.start = -1; // Force recalculate on the next frame
|
|
|
+ }
|
|
|
+ else guiTextBoxState.select = -1;
|
|
|
+}
|
|
|
+
|
|
|
+RAYGUIDEF void GuiTextBoxCopy(const char *text)
|
|
|
+{
|
|
|
+ if ((text != NULL) &&
|
|
|
+ (guiTextBoxState.select != -1) &&
|
|
|
+ (guiTextBoxState.cursor != -1) &&
|
|
|
+ (guiTextBoxState.select != guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ int start = guiTextBoxState.cursor;
|
|
|
+ int end = guiTextBoxState.select;
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor > guiTextBoxState.select)
|
|
|
+ {
|
|
|
+ start = guiTextBoxState.select;
|
|
|
+ end = guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Convert to byte indexes
|
|
|
+ start = GuiTextBoxGetByteIndex(text, 0, 0, start);
|
|
|
+ end = GuiTextBoxGetByteIndex(text, 0, 0, end);
|
|
|
+
|
|
|
+ // FIXME: `TextSubtext()` only lets use copy TEXTSPLIT_MAX_TEXT_LENGTH (1024) bytes
|
|
|
+ // maybe modify `SetClipboardText()` so we can use it only on part of a string
|
|
|
+ const char *clipText = TextSubtext(text, start, end - start);
|
|
|
+
|
|
|
+ SetClipboardText(clipText);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Paste text from clipboard into the active textbox.
|
|
|
+// `text` is the pointer to the buffer used by the textbox while `textSize` is the text buffer max size
|
|
|
+RAYGUIDEF void GuiTextBoxPaste(char *text, int textSize)
|
|
|
+{
|
|
|
+ const char *clipText = GetClipboardText(); // GLFW guaratees this should be UTF8 encoded!
|
|
|
+ int length = strlen(text);
|
|
|
+
|
|
|
+ if ((text != NULL) && (clipText != NULL) && (guiTextBoxState.cursor != -1))
|
|
|
+ {
|
|
|
+ if ((guiTextBoxState.select != -1) && (guiTextBoxState.select != guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ // If there's a selection we'll have to delete it first
|
|
|
+ length -= GuiTextBoxDelete(text, length, true);
|
|
|
+ }
|
|
|
+
|
|
|
+ int clipLen = strlen(clipText); // We want the length in bytes
|
|
|
+
|
|
|
+ // Calculate how many bytes can we copy from clipboard text before we run out of space
|
|
|
+ int size = ((length + clipLen) <= textSize) ? clipLen : textSize - length;
|
|
|
+
|
|
|
+ // Make room by shifting to right the bytes after cursor
|
|
|
+ int startIdx = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+ int endIdx = startIdx + size;
|
|
|
+ memmove(&text[endIdx], &text[startIdx], length - startIdx);
|
|
|
+ text[length + size] = '\0'; // Set the NULL char
|
|
|
+
|
|
|
+ // At long last copy the clipboard text
|
|
|
+ memcpy(&text[startIdx], clipText, size);
|
|
|
+
|
|
|
+ // Set cursor position at the end of the pasted text
|
|
|
+ guiTextBoxState.cursor = 0;
|
|
|
+
|
|
|
+ for (int i = 0; i < (startIdx + size); guiTextBoxState.cursor++)
|
|
|
+ {
|
|
|
+ int next = 0;
|
|
|
+ int letter = GetNextCodepoint(&text[i], &next);
|
|
|
+ if (letter != 0x3f) i += next;
|
|
|
+ else i += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ guiTextBoxState.start = -1; // Force to recalculate on the next frame
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+RAYGUIDEF void GuiTextBoxCut(char* text)
|
|
|
+{
|
|
|
+ if ((text != NULL) &&
|
|
|
+ (guiTextBoxState.select != -1) &&
|
|
|
+ (guiTextBoxState.cursor != -1) &&
|
|
|
+ (guiTextBoxState.select != guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ // First copy selection to clipboard;
|
|
|
+ int start = guiTextBoxState.cursor, end = guiTextBoxState.select;
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor > guiTextBoxState.select)
|
|
|
+ {
|
|
|
+ start = guiTextBoxState.select;
|
|
|
+ end = guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Convert to byte indexes
|
|
|
+ int startIdx = GuiTextBoxGetByteIndex(text, 0, 0, start);
|
|
|
+ int endIdx = GuiTextBoxGetByteIndex(text, 0, 0, end);
|
|
|
+
|
|
|
+ // FIXME: `TextSubtext()` only lets use copy TEXTSPLIT_MAX_TEXT_LENGTH (1024) bytes
|
|
|
+ // maybe modify `SetClipboardText()` so we can use it only on parts of a string
|
|
|
+ const char *clipText = TextSubtext(text, startIdx, endIdx - startIdx);
|
|
|
+ SetClipboardText(clipText);
|
|
|
+
|
|
|
+ // Now delete selection (copy data over it)
|
|
|
+ int len = strlen(text);
|
|
|
+ memmove(&text[startIdx], &text[endIdx], len - endIdx);
|
|
|
+ text[len - (endIdx - startIdx)] = '\0';
|
|
|
+
|
|
|
+ // Adjust text box state
|
|
|
+ guiTextBoxState.cursor = start; // Always set cursor to start of selection
|
|
|
+ if (guiTextBoxState.select < guiTextBoxState.start) guiTextBoxState.start = -1; // Force to recalculate
|
|
|
+ guiTextBoxState.select = -1; // Deselect
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// A text box control supporting text selection, cursor positioning and commonly used keyboard shortcuts.
|
|
|
+// NOTE 1: Requires static variables: framesCounter
|
|
|
+// NOTE 2: Returns if KEY_ENTER pressed (useful for data validation)
|
|
|
+RAYGUIDEF bool GuiTextBoxEx(Rectangle bounds, char *text, int textSize, bool editMode)
|
|
|
+{
|
|
|
+ // Define the cursor movement/selection speed when movement keys are held/pressed
|
|
|
+ #define TEXTBOX_CURSOR_COOLDOWN 5
|
|
|
+
|
|
|
+ static int framesCounter = 0; // Required for blinking cursor
|
|
|
+
|
|
|
+ GuiControlState state = guiState;
|
|
|
+ bool pressed = false;
|
|
|
+
|
|
|
+ // Make sure length doesn't exceed `textSize`. `textSize` is actually the max amount of characters the textbox can handle.
|
|
|
+ int length = strlen(text);
|
|
|
+ if (length > textSize)
|
|
|
+ {
|
|
|
+ text[textSize] = '\0';
|
|
|
+ length = textSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Make sure we have enough room to draw at least 1 character
|
|
|
+ if ((bounds.width - 2*GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING)) < GuiGetStyle(DEFAULT, TEXT_SIZE))
|
|
|
+ {
|
|
|
+ bounds.width = GuiGetStyle(DEFAULT, TEXT_SIZE) + 2*GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Center the text vertically
|
|
|
+ int verticalPadding = (bounds.height - 2*GuiGetStyle(TEXTBOX, BORDER_WIDTH) - GuiGetStyle(DEFAULT, TEXT_SIZE))/2;
|
|
|
+
|
|
|
+ if (verticalPadding < 0)
|
|
|
+ {
|
|
|
+ // Make sure the height is sufficient
|
|
|
+ bounds.height = 2*GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(DEFAULT, TEXT_SIZE);
|
|
|
+ verticalPadding = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Calculate the drawing area for the text inside the control `bounds`
|
|
|
+ Rectangle textRec = { bounds.x + GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING),
|
|
|
+ bounds.y + verticalPadding + GuiGetStyle(TEXTBOX, BORDER_WIDTH),
|
|
|
+ bounds.width - 2*(GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING) + GuiGetStyle(TEXTBOX, BORDER_WIDTH)),
|
|
|
+ GuiGetStyle(DEFAULT, TEXT_SIZE) };
|
|
|
+
|
|
|
+ Vector2 cursorPos = { textRec.x, textRec.y }; // This holds the coordinates inside textRec of the cursor at current position and will be recalculated later
|
|
|
+ bool active = GuiTextBoxIsActive(bounds); // Check if this textbox is the global active textbox
|
|
|
+
|
|
|
+ int selStart = 0, selLength = 0, textStartIndex = 0;
|
|
|
+
|
|
|
+ // Update control
|
|
|
+ //--------------------------------------------------------------------
|
|
|
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
|
|
|
+ {
|
|
|
+ Vector2 mousePoint = GetMousePosition();
|
|
|
+
|
|
|
+ if (editMode)
|
|
|
+ {
|
|
|
+ // Check if we are the global active textbox
|
|
|
+ // A textbox becomes active when the user clicks it :)
|
|
|
+ if (!active)
|
|
|
+ {
|
|
|
+ if (CheckCollisionPointRec(mousePoint, bounds) && (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)))
|
|
|
+ {
|
|
|
+ // Hurray!!! we just became the active textbox
|
|
|
+ active = true;
|
|
|
+ GuiTextBoxSetActive(bounds);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_RIGHT_BUTTON))
|
|
|
+ {
|
|
|
+ // When active and the right mouse is clicked outside the textbox we should deactivate it
|
|
|
+ // NOTE: We set a dummy rect as the active textbox bounds
|
|
|
+ GuiTextBoxSetActive(RAYGUI_CLITERAL(Rectangle){ 0, 0, -1, -1 });
|
|
|
+ active = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (active)
|
|
|
+ {
|
|
|
+ state = GUI_STATE_PRESSED;
|
|
|
+ framesCounter++;
|
|
|
+
|
|
|
+ // Make sure state doesn't have invalid values
|
|
|
+ if (guiTextBoxState.cursor > length) guiTextBoxState.cursor = -1;
|
|
|
+ if (guiTextBoxState.select > length) guiTextBoxState.select = -1;
|
|
|
+ if (guiTextBoxState.start > length) guiTextBoxState.start = -1;
|
|
|
+
|
|
|
+
|
|
|
+ // Check textbox state for changes and recalculate if necesary
|
|
|
+ if (guiTextBoxState.cursor == -1)
|
|
|
+ {
|
|
|
+ // Set cursor to last visible character in textbox
|
|
|
+ guiTextBoxState.cursor = GuiTextBoxMaxCharacters(text, length, textRec);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (guiTextBoxState.start == -1)
|
|
|
+ {
|
|
|
+ // Force recalculate text start position and text start index
|
|
|
+
|
|
|
+ // NOTE: start and index are always in sync
|
|
|
+ // start will hold the starting character position from where the text will be drawn
|
|
|
+ // while index will hold the byte index inside the text for that character
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor == 0)
|
|
|
+ {
|
|
|
+ guiTextBoxState.start = guiTextBoxState.index = 0; // No need to recalculate
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ int pos = 0;
|
|
|
+ int len = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+ guiTextBoxState.index = GuiMeasureTextBoxRev(text, len, textRec, &pos);
|
|
|
+ guiTextBoxState.start = guiTextBoxState.cursor - pos + 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // -----------------
|
|
|
+ // HANDLE KEY INPUT
|
|
|
+ // -----------------
|
|
|
+ // * -> | LSHIFT + -> move cursor to the right | increase selection by one
|
|
|
+ // * <- | LSHIFT + <- move cursor to the left | decrease selection by one
|
|
|
+ // * HOME | LSHIFT + HOME moves cursor to start of text | selects text from cursor to start of text
|
|
|
+ // * END | LSHIFT + END move cursor to end of text | selects text from cursor until end of text
|
|
|
+ // * CTRL + A select all characters in text
|
|
|
+ // * CTRL + C copy selected text
|
|
|
+ // * CTRL + X cut selected text
|
|
|
+ // * CTRL + V remove selected text, if any, then paste clipboard data
|
|
|
+ // * DEL delete character or selection after cursor
|
|
|
+ // * BACKSPACE delete character or selection before cursor
|
|
|
+ // TODO: Add more shortcuts (insert mode, select word, moveto/select prev/next word ...)
|
|
|
+ if (IsKeyPressed(KEY_RIGHT) || (IsKeyDown(KEY_RIGHT) && (framesCounter%TEXTBOX_CURSOR_COOLDOWN == 0)))
|
|
|
+ {
|
|
|
+ if (IsKeyDown(KEY_LEFT_SHIFT))
|
|
|
+ {
|
|
|
+ // Selecting
|
|
|
+ if (guiTextBoxState.select == -1) guiTextBoxState.select = guiTextBoxState.cursor; // Mark selection start
|
|
|
+
|
|
|
+ MoveTextBoxCursorRight(text, length, textRec);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (guiTextBoxState.select != -1 && guiTextBoxState.select != guiTextBoxState.cursor)
|
|
|
+ {
|
|
|
+ // Deselect and move cursor to end of selection
|
|
|
+ if (guiTextBoxState.cursor < guiTextBoxState.select)
|
|
|
+ {
|
|
|
+ guiTextBoxState.cursor = guiTextBoxState.select - 1;
|
|
|
+ MoveTextBoxCursorRight(text, length, textRec);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Move cursor to the right
|
|
|
+ MoveTextBoxCursorRight(text, length, textRec);
|
|
|
+ }
|
|
|
+
|
|
|
+ guiTextBoxState.select = -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ framesCounter = 0;
|
|
|
+ }
|
|
|
+ else if (IsKeyPressed(KEY_LEFT) || (IsKeyDown(KEY_LEFT) && (framesCounter%TEXTBOX_CURSOR_COOLDOWN == 0)))
|
|
|
+ {
|
|
|
+ if (IsKeyDown(KEY_LEFT_SHIFT))
|
|
|
+ {
|
|
|
+ // Selecting
|
|
|
+ if (guiTextBoxState.select == -1) guiTextBoxState.select = guiTextBoxState.cursor; // Mark selection start
|
|
|
+
|
|
|
+ MoveTextBoxCursorLeft(text);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if ((guiTextBoxState.select != -1) && (guiTextBoxState.select != guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ // Deselect and move cursor to start of selection
|
|
|
+ if (guiTextBoxState.cursor > guiTextBoxState.select)
|
|
|
+ {
|
|
|
+ guiTextBoxState.cursor = guiTextBoxState.select;
|
|
|
+
|
|
|
+ if (guiTextBoxState.start > guiTextBoxState.cursor)
|
|
|
+ {
|
|
|
+ guiTextBoxState.start = guiTextBoxState.cursor;
|
|
|
+ guiTextBoxState.index = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.start); // Recalculate byte index
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Move cursor to the left
|
|
|
+ MoveTextBoxCursorLeft(text);
|
|
|
+ }
|
|
|
+
|
|
|
+ guiTextBoxState.select = -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ framesCounter = 0;
|
|
|
+ }
|
|
|
+ else if (IsKeyPressed(KEY_BACKSPACE) || (IsKeyDown(KEY_BACKSPACE) && (framesCounter%TEXTBOX_CURSOR_COOLDOWN) == 0))
|
|
|
+ {
|
|
|
+ GuiTextBoxDelete(text, length, true);
|
|
|
+ }
|
|
|
+ else if (IsKeyPressed(KEY_DELETE) || (IsKeyDown(KEY_DELETE) && (framesCounter%TEXTBOX_CURSOR_COOLDOWN) == 0))
|
|
|
+ {
|
|
|
+ GuiTextBoxDelete(text, length, false);
|
|
|
+ }
|
|
|
+ else if (IsKeyPressed(KEY_HOME))
|
|
|
+ {
|
|
|
+ if (IsKeyDown(KEY_LEFT_SHIFT))
|
|
|
+ {
|
|
|
+ // Select from start of text to cursor
|
|
|
+ if ((guiTextBoxState.select > guiTextBoxState.cursor) || ((guiTextBoxState.select == -1) && (guiTextBoxState.cursor != 0)))
|
|
|
+ {
|
|
|
+ guiTextBoxState.select = guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else guiTextBoxState.select = -1; // Deselect everything
|
|
|
+
|
|
|
+ // Move cursor to start of text
|
|
|
+ guiTextBoxState.cursor = guiTextBoxState.start = guiTextBoxState.index = 0;
|
|
|
+ framesCounter = 0;
|
|
|
+ }
|
|
|
+ else if (IsKeyPressed(KEY_END))
|
|
|
+ {
|
|
|
+ int max = GuiCountCodepointsUntilNewline(text);
|
|
|
+
|
|
|
+ if (IsKeyDown(KEY_LEFT_SHIFT))
|
|
|
+ {
|
|
|
+ if ((guiTextBoxState.select == -1) && (guiTextBoxState.cursor != max))
|
|
|
+ {
|
|
|
+ guiTextBoxState.select = guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else guiTextBoxState.select = -1; // Deselect everything
|
|
|
+
|
|
|
+ int pos = 0;
|
|
|
+ guiTextBoxState.cursor = max;
|
|
|
+ int len = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+ guiTextBoxState.index = GuiMeasureTextBoxRev(text, len, textRec, &pos);
|
|
|
+ guiTextBoxState.start = guiTextBoxState.cursor - pos + 1;
|
|
|
+ }
|
|
|
+ else if (IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_A)) GuiTextBoxSelectAll(text); // CTRL + A > Select all
|
|
|
+ else if (IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_C)) GuiTextBoxCopy(text); // CTRL + C > Copy selected text to clipboard
|
|
|
+ else if (IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_X)) GuiTextBoxCut(text); // CTRL + X > Cut selected text
|
|
|
+ else if (IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_V)) GuiTextBoxPaste(text, textSize); // CTRL + V > Paste clipboard text
|
|
|
+ else if (IsKeyPressed(KEY_ENTER)) pressed = true;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ int key = GetKeyPressed();
|
|
|
+ if ((key >= 32) && ((guiTextBoxState.cursor + 1) < textSize))
|
|
|
+ {
|
|
|
+ if ((guiTextBoxState.select != -1) && (guiTextBoxState.select != guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ // Delete selection
|
|
|
+ GuiTextBoxDelete(text, length, true);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Decode codepoint
|
|
|
+ char out[5] = {0};
|
|
|
+ int sz = EncodeCodepoint(key, &out[0]);
|
|
|
+
|
|
|
+ if (sz != 0)
|
|
|
+ {
|
|
|
+ int startIdx = GuiTextBoxGetByteIndex(text, 0, 0, guiTextBoxState.cursor);
|
|
|
+ int endIdx = startIdx + sz;
|
|
|
+
|
|
|
+ if (endIdx <= textSize && length < textSize - 1)
|
|
|
+ {
|
|
|
+ guiTextBoxState.cursor++;
|
|
|
+ guiTextBoxState.select = -1;
|
|
|
+ memmove(&text[endIdx], &text[startIdx], length - startIdx);
|
|
|
+ memcpy(&text[startIdx], &out[0], sz);
|
|
|
+ length += sz;
|
|
|
+ text[length] = '\0';
|
|
|
+
|
|
|
+ if (guiTextBoxState.start != -1)
|
|
|
+ {
|
|
|
+ const int max = GuiTextBoxMaxCharacters(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec);
|
|
|
+
|
|
|
+ if ((guiTextBoxState.cursor - guiTextBoxState.start) > max) guiTextBoxState.start = -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // -------------
|
|
|
+ // HANDLE MOUSE
|
|
|
+ // -------------
|
|
|
+ if (CheckCollisionPointRec(mousePoint, bounds))
|
|
|
+ {
|
|
|
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
|
|
|
+ {
|
|
|
+ if (CheckCollisionPointRec(mousePoint, textRec))
|
|
|
+ {
|
|
|
+ GuiTextBoxGetCursorFromMouse(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec, &guiTextBoxState.cursor);
|
|
|
+ guiTextBoxState.cursor += guiTextBoxState.start;
|
|
|
+ guiTextBoxState.select = -1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Clicked outside the `textRec` but still inside bounds
|
|
|
+ if (mousePoint.x <= bounds.x+bounds.width/2) guiTextBoxState.cursor = 0 + guiTextBoxState.start;
|
|
|
+ else guiTextBoxState.cursor = guiTextBoxState.start + GuiTextBoxMaxCharacters(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec);
|
|
|
+ guiTextBoxState.select = -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
|
|
|
+ {
|
|
|
+ int cursor = guiTextBoxState.cursor - guiTextBoxState.start;
|
|
|
+ bool move = false;
|
|
|
+ if (CheckCollisionPointRec(mousePoint, textRec))
|
|
|
+ {
|
|
|
+ GuiTextBoxGetCursorFromMouse(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec, &cursor);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Clicked outside the `textRec` but still inside bounds, this means that we must move the text
|
|
|
+ move = true;
|
|
|
+ if (mousePoint.x > bounds.x+bounds.width/2)
|
|
|
+ {
|
|
|
+ cursor = GuiTextBoxMaxCharacters(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ guiTextBoxState.cursor = cursor + guiTextBoxState.start;
|
|
|
+
|
|
|
+ if (guiTextBoxState.select == -1)
|
|
|
+ {
|
|
|
+ // Mark start of selection
|
|
|
+ guiTextBoxState.select = guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Move the text when cursor is positioned before or after the text
|
|
|
+ if ((framesCounter%TEXTBOX_CURSOR_COOLDOWN) == 0 && move)
|
|
|
+ {
|
|
|
+ if (cursor == 0) MoveTextBoxCursorLeft(text);
|
|
|
+ else if (cursor == GuiTextBoxMaxCharacters(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec))
|
|
|
+ {
|
|
|
+ MoveTextBoxCursorRight(text, length, textRec);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Calculate X coordinate of the blinking cursor
|
|
|
+ cursorPos.x = GuiTextBoxGetCursorCoordinates(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec, guiTextBoxState.cursor - guiTextBoxState.start);
|
|
|
+
|
|
|
+ // Update variables
|
|
|
+ textStartIndex = guiTextBoxState.index;
|
|
|
+
|
|
|
+ if (guiTextBoxState.select == -1)
|
|
|
+ {
|
|
|
+ selStart = guiTextBoxState.cursor;
|
|
|
+ selLength = 0;
|
|
|
+ }
|
|
|
+ else if (guiTextBoxState.cursor > guiTextBoxState.select)
|
|
|
+ {
|
|
|
+ selStart = guiTextBoxState.select;
|
|
|
+ selLength = guiTextBoxState.cursor - guiTextBoxState.select;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ selStart = guiTextBoxState.cursor;
|
|
|
+ selLength = guiTextBoxState.select - guiTextBoxState.cursor;
|
|
|
+ }
|
|
|
+
|
|
|
+ // We aren't drawing all of the text so make sure `DrawTextRecEx()` is selecting things correctly
|
|
|
+ if (guiTextBoxState.start > selStart)
|
|
|
+ {
|
|
|
+ selLength -= guiTextBoxState.start - selStart;
|
|
|
+ selStart = 0;
|
|
|
+ }
|
|
|
+ else selStart = selStart - guiTextBoxState.start;
|
|
|
+ }
|
|
|
+ else state = GUI_STATE_FOCUSED;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (CheckCollisionPointRec(mousePoint, bounds))
|
|
|
+ {
|
|
|
+ state = GUI_STATE_FOCUSED;
|
|
|
+ if (IsMouseButtonPressed(0)) pressed = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (active && IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_C))
|
|
|
+ {
|
|
|
+ // If active copy all text to clipboard even when disabled
|
|
|
+
|
|
|
+ // Backup textbox state
|
|
|
+ int select = guiTextBoxState.select;
|
|
|
+ int cursor = guiTextBoxState.cursor;
|
|
|
+ int start = guiTextBoxState.start;
|
|
|
+
|
|
|
+ if ((guiTextBoxState.select == -1) || (guiTextBoxState.select == guiTextBoxState.cursor))
|
|
|
+ {
|
|
|
+ // If no selection then mark all text to be copied to clipboard
|
|
|
+ GuiTextBoxSelectAll(text);
|
|
|
+ }
|
|
|
+
|
|
|
+ GuiTextBoxCopy(text);
|
|
|
+
|
|
|
+ // Restore textbox state
|
|
|
+ guiTextBoxState.select = select;
|
|
|
+ guiTextBoxState.cursor = cursor;
|
|
|
+ guiTextBoxState.start = start;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Draw control
|
|
|
+ //--------------------------------------------------------------------
|
|
|
+ DrawRectangleLinesEx(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha));
|
|
|
+
|
|
|
+ if (state == GUI_STATE_PRESSED)
|
|
|
+ {
|
|
|
+ DrawRectangle(bounds.x + GuiGetStyle(TEXTBOX, BORDER_WIDTH), bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(TEXTBOX, BORDER_WIDTH), bounds.height - 2*GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_FOCUSED)), guiAlpha));
|
|
|
+
|
|
|
+ // Draw blinking cursor
|
|
|
+ if (editMode && active && ((framesCounter/TEXTEDIT_CURSOR_BLINK_FRAMES)%2 == 0) && selLength == 0)
|
|
|
+ {
|
|
|
+ DrawRectangle(cursorPos.x, cursorPos.y, 1, GuiGetStyle(DEFAULT, TEXT_SIZE)*2, Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED)), guiAlpha));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (state == GUI_STATE_DISABLED)
|
|
|
+ {
|
|
|
+ DrawRectangle(bounds.x + GuiGetStyle(TEXTBOX, BORDER_WIDTH), bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(TEXTBOX, BORDER_WIDTH), bounds.height - 2*GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED)), guiAlpha));
|
|
|
+ }
|
|
|
+
|
|
|
+ // Finally draw the text and selection
|
|
|
+ DrawTextRecEx(guiFont, &text[textStartIndex], textRec, GuiGetStyle(DEFAULT, TEXT_SIZE), GuiGetStyle(DEFAULT, TEXT_SPACING), false, Fade(GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3))), guiAlpha), selStart, selLength, GetColor(GuiGetStyle(TEXTBOX, COLOR_SELECTED_FG)), GetColor(GuiGetStyle(TEXTBOX, COLOR_SELECTED_BG)));
|
|
|
+
|
|
|
+ return pressed;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// Module Internal Functions Definition
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+
|
|
|
+static int GetPrevCodepoint(const char *text, const char *start, int *prev)
|
|
|
+{
|
|
|
+ int c = 0x3f;
|
|
|
+ char *p = (char *)text;
|
|
|
+ *prev = 1;
|
|
|
+
|
|
|
+ for (int i = 0; (p >= start) && (i < 4); p--, i++)
|
|
|
+ {
|
|
|
+ if ((((unsigned char)*p) >> 6) != 2)
|
|
|
+ {
|
|
|
+ c = GetNextCodepoint(p, prev);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+// Returns total number of characters(codepoints) in a UTF8 encoded `text` until `\0` or a `\n` is found.
|
|
|
+// NOTE: If a invalid UTF8 sequence is encountered a `?`(0x3f) codepoint is counted instead.
|
|
|
+static inline unsigned int GuiCountCodepointsUntilNewline(const char *text)
|
|
|
+{
|
|
|
+ unsigned int len = 0;
|
|
|
+ char *ptr = (char*)&text[0];
|
|
|
+
|
|
|
+ while ((*ptr != '\0') && (*ptr != '\n'))
|
|
|
+ {
|
|
|
+ int next = 0;
|
|
|
+ int letter = GetNextCodepoint(ptr, &next);
|
|
|
+
|
|
|
+ if (letter == 0x3f) ptr += 1;
|
|
|
+ else ptr += next;
|
|
|
+ ++len;
|
|
|
+ }
|
|
|
+
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+// Highly synchronized with calculations in DrawTextRecEx()
|
|
|
+static int GuiMeasureTextBox(const char *text, int length, Rectangle rec, int *pos, int mode)
|
|
|
+{
|
|
|
+ // Get gui font properties
|
|
|
+ const Font font = guiFont;
|
|
|
+ const float fontSize = GuiGetStyle(DEFAULT, TEXT_SIZE);
|
|
|
+ const float spacing = GuiGetStyle(DEFAULT, TEXT_SPACING);
|
|
|
+
|
|
|
+ int textOffsetX = 0; // Offset between characters
|
|
|
+ float scaleFactor = 0.0f;
|
|
|
+
|
|
|
+ int letter = 0; // Current character
|
|
|
+ int index = 0; // Index position in sprite font
|
|
|
+
|
|
|
+ scaleFactor = fontSize/font.baseSize;
|
|
|
+
|
|
|
+ int i = 0, k = 0;
|
|
|
+ int glyphWidth = 0;
|
|
|
+
|
|
|
+ for (i = 0; i < length; i++, k++)
|
|
|
+ {
|
|
|
+ glyphWidth = 0;
|
|
|
+ int next = 1;
|
|
|
+ letter = GetNextCodepoint(&text[i], &next);
|
|
|
+ if (letter == 0x3f) next = 1;
|
|
|
+ index = GetGlyphIndex(font, letter);
|
|
|
+ i += next - 1;
|
|
|
+
|
|
|
+ if (letter != '\n')
|
|
|
+ {
|
|
|
+ glyphWidth = (font.chars[index].advanceX == 0)?
|
|
|
+ (int)(font.recs[index].width*scaleFactor + spacing):
|
|
|
+ (int)(font.chars[index].advanceX*scaleFactor + spacing);
|
|
|
+
|
|
|
+ if ((textOffsetX + glyphWidth + 1) >= rec.width) break;
|
|
|
+
|
|
|
+ if ((mode == GUI_MEASURE_MODE_CURSOR_POS) && (*pos == k)) break;
|
|
|
+ else if (mode == GUI_MEASURE_MODE_CURSOR_COORDS)
|
|
|
+ {
|
|
|
+ // Check if the mouse pointer is inside the glyph rect
|
|
|
+ Rectangle grec = {rec.x + textOffsetX - 1, rec.y, glyphWidth, (font.baseSize + font.baseSize/2)*scaleFactor - 1 };
|
|
|
+ Vector2 mouse = GetMousePosition();
|
|
|
+
|
|
|
+ if (CheckCollisionPointRec(mouse, grec))
|
|
|
+ {
|
|
|
+ // Smooth selection by dividing the glyph rectangle into 2 equal parts and checking where the mouse resides
|
|
|
+ if (mouse.x > (grec.x + glyphWidth/2))
|
|
|
+ {
|
|
|
+ textOffsetX += glyphWidth;
|
|
|
+ k++;
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else break;
|
|
|
+
|
|
|
+ textOffsetX += glyphWidth;
|
|
|
+ }
|
|
|
+
|
|
|
+ *pos = k;
|
|
|
+
|
|
|
+ return (rec.x + textOffsetX - 1);
|
|
|
+}
|
|
|
+
|
|
|
+// Required by GuiTextBoxEx()
|
|
|
+// Highly synchronized with calculations in DrawTextRecEx()
|
|
|
+static int GuiMeasureTextBoxRev(const char *text, int length, Rectangle rec, int *pos)
|
|
|
+{
|
|
|
+ // Get gui font properties
|
|
|
+ const Font font = guiFont;
|
|
|
+ const float fontSize = GuiGetStyle(DEFAULT, TEXT_SIZE);
|
|
|
+ const float spacing = GuiGetStyle(DEFAULT, TEXT_SPACING);
|
|
|
+
|
|
|
+ int textOffsetX = 0; // Offset between characters
|
|
|
+ float scaleFactor = 0.0f;
|
|
|
+
|
|
|
+ int letter = 0; // Current character
|
|
|
+ int index = 0; // Index position in sprite font
|
|
|
+
|
|
|
+ scaleFactor = fontSize/font.baseSize;
|
|
|
+
|
|
|
+ int i = 0, k = 0;
|
|
|
+ int glyphWidth = 0, prev = 1;
|
|
|
+ for (i = length; i >= 0; i--, k++)
|
|
|
+ {
|
|
|
+ glyphWidth = 0;
|
|
|
+ letter = GetPrevCodepoint(&text[i], &text[0], &prev);
|
|
|
+
|
|
|
+ if (letter == 0x3f) prev = 1;
|
|
|
+ index = GetGlyphIndex(font, letter);
|
|
|
+ i -= prev - 1;
|
|
|
+
|
|
|
+ if (letter != '\n')
|
|
|
+ {
|
|
|
+ glyphWidth = (font.chars[index].advanceX == 0)?
|
|
|
+ (int)(font.recs[index].width*scaleFactor + spacing):
|
|
|
+ (int)(font.chars[index].advanceX*scaleFactor + spacing);
|
|
|
+
|
|
|
+ if ((textOffsetX + glyphWidth + 1) >= rec.width) break;
|
|
|
+ }
|
|
|
+ else break;
|
|
|
+
|
|
|
+ textOffsetX += glyphWidth;
|
|
|
+ }
|
|
|
+
|
|
|
+ *pos = k;
|
|
|
+
|
|
|
+ return (i + prev);
|
|
|
+}
|
|
|
+
|
|
|
+// Calculate cursor coordinates based on the cursor position `pos` inside the `text`.
|
|
|
+static inline int GuiTextBoxGetCursorCoordinates(const char *text, int length, Rectangle rec, int pos)
|
|
|
+{
|
|
|
+ return GuiMeasureTextBox(text, length, rec, &pos, GUI_MEASURE_MODE_CURSOR_POS);
|
|
|
+}
|
|
|
+
|
|
|
+// Calculate cursor position in textbox based on mouse coordinates.
|
|
|
+static inline int GuiTextBoxGetCursorFromMouse(const char *text, int length, Rectangle rec, int* pos)
|
|
|
+{
|
|
|
+ return GuiMeasureTextBox(text, length, rec, pos, GUI_MEASURE_MODE_CURSOR_COORDS);
|
|
|
+}
|
|
|
+
|
|
|
+// Calculates how many characters is the textbox able to draw inside rec
|
|
|
+static inline int GuiTextBoxMaxCharacters(const char *text, int length, Rectangle rec)
|
|
|
+{
|
|
|
+ int pos = -1;
|
|
|
+ GuiMeasureTextBox(text, length, rec, &pos, GUI_MEASURE_MODE_CURSOR_END);
|
|
|
+ return pos;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void MoveTextBoxCursorRight(const char* text, int length, Rectangle textRec)
|
|
|
+{
|
|
|
+ // FIXME: Counting codepoints each time we press the key is expensive, find another way
|
|
|
+ int count = GuiCountCodepointsUntilNewline(text);
|
|
|
+ if (guiTextBoxState.cursor < count ) guiTextBoxState.cursor++;
|
|
|
+
|
|
|
+ const int max = GuiTextBoxMaxCharacters(&text[guiTextBoxState.index], length - guiTextBoxState.index, textRec);
|
|
|
+
|
|
|
+ if ((guiTextBoxState.cursor - guiTextBoxState.start) > max)
|
|
|
+ {
|
|
|
+ const int cidx = GuiTextBoxGetByteIndex(text, guiTextBoxState.index, guiTextBoxState.start, guiTextBoxState.cursor);
|
|
|
+ int pos = 0;
|
|
|
+ guiTextBoxState.index = GuiMeasureTextBoxRev(text, cidx - 1, textRec, &pos);
|
|
|
+ guiTextBoxState.start = guiTextBoxState.cursor - pos;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline void MoveTextBoxCursorLeft(const char* text)
|
|
|
+{
|
|
|
+ if (guiTextBoxState.cursor > 0) guiTextBoxState.cursor--;
|
|
|
+
|
|
|
+ if (guiTextBoxState.cursor < guiTextBoxState.start)
|
|
|
+ {
|
|
|
+ int prev = 0;
|
|
|
+ int letter = GetPrevCodepoint(&text[guiTextBoxState.index - 1], text, &prev);
|
|
|
+ if (letter == 0x3f) prev = 1;
|
|
|
+ guiTextBoxState.start--;
|
|
|
+ guiTextBoxState.index -= prev;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int EncodeCodepoint(unsigned int c, char out[5])
|
|
|
+{
|
|
|
+ int len = 0;
|
|
|
+ if (c <= 0x7f)
|
|
|
+ {
|
|
|
+ out[0] = (char)c;
|
|
|
+ len = 1;
|
|
|
+ }
|
|
|
+ else if (c <= 0x7ff)
|
|
|
+ {
|
|
|
+ out[0] = (char)(((c >> 6) & 0x1f) | 0xc0);
|
|
|
+ out[1] = (char)((c & 0x3f) | 0x80);
|
|
|
+ len = 2;
|
|
|
+ }
|
|
|
+ else if (c <= 0xffff)
|
|
|
+ {
|
|
|
+ out[0] = (char)(((c >> 12) & 0x0f) | 0xe0);
|
|
|
+ out[1] = (char)(((c >> 6) & 0x3f) | 0x80);
|
|
|
+ out[2] = (char)((c & 0x3f) | 0x80);
|
|
|
+ len = 3;
|
|
|
+ }
|
|
|
+ else if (c <= 0x10ffff)
|
|
|
+ {
|
|
|
+ out[0] = (char)(((c >> 18) & 0x07) | 0xf0);
|
|
|
+ out[1] = (char)(((c >> 12) & 0x3f) | 0x80);
|
|
|
+ out[2] = (char)(((c >> 6) & 0x3f) | 0x80);
|
|
|
+ out[3] = (char)((c & 0x3f) | 0x80);
|
|
|
+ len = 4;
|
|
|
+ }
|
|
|
+
|
|
|
+ out[len] = 0;
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+#endif // GUI_TEXTBOX_EXTENDED_IMPLEMENTATION
|
Ray