vitals-account-monitor/mql4/Include/Vitals/VtCard.mqh

//+------------------------------------------------------------------+
//|                                                       VtCard.mqh |
//|                                      Copyright 2026, Allan Niñal |
//|                                  https://www.allanninal.dev/mql5 |
//+------------------------------------------------------------------+
//| The Vitals card: one CCanvas bitmap label on the chart.          |
//|   - Scale = screen DPI / 96 x the UI-scale input.                |
//|   - Theme: Auto (from the chart background), Dark or Light.      |
//|   - Drag by the header, fold to the header, click the tabs;      |
//|     chart scrolling is paused while the mouse is down on it.     |
//|   - Position, fold and tab are kept per chart in terminal global |
//|     variables.                                                   |
//| Everything is drawn in logical units (pixels at 100 % scale) and |
//| multiplied by the scale. If the chart refuses the object (the    |
//| strategy tester) the card stays silent.                          |
//+------------------------------------------------------------------+
// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
#ifndef VTCARD_MQH
#define VTCARD_MQH
#include <Canvas/Canvas.mqh>

enum ENUM_VT_THEME
  {
   VT_THEME_AUTO=0,    // Auto (from the chart background)
   VT_THEME_DARK=1,    // Dark
   VT_THEME_LIGHT=2    // Light
  };

#define VT_CARD_W   460          // logical width
#define VT_ZMAX     96

struct VtPalette
  {
   color bg;
   uchar bg_a;
   color edge,head,ink,label,dim,pos,neg,warn,acc,track,rule;
  };

struct VtZone
  {
   int x1,y1,x2,y2;
   int id,arg;
  };

//--- zone ids
#define VTZ_HEAD   1
#define VTZ_FOLD   2
#define VTZ_TAB    3
#define VTZ_PREV   4
#define VTZ_NEXT   5
#define VTZ_CSV    6
#define VTZ_HTML   7
#define VTZ_ALERT  8

//--- text kinds
#define VTK_SANS   0
#define VTK_MONO   1
#define VTK_SMALL  2
#define VTK_BIG    3
#define VTK_SEC    4
#define VTK_BRAND  5
#define VTK_MONOS  6      // small mono

