🤖 Building a ChatGPT AI Trade Brain in MQL5

There's a moment every algo trader eventually hits. You've built something that talks really well. The AI responds, the response is smart, the analysis sounds convincing — and then you sit there, manually interpreting prose, typing orders by hand, watching entry bars close while you fumble with the lot size field. The chat interface delivered insight. It delivered zero execution. 😤

That gap ends here.

This article is the story of how a sophisticated MQL5 AI chat assistant gets surgically rebuilt into something that doesn't just talk about trades — it places them. We design a dispatch-driven architecture where every analytical action (seven of them, covering everything from a two-bar momentum check to a full fifty-bar support/resistance scan) routes through a single central handler via stable integer IDs. We discipline the AI into speaking a line-based KEY:VALUE protocol instead of free-form prose, so responses are machine-parseable regardless of how chatty the model gets. We wire a pending order matrix that maps level type and trade bias to the correct order type automatically. And we build the UI to match — a split-action signal button, a caret-aware custom editor, pixel-accurate binary-search text fitting, thirteen hand-drawn semantic icons, a virtualized search popup with filter caching, and a toast notification system with a live countdown progress bar.

By the time you finish reading, you'll have a working MQL5 Expert Advisor that presents a seven-action signal console on your chart, generates structured AI trade signals, places real orders, and paints every decision as a labeled bar-anchored drawing — auditable, backtestable, and built to grow.

1. 🏗️ The Problem With Chatbots That Can't Trade

Let's be honest about what the previous version of this assistant actually was: a very expensive autocomplete with a pretty face. 💅

You'd open the dashboard, type "what's the trend on this pair?", and get back two paragraphs of nuanced market commentary. Beautiful. Completely useless for automation. The response was prose. Code cannot parse prose. You can't feed "the recent price action suggests a cautiously bullish bias with notable resistance overhead" into OrderSend(). Every signal still lived entirely in your head, and your head is fallible, slow, and prone to FOMO.

The structural problems were three-deep. First, every response came back as unstructured text — no consistent format, no machine-readable fields, nothing a parser could grab onto. Second, every type of analysis (scalp signal, daily bias, trend read) funneled through the same single chat box with no way to give each one its own data preparation, prompt template, or execution path. Third, even when a useful signal did emerge, nothing on the chart showed that a decision had been made. No arrow on the entry bar. No line on the level. Nothing. The trader carried the signal mentally, and mental signals have a half-life measured in minutes. ⏱️

The fix isn't a smarter prompt. The fix is architecture. By the end, you will have the following outcome.

What a Dispatch-Driven System Actually Means

Picture a hotel concierge desk. 🏨 The concierge doesn't handle every guest request by improvising from scratch. They have a laminated card behind the counter: "spa booking → call extension 12, restaurant reservation → call extension 34, airport transfer → call extension 56." A guest walks up, states a need, the concierge reads the card, makes one call. New service added? New line on the card. Nothing else changes.

That's what we're building. Each of our seven trading actions has a stable integer ID — its "extension number." The dispatcher is the concierge. A button click is the guest. The entire routing system fits in one switch statement. Adding an eighth action in a future version means adding one row to three arrays and one case to the switch. The UI button appears automatically. The hover code routes automatically. The events dispatch automatically.

The Seven Actions and What They Actually Do

Rather than list these as a table and call it a day, let's walk through the analytical logic each one represents — because understanding why these seven were chosen matters for extending the system intelligently.

Get Chart Data is the foundation action. It dumps recent OHLC bars, indicator readings, and symbol metadata into the chat as context. You use this before asking follow-up questions — it's the "here's what I'm looking at" primer that makes subsequent AI responses grounded rather than generic.

Twin Bars exploits one of the most reliable momentum signals in candlestick analysis: two consecutive bars closing in the same direction with the same character. If Bar 1 and Bar 2 are both clean bullish closes, the path of least resistance is up. If they're both bearish, it's down. This action checks the last two closed bars, classifies them, and emits BUY, SELL, or NONE. Clean, fast, low-noise.

Quick Scalp widens the lens to ten bars and hunts for candlestick patterns — engulfing bars, pin bars, inside bars, morning/evening stars. The signal targets the current intraday opportunity rather than a longer-term view. It's designed for the trader who wants a fast machine-generated entry trigger without sitting through a full analysis cycle.

Daily Signal steps up to the H1 timeframe and pulls every closed hourly bar from today's session. It's asking a directional bias question: given how today has played out so far, which way is the market leaning? The answer comes back as a directional momentum score that drives a market order entry.

Trend Read takes the widest analytical view of the signal actions — thirty bars, full trend analysis, with two price anchor points returned that the program uses to draw an actual trendline on the chart. This is where the system starts producing chart drawings that persist, not just chat text that disappears when you scroll.

Key Level scans fifty bars for one significant horizontal S/R level, classifies it as support or resistance, and determines whether the current price action favors bouncing off it or breaking through it. The bounce-or-break decision, combined with the support-or-resistance classification, completely determines the pending order type through a 2×2 matrix — no ambiguity, no manual decision.

Clear Drawings is pure housekeeping. Every trendline, arrow, horizontal line, and label the program painted on the chart gets wiped in a single command. Essential after a backtesting session when the chart looks like a kindergarten art project. 🎨

The AI output protocol underpinning all six analytical actions is the same: one fact per line, no JSON, no nested braces. SIGNAL: BUY, ENTRY: 1.10250, LEVEL_TYPE: SUPPORT, BIAS: BOUNCE. The parser reads lines, extracts values, ignores everything else. It's deliberately designed to survive the AI appending commentary — because it always does.

2. 🎨 Building the Visual Foundation — Theme, Primitives, and the Drawing Stack

Every pixel you see on the dashboard — the rounded corners, the anti-aliased text, the smooth icon lines, the gradient-free flat chat bubbles — traces back to two foundational files. Everything else in the program is a consumer of these primitives. We build them first, we build them right, and we never touch them again.

The Theme System: One Function, Total Control

The theme file holds every color, font size, layout dimension, and glyph code the program references. All of them. Centralized. This sounds obvious until you've spent three hours hunting across a 4,000-line codebase to change one padding value that affects eight different UI elements. We've all been there. 😅

The architecture here is simple: every visual constant is either a preprocessor #define (compile-time, zero runtime overhead) or a global color variable filled by a single function call. That function is Ai_ApplyTheme.

