29210372/Article-22495-Dispatch-Driven-AI-Trading-Signals
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Article-22495-Dispatch-Driv.../AI Canvas Editor.mqh

916 lines
No EOL
33 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| 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(CCanvas &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(CCanvas &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
Reference in a new issue View git blame Copy permalink