| //+------------------------------------------------------------------+
|
| //| AI Canvas Editor.mqh |
|
| //| Copyright 2026, Allan Munene Mutiiria. |
|
| //| https://t.me/Forex_Algo_Trader |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2026, Allan Munene Mutiiria."
|
| #property link "https://t.me/Forex_Algo_Trader"
|
|
|
| //--- Include guard
|
| #ifndef AI_CANVAS_EDITOR_MQH
|
| #define AI_CANVAS_EDITOR_MQH
|
|
|
| //--- Include required libraries
|
| #include <Canvas/Canvas.mqh>
|
| #include "AI Canvas Theme.mqh"
|
| #include "AI Canvas Primitives.mqh"
|
| #include "AI Canvas Scrollbar.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Multi-line scrollable text editor with caret and selection |
|
| //+------------------------------------------------------------------+
|
| class CAiEditor
|
| {
|
| public:
|
| string buffer; // Full text content
|
| int caret; // Caret character position
|
| int anchor; // Selection anchor position (-1 = none)
|
| bool focused; // Focus state flag
|
| string fontName; // Font name for rendering
|
| int fontSize; // Font size in points
|
| int padX; // Horizontal padding
|
| int padY; // Vertical padding
|
| int wrapWidth; // Word-wrap width in pixels
|
| int lineH; // Line height in pixels
|
| AiScrollState scroll; // Vertical scroll state
|
| string visLines[]; // Visual line strings (post-wrap)
|
| int bufOffsets[]; // Buffer offsets per visual line
|
| bool blinkOn; // Caret blink toggle
|
| ulong lastBlinkMs; // Last blink toggle timestamp
|
| string placeholder; // Placeholder text when empty
|
|
|
| //--- Persistent off-screen canvas for clip and blend operations
|
| CAiCanvasFast tmpCanvas; // Reusable scratch canvas
|
| bool tmpCanvasReady; // Scratch canvas init flag
|
| int tmpCanvasW; // Scratch canvas width
|
| int tmpCanvasH; // Scratch canvas height
|
| string tmpCanvasName; // Unique scratch canvas object name
|
|
|
| CAiEditor();
|
| void Init(const string fnt, int fsz, int padInX, int padInY);
|
| void SetWrapWidth(int wrapW);
|
| void SetPlaceholder(const string s) { placeholder = s; }
|
| void SetText(const string s);
|
| string GetText() const { return buffer; }
|
| bool IsEmpty() const { return StringLen(buffer) == 0; }
|
| void Rebuild();
|
| bool HasSelection();
|
| bool GetSelectionRange(int &s, int &e);
|
| bool DeleteSelection();
|
| void ClearSelection() { anchor = -1; }
|
| void SelectAll();
|
| void InsertChar(const string ch);
|
| void InsertNewline() { InsertChar("\n"); }
|
| void Backspace();
|
| void DeleteChar();
|
| void MoveCaretLeft();
|
| void MoveCaretRight();
|
| void MoveCaretUp();
|
| void MoveCaretDown();
|
| void MoveCaretHome();
|
| void MoveCaretEnd();
|
| void ShiftExtendLeft();
|
| void ShiftExtendRight();
|
| void ShiftExtendUp();
|
| void ShiftExtendDown();
|
| void ShiftExtendHome();
|
| void ShiftExtendEnd();
|
| void SetCaretFromMouse(int localX, int localY);
|
| bool HandleKeydown(int vk, bool shift, bool ctrl);
|
| void UpdateBlink();
|
| void EnsureCaretVisible();
|
| void Render(CAiCanvasFast &canvas, int rectL, int rectT, int rectR, int rectB,
|
| CAiCanvasPrimitives &prim);
|
| private:
|
| void FindLineCol(int caretPos, int &outLine, int &outCol);
|
| int ColPxToCharIndex(const string line, int xPx);
|
| int CharIndexToColPx(const string line, int charIdx);
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Construct editor with default state |
|
| //+------------------------------------------------------------------+
|
| CAiEditor::CAiEditor()
|
| {
|
| //--- Initialize text and selection state
|
| buffer = "";
|
| caret = 0;
|
| anchor = -1;
|
| focused = false;
|
| //--- Initialize font and layout defaults
|
| fontName = "Arial";
|
| fontSize = AI_FONT_BODY;
|
| padX = 8;
|
| padY = 6;
|
| wrapWidth = 200;
|
| lineH = 16;
|
| //--- Initialize scroll, blink, and placeholder
|
| AiScrollInit(scroll);
|
| blinkOn = true;
|
| lastBlinkMs = 0;
|
| placeholder = "";
|
| //--- Initialize scratch canvas state
|
| tmpCanvasReady = false;
|
| tmpCanvasW = 0;
|
| tmpCanvasH = 0;
|
| //--- Generate unique scratch canvas name per instance
|
| static int s_editorInstanceCounter = 0;
|
| s_editorInstanceCounter++;
|
| tmpCanvasName = "AiEditorTmpPersistent_" + IntegerToString(s_editorInstanceCounter);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize font and padding |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::Init(const string fnt, int fsz, int padInX, int padInY)
|
| {
|
| //--- Apply font and padding settings
|
| fontName = fnt;
|
| fontSize = fsz;
|
| padX = padInX;
|
| padY = padInY;
|
| //--- Compute line height from font metrics
|
| lineH = AiTextHeight(fnt, fsz) + 2;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set wrap width and rebuild visual lines |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::SetWrapWidth(int w)
|
| {
|
| //--- Bail if unchanged
|
| if(w == wrapWidth)
|
| return;
|
| wrapWidth = w;
|
| Rebuild();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Replace buffer content and reset caret |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::SetText(const string s)
|
| {
|
| //--- Replace buffer and reset selection
|
| buffer = s;
|
| caret = StringLen(buffer);
|
| anchor = -1;
|
| Rebuild();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Rebuild visual lines array from buffer |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::Rebuild()
|
| {
|
| //--- Reset visual line arrays
|
| ArrayResize(visLines, 0);
|
| ArrayResize(bufOffsets, 0);
|
| if(wrapWidth <= 0)
|
| wrapWidth = 200;
|
| //--- Walk buffer one logical line at a time
|
| const int textLen = StringLen(buffer);
|
| int bufLineStart = 0;
|
| for(int i = 0; i <= textLen; i++)
|
| {
|
| bool atEnd = (i == textLen);
|
| bool atNL = (!atEnd && StringGetCharacter(buffer, i) == '\n');
|
| if(!atEnd && !atNL)
|
| continue;
|
| //--- Extract logical line content
|
| int bufLineLen = i - bufLineStart;
|
| string bufLine = StringSubstr(buffer, bufLineStart, bufLineLen);
|
| int localStart = 0;
|
| //--- Wrap logical line into visual segments
|
| while(localStart <= bufLineLen)
|
| {
|
| int remainLen = bufLineLen - localStart;
|
| string remain = StringSubstr(bufLine, localStart, remainLen);
|
| //--- Empty line case - emit empty visual line
|
| if(wrapWidth <= 0 || remainLen == 0)
|
| {
|
| int sz = ArraySize(visLines);
|
| ArrayResize(visLines, sz + 1);
|
| ArrayResize(bufOffsets, sz + 1);
|
| visLines[sz] = remain;
|
| bufOffsets[sz] = bufLineStart + localStart;
|
| break;
|
| }
|
| //--- Whole remainder fits - emit as one visual line
|
| int wholeW = AiTextWidth(remain, fontName, fontSize);
|
| if(wholeW <= wrapWidth)
|
| {
|
| int sz = ArraySize(visLines);
|
| ArrayResize(visLines, sz + 1);
|
| ArrayResize(bufOffsets, sz + 1);
|
| visLines[sz] = remain;
|
| bufOffsets[sz] = bufLineStart + localStart;
|
| break;
|
| }
|
| //--- Binary search for max prefix that fits
|
| int lo = 1, hi = remainLen, fitK = 1;
|
| while(lo <= hi)
|
| {
|
| int mid = (lo + hi) / 2;
|
| string prefix = StringSubstr(remain, 0, mid);
|
| int pw = AiTextWidth(prefix, fontName, fontSize);
|
| if(pw <= wrapWidth)
|
| {
|
| fitK = mid;
|
| lo = mid + 1;
|
| }
|
| else
|
| {
|
| hi = mid - 1;
|
| }
|
| }
|
| //--- Prefer wrapping at last space before fit point
|
| int breakAt = fitK;
|
| bool foundSpace = false;
|
| for(int k = fitK; k >= 1; k--)
|
| {
|
| ushort ch = StringGetCharacter(remain, k - 1);
|
| if(ch == ' ')
|
| {
|
| breakAt = k - 1;
|
| foundSpace = true;
|
| break;
|
| }
|
| }
|
| //--- Emit visual line and advance
|
| int consume;
|
| string visualLine;
|
| if(foundSpace)
|
| {
|
| visualLine = StringSubstr(remain, 0, breakAt);
|
| consume = breakAt + 1;
|
| }
|
| else
|
| {
|
| visualLine = StringSubstr(remain, 0, fitK);
|
| consume = fitK;
|
| }
|
| int sz = ArraySize(visLines);
|
| ArrayResize(visLines, sz + 1);
|
| ArrayResize(bufOffsets, sz + 1);
|
| visLines[sz] = visualLine;
|
| bufOffsets[sz] = bufLineStart + localStart;
|
| localStart += consume;
|
| }
|
| bufLineStart = i + 1;
|
| }
|
| //--- Ensure at least one empty line exists
|
| if(ArraySize(visLines) == 0)
|
| {
|
| ArrayResize(visLines, 1);
|
| ArrayResize(bufOffsets, 1);
|
| visLines[0] = "";
|
| bufOffsets[0] = 0;
|
| }
|
| //--- Update scroll total height and clamp
|
| scroll.totalH = lineH * ArraySize(visLines);
|
| AiScrollClamp(scroll);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if a non-empty selection exists |
|
| //+------------------------------------------------------------------+
|
| bool CAiEditor::HasSelection()
|
| {
|
| //--- No anchor or zero-width range means no selection
|
| if(anchor < 0)
|
| return false;
|
| if(anchor == caret)
|
| return false;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get normalized selection range start/end |
|
| //+------------------------------------------------------------------+
|
| bool CAiEditor::GetSelectionRange(int &s, int &e)
|
| {
|
| //--- Bail when no selection
|
| if(!HasSelection())
|
| {
|
| s = e = 0;
|
| return false;
|
| }
|
| //--- Normalize ordering
|
| s = (anchor < caret) ? anchor : caret;
|
| e = (anchor > caret) ? anchor : caret;
|
| //--- Clamp to buffer bounds
|
| const int len = StringLen(buffer);
|
| if(s < 0)
|
| s = 0;
|
| if(e > len)
|
| e = len;
|
| if(s > e)
|
| s = e;
|
| return e > s;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Delete the current selection from buffer |
|
| //+------------------------------------------------------------------+
|
| bool CAiEditor::DeleteSelection()
|
| {
|
| //--- Bail if no selection
|
| int s, e;
|
| if(!GetSelectionRange(s, e))
|
| return false;
|
| //--- Splice buffer around selection
|
| const int len = StringLen(buffer);
|
| const string before = (s > 0) ? StringSubstr(buffer, 0, s) : "";
|
| const string after = (e < len) ? StringSubstr(buffer, e, len - e) : "";
|
| buffer = before + after;
|
| //--- Reset caret to splice point
|
| caret = s;
|
| anchor = -1;
|
| Rebuild();
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Select the entire buffer content |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::SelectAll()
|
| {
|
| //--- Anchor to start, caret at end
|
| const int len = StringLen(buffer);
|
| if(len <= 0)
|
| {
|
| anchor = -1;
|
| caret = 0;
|
| return;
|
| }
|
| anchor = 0;
|
| caret = len;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Insert character/string at caret |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::InsertChar(const string ch)
|
| {
|
| //--- Bail on empty input
|
| if(StringLen(ch) == 0)
|
| return;
|
| //--- Replace selection if present
|
| DeleteSelection();
|
| //--- Clamp caret to valid range
|
| int len = StringLen(buffer);
|
| if(caret < 0)
|
| caret = 0;
|
| if(caret > len)
|
| caret = len;
|
| //--- Splice in the new content
|
| string before = StringSubstr(buffer, 0, caret);
|
| string after = StringSubstr(buffer, caret, len - caret);
|
| buffer = before + ch + after;
|
| caret += StringLen(ch);
|
| Rebuild();
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Delete character before caret |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::Backspace()
|
| {
|
| //--- Delete selection first if present
|
| if(DeleteSelection())
|
| {
|
| EnsureCaretVisible();
|
| return;
|
| }
|
| if(caret <= 0)
|
| return;
|
| //--- Splice out character before caret
|
| int len = StringLen(buffer);
|
| string before = StringSubstr(buffer, 0, caret - 1);
|
| string after = (caret < len) ? StringSubstr(buffer, caret, len - caret) : "";
|
| buffer = before + after;
|
| caret--;
|
| Rebuild();
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Delete character at caret |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::DeleteChar()
|
| {
|
| //--- Delete selection first if present
|
| if(DeleteSelection())
|
| {
|
| EnsureCaretVisible();
|
| return;
|
| }
|
| int len = StringLen(buffer);
|
| if(caret >= len)
|
| return;
|
| //--- Splice out character at caret
|
| string before = StringSubstr(buffer, 0, caret);
|
| string after = StringSubstr(buffer, caret + 1, len - caret - 1);
|
| buffer = before + after;
|
| Rebuild();
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Translate buffer position to visual line and column |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::FindLineCol(int caretPos, int &outLine, int &outCol)
|
| {
|
| //--- Find the visual line containing the position
|
| const int n = ArraySize(visLines);
|
| int line = 0;
|
| for(int i = 0; i < n; i++)
|
| {
|
| if(bufOffsets[i] <= caretPos)
|
| line = i;
|
| else
|
| break;
|
| }
|
| //--- Compute column within line
|
| outLine = line;
|
| outCol = caretPos - bufOffsets[line];
|
| //--- Clamp column to line length
|
| int lineLen = StringLen(visLines[line]);
|
| if(outCol > lineLen)
|
| outCol = lineLen;
|
| if(outCol < 0)
|
| outCol = 0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Move caret one position left |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::MoveCaretLeft()
|
| {
|
| //--- Collapse selection to start
|
| int s, e;
|
| if(GetSelectionRange(s, e))
|
| {
|
| caret = s;
|
| anchor = -1;
|
| EnsureCaretVisible();
|
| return;
|
| }
|
| //--- Step back one character
|
| if(caret > 0)
|
| caret--;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Move caret one position right |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::MoveCaretRight()
|
| {
|
| //--- Collapse selection to end
|
| int s, e;
|
| if(GetSelectionRange(s, e))
|
| {
|
| caret = e;
|
| anchor = -1;
|
| EnsureCaretVisible();
|
| return;
|
| }
|
| //--- Step forward one character
|
| int len = StringLen(buffer);
|
| if(caret < len)
|
| caret++;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Move caret up one visual line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::MoveCaretUp()
|
| {
|
| //--- Clear selection and locate caret
|
| ClearSelection();
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| if(line <= 0)
|
| return;
|
| //--- Map column to previous line
|
| int prevLineLen = StringLen(visLines[line - 1]);
|
| int newCol = (col <= prevLineLen) ? col : prevLineLen;
|
| caret = bufOffsets[line - 1] + newCol;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Move caret down one visual line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::MoveCaretDown()
|
| {
|
| //--- Clear selection and locate caret
|
| ClearSelection();
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| int n = ArraySize(visLines);
|
| if(line >= n - 1)
|
| return;
|
| //--- Map column to next line
|
| int nextLineLen = StringLen(visLines[line + 1]);
|
| int newCol = (col <= nextLineLen) ? col : nextLineLen;
|
| caret = bufOffsets[line + 1] + newCol;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Move caret to start of line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::MoveCaretHome()
|
| {
|
| //--- Snap caret to line start
|
| ClearSelection();
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| caret = bufOffsets[line];
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Move caret to end of line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::MoveCaretEnd()
|
| {
|
| //--- Snap caret to line end
|
| ClearSelection();
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| caret = bufOffsets[line] + StringLen(visLines[line]);
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Extend selection one position left |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::ShiftExtendLeft()
|
| {
|
| //--- Set anchor and step back
|
| if(anchor < 0)
|
| anchor = caret;
|
| if(caret > 0)
|
| caret--;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Extend selection one position right |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::ShiftExtendRight()
|
| {
|
| //--- Set anchor and step forward
|
| if(anchor < 0)
|
| anchor = caret;
|
| const int len = StringLen(buffer);
|
| if(caret < len)
|
| caret++;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Extend selection up one visual line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::ShiftExtendUp()
|
| {
|
| //--- Set anchor and move to previous line
|
| if(anchor < 0)
|
| anchor = caret;
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| if(line <= 0)
|
| return;
|
| int prevLineLen = StringLen(visLines[line - 1]);
|
| int newCol = (col <= prevLineLen) ? col : prevLineLen;
|
| caret = bufOffsets[line - 1] + newCol;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Extend selection down one visual line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::ShiftExtendDown()
|
| {
|
| //--- Set anchor and move to next line
|
| if(anchor < 0)
|
| anchor = caret;
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| int n = ArraySize(visLines);
|
| if(line >= n - 1)
|
| return;
|
| int nextLineLen = StringLen(visLines[line + 1]);
|
| int newCol = (col <= nextLineLen) ? col : nextLineLen;
|
| caret = bufOffsets[line + 1] + newCol;
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Extend selection to start of line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::ShiftExtendHome()
|
| {
|
| //--- Set anchor and snap to line start
|
| if(anchor < 0)
|
| anchor = caret;
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| caret = bufOffsets[line];
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Extend selection to end of line |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::ShiftExtendEnd()
|
| {
|
| //--- Set anchor and snap to line end
|
| if(anchor < 0)
|
| anchor = caret;
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| caret = bufOffsets[line] + StringLen(visLines[line]);
|
| EnsureCaretVisible();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Convert pixel x within a line to character index |
|
| //+------------------------------------------------------------------+
|
| int CAiEditor::ColPxToCharIndex(const string line, int xPx)
|
| {
|
| //--- Handle empty line and left edge
|
| const int len = StringLen(line);
|
| if(len == 0 || xPx <= 0)
|
| return 0;
|
| //--- Past line end - clamp to length
|
| int totalW = AiTextWidth(line, fontName, fontSize);
|
| if(xPx >= totalW)
|
| return len;
|
| //--- Walk prefixes finding nearest character boundary
|
| int prevW = 0;
|
| for(int i = 1; i <= len; i++)
|
| {
|
| string prefix = StringSubstr(line, 0, i);
|
| int w = AiTextWidth(prefix, fontName, fontSize);
|
| int mid = (prevW + w) / 2;
|
| if(xPx < mid)
|
| return i - 1;
|
| prevW = w;
|
| }
|
| return len;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Convert character index in line to pixel x |
|
| //+------------------------------------------------------------------+
|
| int CAiEditor::CharIndexToColPx(const string line, int charIdx)
|
| {
|
| //--- Zero index is at left edge
|
| if(charIdx <= 0)
|
| return 0;
|
| //--- Measure prefix width
|
| string prefix = StringSubstr(line, 0, charIdx);
|
| return AiTextWidth(prefix, fontName, fontSize);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set caret position from mouse click coordinates |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::SetCaretFromMouse(int localX, int localY)
|
| {
|
| //--- Convert mouse y to content line
|
| int contentY = localY - padY + scroll.scrollPx;
|
| if(contentY < 0)
|
| contentY = 0;
|
| int line = contentY / lineH;
|
| int n = ArraySize(visLines);
|
| if(line < 0)
|
| line = 0;
|
| if(line >= n)
|
| line = n - 1;
|
| //--- Convert mouse x to column
|
| int xInLine = localX - padX;
|
| if(xInLine < 0)
|
| xInLine = 0;
|
| int col = ColPxToCharIndex(visLines[line], xInLine);
|
| //--- Apply caret position and clear selection
|
| caret = bufOffsets[line] + col;
|
| ClearSelection();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Process keyboard input event |
|
| //+------------------------------------------------------------------+
|
| bool CAiEditor::HandleKeydown(int vk, bool shift, bool ctrl)
|
| {
|
| //--- Ignore when unfocused
|
| if(!focused)
|
| return false;
|
| //--- Ignore modifier-only keys
|
| if(vk == 16 || vk == 17 || vk == 18 || vk == 20 ||
|
| vk == 144 || vk == 145 || vk == 91 || vk == 92 || vk == 93)
|
| return false;
|
| //--- Handle shift-modified navigation (selection extension)
|
| if(shift)
|
| {
|
| if(vk == 37)
|
| {
|
| ShiftExtendLeft();
|
| return true;
|
| }
|
| if(vk == 39)
|
| {
|
| ShiftExtendRight();
|
| return true;
|
| }
|
| if(vk == 38)
|
| {
|
| ShiftExtendUp();
|
| return true;
|
| }
|
| if(vk == 40)
|
| {
|
| ShiftExtendDown();
|
| return true;
|
| }
|
| if(vk == 36)
|
| {
|
| ShiftExtendHome();
|
| return true;
|
| }
|
| if(vk == 35)
|
| {
|
| ShiftExtendEnd();
|
| return true;
|
| }
|
| }
|
| //--- Handle plain navigation keys
|
| if(vk == 37)
|
| {
|
| MoveCaretLeft();
|
| return true;
|
| }
|
| if(vk == 39)
|
| {
|
| MoveCaretRight();
|
| return true;
|
| }
|
| if(vk == 38)
|
| {
|
| MoveCaretUp();
|
| return true;
|
| }
|
| if(vk == 40)
|
| {
|
| MoveCaretDown();
|
| return true;
|
| }
|
| if(vk == 36)
|
| {
|
| MoveCaretHome();
|
| return true;
|
| }
|
| if(vk == 35)
|
| {
|
| MoveCaretEnd();
|
| return true;
|
| }
|
| //--- Handle editing keys
|
| if(vk == 8)
|
| {
|
| Backspace();
|
| return true;
|
| }
|
| if(vk == 46)
|
| {
|
| DeleteChar();
|
| return true;
|
| }
|
| if(vk == 13 && shift)
|
| {
|
| InsertNewline();
|
| return true;
|
| }
|
| //--- Filter to printable virtual keys
|
| bool isPrintableVk = (vk == 32) ||
|
| (vk >= 48 && vk <= 57) ||
|
| (vk >= 65 && vk <= 90) ||
|
| (vk >= 96 && vk <= 111) ||
|
| (vk >= 186 && vk <= 223);
|
| if(!isPrintableVk)
|
| return false;
|
| //--- Translate to character and insert
|
| short uch = TranslateKey(vk);
|
| if(uch <= 0)
|
| return false;
|
| ushort code = (ushort)uch;
|
| string ch = ShortToString(code);
|
| InsertChar(ch);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update caret blink state based on elapsed time |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::UpdateBlink()
|
| {
|
| //--- Always on when unfocused
|
| if(!focused)
|
| {
|
| blinkOn = true;
|
| return;
|
| }
|
| //--- Toggle every 500ms
|
| ulong now = GetTickCount64();
|
| if(now - lastBlinkMs >= 500)
|
| {
|
| blinkOn = !blinkOn;
|
| lastBlinkMs = now;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Auto-scroll so caret is within viewport |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::EnsureCaretVisible()
|
| {
|
| //--- Compute caret line bounds
|
| int line, col;
|
| FindLineCol(caret, line, col);
|
| int caretLineY = line * lineH;
|
| int caretLineBottom = caretLineY + lineH;
|
| //--- Scroll up or down to keep caret visible
|
| if(caretLineY < scroll.scrollPx)
|
| {
|
| scroll.scrollPx = caretLineY;
|
| }
|
| else
|
| if(caretLineBottom > scroll.scrollPx + scroll.viewportH)
|
| {
|
| scroll.scrollPx = caretLineBottom - scroll.viewportH;
|
| }
|
| AiScrollClamp(scroll);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Render editor text, selection, and caret |
|
| //+------------------------------------------------------------------+
|
| void CAiEditor::Render(CAiCanvasFast &canvas, int rectL, int rectT, int rectR, int rectB,
|
| CAiCanvasPrimitives &prim)
|
| {
|
| //--- Compute content rect from outer rect and padding
|
| const int contentL = rectL + padX;
|
| const int contentT = rectT + padY;
|
| const int contentR = rectR - padX;
|
| const int contentB = rectB - padY;
|
| const int viewportW = contentR - contentL;
|
| const int viewportH = contentB - contentT;
|
| if(viewportW <= 0 || viewportH <= 0)
|
| return;
|
| //--- Update scroll viewport and clamp
|
| scroll.viewportH = viewportH;
|
| AiScrollClamp(scroll);
|
| //--- Recompute wrap if viewport width changed
|
| const int effectiveWrapW = viewportW - 10;
|
| if(wrapWidth != effectiveWrapW)
|
| {
|
| wrapWidth = effectiveWrapW;
|
| Rebuild();
|
| }
|
| //--- Determine if placeholder should display
|
| const bool showPlaceholder = (StringLen(buffer) == 0)
|
| && StringLen(placeholder) > 0;
|
| //--- Read host canvas dimensions
|
| const int cw = canvas.Width();
|
| const int ch = canvas.Height();
|
| //--- Ensure scratch canvas matches host size
|
| if(!tmpCanvasReady || tmpCanvasW < cw || tmpCanvasH < ch)
|
| {
|
| if(tmpCanvasReady)
|
| tmpCanvas.Destroy();
|
| const int newW = MathMax(cw, tmpCanvasW);
|
| const int newH = MathMax(ch, tmpCanvasH);
|
| if(!tmpCanvas.CreateBitmap(tmpCanvasName, 0, 0, newW, newH, COLOR_FORMAT_ARGB_NORMALIZE))
|
| return;
|
| tmpCanvasW = newW;
|
| tmpCanvasH = newH;
|
| tmpCanvasReady = true;
|
| }
|
| //--- Clear content region and seed from host canvas
|
| tmpCanvas.FillRectFast(MathMax(contentL, 0), MathMax(contentT, 0),
|
| MathMin(contentR, cw), MathMin(contentB, ch), 0);
|
| tmpCanvas.CopyRectFromCanvas(canvas, contentL, contentT, contentR, contentB);
|
| //--- Alias scratch canvas as tmp for the render block
|
| #define tmp tmpCanvas
|
| tmp.FontSet(fontName, -(fontSize * 10));
|
| const int n = ArraySize(visLines);
|
| //--- Draw selection highlights when focused with text
|
| if(focused && !showPlaceholder)
|
| {
|
| int selS, selE;
|
| if(GetSelectionRange(selS, selE))
|
| {
|
| const uint selArgb = ColorToARGB(g_ai_selectionBg, 140);
|
| //--- Iterate visual lines and intersect with selection
|
| for(int liS = 0; liS < n; liS++)
|
| {
|
| const int lineStart = bufOffsets[liS];
|
| const int lineLen = StringLen(visLines[liS]);
|
| const int lineEnd = lineStart + lineLen;
|
| const int subS = (selS > lineStart) ? selS : lineStart;
|
| const int subE = (selE < lineEnd) ? selE : lineEnd;
|
| if(subE <= subS)
|
| continue;
|
| //--- Measure pre-selection and selection widths
|
| const int preStart = lineStart;
|
| const int preCount = subS - preStart;
|
| const int selCount = subE - subS;
|
| const string preSel = (preCount > 0) ? StringSubstr(buffer, preStart, preCount) : "";
|
| const string inSel = (selCount > 0) ? StringSubstr(buffer, subS, selCount) : "";
|
| const int preW = (StringLen(preSel) > 0) ? tmp.TextWidth(preSel) : 0;
|
| const int selW = (StringLen(inSel) > 0) ? tmp.TextWidth(inSel) : 0;
|
| //--- Add small sliver when selection spans newline
|
| const bool inclTrailNL = (selE > lineEnd && lineEnd < StringLen(buffer)
|
| && StringGetCharacter(buffer, lineEnd) == '\n');
|
| const int sliverW = inclTrailNL ? 4 : 0;
|
| //--- Compute screen rect for highlight
|
| const int rL = contentL + preW;
|
| const int rR = rL + selW + sliverW;
|
| const int rT = contentT + liS * lineH - scroll.scrollPx;
|
| const int rB = rT + lineH;
|
| if(rB <= contentT || rT >= contentB)
|
| continue;
|
| //--- Blend selection color over pixels
|
| for(int yy = rT; yy < rB; yy++)
|
| for(int xx = rL; xx < rR; xx++)
|
| WidgetAiBlendPixel(tmp, xx, yy, selArgb);
|
| }
|
| }
|
| }
|
| //--- Draw placeholder or visual lines
|
| if(showPlaceholder)
|
| {
|
| AiStampTextAA(tmp, contentL, contentT, placeholder, fontName, fontSize, g_ai_subText);
|
| }
|
| else
|
| {
|
| for(int li = 0; li < n; li++)
|
| {
|
| const int lineY = contentT + li * lineH - scroll.scrollPx;
|
| if(lineY + lineH < contentT)
|
| continue;
|
| if(lineY > contentB)
|
| break;
|
| if(StringLen(visLines[li]) > 0)
|
| AiStampTextAA(tmp, contentL, lineY, visLines[li], fontName, fontSize, g_ai_bodyText);
|
| }
|
| }
|
| //--- Draw blinking caret when focused
|
| if(focused && blinkOn)
|
| {
|
| int caretX, caretY1, caretY2;
|
| if(showPlaceholder)
|
| {
|
| caretX = contentL;
|
| caretY1 = contentT + 1;
|
| caretY2 = caretY1 + lineH - 3;
|
| }
|
| else
|
| {
|
| int caretLine, caretCol;
|
| FindLineCol(caret, caretLine, caretCol);
|
| caretX = contentL + CharIndexToColPx(visLines[caretLine], caretCol);
|
| caretY1 = contentT + caretLine * lineH - scroll.scrollPx + 1;
|
| caretY2 = caretY1 + lineH - 3;
|
| }
|
| const uint caretArgb = ColorToARGB(g_ai_caretColor, 255);
|
| WidgetAiThickLineAA(tmp, caretX, caretY1, caretX, caretY2, 1, caretArgb);
|
| }
|
| //--- Copy rendered region back to host canvas
|
| tmp.CopyRectToCanvas(canvas, contentL, contentT, contentR, contentB);
|
| //--- Undefine scratch alias
|
| #undef tmp
|
| //--- Draw scrollbar when content exceeds viewport
|
| if(AiScrollVisible(scroll))
|
| {
|
| const int sbW = 4;
|
| const int sbRightPad = 2;
|
| scroll.trackL = contentR - sbW - sbRightPad;
|
| scroll.trackT = contentT;
|
| scroll.trackR = scroll.trackL + sbW;
|
| scroll.trackB = contentB;
|
| AiScrollDraw(canvas, scroll, prim);
|
| }
|
| }
|
|
|
| #endif // AI_CANVAS_EDITOR_MQH
|
| //+------------------------------------------------------------------+
|