//+------------------------------------------------------------------+
//|                                              AI Canvas Theme.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"

#ifndef AI_CANVAS_THEME_MQH
#define AI_CANVAS_THEME_MQH

//+------------------------------------------------------------------+
//| Layout Dimensions                                                |
//+------------------------------------------------------------------+
#define AI_SIDEBAR_W_EXPANDED   150
#define AI_SIDEBAR_W_COLLAPSED  50
//--- REST OF DIMENSIONS AS BEFORE

//+------------------------------------------------------------------+
//| Apply theme palette - true = dark, false = light                 |
//+------------------------------------------------------------------+
void Ai_ApplyTheme(bool dark)
  {
   g_ai_darkTheme = dark;
   if(dark)
     {
      g_ai_bg             = C'22,26,36';
      g_ai_panelAlt       = C'28,33,46';
      g_ai_headerBg       = C'30,35,48';
      g_ai_sidebarBg      = C'24,29,40';
      g_ai_promptBg       = C'34,30,24';
      g_ai_border         = C'95,105,125';
      g_ai_borderAccent   = C'130,140,160';
      g_ai_titleText      = C'225,230,240';
      g_ai_subText        = C'140,150,170';
      g_ai_bodyText       = C'215,220,232';
      g_ai_userBubbleText = C'200,210,225';
      g_ai_aiBubbleText   = C'140,180,255';
      g_ai_userBubbleBg   = C'40,48,65';
      g_ai_aiBubbleBg     = C'35,55,90';
      g_ai_timestampText  = C'105,115,135';
      //--- SAME APPROACH FOR THE REST OF THE MEMBERS
     }
  }

#endif // AI_CANVAS_THEME_MQH

Ai_ApplyTheme(true) assigns the entire dark palette in one pass. Ai_ApplyTheme(false) does the same for light. Calling it from the theme toggle button in the interact layer means the entire dashboard repaints in the new colors on the next Ai_RenderAll() — no per-element color logic anywhere. One function. Total control. ✅

Font sizes cover six use cases: title text, body text, button labels, chat snippet previews, timestamps, and toolbar labels. Glyph codes map readable names to raw font characters — AI_GLYPH_CLOSE = "r" renders as a close cross in Webdings. The rest of the codebase references AI_GLYPH_CLOSE, never "r". When you look at the code six months from now, you'll thank yourself. 🙏

The Pixel Engine — Why We Subclass CCanvas

Here's something MQL5 developers rarely talk about: calling PixelSet and PixelGet on a CCanvas object for every pixel in a blend operation is genuinely slow. Those are virtual function calls. When you're compositing text glyphs, painting chat bubbles, blending rounded rectangles at 4× supersampling and then downsampling — you're making millions of those calls per render frame.

The fix is surgical. We subclass CCanvas into CAiCanvasFast and expose the internal pixel buffer directly:

//+------------------------------------------------------------------+
//|                                         AI Canvas Primitives.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"

#ifndef AI_CANVAS_PRIMITIVES_MQH
#define AI_CANVAS_PRIMITIVES_MQH

#include <Canvas/Canvas.mqh>
#include "AI Canvas Theme.mqh"

//+------------------------------------------------------------------+
//| Fast canvas subclass with direct pixel buffer access             |
//+------------------------------------------------------------------+
class CAiCanvasFast : public CCanvas
  {
public:
   uint GetPixelDirect(int x, int y) const
     {
      return m_pixels[y * Width() + x];
     }

   void SetPixelDirect(int x, int y, uint v)
     {
      m_pixels[y * Width() + x] = v;
     }

   void CopyRectFromCanvas(CCanvas &src, int l, int t, int r, int b)
     {
      const int sw = src.Width();
      const int sh = src.Height();
      const int dw = Width();
      const int dh = Height();
      const int cl = MathMax(0, l);
      const int ct = MathMax(0, t);
      const int cr = MathMin(MathMin(r, sw), dw);
      const int cb = MathMin(MathMin(b, sh), dh);
      for(int yy = ct; yy < cb; yy++)
        {
         const int rowBase = yy * dw;
         for(int xx = cl; xx < cr; xx++)
            m_pixels[rowBase + xx] = src.PixelGet(xx, yy);
        }
     }

   void CopyRectToCanvas(CCanvas &dst, int l, int t, int r, int b)
     {
      const int dwOther = dst.Width();
      const int dhOther = dst.Height();
      const int sw = Width();
      const int sh = Height();
      const int cl = MathMax(0, l);
      const int ct = MathMax(0, t);
      const int cr = MathMin(MathMin(r, sw), dwOther);
      const int cb = MathMin(MathMin(b, sh), dhOther);
      for(int yy = ct; yy < cb; yy++)
        {
         const int rowBase = yy * sw;
         for(int xx = cl; xx < cr; xx++)
            dst.PixelSet(xx, yy, m_pixels[rowBase + xx]);
        }
     }

   void FillRectFast(int l, int t, int r, int b, uint argb)
     {
      const int w = Width();
      const int h = Height();
      const int cl = MathMax(0, l);
      const int ct = MathMax(0, t);
      const int cr = MathMin(r, w);
      const int cb = MathMin(b, h);
      for(int yy = ct; yy < cb; yy++)
        {
         const int rowBase = yy * w;
         for(int xx = cl; xx < cr; xx++)
            m_pixels[rowBase + xx] = argb;
        }
     }
  };

