1075 lines
46 KiB
C
1075 lines
46 KiB
C
/*******************************************************************************************
|
|
*
|
|
* 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)
|
|
|
|
#ifndef RAYGUI_H
|
|
#include "raygui.h"
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// 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 <= (int)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 = GetCharPressed();
|
|
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;
|
|
|
|
if (IsKeyPressed(KEY_ENTER) || (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(0))) pressed = true;
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|
|
|
|
if (CheckCollisionPointRec(mousePoint, bounds))
|
|
{
|
|
state = GUI_STATE_FOCUSED;
|
|
if (IsMouseButtonPressed(0)) pressed = true;
|
|
}
|
|
|
|
}
|
|
|
|
if (pressed) framesCounter = 0;
|
|
}
|
|
|
|
// 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
|