class CVtCard
  {
public:
   CCanvas   cv;
   string    name;
   long      chart;
   bool      ok;
   int       px,py;                  // position on the chart (pixels)
   int       pw,ph;                  // size (pixels)
   double    scale;
   bool      light;
   bool      folded;
   int       tab;
   VtPalette pal;
   VtZone    zones[VT_ZMAX];
   int       nz;
   //--- font cache
   string    m_face;
   int       m_size,m_flags;
   //--- interaction
   bool      m_down,m_drag,m_hit_card;
   int       m_press_x,m_press_y,m_off_x,m_off_y;
   bool      m_scroll_saved;
   bool      m_scroll_orig;
   bool      m_mouse_orig;
   //--- fonts (changeable for tests)
   string    face_sans,face_mono;

            CVtCard(): ok(false),px(12),py(22),pw(0),ph(0),scale(1.0),light(false),folded(false),tab(0),nz(0),
                       m_down(false),m_drag(false),m_hit_card(false),m_scroll_saved(false)
     { face_sans="Segoe UI"; face_mono="Consolas"; m_face=""; m_size=0; m_flags=0; }

   //--- scale: DPI/96 x the UI-scale input
   static double ScaleFor(const double ui)
     {
      double dpi=(double)TerminalInfoInteger(TERMINAL_SCREEN_DPI);
      if(dpi<=0)
         dpi=96;
      return(MathMax(0.5,MathMin(4.0,dpi/96.0*ui)));
     }
   int      S(const double v) const { return((int)MathRound(v*scale)); }

   void     SetTheme(const ENUM_VT_THEME t)
     {
      bool l=false;
      if(t==VT_THEME_LIGHT)
         l=true;
      else
         if(t==VT_THEME_AUTO)
           {
            color bg=(color)ChartGetInteger(chart,CHART_COLOR_BACKGROUND);
            double lum=0.2126*(bg&0xFF)+0.7152*((bg>>8)&0xFF)+0.0722*((bg>>16)&0xFF);
            l=(lum>127.5);
           }
      light=l;
      if(!light)
        {
         pal.bg=C'21,26,30'; pal.bg_a=255; pal.edge=C'42,51,56'; pal.head=C'26,32,36'; pal.ink=C'215,222,226';
         pal.label=C'139,151,158'; pal.dim=C'91,102,108'; pal.pos=C'98,184,140'; pal.neg=C'224,123,112';
         pal.warn=C'217,166,72'; pal.acc=C'115,169,214'; pal.track=C'37,45,50'; pal.rule=C'35,43,47';
        }
      else
        {
         pal.bg=C'250,251,250'; pal.bg_a=255; pal.edge=C'214,219,221'; pal.head=C'239,242,241'; pal.ink=C'30,37,40';
         pal.label=C'95,107,113'; pal.dim=C'154,164,169'; pal.pos=C'46,134,87'; pal.neg=C'193,73,62';
         pal.warn=C'168,118,26'; pal.acc=C'47,111,166'; pal.track=C'228,232,232'; pal.rule=C'227,231,231';
        }
     }

   bool     Create(const string objname,const int w_logical,const double h_logical)
     {
      chart=ChartID();
      name=objname;
      pw=S(w_logical); ph=S(h_logical);
      ObjectDelete(chart,name);
      ok=cv.CreateBitmapLabel(chart,0,name,px,py,pw,ph,COLOR_FORMAT_ARGB_NORMALIZE);
      if(ok)
        {
         ObjectSetInteger(chart,name,OBJPROP_SELECTABLE,false);
         ObjectSetInteger(chart,name,OBJPROP_HIDDEN,true);
         ObjectSetInteger(chart,name,OBJPROP_BACK,false);
         ObjectSetInteger(chart,name,OBJPROP_ZORDER,100);
         ObjectSetInteger(chart,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
         ObjectSetInteger(chart,name,OBJPROP_ANCHOR,ANCHOR_LEFT_UPPER);
        }
      return(ok);
     }
   void     Destroy()
     {
      if(ok)
         cv.Destroy();
      ok=false;
      ObjectDelete(chart,name);
     }
   //--- change the bitmap size (logical height); the content is redrawn by the caller
   bool     Resize(const double h_logical)
     {
      int nh=S(h_logical);
      if(!ok || nh==ph)
         return(true);
      ph=nh;
      return(cv.Resize(pw,ph));
     }
   void     MoveTo(const int x,const int y)
     {
      px=x; py=y;
      if(ok)
        {
         ObjectSetInteger(chart,name,OBJPROP_XDISTANCE,px);
         ObjectSetInteger(chart,name,OBJPROP_YDISTANCE,py);
        }
     }
   void     Clamp()
     {
      int cw=(int)ChartGetInteger(chart,CHART_WIDTH_IN_PIXELS);
      int ch=(int)ChartGetInteger(chart,CHART_HEIGHT_IN_PIXELS);
      int nx=MathMax(0,MathMin(px,cw-pw));
      int ny=MathMax(0,MathMin(py,ch-MathMin(ph,S(34))));     // always keep the header reachable
      if(cw<=pw)
         nx=0;
      if(nx!=px || ny!=py)
         MoveTo(nx,ny);
     }

   //--- state kept per chart
   string   Key(const string k) const { return("VITALS_"+IntegerToString(chart)+"_"+k); }
   void     Load(const int defx,const int defy)
     {
      px=S(defx); py=S(defy);
      if(GlobalVariableCheck(Key("x")))
        { px=(int)GlobalVariableGet(Key("x")); py=(int)GlobalVariableGet(Key("y")); }
      folded=(GlobalVariableCheck(Key("fold")) && GlobalVariableGet(Key("fold"))>0.5);
      tab=(GlobalVariableCheck(Key("tab")) ? (int)GlobalVariableGet(Key("tab")) : 0);
     }
   void     Save()
     {
      GlobalVariableSet(Key("x"),px);
      GlobalVariableSet(Key("y"),py);
      GlobalVariableSet(Key("fold"),folded ? 1 : 0);
      GlobalVariableSet(Key("tab"),tab);
     }

   //--- drawing -------------------------------------------------------------------------------------------------------
   //--- the card is fully opaque: a translucent colour is pre-blended with the card background instead of letting the
   //    canvas lower the pixel alpha (candles showed through bars drawn with alpha < 255)
   uint     A(const color c,const int alpha=255) const
     {
      if(alpha>=255)
         return(ColorToARGB(c,255));
      int r=(c&0xFF),g=((c>>8)&0xFF),b=((c>>16)&0xFF);
      int br=(pal.bg&0xFF),bgg=((pal.bg>>8)&0xFF),bb=((pal.bg>>16)&0xFF);
      color m=(color)(((r*alpha+br*(255-alpha))/255) | (((g*alpha+bgg*(255-alpha))/255)<<8) | (((b*alpha+bb*(255-alpha))/255)<<16));
      return(ColorToARGB(m,255));
     }
   void     Font(const int kind)
     {
      string f=face_sans;
      int sz=16,fl=FW_NORMAL;
      switch(kind)
        {
         case VTK_MONO:  f=face_mono; sz=14; break;
         case VTK_SMALL: sz=14; break;
         case VTK_BIG:   f=face_mono; sz=23; fl=FW_NORMAL; break;
         case VTK_SEC:   sz=12; fl=FW_SEMIBOLD; break;
         case VTK_BRAND: sz=15; fl=FW_SEMIBOLD; break;
         case VTK_MONOS: f=face_mono; sz=13; break;
         default:        sz=16; break;
        }
      int px_size=S(sz);
      if(f!=m_face || px_size!=m_size || fl!=m_flags)
        {
         cv.FontSet(f,px_size,fl);
         m_face=f; m_size=px_size; m_flags=fl;
        }
     }
   //--- text at logical x,y; align: 0 left, 1 right (x = right edge), 2 centre
   void     Txt(const double x,const double y,const string s,const color clr,const int kind=VTK_SANS,const int align=0,
                const int alpha=255)
     {
      if(s=="")
         return;
      Font(kind);
      uint fl=(align==1 ? TA_RIGHT : (align==2 ? TA_CENTER : TA_LEFT))|TA_TOP;
      cv.TextOut(S(x),S(y),s,A(clr,alpha),fl);
     }
   int      TextW(const string s,const int kind)
     {
      Font(kind);
      int w,h;
      cv.TextSize(s,w,h);
      return((int)MathRound(w/scale));
     }
   void     Fill(const double x1,const double y1,const double x2,const double y2,const color clr,const int alpha=255)
     {
      cv.FillRectangle(S(x1),S(y1),MathMax(S(x1),S(x2)-1),MathMax(S(y1),S(y2)-1),A(clr,alpha));
     }
   void     Box(const double x1,const double y1,const double x2,const double y2,const color clr,const int alpha=255)
     {
      cv.Rectangle(S(x1),S(y1),MathMax(S(x1),S(x2)-1),MathMax(S(y1),S(y2)-1),A(clr,alpha));
     }
   void     HLine(const double x1,const double x2,const double y,const color clr,const int alpha=255)
     {
      int yy=S(y);
      cv.FillRectangle(S(x1),yy,MathMax(S(x1),S(x2)-1),yy,A(clr,alpha));
     }
   void     VLine(const double x,const double y1,const double y2,const color clr,const int alpha=255)
     {
      int xx=S(x);
      cv.FillRectangle(xx,S(y1),xx,MathMax(S(y1),S(y2)-1),A(clr,alpha));
     }

   //--- hit zones
   void     ZoneReset() { nz=0; }
   void     Zone(const double x1,const double y1,const double x2,const double y2,const int id,const int arg=0)
     {
      if(nz>=VT_ZMAX)
         return;
      zones[nz].x1=S(x1); zones[nz].y1=S(y1); zones[nz].x2=S(x2); zones[nz].y2=S(y2);
      zones[nz].id=id; zones[nz].arg=arg;
      nz++;
     }
   bool     ZoneAt(const int x,const int y,int &id,int &arg) const     // x,y relative to the card
     {
      for(int i=nz-1; i>=0; i--)
         if(x>=zones[i].x1 && x<zones[i].x2 && y>=zones[i].y1 && y<zones[i].y2)
           { id=zones[i].id; arg=zones[i].arg; return(true); }
      return(false);
     }
   bool     Inside(const int x,const int y) const { return(ok && x>=px && x<px+pw && y>=py && y<py+ph); }

   //--- the frame: background, border, header; returns the y (logical) where the tabs start
   void     Frame(const double h_logical)
     {
      cv.Erase(0);
      Fill(0,0,VT_CARD_W,h_logical,pal.bg,pal.bg_a);
      Fill(0,0,VT_CARD_W,28,pal.head);
      HLine(0,VT_CARD_W,28,pal.edge);
      Box(0,0,VT_CARD_W,h_logical,pal.edge);
     }
   void     Update() { if(ok) cv.Update(true); }
  };

#endif
//+------------------------------------------------------------------+