//+------------------------------------------------------------------+
//| Drawing primitives helper class                                  |
//+------------------------------------------------------------------+
class CAiCanvasPrimitives
  {
public:
   bool          m_hrFillReady;
   bool          m_hrBorderReady;
   int           m_hrFillW;
   int           m_hrFillH;
   int           m_hrBorderW;
   int           m_hrBorderH;
   CAiCanvasFast m_hrFill;
   CAiCanvasFast m_hrBorder;

                  CAiCanvasPrimitives();
   bool           EnsureHrFill(int needW, int needH);
   bool           EnsureHrBorder(int needW, int needH);
   void           BlendPixelSet(CCanvas &canvas, int x, int y, uint sourceARGB);
   void           DownsampleCanvas(CCanvas &dst, CCanvas &src, int factor);
   void           FillCornerQuadrantHR(CCanvas &canvas, int cx, int cy, int radius, uint argb, int signX, int signY);
   void           FillRoundRectHR(CCanvas &canvas, int x, int y, int w, int h, int radius, uint argb);
   void           FillSelectiveRoundRectHR(CCanvas &canvas, int x, int y, int w, int h, int radius, uint argb,
                                            bool rTL, bool rTR, bool rBL, bool rBR);
   void           FillTriangleHR(CCanvas &canvas, int x0, int y0, int x1, int y1, int x2, int y2, uint argb);
   void           FillQuadrilateralBorder(CCanvas &canvas, double &vx[], double &vy[], uint argb);
   void           DrawBorderEdge(CCanvas &canvas, double x0, double y0, double x1, double y1, int thickness, uint argb);
   bool           IsAngleBetween(double angle, double startAngle, double endAngle);
   void           DrawCornerArc(CCanvas &canvas, int cx, int cy, int radius, int thickness, uint argb, double startAngle, double endAngle);
   void           DrawSelectiveRoundRectBorderHR(CCanvas &canvas, int x, int y, int w, int h, int radius, uint argb, int thickness,
                                                  bool rTL, bool rTR, bool rBL, bool rBR);
   void           FillCircleAA(CCanvas &canvas, int cx, int cy, int radius, uint argb);
   void           DrawCircleBorderAA(CCanvas &canvas, int cx, int cy, int radius, int thickness, uint argb);
   void           DrawRoundRectBorderObStyle(CCanvas &canvas, int x, int y, int w, int h, int radius, uint argb,
                                              bool drawTop, bool drawLeft, bool drawRight, bool drawBottom,
                                              bool arcTL, bool arcTR, bool arcBL, bool arcBR);
   void           FillRoundRectSharp(CCanvas &target, int x, int y, int w, int h, int radius, uint argb, int factor = 4);
   void           DrawRoundRectBorderSharp(CCanvas &target, int x, int y, int w, int h, int radius, int thickness, uint argb, int factor = 4);
  };

GetPixelDirect and SetPixelDirect use the row-major formula y * Width() + x directly — no virtual dispatch, no bounds overhead (we handle clamping at the call site where it makes sense). FillRectFast fills a rectangle row by row with a single inner loop. CopyRectFromCanvas and CopyRectToCanvas bulk-transfer rectangular regions between canvases — a pattern we use heavily in the search popup's clipped rendering.

The CAiCanvasPrimitives class owns two off-screen CAiCanvasFast instances — m_hrFill and m_hrBorder. These are the supersampling working canvases. When we need a sharp anti-aliased rounded rectangle, we render it at 4× resolution into m_hrFill, then box-average the result down to 1× for the main canvas. The EnsureHrFill and EnsureHrBorder methods grow these working canvases lazily — they allocate only when a request needs more space than already exists. First time costs. Every subsequent call is free. ♻️

The Text Anti-Aliasing Trick Nobody Teaches

TextOut in MQL5 renders text into a pixel buffer. What it doesn't give you is per-pixel alpha coverage. Without alpha coverage, stamping text onto a colored background produces hard opaque edges that look terrible on anything except pure white.

Here's how we solve it with a technique called the dual-buffer method:

//+------------------------------------------------------------------+
//| Stamp anti-aliased text on canvas using dual-buffer technique    |
//+------------------------------------------------------------------+
void AiStampTextAA(CCanvas &dst, int x, int y, const string txt,
                   const string fontName, int fontSize, color textColor)
  {
   if(StringLen(txt) == 0) return;

   TextSetFont(fontName, -(fontSize * 10));
   uint twU = 0, thU = 0;
   TextGetSize(txt, twU, thU);
   int tw = (int)twU, th = (int)thU;
   if(tw <= 0 || th <= 0) return;

   //--- Render onto black background
   const uint textArgb = ColorToARGB(textColor, 255);
   uint bufB[]; ArrayResize(bufB, tw * th);
   ArrayFill(bufB, 0, tw * th, 0xFF000000);
   TextOut(txt, 0, 0, TA_LEFT | TA_TOP, bufB, tw, th, textArgb, COLOR_FORMAT_ARGB_NORMALIZE);

   //--- Render onto white background
   uint bufW[]; ArrayResize(bufW, tw * th);
   ArrayFill(bufW, 0, tw * th, 0xFFFFFFFF);
   TextOut(txt, 0, 0, TA_LEFT | TA_TOP, bufW, tw, th, textArgb, COLOR_FORMAT_ARGB_NORMALIZE);

   const int cW = dst.Width(), cH = dst.Height();
   const uchar srcR = (uchar)( textColor        & 0xFF);
   const uchar srcG = (uchar)((textColor >>  8) & 0xFF);
   const uchar srcB = (uchar)((textColor >> 16) & 0xFF);

   //--- Derive per-pixel alpha from black-vs-white difference
   for(int py = 0; py < th; py++)
     {
      for(int px = 0; px < tw; px++)
        {
         int i = py * tw + px;
         int dR = (int)((bufW[i] >> 16) & 0xFF) - (int)((bufB[i] >> 16) & 0xFF);
         int dG = (int)((bufW[i] >>  8) & 0xFF) - (int)((bufB[i] >>  8) & 0xFF);
         int dB = (int)( bufW[i]        & 0xFF) - (int)( bufB[i]        & 0xFF);
         int a  = 255 - (dR + dG + dB) / 3;
         if(a <= 0) continue;
         if(a > 255) a = 255;

         int dstX = x + px, dstY = y + py;
         if(dstX < 0 || dstX >= cW || dstY < 0 || dstY >= cH) continue;

         //--- Porter-Duff over blend
         uint existing = dst.PixelGet(dstX, dstY);
         double sA = (double)a / 255.0;
         double dA = ((existing >> 24) & 0xFF) / 255.0;
         double oA = sA + dA * (1.0 - sA);
         if(oA <= 0.0) continue;
         double sRf = srcR / 255.0, sGf = srcG / 255.0, sBf = srcB / 255.0;
         double dRf = ((existing >> 16) & 0xFF) / 255.0;
         double dGf = ((existing >>  8) & 0xFF) / 255.0;
         double dBf = ( existing        & 0xFF) / 255.0;
         uint outPix = ((uint)(uchar)(oA * 255.0 + 0.5) << 24) |
                       ((uint)(uchar)((sRf*sA + dRf*dA*(1.0-sA)) / oA * 255.0 + 0.5) << 16) |
                       ((uint)(uchar)((sGf*sA + dGf*dA*(1.0-sA)) / oA * 255.0 + 0.5) <<  8) |
                        (uint)(uchar)((sBf*sA + dBf*dA*(1.0-sA)) / oA * 255.0 + 0.5);
         dst.PixelSet(dstX, dstY, outPix);
        }
     }
  }

The core insight: render the same text twice — once over pure black (bufB), once over pure white (bufW). Where a pixel is fully inside the glyph, both buffers receive the source color and their difference is zero. Where a pixel is fully outside, the buffers keep their black and white fills — maximum difference. Anti-aliased edges fall in between, proportional to how much of the glyph covers that pixel. Invert the averaged difference and you have a clean alpha mask. Run that through a standard Porter-Duff over-blend and your text composites perfectly over any background color in the dashboard. Blue bubble, dark panel, beige prompt pane — the text looks sharp everywhere. 🔬

Binary Search Beats Character Counting Every Time

One of the subtle-but-visible improvements over the previous article is how chat titles, popup snippets, and button labels get truncated to fit their allocated pixel width. The old way counted characters and hoped for the best. The problem with counting characters on a proportional font is that "iiiiii" and "MMMMMM" are the same length in characters but wildly different in pixels. Naive truncation produces labels that sometimes have a gaping right margin and sometimes overflow their container — neither is acceptable.

The fix: binary search. 🔎

//+------------------------------------------------------------------+
//| Fit text to maximum pixel width with ellipsis                    |
//+------------------------------------------------------------------+
string Ai_FitTextToWidth(const string text, const string fontName, int fontSize, int maxWidthPx)
  {
   if(StringLen(text) == 0)  return "";
   if(maxWidthPx <= 0)       return "";

   //--- Fast path: full text already fits
   const int fullW = AiTextWidth(text, fontName, fontSize);
   if(fullW <= maxWidthPx) return text;

   //--- Edge case: even "..." is too wide
   const string ellipsis = "...";
   const int ellipsisW = AiTextWidth(ellipsis, fontName, fontSize);
   if(ellipsisW > maxWidthPx) return "";

   //--- Binary search: find the longest prefix that fits with "..." appended
   const int n = StringLen(text);
   int lo = 0, hi = n;
   while(lo < hi)
     {
      const int mid = (lo + hi + 1) / 2;
      const string trial = StringSubstr(text, 0, mid) + ellipsis;
      if(AiTextWidth(trial, fontName, fontSize) <= maxWidthPx)
         lo = mid;
      else
         hi = mid - 1;
     }

   if(lo <= 0) return ellipsis;
   return StringSubstr(text, 0, lo) + ellipsis;
  }

The binary search converges in log₂(n) iterations — roughly 10 calls for a 1000-character string. The key variables lo and hi bracket the candidate prefix length. When the trial string (prefix + "...") fits within budget, lo advances to try for longer. When it overflows, hi retreats. The bracket collapses to the exact longest prefix that fits. Every single truncated label in the entire program — sidebar chat titles, search snippets, dropdown labels — now lands within one pixel of its budget regardless of character composition. It's a small thing that makes the whole dashboard look significantly more professional. ✨

Drawing Icons That Actually Mean Something

Webdings and Wingdings had to go. 👋

Using font characters as icons means you're constrained by whatever glyphs the font designer decided to include, at whatever size they were drawn, with whatever proportions they chose. You get no control over stroke weight, semantic color, or pixel alignment. The toolbar for a trading dashboard should communicate intent instantly — the trend icon should look like a trendline, the level icon should look like a horizontal bar, the lightning bolt for Quick Scalp should actually spark energy.

So we drew all thirteen icons ourselves. Each one takes a canvas, a corner position, a size, and a color. Each uses AiThickLineAA, AiIconLine, and AiStrokeArcAA for their strokes. AiIconLine implements Xiaolin Wu's line algorithm — iterate along the major axis, plot two adjacent pixels with complementary fractional weights so lines stay smooth at any angle:

//+------------------------------------------------------------------+
//| Draw chevron arrow (used for expand/collapse indicators)         |
//+------------------------------------------------------------------+
void AiDrawChevron(CCanvas &canvas, int cx, int cy, bool pointUp, uint argb)
  {
   if(pointUp)
     {
      AiThickLineAA(canvas, cx - 4, cy + 2, cx,     cy - 2, 2, argb);
      AiThickLineAA(canvas, cx,     cy - 2, cx + 4, cy + 2, 2, argb);
     }
   else
     {
      AiThickLineAA(canvas, cx - 4, cy - 2, cx,     cy + 2, 2, argb);
      AiThickLineAA(canvas, cx,     cy + 2, cx + 4, cy - 2, 2, argb);
     }
  }

//+------------------------------------------------------------------+
//| Anti-aliased line using Xiaolin Wu algorithm                     |
//+------------------------------------------------------------------+
void AiIconLine(CCanvas &canvas, double x0, double y0, double x1, double y1, uint argb)
  {
   double dxL = x1 - x0, dyL = y1 - y0;
   bool steep = MathAbs(dyL) > MathAbs(dxL);

   if(steep)
     {
      if(y0 > y1) { double t; t=x0;x0=x1;x1=t; t=y0;y0=y1;y1=t; }
      double grad = (y1 == y0) ? 0.0 : (x1 - x0) / (y1 - y0);
      int iy0 = (int)MathRound(y0), iy1 = (int)MathRound(y1);
      double xf = x0 + grad * (iy0 - y0);
      for(int iy = iy0; iy <= iy1; iy++)
        {
         int ix = (int)MathFloor(xf);
         double frac = xf - ix;
         AiIconAAPlot(canvas, ix,     iy, 1.0 - frac, argb);
         AiIconAAPlot(canvas, ix + 1, iy, frac,       argb);
         xf += grad;
        }
     }
   else
     {
      if(x0 > x1) { double t; t=x0;x0=x1;x1=t; t=y0;y0=y1;y1=t; }
      double grad = (x1 == x0) ? 0.0 : (y1 - y0) / (x1 - x0);
      int ix0 = (int)MathRound(x0), ix1 = (int)MathRound(x1);
      double yf = y0 + grad * (ix0 - x0);
      for(int ix = ix0; ix <= ix1; ix++)
        {
         int iy = (int)MathFloor(yf);
         double frac = yf - iy;
         AiIconAAPlot(canvas, ix, iy,     1.0 - frac, argb);
         AiIconAAPlot(canvas, ix, iy + 1, frac,       argb);
         yf += grad;
        }
     }
  }

//--- ALL OTHER ICONS FOLLOW THE SAME APPROACH

Each of the thirteen icon drawers gets a semantic color — the trend icon draws in the trend accent color, the key level icon draws in the level accent color, the clear icon draws in a muted warning red. When the user glances at the toolbar, the colors reinforce the meaning before the label even registers. That's icon design that earns its keep. 🎯

Rendering Markdown in Chat Bubbles

The AI loves to respond with **bold** text for signal names and *italic* for emphasis. In the previous article, asterisks rendered as literal asterisks in the chat bubble. That's fixed now.

The inline markdown parser walks a line character by character, accumulates plain text in a buffer, and emits a new styled run whenever it hits an asterisk sequence:

//+------------------------------------------------------------------+
//| Styled text run (one segment of consistent bold/italic state)    |
//+------------------------------------------------------------------+
struct AiMdRun
  {
   string text;
   bool   bold;
   bool   italic;
  };

//+------------------------------------------------------------------+
//| Parse markdown line into sequence of styled runs                 |
//+------------------------------------------------------------------+
void AiMdParseInline(const string txt, AiMdRun &runs[])
  {
   ArrayResize(runs, 0);
   const int len = StringLen(txt);
   if(len == 0) return;

   bool curBold = false, curItalic = false;
   string buf = "";

   #define AI_MD_FLUSH() \
   { \
      if(StringLen(buf) > 0) { \
         const int sz = ArraySize(runs); \
         ArrayResize(runs, sz + 1); \
         runs[sz].text   = buf; \
         runs[sz].bold   = curBold; \
         runs[sz].italic = curItalic; \
         buf = ""; \
      } \
   }

   int i = 0;
   while(i < len)
     {
      const ushort ch = StringGetCharacter(txt, i);
      if(ch == '*')
        {
         if(i + 2 < len
            && StringGetCharacter(txt, i+1) == '*'
            && StringGetCharacter(txt, i+2) == '*')
           { AI_MD_FLUSH(); curBold=!curBold; curItalic=!curItalic; i+=3; continue; }
         if(i + 1 < len && StringGetCharacter(txt, i+1) == '*')
           { AI_MD_FLUSH(); curBold=!curBold; i+=2; continue; }
         AI_MD_FLUSH(); curItalic=!curItalic; i++; continue;
        }
      buf += StringSubstr(txt, i, 1);
      i++;
     }
   AI_MD_FLUSH();
   #undef AI_MD_FLUSH
  }

//+------------------------------------------------------------------+
//| Resolve font name for a run's style flags                        |
//+------------------------------------------------------------------+
string AiMdRunFont(const AiMdRun &r)
  {
   if(r.bold && r.italic) return "Arial Bold Italic";
   if(r.bold)             return "Arial Bold";
   if(r.italic)           return "Arial Italic";
   return "Arial";
  }

//+------------------------------------------------------------------+
//| Measure total pixel width of a run sequence                      |
//+------------------------------------------------------------------+
int AiMdRunsWidth(const AiMdRun &runs[], int fontSize)
  {
   int total = 0;
   const int n = ArraySize(runs);
   for(int i = 0; i < n; i++)
      total += AiTextWidth(runs[i].text, AiMdRunFont(runs[i]), fontSize);
   return total;
  }

//+------------------------------------------------------------------+
//| Stamp styled runs onto canvas side by side                       |
//+------------------------------------------------------------------+
void AiMdStampRuns(CCanvas &canvas, int x, int y,
                    const AiMdRun &runs[], int fontSize, color textCol)
  {
   int curX = x;
   const int n = ArraySize(runs);
   for(int i = 0; i < n; i++)
     {
      if(StringLen(runs[i].text) == 0) continue;
      const string font = AiMdRunFont(runs[i]);
      AiStampTextAA(canvas, curX, y, runs[i].text, font, fontSize, textCol);
      curX += AiTextWidth(runs[i].text, font, fontSize);
     }
  }

//+------------------------------------------------------------------+
//| Track style state at end of line (for multi-line wrap continuity)|
//+------------------------------------------------------------------+
void AiMdComputeEndState(const string txt, bool &openBold, bool &openItalic)
  {
   const int len = StringLen(txt);
   if(len == 0) return;
   int i = 0;
   while(i < len)
     {
      const ushort ch = StringGetCharacter(txt, i);
      if(ch == '*')
        {
         if(i+2 < len && StringGetCharacter(txt,i+1)=='*' && StringGetCharacter(txt,i+2)=='*')
           { openBold=!openBold; openItalic=!openItalic; i+=3; continue; }
         if(i+1 < len && StringGetCharacter(txt,i+1)=='*')
           { openBold=!openBold; i+=2; continue; }
         openItalic=!openItalic; i++; continue;
        }
      i++;
     }
  }

//+------------------------------------------------------------------+
//| Return the marker prefix to reopen styles on continuation lines  |
//+------------------------------------------------------------------+
string AiMdReopenMarkers(const bool openBold, const bool openItalic)
  {
   if(openBold && openItalic) return "***";
   if(openBold)               return "**";
   if(openItalic)             return "*";
   return "";
  }

The AI_MD_FLUSH macro emits whatever is in the accumulation buffer as a new run before changing style state. The order of asterisk checks matters — *** must be tested before **, which must be tested before *, or shorter sequences incorrectly match the start of longer ones.

AiMdComputeEndState tracks which styles are still open at the end of a line. This exists for paragraph wrapping: when **bold text opens on visual line 1 and closes on visual line 2, the renderer needs to know to start line 2 already in bold state. AiMdReopenMarkers converts that end-state back into the opening marker sequence to inject at the start of the continuation. Wrapped bold text stays bold. Wrapped italic text stays italic. The chat bubbles look like they were designed by an adult. 👨‍💼

3. 🗂️ The State Layer — Where All the Data Lives

One Header, Every Global

The previous article scattered globals across multiple files and kept finding new places to add them as features grew. This article consolidates everything — the dispatch tables, toast state, drag state, popup flags, editor state, scroll positions — into one dedicated state header. Any module that needs to read or write program state includes this single file. No surprises, no circular dependency hunting, no "where was that flag declared again?" archaeology sessions. 🏺

The most interesting new additions are the dispatch tables, which turn the action system from code into data:

//+------------------------------------------------------------------+
//|                                              AI Canvas State.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"

#ifndef AI_CANVAS_STATE_MQH
#define AI_CANVAS_STATE_MQH

#include "AI Canvas Theme.mqh"

#define AI_CANVAS_NAME_MAIN    "ChatGPT_AI_MainCanvas"
#define AI_CANVAS_NAME_PROMPT  "ChatGPT_AI_PromptCanvas"

//+------------------------------------------------------------------+
//| Chat Record                                                      |
//+------------------------------------------------------------------+
struct Chat
  {
   int    id;
   string title;
   string history;
  };

//+------------------------------------------------------------------+
//| Chat State                                                       |
//+------------------------------------------------------------------+
Chat   g_ai_chats[];
int    g_ai_currentChatId        = -1;
string g_ai_currentTitle         = "";
string g_ai_conversationHistory  = "";
string g_ai_currentPrompt        = "";

//+------------------------------------------------------------------+
//| UI Visibility                                                    |
//+------------------------------------------------------------------+
bool g_ai_sidebarExpanded  = true;
bool g_ai_dashboardVisible = true;

//+------------------------------------------------------------------+
//| Popup Flags                                                      |
//+------------------------------------------------------------------+
bool   g_ai_showSmallHistory  = false;
bool   g_ai_showBigHistory    = false;
bool   g_ai_showSearch        = false;
bool   g_ai_justOpenedSmall   = false;
bool   g_ai_justOpenedBig     = false;
bool   g_ai_justOpenedSearch  = false;
string g_ai_searchQuery       = "";

//+------------------------------------------------------------------+
//| Drag State                                                       |
//+------------------------------------------------------------------+
bool g_ai_dragging    = false;
int  g_ai_dragOffsetX = 0;
int  g_ai_dragOffsetY = 0;

//+------------------------------------------------------------------+
//| Dashboard Position                                               |
//+------------------------------------------------------------------+
int AI_DASHBOARD_X = AI_DASHBOARD_X_DEFAULT;
int AI_DASHBOARD_Y = AI_DASHBOARD_Y_DEFAULT;

//+------------------------------------------------------------------+
//| Footer Dropdown State                                            |
//+------------------------------------------------------------------+
bool g_ai_showFooterDropdown       = false;
int  g_ai_footerDropdownSelectedIdx = 0;

//+------------------------------------------------------------------+
//| Action Dispatch Tables                                           |
//+------------------------------------------------------------------+
const int    AI_FOOTER_DD_COUNT    = 7;
const string AI_FOOTER_DD_LABELS[] = {
   "Get Chart Data",
   "Twin Bars",
   "Quick Scalp",
   "Daily Signal",
   "Trend Read",
   "Key Level",
   "Clear Drawings"
};
const int AI_FOOTER_DD_ACTION_IDS[] = { 0, 1, 2, 3, 4, 5, 6 };
const int AI_FOOTER_DD_ICONS[]      = { 0, 1, 2, 3, 4, 5, 6 };

//+------------------------------------------------------------------+
//| API Throttle                                                     |
//+------------------------------------------------------------------+
bool g_ai_signalRequestInFlight = false;

//+------------------------------------------------------------------+
//| Animation State                                                  |
//+------------------------------------------------------------------+
datetime g_ai_lastBarTime  = 0;
int      g_ai_spinnerCycle = 0;

//+------------------------------------------------------------------+
//| Toast Notification                                               |
//+------------------------------------------------------------------+
string g_ai_toastText     = "";
bool   g_ai_toastIsError  = false;
ulong  g_ai_toastExpiryMs = 0;

//+------------------------------------------------------------------+
//| Hover and Input State                                            |
//+------------------------------------------------------------------+
bool g_ai_overPencilIcon           = false;
bool g_ai_lastRenderedSendDisabled = true;

//--- CHAT DECODE AND ENCODE LOGIC REMAINS AS BEFORE

#endif // AI_CANVAS_STATE_MQH

Three arrays — AI_FOOTER_DD_LABELS, AI_FOOTER_DD_ACTION_IDS, AI_FOOTER_DD_ICONS — and the entire seven-button dispatch system is data-driven. The UI render loop iterates these arrays to draw buttons. The dropdown renders from them. The dispatcher uses the ID. Change a label in AI_FOOTER_DD_LABELS and it updates everywhere simultaneously — button label, dropdown item, tooltip. That's the payoff for keeping data and behavior separated.

g_ai_signalRequestInFlight deserves a mention. It's one boolean that prevents parallel API calls. Without it, an impatient user who triple-clicks Twin Bars fires three simultaneous HTTP requests, gets three responses back in unpredictable order, and potentially places three orders on what was supposed to be one signal. The throttle flag sets on request start and clears on response — second click while first is in flight does nothing. Simple, effective, and the kind of guard that separates "seems to work" from "won't blow up in production." 🛡️

Scrollbars That Actually Reuse Code

In the previous article, the scroll logic for the chat pane, the big history popup, and the search popup were three separate but nearly identical sets of globals and math. Change the thumb sizing formula in one place and forget to change it in the others. Classic. Here, all of it consolidates into one struct and four helper functions:

//+------------------------------------------------------------------+
//|                                          AI Canvas Scrollbar.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"

#ifndef AI_CANVAS_SCROLLBAR_MQH
#define AI_CANVAS_SCROLLBAR_MQH

#include "AI Canvas Theme.mqh"
#include "AI Canvas Primitives.mqh"

//+------------------------------------------------------------------+
//| Everything one scrollbar needs to know about itself              |
//+------------------------------------------------------------------+
struct AiScrollState
  {
   int  trackL, trackT, trackR, trackB;   // Track bounds
   int  scrollPx;                          // Current scroll offset in pixels
   int  viewportH;                         // Visible region height
   int  totalH;                            // Total content height
   bool hoveredArea;                       // Mouse inside track area
   bool hoveredThumb;                      // Mouse over thumb
   bool dragging;                          // Thumb drag in progress
   bool hover;
   int  dragOriginPx;                      // Scroll position when drag started
   int  dragOriginY;                       // Mouse Y when drag started
  };

void AiScrollInit(AiScrollState &s)
  {
   s.trackL=0; s.trackT=0; s.trackR=0; s.trackB=0;
   s.scrollPx=0; s.viewportH=0; s.totalH=0;
   s.hoveredArea=false; s.hoveredThumb=false;
   s.hover=false; s.dragging=false;
   s.dragOriginPx=0; s.dragOriginY=0;
  }

int AiScrollMax(const AiScrollState &s)
  {
   int m = s.totalH - s.viewportH;
   return (m < 0) ? 0 : m;
  }

bool AiScrollVisible(const AiScrollState &s)
  {
   return AiScrollMax(s) > 0;
  }

void AiScrollClamp(AiScrollState &s)
  {
   int m = AiScrollMax(s);
   if(s.scrollPx < 0) s.scrollPx = 0;
   if(s.scrollPx > m) s.scrollPx = m;
  }

//--- REMAINING SCROLLBAR DRAW AND HIT-TEST LOGIC FOLLOWS THE SAME APPROACH

#endif // AI_CANVAS_SCROLLBAR_MQH

One AiScrollState instance per scrollable region. Pass whichever instance you need to the draw function, the hit-test function, the wheel handler. Change the thumb sizing logic once — it changes for all three regions. This is the scrollbar. It's not exciting. It doesn't need to be. ✅

4. ⌨️ A Real Text Editor, Finally

If the previous article's OBJ_EDIT field was a toy kitchen, the new CAiEditor class is a professional stove. You didn't see what you were typing until Enter. You couldn't add a newline. You couldn't click in the middle of your prompt to fix a typo. You were flying blind every time you composed a message.

The new editor owns its buffer entirely. It renders its own caret (with blink animation). It wraps text across lines. It handles selections, Shift+arrow extensions, Home/End, Backspace, Delete, click-to-position, and Ctrl shortcuts. It renders onto the canvas directly. Here's the class declaration:

//+------------------------------------------------------------------+
//|                                             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"

#ifndef AI_CANVAS_EDITOR_MQH
#define AI_CANVAS_EDITOR_MQH

#include <Canvas/Canvas.mqh>
#include "AI Canvas Theme.mqh"
#include "AI Canvas Primitives.mqh"
#include "AI Canvas Scrollbar.mqh"

//+------------------------------------------------------------------+
//| Multi-line scrollable canvas text editor                         |
//+------------------------------------------------------------------+
class CAiEditor
  {
public:
   string         buffer;
   int            caret;
   int            anchor;         // Selection anchor (-1 = no selection)
   bool           focused;
   string         fontName;
   int            fontSize;
   int            padX, padY;
   int            wrapWidth;
   int            lineH;
   AiScrollState  scroll;
   string         visLines[];    // Visual lines after word-wrap
   int            bufOffsets[];  // Buffer char offset per visual line
   bool           blinkOn;
   ulong          lastBlinkMs;
   string         placeholder;
   CAiCanvasFast  tmpCanvas;
   bool           tmpCanvasReady;
   int            tmpCanvasW, tmpCanvasH;
   string         tmpCanvasName;

                     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);
  };

The class has one instance per editor in the program: g_ai_editor for the prompt pane, g_ai_searchEditor for the search popup query field. The static instance counter in the constructor generates unique canvas names for each one — because two editors sharing a canvas name would corrupt each other's off-screen blending buffers. That's the kind of bug that takes four hours to diagnose. 🐛

Building the Editor: Construction Through Mutation

CAiEditor::CAiEditor()
  {
   buffer = ""; caret = 0; anchor = -1; focused = false;
   fontName = "Arial"; fontSize = AI_FONT_BODY;
   padX = 8; padY = 6; wrapWidth = 200; lineH = 16;
   AiScrollInit(scroll);
   blinkOn = true; lastBlinkMs = 0; placeholder = "";
   tmpCanvasReady = false; tmpCanvasW = 0; tmpCanvasH = 0;
   static int s_editorInstanceCounter = 0;
   s_editorInstanceCounter++;
   tmpCanvasName = "AiEditorTmpPersistent_" + IntegerToString(s_editorInstanceCounter);
  }

void CAiEditor::Init(const string fnt, int fsz, int padInX, int padInY)
  {
   fontName = fnt; fontSize = fsz; padX = padInX; padY = padInY;
   lineH = AiTextHeight(fnt, fsz) + 2;
  }

void CAiEditor::SetWrapWidth(int w)
  {
   if(w == wrapWidth) return;
   wrapWidth = w;
   Rebuild();
  }

void CAiEditor::SetText(const string s)
  {
   buffer = s; caret = StringLen(buffer); anchor = -1;
   Rebuild();
  }

bool CAiEditor::HasSelection()
  {
   if(anchor < 0) return false;
   if(anchor == caret) return false;
   return true;
  }

bool CAiEditor::GetSelectionRange(int &s, int &e)
  {
   if(!HasSelection()) { s = e = 0; return false; }
   s = (anchor < caret) ? anchor : caret;
   e = (anchor > caret) ? anchor : caret;
   const int len = StringLen(buffer);
   if(s < 0) s = 0;
   if(e > len) e = len;
   if(s > e) s = e;
   return e > s;
  }

bool CAiEditor::DeleteSelection()
  {
   int s, e;
   if(!GetSelectionRange(s, e)) return false;
   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;
   caret = s; anchor = -1;
   Rebuild();
   return true;
  }

void CAiEditor::SelectAll()
  {
   const int len = StringLen(buffer);
   if(len <= 0) { anchor = -1; caret = 0; return; }
   anchor = 0; caret = len;
  }

void CAiEditor::InsertChar(const string ch)
  {
   if(StringLen(ch) == 0) return;
   DeleteSelection();
   int len = StringLen(buffer);
   if(caret < 0) caret = 0;
   if(caret > len) caret = len;
   string before = StringSubstr(buffer, 0, caret);
   string after  = StringSubstr(buffer, caret, len - caret);
   buffer = before + ch + after;
   caret += StringLen(ch);
   Rebuild();
   EnsureCaretVisible();
  }

void CAiEditor::Backspace()
  {
   if(DeleteSelection()) { EnsureCaretVisible(); return; }
   if(caret <= 0) return;
   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();
  }

void CAiEditor::DeleteChar()
  {
   if(DeleteSelection()) { EnsureCaretVisible(); return; }
   int len = StringLen(buffer);
   if(caret >= len) return;
   string before = StringSubstr(buffer, 0, caret);
   string after  = StringSubstr(buffer, caret + 1, len - caret - 1);
   buffer = before + after;
   Rebuild();
   EnsureCaretVisible();
  }

The principle baked into every mutation method is selection-first. InsertChar calls DeleteSelection() before inserting — so typing while text is highlighted replaces the highlighted text, exactly like every editor you've ever used. Backspace does the same. DeleteChar does the same. This single rule handles the "delete selected text" interaction for free in all three mutation paths without any special-casing.

EnsureCaretVisible runs after every mutation and navigation to scroll the viewport so the caret stays visible. This prevents the frustrating experience of typing and watching your cursor disappear off the bottom of the prompt pane. The scroll position tracks the caret, not the other way around.

The Keyboard Handler: Virtual Keys to Editor Actions

MetaTrader delivers keyboard events as virtual key codes in CHARTEVENT_KEYDOWN. Here's the full dispatcher:

bool CAiEditor::HandleKeydown(int vk, bool shift, bool ctrl)
  {
   if(!focused) return false;

   //--- Ignore modifier-only key events (Shift, Ctrl, Alt, CapsLock, etc.)
   if(vk == 16 || vk == 17 || vk == 18 || vk == 20 ||
      vk == 144 || vk == 145 || vk == 91 || vk == 92 || vk == 93) return false;

   //--- Shift+navigation extends the selection
   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; }
     }

   //--- Plain navigation collapses the selection and moves
   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; }

   //--- Backspace (8), Delete (46)
   if(vk == 8)  { Backspace();  return true; }
   if(vk == 46) { DeleteChar(); return true; }

   //--- Shift+Enter inserts a newline (plain Enter is handled at interact level as Send)
   if(vk == 13 && shift) { InsertNewline(); return true; }

   //--- Filter to printable key ranges
   bool isPrintableVk = (vk == 32) ||
                         (vk >= 48 && vk <= 57)  ||   // digit row
                         (vk >= 65 && vk <= 90)  ||   // letter row
                         (vk >= 96 && vk <= 111) ||   // numpad
                         (vk >= 186 && vk <= 223);     // OEM punctuation
   if(!isPrintableVk) return false;

   //--- Translate VK to actual typed character respecting keyboard layout
   short uch = TranslateKey(vk);
   if(uch <= 0) return false;
   InsertChar(ShortToString((ushort)uch));
   return true;
  }

The plain Enter (vk == 13) without Shift is conspicuously absent here — it's intentionally intercepted higher up in the interact layer and routed to "send the prompt." Shift+Enter is the user's newline inside a multi-line message. This is the behavior every modern messaging app uses and users expect it without being told. 💬

TranslateKey is MetaTrader's built-in keyboard-layout-aware translator. It consults the OS keyboard layout and current modifier state and returns the Unicode character the user actually pressed. This is what makes the editor work correctly on QWERTY, AZERTY, QWERTZ, and Cyrillic layouts without any extra code on our side. The OS does the heavy lifting.

5. 🎛️ The Dashboard Render Layer

The entire dashboard is a single canvas bitmap. Not a collection of OBJ_LABEL objects repositioned on each refresh. Not a mix of chart objects and canvas regions. One canvas, redrawn completely on every state change. This gives us total layout control, pixel-perfect positioning, and zero flicker from object repositioning.

Toast Notifications With a Countdown Bar

After clearing a chat, deleting a history entry, or wiping chart drawings, users need feedback. Nobody should stare at a dashboard after a destructive action wondering if anything happened. The toast system solves this with a 5-second timed banner:

void Ai_ShowToast(string text, bool isError)
  {
   g_ai_toastText     = text;
   g_ai_toastIsError  = isError;
   g_ai_toastExpiryMs = GetTickCount64() + 5000;
  }

void Ai_RenderToast()
  {
   if(StringLen(g_ai_toastText) == 0) return;
   const ulong now = GetTickCount64();
   if(now > g_ai_toastExpiryMs) return;

   const int padX = 16, padY = 8;
   const string toastFont = "Arial Bold";
   const int    toastSize = 10;

   const int textW = AiTextWidth(g_ai_toastText, toastFont, toastSize);
   const int textH = AiTextHeight(toastFont, toastSize);

   const int barH   = 2;
   const int barGap = 6;
   const int boxW   = textW + 2 * padX;
   const int boxH   = textH + barGap + barH + 2 * padY;

   //--- Center below header
   const int mainContentL = Ai_MainContentX();
   const int mainContentR = Ai_DashboardW();
   const int boxL = mainContentL + ((mainContentR - mainContentL) - boxW) / 2;
   const int boxT = AI_HEADER_H + 6;

   g_ai_prim.FillRoundRectSharp(g_ai_canvMain, boxL, boxT, boxW, boxH, 8,
                                  ColorToARGB(g_ai_toastBg, 255));
   g_ai_prim.DrawRoundRectBorderSharp(g_ai_canvMain, boxL, boxT, boxW, boxH, 8, 1,
                                       ColorToARGB(g_ai_toastBorder, 255));

   const color textCol = g_ai_toastIsError ? g_ai_toastError : g_ai_toastSuccess;
   AiStampTextAA(g_ai_canvMain, boxL + padX, boxT + padY,
                  g_ai_toastText, toastFont, toastSize, textCol);

   //--- Progress bar: shrinks from center as time runs out
   const int   trackL    = boxL + padX;
   const int   trackR    = boxL + boxW - padX;
   const int   trackW    = trackR - trackL;
   const int   trackY    = boxT + padY + textH + barGap;
   const ulong totalLife = 5000;
   const long  remaining = (long)g_ai_toastExpiryMs - (long)now;
   double ratio = (double)remaining / (double)totalLife;
   if(ratio < 0.0) ratio = 0.0;
   if(ratio > 1.0) ratio = 1.0;
   const int fillW = (int)(trackW * ratio);
   const int fillL = trackL + (trackW - fillW) / 2;

   //--- Gray track
   g_ai_canvMain.FillRectangle(trackL, trackY, trackR - 1, trackY + barH - 1,
                                  ColorToARGB(g_ai_toastBorder, 255));
   //--- Colored fill that shrinks toward center
   if(fillW > 0)
      g_ai_canvMain.FillRectangle(fillL, trackY, fillL + fillW - 1, trackY + barH - 1,
                                     ColorToARGB(textCol, 255));
  }

The progress bar shrinks symmetrically from both ends toward the center as the 5 seconds elapse — fillL = trackL + (trackW - fillW) / 2 keeps the fill centered on the track. The result is a visual countdown that communicates time-remaining intuitively, without the user having to read a number. Green for success, red for error. The 500ms timer driving the caret blink also triggers a ChartRedraw() on every tick, which keeps the progress bar animating smoothly. ⏳