Tick_Forge/market/Tick_Forge.mq5

//+------------------------------------------------------------------+
//| Tick_Forge.mq5                                                    |
//| Copyright (c) 2026 Joshua Dunnink. MIT License (see LICENSE).     |
//|                                                                   |
//| Build custom backtesting symbols from your broker's own history:  |
//|   - shift the raw timestamps by hours or days                     |
//|   - rescale / reshape prices with a typed function                |
//|   - write real (transformed) ticks or M1 bars                     |
//| The result is an ordinary custom symbol the Strategy Tester can   |
//| use (Every tick / Every tick based on real ticks / 1 minute OHLC).|
//|                                                                   |
//| A utility: attach it to any chart to open its window. It never    |
//| trades. The source is open and it uses no DLL. It writes only the |
//| custom symbol (its bars and ticks) - nothing else.                |
//+------------------------------------------------------------------+
#property copyright "Copyright (c) 2026 Joshua Dunnink - MIT License"
#property link      "https://forge.mql5.io/joshuadunnink/Tick_Forge"
#property version   "1.04"
#property description "Tick Forge builds custom symbols for the Strategy Tester from your broker's own history."
#property description "Shift the timestamps, rescale or reshape the prices with a typed function, test your EA on the result."
#property description "Utility: it never trades. Free and open source (MIT). No DLL, no internet access."
#property strict

// ---- inlined from TF_Gui.mqh ----
//+------------------------------------------------------------------+
//| TF_Gui.mqh - Tick Forge window (CAppDialog) and overview plot     |
//| Copyright (c) 2026 Joshua Dunnink. MIT License (see LICENSE).     |
//| Shared by the indicator (Tick_Forge.mq5) and the developer Expert.|
//| No Sleep() and no MessageBox() (not allowed in indicators): long  |
//| work runs one day / one month per Tick() call from a host timer.  |
//+------------------------------------------------------------------+
#include <Controls\Dialog.mqh>
#include <Controls\Button.mqh>
#include <Controls\Edit.mqh>
#include <Controls\Label.mqh>
#include <Controls\ComboBox.mqh>
#include <Controls\CheckBox.mqh>
#include <Canvas\Canvas.mqh>
// ---- inlined from TF_Engine.mqh ----
//+------------------------------------------------------------------+
//| TF_Engine.mqh - Tick Forge data generator                         |
//| Copyright (c) 2026 Joshua Dunnink. MIT License (see LICENSE).     |
//|                                                                   |
//| Reads the broker's own history for a source symbol, shifts the    |
//| raw timestamps, maps every price through a user function, and     |
//| writes the result into a custom symbol.                           |
//+------------------------------------------------------------------+
// ---- inlined from TF_Expr.mqh ----
//+------------------------------------------------------------------+
//| TF_Expr.mqh - Tick Forge price-function parser                    |
//| Copyright (c) 2026 Joshua Dunnink. MIT License (see LICENSE).     |
//|                                                                   |
//| A small, safe expression compiler: text -> reverse-polish program |
//| -> fast evaluation. No eval, no file access, no side effects.     |
//|                                                                   |
//| Variables  p (x)  original price     p0  first price in range     |
//|            r      p / p0             t   progress in range, 0..1  |
//|            d      days since range start                          |
//| Operators  + - * / ^  and unary minus, parentheses                |
//| Functions  abs sqrt ln log10 exp sin cos pow(a,b) min(a,b) max(a,b)|
//| Constants  pi e                                                   |
//+------------------------------------------------------------------+

enum ENUM_TF_OP
  {
   TFOP_NUM = 0, TFOP_P, TFOP_P0, TFOP_R, TFOP_T, TFOP_D,
   TFOP_ADD, TFOP_SUB, TFOP_MUL, TFOP_DIV, TFOP_POW, TFOP_NEG,
   TFOP_ABS, TFOP_SQRT, TFOP_LN, TFOP_LOG10, TFOP_EXP, TFOP_SIN, TFOP_COS,
   TFOP_MIN, TFOP_MAX
  };

class CTFExpr
  {
private:
   string            m_src;
   int               m_pos;
   string            m_err;
   int               m_op[];
   double            m_val[];
   int               m_n;
   int               m_depth, m_maxdepth;

   void              Emit(const int op, const double v = 0.0);
   void              SkipWs();
   bool              Fail(const string e) { if(m_err == "") m_err = e + " at position " + IntegerToString(m_pos + 1); return false; }
   bool              ParseExpr();
   bool              ParseTerm();
   bool              ParseUnary();
   bool              ParsePower();
   bool              ParsePrimary();
   bool              Peek(const ushort c);
   int               FuncOp(const string name, int &argc);

public:
                     CTFExpr() : m_n(0) {}
   bool              Compile(const string text);
   string            Error() const { return m_err; }
   double            Eval(const double p, const double p0, const double t, const double d) const;
  };

void CTFExpr::Emit(const int op, const double v)
  {
   if(ArraySize(m_op) <= m_n) { ArrayResize(m_op, m_n + 32); ArrayResize(m_val, m_n + 32); }
   m_op[m_n] = op; m_val[m_n] = v; m_n++;
   // stack bookkeeping: pushes +1, binary ops -1, unary/func1 0
   switch(op)
     {
      case TFOP_NUM: case TFOP_P: case TFOP_P0: case TFOP_R: case TFOP_T: case TFOP_D:
         m_depth++; if(m_depth > m_maxdepth) m_maxdepth = m_depth; break;
      case TFOP_ADD: case TFOP_SUB: case TFOP_MUL: case TFOP_DIV: case TFOP_POW: case TFOP_MIN: case TFOP_MAX:
         m_depth--; break;
      default: break;
     }
  }

void CTFExpr::SkipWs() { while(m_pos < StringLen(m_src) && (m_src[m_pos] == ' ' || m_src[m_pos] == '\t')) m_pos++; }

bool CTFExpr::Peek(const ushort c) { SkipWs(); return (m_pos < StringLen(m_src) && m_src[m_pos] == c); }

bool CTFExpr::Compile(const string text)
  {
   m_src = text; m_pos = 0; m_err = ""; m_n = 0; m_depth = 0; m_maxdepth = 0;
   ArrayResize(m_op, 32); ArrayResize(m_val, 32);
   if(StringLen(text) == 0) { m_err = "empty expression"; return false; }
   if(!ParseExpr()) return false;
   SkipWs();
   if(m_pos < StringLen(m_src)) return Fail("unexpected '" + StringSubstr(m_src, m_pos, 1) + "'");
   if(m_maxdepth > 60) { m_err = "expression too deep"; return false; }
   return true;
  }

bool CTFExpr::ParseExpr()
  {
   if(!ParseTerm()) return false;
   while(true)
     {
      SkipWs();
      if(m_pos >= StringLen(m_src)) return true;
      ushort c = m_src[m_pos];
      if(c != '+' && c != '-') return true;
      m_pos++;
      if(!ParseTerm()) return false;
      Emit(c == '+' ? TFOP_ADD : TFOP_SUB);
     }
   return true;
  }

bool CTFExpr::ParseTerm()
  {
   if(!ParseUnary()) return false;
   while(true)
     {
      SkipWs();
      if(m_pos >= StringLen(m_src)) return true;
      ushort c = m_src[m_pos];
      if(c != '*' && c != '/') return true;
      m_pos++;
      if(!ParseUnary()) return false;
      Emit(c == '*' ? TFOP_MUL : TFOP_DIV);
     }
   return true;
  }

bool CTFExpr::ParseUnary()
  {
   SkipWs();
   if(m_pos < StringLen(m_src) && (m_src[m_pos] == '-' || m_src[m_pos] == '+'))
     {
      bool neg = (m_src[m_pos] == '-');
      m_pos++;
      if(!ParseUnary()) return false;
      if(neg) Emit(TFOP_NEG);
      return true;
     }
   return ParsePower();
  }

bool CTFExpr::ParsePower()
  {
   if(!ParsePrimary()) return false;
   SkipWs();
   if(m_pos < StringLen(m_src) && m_src[m_pos] == '^')
     {
      m_pos++;
      if(!ParseUnary()) return false;     // right associative, allows 2^-1
      Emit(TFOP_POW);
     }
   return true;
  }

int CTFExpr::FuncOp(const string name, int &argc)
  {
   argc = 1;
   if(name == "abs")   return TFOP_ABS;
   if(name == "sqrt")  return TFOP_SQRT;
   if(name == "ln")    return TFOP_LN;
   if(name == "log10") return TFOP_LOG10;
   if(name == "exp")   return TFOP_EXP;
   if(name == "sin")   return TFOP_SIN;
   if(name == "cos")   return TFOP_COS;
   argc = 2;
   if(name == "pow")   return TFOP_POW;
   if(name == "min")   return TFOP_MIN;
   if(name == "max")   return TFOP_MAX;
   return -1;
  }

bool CTFExpr::ParsePrimary()
  {
   SkipWs();
   if(m_pos >= StringLen(m_src)) return Fail("unexpected end");
   ushort c = m_src[m_pos];
   if(c == '(')
     {
      m_pos++;
      if(!ParseExpr()) return false;
      if(!Peek(')')) return Fail("missing ')'");
      m_pos++;
      return true;
     }
   if((c >= '0' && c <= '9') || c == '.')
     {
      int s = m_pos;
      while(m_pos < StringLen(m_src) && ((m_src[m_pos] >= '0' && m_src[m_pos] <= '9') || m_src[m_pos] == '.')) m_pos++;
      // optional exponent 1e-3
      if(m_pos < StringLen(m_src) && (m_src[m_pos] == 'e' || m_src[m_pos] == 'E'))
        {
         int save = m_pos; m_pos++;
         if(m_pos < StringLen(m_src) && (m_src[m_pos] == '+' || m_src[m_pos] == '-')) m_pos++;
         int ds = m_pos;
         while(m_pos < StringLen(m_src) && m_src[m_pos] >= '0' && m_src[m_pos] <= '9') m_pos++;
         if(m_pos == ds) m_pos = save;
        }
      Emit(TFOP_NUM, StringToDouble(StringSubstr(m_src, s, m_pos - s)));
      return true;
     }
   if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
     {
      int s = m_pos;
      while(m_pos < StringLen(m_src) && ((m_src[m_pos] >= 'a' && m_src[m_pos] <= 'z') || (m_src[m_pos] >= 'A' && m_src[m_pos] <= 'Z') ||
            (m_src[m_pos] >= '0' && m_src[m_pos] <= '9') || m_src[m_pos] == '_')) m_pos++;
      string id = StringSubstr(m_src, s, m_pos - s);
      StringToLower(id);
      if(Peek('('))
        {
         int argc;
         int op = FuncOp(id, argc);
         if(op < 0) return Fail("unknown function '" + id + "'");
         m_pos++;                                   // (
         if(!ParseExpr()) return false;
         if(argc == 2)
           {
            if(!Peek(',')) return Fail("function '" + id + "' needs 2 arguments");
            m_pos++;
            if(!ParseExpr()) return false;
           }
         if(!Peek(')')) return Fail("missing ')'");
         m_pos++;
         Emit(op);
         return true;
        }
      if(id == "p" || id == "x") { Emit(TFOP_P);  return true; }
      if(id == "p0")             { Emit(TFOP_P0); return true; }
      if(id == "r")              { Emit(TFOP_R);  return true; }
      if(id == "t")              { Emit(TFOP_T);  return true; }
      if(id == "d")              { Emit(TFOP_D);  return true; }
      if(id == "pi")             { Emit(TFOP_NUM, M_PI); return true; }
      if(id == "e")              { Emit(TFOP_NUM, M_E);  return true; }
      m_pos = s;
      return Fail("unknown name '" + id + "'");
     }
   return Fail("unexpected '" + StringSubstr(m_src, m_pos, 1) + "'");
  }

double CTFExpr::Eval(const double p, const double p0, const double t, const double d) const
  {
   double st[64];
   int sp = 0;
   for(int i = 0; i < m_n; i++)
     {
      switch(m_op[i])
        {
         case TFOP_NUM: st[sp++] = m_val[i]; break;
         case TFOP_P:   st[sp++] = p; break;
         case TFOP_P0:  st[sp++] = p0; break;
         case TFOP_R:   st[sp++] = (p0 != 0.0 ? p / p0 : 0.0); break;
         case TFOP_T:   st[sp++] = t; break;
         case TFOP_D:   st[sp++] = d; break;
         case TFOP_ADD: sp--; st[sp - 1] += st[sp]; break;
         case TFOP_SUB: sp--; st[sp - 1] -= st[sp]; break;
         case TFOP_MUL: sp--; st[sp - 1] *= st[sp]; break;
         case TFOP_DIV: sp--; st[sp - 1] = (st[sp] != 0.0 ? st[sp - 1] / st[sp] : MathArcsin(2.0)); break;   // NaN
         case TFOP_POW: sp--; st[sp - 1] = MathPow(st[sp - 1], st[sp]); break;
         case TFOP_NEG: st[sp - 1] = -st[sp - 1]; break;
         case TFOP_ABS: st[sp - 1] = MathAbs(st[sp - 1]); break;
         case TFOP_SQRT:  st[sp - 1] = MathSqrt(st[sp - 1]); break;
         case TFOP_LN:    st[sp - 1] = MathLog(st[sp - 1]); break;
         case TFOP_LOG10: st[sp - 1] = MathLog10(st[sp - 1]); break;
         case TFOP_EXP:   st[sp - 1] = MathExp(st[sp - 1]); break;
         case TFOP_SIN:   st[sp - 1] = MathSin(st[sp - 1]); break;
         case TFOP_COS:   st[sp - 1] = MathCos(st[sp - 1]); break;
         case TFOP_MIN:   sp--; st[sp - 1] = MathMin(st[sp - 1], st[sp]); break;
         case TFOP_MAX:   sp--; st[sp - 1] = MathMax(st[sp - 1], st[sp]); break;
        }
     }
   return (sp == 1 ? st[0] : MathArcsin(2.0));
  }
//+------------------------------------------------------------------+

// ---- end TF_Expr.mqh ----

void TF_Status(const string s);          // implemented by the host program (logs + updates the GUI)

enum ENUM_TF_MODE
  {
   TF_MODE_TICKS = 0,    // Real ticks (transformed) + M1 bars rebuilt from them
   TF_MODE_BARS  = 1     // M1 bars only (tester synthesizes the ticks)
  };

struct CTFJob
  {
   string            src;            // source symbol (broker data)
   string            name;           // custom symbol to write
   datetime          from;           // first day (00:00)
   datetime          to;             // last day (inclusive)
   int               mode;           // ENUM_TF_MODE
   long              offset_sec;     // raw timestamp shift, seconds (may be negative)
   string            expr;           // price function
   bool              scale_spread;   // spread follows the price factor
   bool              auto_digits;    // add digits when the price level shrinks
  };

struct CTFResult
  {
   bool              ok;
   string            err;
   long              ticks;
   long              bars;
   int               digits;
   double            p0;
  };

//--- helpers -------------------------------------------------------
// Sleep() is not allowed in indicators; a short busy wait is enough to let a history download answer.
void TF_Wait(const uint ms)
  {
   const uint t = GetTickCount();
   while(GetTickCount() - t < ms) { }
  }
bool TF_IsFinite(const double v) { return MathIsValidNumber(v); }

bool TF_SymbolExists(const string name, bool &custom)
  {
   custom = false;
   for(int i = 0; i < SymbolsTotal(false); i++)
      if(SymbolName(i, false) == name)
        {
         custom = (bool)SymbolInfoInteger(name, SYMBOL_CUSTOM);
         return true;
        }
   return false;
  }

string TF_DataPath(const string name)
  {
   return TerminalInfoString(TERMINAL_DATA_PATH) + "\\bases\\Custom\\history\\" + name;
  }
string TF_TickPath(const string name)
  {
   return TerminalInfoString(TERMINAL_DATA_PATH) + "\\bases\\Custom\\ticks\\" + name;
  }

//--- the engine ----------------------------------------------------
class CTFEngine
  {
private:
   CTFJob            m_job;
   CTFExpr           m_ex;
   double            m_p0;
   double            m_span;         // seconds in the range
   datetime          m_from;
   int               m_digits_src, m_digits_dst;
   double            m_point_dst;
   long              m_bad;
   int               m_i, m_days;    // stepwise run: next day index, number of days
   uint              m_ready_at;     // GetTickCount() before which no write is attempted

   double            Map(const double price, const datetime t);
   double            PointDst() const { return m_point_dst; }
   bool              Prepare(CTFResult &res);
   bool              WriteTicksDay(const datetime day, CTFResult &res);
   bool              WriteBarsChunk(const datetime a, const datetime b, CTFResult &res);
   void              FlushMinute(MqlRates &cur, MqlRates &out[], int &n);
   bool              SetupSymbol(CTFResult &res);

public:
                     CTFEngine() : m_bad(0), m_i(0), m_days(0), m_ready_at(0), m_p0(0), m_span(0), m_from(0), m_digits_src(0), m_digits_dst(0), m_point_dst(0) {}
   bool              Preview(const CTFJob &job, double &first, double &last, double &mid, string &err);
   bool              Series(const CTFJob &job, datetime &tm[], double &orig[], double &neu[], string &tfname, string &err);
   bool              Begin(const CTFJob &job, CTFResult &res);   // validate, create the symbol; then call Step() until Done()
   bool              Step(CTFResult &res);                        // write one day (returns false on error)
   bool              Done() const { return m_i >= m_days; }
   int               DayIndex() const { return m_i; }
   int               Days() const { return m_days; }
   bool              Run(const CTFJob &job, CTFResult &res);      // all steps at once (for tools; blocks)
  };

double CTFEngine::Map(const double price, const datetime t)
  {
   double tt = (m_span > 0.0 ? (double)(t - m_from) / m_span : 0.0);
   if(tt < 0.0) tt = 0.0;
   if(tt > 1.0) tt = 1.0;
   double v = m_ex.Eval(price, m_p0, tt, (double)(t - m_from) / 86400.0);
   if(!TF_IsFinite(v) || v <= 0.0) { m_bad++; return 0.0; }
   return v;
  }

//--- first M1 open on/after the range start ---------------------------
bool TF_FirstOpen(const string sym, const datetime from, const datetime to, double &p0, datetime &t0)
  {
   MqlRates r[];
   for(int attempt = 0; attempt < 4; attempt++)
     {
      int n = CopyRates(sym, PERIOD_M1, from, MathMin(from + 7 * 86400, to + 86400), r);
      if(n > 0) { p0 = r[0].open; t0 = r[0].time; return true; }
      TF_Wait(250);
     }
   return false;
  }

bool CTFEngine::Preview(const CTFJob &job, double &first, double &last, double &mid, string &err)
  {
   m_job = job; m_bad = 0; err = "";
   if(!m_ex.Compile(job.expr)) { err = m_ex.Error(); return false; }
   datetime t0;
   if(!TF_FirstOpen(job.src, job.from, job.to, m_p0, t0)) { err = "no M1 bars for " + job.src + " in range"; return false; }
   m_from = job.from; m_span = (double)(job.to + 86400 - job.from);
   MqlRates r[];
   int n = CopyRates(job.src, PERIOD_M1, job.to, 1, r);       // 1 bar at/ before range end
   double pl = (n > 0 ? r[0].close : m_p0);
   first = Map(m_p0, job.from);
   mid   = Map((m_p0 + pl) / 2.0, job.from + (datetime)(m_span / 2));
   last  = Map(pl, job.to + 86400);
   if(m_bad > 0) { err = "function gives zero/negative/invalid prices"; return false; }
   return true;
  }

//--- overview series: whole range, source vs result, timeframe chosen from the span ---
bool CTFEngine::Series(const CTFJob &job, datetime &tm[], double &orig[], double &neu[], string &tfname, string &err)
  {
   m_job = job; m_bad = 0; err = "";
   if(!m_ex.Compile(job.expr)) { err = m_ex.Error(); return false; }
   datetime t0;
   if(!TF_FirstOpen(job.src, job.from, job.to, m_p0, t0)) { err = "no M1 bars for " + job.src + " in range"; return false; }
   m_from = job.from; m_span = (double)(job.to + 86400 - job.from);
   double days = m_span / 86400.0;
   ENUM_TIMEFRAMES tf = (days <= 3 ? PERIOD_M5 : days <= 14 ? PERIOD_M30 : days <= 120 ? PERIOD_H1 : days <= 700 ? PERIOD_H4 : PERIOD_D1);
   tfname = StringSubstr(EnumToString(tf), 7);
   MqlRates r[];
   int n = -1;
   for(int a = 0; a < 3 && n <= 0; a++)
     {
      n = CopyRates(job.src, tf, job.from, job.to + 86400 - 1, r);
      if(n <= 0) TF_Wait(250);
     }
   if(n <= 1) { err = "no " + tfname + " bars in that range"; return false; }
   int stride = (n > 600 ? (n + 599) / 600 : 1), m = 0;
   ArrayResize(tm, n / stride + 1); ArrayResize(orig, n / stride + 1); ArrayResize(neu, n / stride + 1);
   for(int i = 0; i < n; i += stride)
     {
      double v = Map(r[i].close, r[i].time);
      if(v <= 0.0) { err = "function gives zero/negative/invalid prices"; return false; }
      tm[m] = r[i].time; orig[m] = r[i].close; neu[m] = v; m++;
     }
   ArrayResize(tm, m); ArrayResize(orig, m); ArrayResize(neu, m);
   return true;
  }

//--- digits / contract properties --------------------------------------
bool CTFEngine::SetupSymbol(CTFResult &res)
  {
   bool custom;
   bool exists = TF_SymbolExists(m_job.name, custom);
   if(exists && !custom) { res.err = "'" + m_job.name + "' is a real broker symbol - choose another name"; return false; }
   if(exists)
     {
      CustomRatesDelete(m_job.name, 0, LONG_MAX);
      CustomTicksDelete(m_job.name, 0, LONG_MAX);
     }
   else if(!CustomSymbolCreate(m_job.name, "Tick Forge", m_job.src))
     { res.err = StringFormat("CustomSymbolCreate failed (err %d)", GetLastError()); return false; }
   SymbolSelect(m_job.name, true);

   // trading permissions follow the source, so an Expert's orders are accepted exactly as on the real symbol
   const ENUM_SYMBOL_INFO_INTEGER props[] = {SYMBOL_FILLING_MODE, SYMBOL_ORDER_MODE, SYMBOL_EXPIRATION_MODE, SYMBOL_TRADE_EXEMODE, SYMBOL_TRADE_MODE};
   for(int k = 0; k < ArraySize(props); k++)
      CustomSymbolSetInteger(m_job.name, props[k], SymbolInfoInteger(m_job.src, props[k]));

   // sample the price factor across the range to size the digits
   m_digits_src = (int)SymbolInfoInteger(m_job.src, SYMBOL_DIGITS);
   double psrc = SymbolInfoDouble(m_job.src, SYMBOL_POINT);
   double sumlog = 0.0; int cnt = 0;
   MqlRates r[];
   for(int k = 0; k <= 12; k++)
     {
      datetime tk = m_job.from + (datetime)((m_job.to + 86400 - m_job.from) * k / 12);
      if(tk >= m_job.to + 86400) tk = m_job.to;
      if(CopyRates(m_job.src, PERIOD_M1, tk, 1, r) > 0 && r[0].close > 0.0)
        {
         double f = Map(r[0].close, tk);
         if(f > 0.0) { sumlog += MathLog10(f / r[0].close); cnt++; }
        }
     }
   if(m_bad > 0) { res.err = "function gives zero/negative/invalid prices on sampled data"; return false; }
   double lg = (cnt > 0 ? sumlog / cnt : 0.0);
   m_digits_dst = m_digits_src;
   if(m_job.auto_digits && lg < 0.0) m_digits_dst = (int)MathMin(8, m_digits_src + (int)MathRound(-lg));
   m_point_dst = MathPow(10.0, -m_digits_dst);
   res.digits = m_digits_dst;

   if(m_digits_dst != m_digits_src)
     {
      CustomSymbolSetInteger(m_job.name, SYMBOL_DIGITS, m_digits_dst);
      CustomSymbolSetDouble(m_job.name, SYMBOL_POINT, m_point_dst);
      double ts = SymbolInfoDouble(m_job.src, SYMBOL_TRADE_TICK_SIZE);
      double tv = SymbolInfoDouble(m_job.src, SYMBOL_TRADE_TICK_VALUE);
      double tvp = SymbolInfoDouble(m_job.src, SYMBOL_TRADE_TICK_VALUE_PROFIT);
      double tvl = SymbolInfoDouble(m_job.src, SYMBOL_TRADE_TICK_VALUE_LOSS);
      double nts = m_point_dst, ratio = (ts > 0.0 ? nts / ts : 1.0);
      CustomSymbolSetDouble(m_job.name, SYMBOL_TRADE_TICK_SIZE, nts);
      CustomSymbolSetDouble(m_job.name, SYMBOL_TRADE_TICK_VALUE, tv * ratio);
      CustomSymbolSetDouble(m_job.name, SYMBOL_TRADE_TICK_VALUE_PROFIT, tvp * ratio);
      CustomSymbolSetDouble(m_job.name, SYMBOL_TRADE_TICK_VALUE_LOSS, tvl * ratio);
     }
   m_ready_at = GetTickCount() + 1500;            // a fresh custom symbol rejects its first write (err 4301): Step() waits
   return true;
  }

//--- one UTC-day of ticks -----------------------------------------------
void CTFEngine::FlushMinute(MqlRates &cur, MqlRates &out[], int &n)
  {
   if(cur.time == 0) return;
   if(ArraySize(out) <= n) ArrayResize(out, n + 1024);
   out[n++] = cur;
  }

bool CTFEngine::WriteTicksDay(const datetime day, CTFResult &res)
  {
   MqlTick src[];
   ulong a = (ulong)day * 1000, b = ((ulong)day + 86400) * 1000 - 1;
   int got = -1;
   for(int attempt = 0; attempt < 3 && got < 0; attempt++)
     {
      ResetLastError();
      got = CopyTicksRange(m_job.src, src, COPY_TICKS_ALL, a, b);
      if(got < 0) TF_Wait(200);
     }
   if(got <= 0) return true;                      // weekend / no data: nothing to write

   MqlTick dst[]; ArrayResize(dst, got);
   MqlRates bars[]; ArrayResize(bars, 1500);
   int nb = 0;
   MqlRates cur; ZeroMemory(cur);
   long off_msc = m_job.offset_sec * 1000;
   double pt = m_point_dst;
   int w = 0;
   for(int i = 0; i < got; i++)
     {
      double bid = src[i].bid, ask = src[i].ask;
      if(bid <= 0.0) continue;
      datetime ot = (datetime)(src[i].time_msc / 1000);
      double nb_ = Map(bid, ot);
      if(nb_ <= 0.0) { res.err = "function produced an invalid price"; return false; }
      double k = nb_ / bid;
      double na = 0.0;
      if(ask > 0.0)
        {
         double sp = ask - bid;
         na = nb_ + (m_job.scale_spread ? sp * k : sp);
        }
      nb_ = NormalizeDouble(nb_, m_digits_dst);
      na  = (na > 0.0 ? NormalizeDouble(na, m_digits_dst) : 0.0);
      dst[w].time_msc = src[i].time_msc + off_msc;
      dst[w].time = (datetime)(dst[w].time_msc / 1000);
      dst[w].bid = nb_; dst[w].ask = na; dst[w].last = 0.0; dst[w].volume = 0; dst[w].volume_real = 0.0;
      dst[w].flags = src[i].flags & (TICK_FLAG_BID | TICK_FLAG_ASK);
      if(dst[w].flags == 0) dst[w].flags = TICK_FLAG_BID | TICK_FLAG_ASK;

      // M1 aggregation on the shifted clock
      datetime mt = (datetime)((dst[w].time / 60) * 60);
      int spr = (na > 0.0 ? (int)MathRound((na - nb_) / pt) : 0);
      if(cur.time != mt)
        {
         FlushMinute(cur, bars, nb);
         cur.time = mt; cur.open = cur.high = cur.low = cur.close = nb_;
         cur.tick_volume = 1; cur.spread = spr; cur.real_volume = 0;
        }
      else
        {
         if(nb_ > cur.high) cur.high = nb_;
         if(nb_ < cur.low)  cur.low = nb_;
         cur.close = nb_; cur.tick_volume++; cur.spread = spr;
        }
      w++;
     }
   FlushMinute(cur, bars, nb);
   if(w == 0) return true;
   ArrayResize(dst, w);
   ArrayResize(bars, nb);

   ResetLastError();
   int dt = CustomTicksReplace(m_job.name, dst[0].time_msc, dst[w - 1].time_msc, dst);
   if(dt < 0) { res.err = StringFormat("CustomTicksReplace failed (err %d)", GetLastError()); return false; }
   res.ticks += dt;
   if(nb > 0)
     {
      ResetLastError();
      int db = CustomRatesReplace(m_job.name, bars[0].time, bars[nb - 1].time + 60, bars);
      if(db < 0) { res.err = StringFormat("CustomRatesReplace failed (err %d)", GetLastError()); return false; }
      res.bars += db;
     }
   return true;
  }

//--- bars-only chunk -----------------------------------------------------
bool CTFEngine::WriteBarsChunk(const datetime a, const datetime b, CTFResult &res)
  {
   MqlRates src[];
   int got = -1;
   for(int attempt = 0; attempt < 3 && got < 0; attempt++)
     {
      ResetLastError();
      got = CopyRates(m_job.src, PERIOD_M1, a, b, src);
      if(got < 0) TF_Wait(200);
     }
   if(got <= 0) return true;
   MqlRates dst[]; ArrayResize(dst, got);
   for(int i = 0; i < got; i++)
     {
      double c = src[i].close;
      double o = Map(src[i].open, src[i].time), h = Map(src[i].high, src[i].time);
      double l = Map(src[i].low, src[i].time),  cl = Map(c, src[i].time);
      if(o <= 0.0 || h <= 0.0 || l <= 0.0 || cl <= 0.0) { res.err = "function produced an invalid price"; return false; }
      double hi = MathMax(MathMax(o, h), MathMax(l, cl)), lo = MathMin(MathMin(o, h), MathMin(l, cl));
      double k = (c > 0.0 ? cl / c : 1.0);
      dst[i].time  = (datetime)(src[i].time + m_job.offset_sec);
      dst[i].open  = NormalizeDouble(o, m_digits_dst);
      dst[i].high  = NormalizeDouble(hi, m_digits_dst);
      dst[i].low   = NormalizeDouble(lo, m_digits_dst);
      dst[i].close = NormalizeDouble(cl, m_digits_dst);
      dst[i].tick_volume = src[i].tick_volume;
      dst[i].real_volume = 0;
      // source spread is in source points; express it in destination points
      double sp_price = src[i].spread * SymbolInfoDouble(m_job.src, SYMBOL_POINT) * (m_job.scale_spread ? k : 1.0);
      dst[i].spread = (int)MathRound(sp_price / m_point_dst);
     }
   ResetLastError();
   int d = CustomRatesReplace(m_job.name, dst[0].time, dst[got - 1].time + 60, dst);
   if(d < 0) { res.err = StringFormat("CustomRatesReplace failed (err %d)", GetLastError()); return false; }
   res.bars += d;
   return true;
  }

bool CTFEngine::Begin(const CTFJob &job, CTFResult &res)
  {
   m_job = job; m_bad = 0; m_i = 0; m_days = 0; m_ready_at = 0;
   res.ok = false; res.err = ""; res.ticks = 0; res.bars = 0; res.digits = 0; res.p0 = 0.0;
   if(!m_ex.Compile(job.expr)) { res.err = "function: " + m_ex.Error(); return false; }
   if(job.to < job.from) { res.err = "end date is before start date"; return false; }
   datetime t0;
   if(!TF_FirstOpen(job.src, job.from, job.to, m_p0, t0)) { res.err = "no M1 bars for " + job.src + " in that range"; return false; }
   res.p0 = m_p0;
   m_from = job.from; m_span = (double)(job.to + 86400 - job.from);
   if(!SetupSymbol(res)) return false;
   m_days = (int)((job.to - job.from) / 86400) + 1;
   return true;
  }

bool CTFEngine::Step(CTFResult &res)
  {
   if(Done()) { res.ok = true; return true; }
   if((int)(GetTickCount() - m_ready_at) < 0) return true;      // symbol still settling
   datetime day = m_job.from + (datetime)m_i * 86400;
   bool ok = (m_job.mode == TF_MODE_TICKS ? WriteTicksDay(day, res) : WriteBarsChunk(day, day + 86400 - 60, res));
   if(!ok) return false;
   if(m_bad > 0) { res.err = "function produced an invalid price"; return false; }
   TF_Status(StringFormat("%s  day %d/%d   ticks %I64d   M1 bars %I64d", TimeToString(day, TIME_DATE), m_i + 1, m_days, res.ticks, res.bars));
   m_i++;
   if(Done()) res.ok = true;
   return true;
  }

bool CTFEngine::Run(const CTFJob &job, CTFResult &res)
  {
   if(!Begin(job, res)) return false;
   while(!Done())
      if(!Step(res)) return false;
   return true;
  }
//+------------------------------------------------------------------+

// ---- end TF_Engine.mqh ----

#define TF_W      1030
#define TF_CW     540
#define TF_H      596
#define TF_PLOT_H 554
#define TF_LBL_W  150
#define TF_X      10

string g_presets_txt[] = {"Original prices (control)", "Multiply x2", "Multiply x0.5", "Squared move (extreme)", "Ramp x1 -> x2 over range", "Offset +1000", "Inverted move"};
string g_presets_fn[]  = {"p", "p*2", "p*0.5", "p0*r^2", "p*(1+t)", "p+1000", "p0*p0/p"};

//+------------------------------------------------------------------+
//| Overview plot: source and result price over the whole range       |
//+------------------------------------------------------------------+
class CTFPlot : public CWnd
  {
private:
   CCanvas           m_cv;
   string            m_obj;
   bool              m_ok;
   void              Panel(const int top, const int h, const string title, const datetime &t[], const double &v[], const int n,
                           const long shift, const uint clr);
public:
                     CTFPlot() : m_ok(false) {}
   virtual bool      Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2);
   virtual bool      OnMove(void);
   virtual bool      OnShow(void) { if(m_ok) ObjectSetInteger(m_chart_id, m_obj, OBJPROP_TIMEFRAMES, OBJ_ALL_PERIODS); return true; }
   virtual bool      OnHide(void) { if(m_ok) ObjectSetInteger(m_chart_id, m_obj, OBJPROP_TIMEFRAMES, OBJ_NO_PERIODS); return true; }
   virtual bool      OnDestroy(void) { if(m_ok) { m_cv.Destroy(); m_ok = false; } return true; }
   void              Hint(const string a, const string b = "");
   void              Lines(const string a, const string b = "", const string c = "");
   void              Para(const string a, const string b = "");
   void              Draw(const datetime &t[], const double &o[], const double &v[], const int n, const long shift,
                          const string srcTitle, const string dstTitle, const string note);
  };

bool CTFPlot::Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2)
  {
   if(!CWnd::Create(chart, name, subwin, x1, y1, x2, y2)) return false;
   m_obj = name + "cv";
   m_ok = m_cv.CreateBitmapLabel(chart, subwin, m_obj, x1, y1, x2 - x1, y2 - y1, COLOR_FORMAT_ARGB_NORMALIZE);
   if(m_ok) { ObjectSetInteger(chart, m_obj, OBJPROP_SELECTABLE, false); Hint("Press Preview to see the whole range:", "source on top, result below."); }
   return m_ok;
  }

bool CTFPlot::OnMove(void)
  {
   if(!m_ok) return true;
   ObjectSetInteger(m_chart_id, m_obj, OBJPROP_XDISTANCE, Left());
   ObjectSetInteger(m_chart_id, m_obj, OBJPROP_YDISTANCE, Top());
   return true;
  }

void CTFPlot::Hint(const string a, const string b)
  {
   if(!m_ok) return;
   m_cv.Erase(ColorToARGB(clrWhite, 255));
   m_cv.Rectangle(0, 0, m_cv.Width() - 1, m_cv.Height() - 1, ColorToARGB(C'150,150,150', 255));
   m_cv.FontSet("Arial", -100);
   m_cv.TextOut(m_cv.Width() / 2, m_cv.Height() / 2 - 14, a, ColorToARGB(C'90,90,90', 255), TA_CENTER);
   m_cv.TextOut(m_cv.Width() / 2, m_cv.Height() / 2 + 6, b, ColorToARGB(C'90,90,90', 255), TA_CENTER);
   m_cv.Update();
  }

void CTFPlot::Para(const string a, const string b)
  {
   if(!m_ok) return;
   m_cv.Erase(0);
   m_cv.FontSet("Arial", -80);
   const uint clr = ColorToARGB(C'40,40,40', 255);
   int y = 0;
   for(int pass = 0; pass < 2; pass++)
     {
      string rest = (pass == 0 ? a : b);
      while(StringLen(rest) > 0 && y < m_cv.Height() - 12)
        {
         string line = rest;
         if(StringLen(rest) > 92)
           {
            int cut = 92;
            while(cut > 40 && StringGetCharacter(rest, cut) != ' ') cut--;
            line = StringSubstr(rest, 0, cut);
            rest = StringSubstr(rest, cut + 1);
           }
         else rest = "";
         m_cv.TextOut(0, y, line, clr, TA_LEFT);
         y += 14;
        }
     }
   m_cv.Update();
  }

void CTFPlot::Lines(const string a, const string b, const string c)
  {
   if(!m_ok) return;
   m_cv.Erase(0);
   m_cv.FontSet("Arial", -70);
   const uint clr = ColorToARGB(C'60,60,60', 255);
   m_cv.TextOut(0, 0, a, clr, TA_LEFT);
   if(b != "") m_cv.TextOut(0, 16, b, clr, TA_LEFT);
   if(c != "") m_cv.TextOut(0, 32, c, clr, TA_LEFT);
   m_cv.Update();
  }

void CTFPlot::Panel(const int top, const int h, const string title, const datetime &t[], const double &v[], const int n,
                    const long shift, const uint clr)
  {
   const int L = 62, R = m_cv.Width() - 10, B = top + h - 22, T = top + 18;
   double lo = v[0], hi = v[0];
   for(int i = 1; i < n; i++) { if(v[i] < lo) lo = v[i]; if(v[i] > hi) hi = v[i]; }
   double pad = (hi - lo) * 0.05; if(pad <= 0.0) pad = MathMax(MathAbs(hi) * 0.01, 1e-9);
   lo -= pad; hi += pad;
   m_cv.FontSet("Arial", -80);
   m_cv.TextOut(L, top, title, ColorToARGB(C'30,30,30', 255), TA_LEFT);
   uint grid = ColorToARGB(C'225,225,225', 255), axis = ColorToARGB(C'120,120,120', 255);
   for(int g = 0; g <= 4; g++)
     {
      int y = B - (B - T) * g / 4;
      m_cv.Line(L, y, R, y, grid);
      m_cv.TextOut(L - 4, y - 6, DoubleToString(lo + (hi - lo) * g / 4.0, hi > 1000 ? 0 : hi > 10 ? 2 : 5), ColorToARGB(C'80,80,80', 255), TA_RIGHT);
     }
   m_cv.Rectangle(L, T, R, B, axis);
   for(int g = 0; g <= 4; g++)
     {
      int idx = (n - 1) * g / 4, x = L + (R - L) * idx / MathMax(n - 1, 1);
      m_cv.Line(x, B, x, B + 3, axis);
      m_cv.TextOut(x, B + 4, TimeToString((datetime)(t[idx] + shift), TIME_DATE), ColorToARGB(C'80,80,80', 255), g == 0 ? TA_LEFT : g == 4 ? TA_RIGHT : TA_CENTER);
     }
   int px = 0, py = 0;
   for(int i = 0; i < n; i++)
     {
      int x = L + (int)((double)(R - L) * i / MathMax(n - 1, 1));
      int y = B - (int)((B - T) * (v[i] - lo) / (hi - lo));
      if(i > 0) { m_cv.Line(px, py, x, y, clr); m_cv.Line(px, py + 1, x, y + 1, clr); }
      px = x; py = y;
     }
  }

void CTFPlot::Draw(const datetime &t[], const double &o[], const double &v[], const int n, const long shift,
                   const string srcTitle, const string dstTitle, const string note)
  {
   if(!m_ok || n < 2) return;
   m_cv.Erase(ColorToARGB(clrWhite, 255));
   m_cv.Rectangle(0, 0, m_cv.Width() - 1, m_cv.Height() - 1, ColorToARGB(C'150,150,150', 255));
   const int h = (m_cv.Height() - 30) / 2;
   Panel(4, h, srcTitle, t, o, n, 0, ColorToARGB(C'90,90,90', 255));
   Panel(4 + h + 4, h, dstTitle, t, v, n, shift, ColorToARGB(C'20,110,60', 255));
   m_cv.FontSet("Arial", -70);
   m_cv.TextOut(8, m_cv.Height() - 16, note, ColorToARGB(C'90,90,90', 255), TA_LEFT);
   m_cv.Update();
  }

//+------------------------------------------------------------------+
class CTickForgeDlg : public CAppDialog
  {
private:
   CLabel            m_l[16];
   CComboBox         m_src, m_mode, m_unit, m_preset;
   CEdit             m_symname, m_from, m_to, m_off, m_fn;
   CTFPlot           m_hint, m_paths;   // canvas text blocks (a CLabel clips long text)
   CCheckBox         m_spread, m_digits;
   CButton           m_btnPrev, m_btnScan, m_btnFull, m_btnGo, m_btnAudit, m_btnDel;
   CLabel            m_avail, m_prev;
   CTFPlot           m_status;              // wrapped status text (a CLabel clips long text)
   string            m_sa, m_sb;
   CTFPlot           m_plot;
   bool              m_busy;
   bool              m_closed;
   CTFEngine         m_eng;                 // stepwise generator, driven by Tick() from the host timer
   CTFResult         m_res;
   bool              m_running;
   bool              m_audit;               // audit-set run in progress
   int               m_ai;                  // index of the audit symbol being written
   CTFJob            m_ajob;
   string            m_abase;
   string            m_confirm, m_jname;    // overwrite confirmation (second click), symbol being written
   bool              m_scanning;
   datetime          m_sm, m_sto, m_srs, m_sl;
   int               m_srun;
   string            m_sres, m_ssrc;

   bool              AddLabel(const int idx, const string text, const int y);
   bool              BuildJob(CTFJob &job, string &err);
   void              RefreshAvail();
   void              RefreshPaths();
   void              Say(const string a, const string b = "");

   void              OnChangeSource();
   void              OnChangePreset();
   void              OnEndEditName() { ClearConfirm(); RefreshPaths(); }
   void              ClearConfirm() { if(m_confirm != "") { m_confirm = ""; m_btnGo.Text("GENERATE SYMBOL"); AuditButtonsReset(); } }
   void              ScanStep();
   void              OnClickFull();
   void              OnClickPreview();
   void              OnClickScan();
   void              OnClickGenerate();
   void              OnClickAudit();
   void              OnClickDeleteAudit();
   bool              StartAuditJob();
   bool              WriteManifest();
   void              AuditButtonsReset();

public:
                     CTickForgeDlg() : m_busy(false), m_closed(false), m_running(false), m_audit(false), m_ai(0), m_scanning(false), m_srun(0) {}
   virtual bool      Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2);
   virtual bool      OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam);
   virtual void      OnClickButtonClose(void) { m_closed = true; }   // the host program removes itself
   bool              Closed() const { return m_closed; }
   void              Tick();                // call from the host timer (about every 30 ms)
   void              SetStatus(const string s) { m_sa = s; m_status.Para(m_sa, m_sb); ChartRedraw(); }
   string            Status() { return m_sa; }
   bool              Busy() const { return m_running || m_scanning; }
   // developer hook: fill the form and press GENERATE exactly as a user would (twice, to pass the overwrite confirmation)
   void              FillAndGenerate(const string src, const string name, const string from, const string to, const int mode, const double offh, const string fn)
     {
      m_src.SelectByText(src);
      OnChangeSource();
      m_symname.Text(name);
      m_from.Text(from); m_to.Text(to);
      m_mode.Select(mode);
      m_unit.Select(0);
      m_off.Text(DoubleToString(offh, 2));
      m_fn.Text(fn);
      OnClickGenerate();
      OnClickGenerate();
     }
   void              FillAndAudit(const string src, const string name, const string from, const string to, const int mode)
     {
      m_src.SelectByText(src);
      OnChangeSource();
      m_symname.Text(name);
      m_from.Text(from); m_to.Text(to);
      m_mode.Select(mode);
      m_unit.Select(0);
      m_off.Text("0"); m_fn.Text("p");
      OnClickAudit();
      OnClickAudit();
     }
   void              ShotPreview(const string src, const string from, const string to, const double offh, const string fn)
     {
      if(src != "") m_src.SelectByText(src);
      OnChangeSource();
      if(from != "") m_from.Text(from);
      if(to != "") m_to.Text(to);
      m_off.Text(DoubleToString(offh, 2));
      for(int i = 0; i < ArraySize(g_presets_fn); i++) if(g_presets_fn[i] == fn) m_preset.Select(i);
      m_fn.Text(fn);
      OnClickPreview();
     }
  };

EVENT_MAP_BEGIN(CTickForgeDlg)
   ON_EVENT(ON_CHANGE, m_src, OnChangeSource)
   ON_EVENT(ON_CHANGE, m_preset, OnChangePreset)
   ON_EVENT(ON_END_EDIT, m_symname, OnEndEditName)
   ON_EVENT(ON_CLICK, m_btnFull, OnClickFull)
   ON_EVENT(ON_CLICK, m_btnPrev, OnClickPreview)
   ON_EVENT(ON_CLICK, m_btnScan, OnClickScan)
   ON_EVENT(ON_CLICK, m_btnGo, OnClickGenerate)
   ON_EVENT(ON_CLICK, m_btnAudit, OnClickAudit)
   ON_EVENT(ON_CLICK, m_btnDel, OnClickDeleteAudit)
EVENT_MAP_END(CAppDialog)

CTickForgeDlg *g_dlg = NULL;

void TF_Status(const string s)
  {
   Print("TickForge: ", s);
   if(g_dlg != NULL) g_dlg.SetStatus(s);
  }

bool CTickForgeDlg::AddLabel(const int idx, const string text, const int y)
  {
   if(!m_l[idx].Create(m_chart_id, m_name + "L" + IntegerToString(idx), m_subwin, TF_X, y + 4, TF_X + TF_LBL_W, y + 24)) return false;
   m_l[idx].Text(text);
   return Add(m_l[idx]);
  }

bool CTickForgeDlg::Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2)
  {
   if(!CAppDialog::Create(chart, name, subwin, x1, y1, x2, y2)) return false;
   const int X2 = TF_X + TF_LBL_W + 5;               // control column
   const int XR = TF_CW - 30;                          // right edge
   int y = 8;

   AddLabel(0, "Source symbol", y);
   m_src.Create(m_chart_id, m_name + "src", m_subwin, X2, y, XR, y + 24); Add(m_src);
   for(int i = 0, k = 0; i < SymbolsTotal(true); i++)
     {
      string s = SymbolName(i, true);
      if((bool)SymbolInfoInteger(s, SYMBOL_CUSTOM)) continue;
      m_src.ItemAdd(s, k++);
     }
   m_src.Select(0);
   string cur = Symbol();
   m_src.SelectByText(cur);

   y += 30;
   AddLabel(1, "Custom symbol name", y);
   m_symname.Create(m_chart_id, m_name + "nm", m_subwin, X2, y, XR, y + 24); Add(m_symname);

   y += 30;
   AddLabel(2, "Broker data available", y);
   m_avail.Create(m_chart_id, m_name + "av", m_subwin, X2, y + 4, XR, y + 24); m_avail.Text(""); Add(m_avail);

   y += 30;
   AddLabel(3, "From (YYYY.MM.DD)", y);
   m_from.Create(m_chart_id, m_name + "fr", m_subwin, X2, y, X2 + 110, y + 24); Add(m_from);
   m_l[12].Create(m_chart_id, m_name + "L12", m_subwin, X2 + 120, y + 4, X2 + 170, y + 24); m_l[12].Text("to"); Add(m_l[12]);
   m_to.Create(m_chart_id, m_name + "to", m_subwin, X2 + 140, y, X2 + 250, y + 24); Add(m_to);
   m_btnFull.Create(m_chart_id, m_name + "bf", m_subwin, X2 + 262, y, XR, y + 24); m_btnFull.Text("Use full range"); Add(m_btnFull);

   y += 30;
   AddLabel(4, "Data type", y);
   m_mode.Create(m_chart_id, m_name + "md", m_subwin, X2, y, XR, y + 24); Add(m_mode);
   m_mode.ItemAdd("Real ticks (transformed) + M1 bars", 0);
   m_mode.ItemAdd("M1 bars only (tester builds the ticks)", 1);
   m_mode.Select(0);

   y += 30;
   AddLabel(5, "Time offset", y);
   m_off.Create(m_chart_id, m_name + "of", m_subwin, X2, y, X2 + 90, y + 24); m_off.Text("0"); Add(m_off);
   m_unit.Create(m_chart_id, m_name + "un", m_subwin, X2 + 100, y, X2 + 200, y + 24); Add(m_unit);
   m_unit.ItemAdd("hours", 0); m_unit.ItemAdd("days", 1); m_unit.Select(0);
   m_l[13].Create(m_chart_id, m_name + "L13", m_subwin, X2 + 210, y + 4, XR, y + 24); m_l[13].Text("raw clock shift, - = earlier"); Add(m_l[13]);

   y += 30;
   AddLabel(6, "Price function preset", y);
   m_preset.Create(m_chart_id, m_name + "ps", m_subwin, X2, y, XR, y + 24); Add(m_preset);
   for(int i = 0; i < ArraySize(g_presets_txt); i++) m_preset.ItemAdd(g_presets_txt[i], i);
   m_preset.Select(0);

   y += 30;
   AddLabel(7, "New price  = f(...)", y);
   m_fn.Create(m_chart_id, m_name + "fn", m_subwin, X2, y, XR, y + 24); m_fn.Text("p"); Add(m_fn);

   y += 26;
   m_hint.Create(m_chart_id, m_name + "hint", m_subwin, TF_X, y, XR, y + 16); Add(m_hint);
   m_hint.Lines("p price | p0 first price | r = p/p0 | t 0..1 over range | d days    + - * / ^ ( )   abs sqrt ln log10 exp sin cos pow min max");

   y += 26;
   m_spread.Create(m_chart_id, m_name + "sp", m_subwin, X2, y, XR, y + 22); m_spread.Text("Spread follows the price factor"); m_spread.Checked(true); Add(m_spread);
   y += 24;
   m_digits.Create(m_chart_id, m_name + "dg", m_subwin, X2, y, XR, y + 22); m_digits.Text("Add digits when prices shrink"); m_digits.Checked(true); Add(m_digits);

   y += 30;
   AddLabel(8, "Old -> new price", y);
   m_prev.Create(m_chart_id, m_name + "pv", m_subwin, X2, y + 4, XR, y + 24); m_prev.Text(""); Add(m_prev);

   y += 34;
   m_btnPrev.Create(m_chart_id, m_name + "b1", m_subwin, TF_X, y, TF_X + 120, y + 28); m_btnPrev.Text("Preview"); Add(m_btnPrev);
   m_btnScan.Create(m_chart_id, m_name + "b2", m_subwin, TF_X + 130, y, TF_X + 290, y + 28); m_btnScan.Text("Scan tick availability"); Add(m_btnScan);
   m_btnGo.Create(m_chart_id, m_name + "b3", m_subwin, TF_X + 300, y, XR, y + 28); m_btnGo.Text("GENERATE SYMBOL"); m_btnGo.ColorBackground(C'30,120,60'); m_btnGo.Color(clrWhite); Add(m_btnGo);

   y += 34;
   m_btnAudit.Create(m_chart_id, m_name + "b4", m_subwin, TF_X, y, TF_X + 250, y + 28); m_btnAudit.Text("Audit set (7 symbols)"); Add(m_btnAudit);
   m_btnDel.Create(m_chart_id, m_name + "b5", m_subwin, TF_X + 260, y, XR, y + 28); m_btnDel.Text("Delete audit set"); Add(m_btnDel);

   y += 38;
   m_paths.Create(m_chart_id, m_name + "paths", m_subwin, TF_X, y, XR, y + 50); Add(m_paths);

   y += 52;
   m_status.Create(m_chart_id, m_name + "status", m_subwin, TF_X, y, XR, y + 60); Add(m_status);
   Say("Ready.");

   m_plot.Create(m_chart_id, m_name + "plot", m_subwin, TF_CW + 10, 8, TF_W - 40, 8 + TF_PLOT_H); Add(m_plot);
   OnChangeSource();
   return true;
  }

void CTickForgeDlg::Say(const string a, const string b)
  {
   m_sa = a; m_sb = b; m_status.Para(a, b); ChartRedraw();
  }

void CTickForgeDlg::OnChangeSource()
  {
   ClearConfirm();
   string s = m_src.Select();
   if(s != "") m_symname.Text(s + "_TF");
   RefreshAvail();
   RefreshPaths();
  }

void CTickForgeDlg::OnChangePreset()
  {
   int i = (int)m_preset.Value();
   if(i >= 0 && i < ArraySize(g_presets_fn)) m_fn.Text(g_presets_fn[i]);
  }

void CTickForgeDlg::RefreshPaths()
  {
   string n = m_symname.Text(), root = TerminalInfoString(TERMINAL_DATA_PATH);
   if(StringLen(root) > 92) root = StringSubstr(root, 0, 28) + " ... " + StringSubstr(root, StringLen(root) - 58);
   m_paths.Lines("Data folder:  " + root,
                 "Bars stored in:   <data folder>\\bases\\Custom\\history\\" + n,
                 "Ticks stored in:  <data folder>\\bases\\Custom\\ticks\\" + n);
  }

void CTickForgeDlg::RefreshAvail()
  {
   string s = m_src.Select();
   if(s == "") return;
   SymbolSelect(s, true);
   long a = SeriesInfoInteger(s, PERIOD_M1, SERIES_SERVER_FIRSTDATE);
   long b = SeriesInfoInteger(s, PERIOD_M1, SERIES_LASTBAR_DATE);
   if(a <= 0) { Bars(s, PERIOD_M1); a = SeriesInfoInteger(s, PERIOD_M1, SERIES_SERVER_FIRSTDATE); b = SeriesInfoInteger(s, PERIOD_M1, SERIES_LASTBAR_DATE); }
   if(a > 0)
     {
      m_avail.Text("M1 bars " + TimeToString((datetime)a, TIME_DATE) + " .. " + TimeToString((datetime)b, TIME_DATE) + "  (ticks: use Scan)");
      m_from.Text(TimeToString((datetime)MathMax(a, (long)(b - 30 * 86400)), TIME_DATE));
      m_to.Text(TimeToString((datetime)b, TIME_DATE));
     }
   else m_avail.Text("no M1 history yet - open a chart of this symbol first");
  }

void CTickForgeDlg::OnClickFull()
  {
   string s = m_src.Select();
   long a = SeriesInfoInteger(s, PERIOD_M1, SERIES_SERVER_FIRSTDATE);
   long b = SeriesInfoInteger(s, PERIOD_M1, SERIES_LASTBAR_DATE);
   if(a > 0) { m_from.Text(TimeToString((datetime)a, TIME_DATE)); m_to.Text(TimeToString((datetime)b, TIME_DATE)); }
  }

bool CTickForgeDlg::BuildJob(CTFJob &job, string &err)
  {
   err = "";
   job.src = m_src.Select();
   job.name = m_symname.Text();
   StringTrimLeft(job.name); StringTrimRight(job.name);
   if(job.src == "") { err = "choose a source symbol"; return false; }
   if(StringLen(job.name) == 0 || StringLen(job.name) > 31) { err = "symbol name must be 1-31 characters"; return false; }
   for(int i = 0; i < StringLen(job.name); i++)
     {
      ushort c = job.name[i];
      bool ok = (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_' || c == '.' || c == '-' || c == '#';
      if(!ok) { err = "symbol name: letters, digits, _ . - # only"; return false; }
     }
   job.from = StringToTime(m_from.Text() + " 00:00");
   job.to   = StringToTime(m_to.Text() + " 00:00");
   if(job.from <= 0 || job.to <= 0) { err = "dates must look like 2024.03.15"; return false; }
   if(job.to < job.from) { err = "end date is before start date"; return false; }
   job.mode = (int)m_mode.Value();
   double v = StringToDouble(m_off.Text());
   job.offset_sec = (long)MathRound(v * (m_unit.Value() == 1 ? 86400.0 : 3600.0));
   job.expr = m_fn.Text();
   job.scale_spread = m_spread.Checked();
   job.auto_digits = m_digits.Checked();
   return true;
  }

void CTickForgeDlg::OnClickPreview()
  {
   CTFJob job; string err;
   if(!BuildJob(job, err)) { Say("Cannot preview: " + err); return; }
   Say("Reading price history for the overview...");
   CTFEngine eng; datetime t[]; double o[], v[]; string tfn;
   if(!eng.Series(job, t, o, v, tfn, err)) { Say("Cannot preview: " + err); m_prev.Text(""); m_plot.Hint("Cannot preview:", err); return; }
   int n = ArraySize(t);
   int dg = (int)SymbolInfoInteger(job.src, SYMBOL_DIGITS);
   m_prev.Text("start " + DoubleToString(o[0], dg) + " -> " + DoubleToString(v[0], dg) + "   end " + DoubleToString(o[n - 1], dg) + " -> " + DoubleToString(v[n - 1], dg));
   string off = (job.offset_sec == 0 ? "no time shift" : StringFormat("shifted %+.1f h", job.offset_sec / 3600.0));
   m_plot.Draw(t, o, v, n, job.offset_sec, "Source " + job.src + "  (broker dates)",
               "Result " + job.name + "   f(p) = " + job.expr + "   " + off,
               StringFormat("%d points, %s closes, whole range. Each panel has its own price axis.", n, tfn));
   if(job.offset_sec > 0 && (long)job.to + 86400 + job.offset_sec > (long)TimeCurrent())
      Say("Preview OK - check the shape in the panel on the right.", "NOTE: with this shift the data ends after today; the Strategy Tester can only use the part up to today.");
   else
      Say("Preview OK - check the shape in the panel on the right.", "");
  }

void CTickForgeDlg::OnClickScan()
  {
   if(m_scanning || m_running) return;
   CTFJob job; string err;
   if(!BuildJob(job, err)) { Say("Cannot scan: " + err); return; }
   m_ssrc = job.src; m_sto = job.to; m_sres = ""; m_srun = 0; m_srs = 0; m_sl = 0;
   MqlDateTime d; TimeToStruct(job.from, d); d.day = 1; d.hour = d.min = d.sec = 0;
   m_sm = StructToTime(d);
   m_scanning = true;
   m_btnScan.Text("Scanning...");
   Say("Scanning tick history month by month (may download from the broker)...");
  }

void CTickForgeDlg::ScanStep()
  {
   MqlTick tk[];
   MqlDateTime e; TimeToStruct(m_sm, e); e.mon++; if(e.mon > 12) { e.mon = 1; e.year++; }
   datetime nx = StructToTime(e);
   bool has = (CopyTicks(m_ssrc, tk, COPY_TICKS_ALL, (ulong)m_sm * 1000, 1) > 0 && tk[0].time < nx);
   if(has) { if(m_srun == 0) m_srs = m_sm; m_srun++; m_sl = m_sm; }
   else if(m_srun > 0) { m_sres += TimeToString(m_srs, TIME_DATE) + ".." + TimeToString(m_sl, TIME_DATE) + "  "; m_srun = 0; }
   m_sm = nx;
   if(m_sm <= m_sto) return;
   if(m_srun > 0) m_sres += TimeToString(m_srs, TIME_DATE) + ".." + TimeToString(m_sl, TIME_DATE);
   m_scanning = false;
   m_btnScan.Text("Scan tick availability");
   Say(m_sres == "" ? "No ticks for this range - use 'M1 bars only'." : "Months with ticks: " + m_sres, "Format: first day of first month .. first day of last month");
  }

void CTickForgeDlg::OnClickGenerate()
  {
   if(m_running || m_scanning) return;
   CTFJob job; string err;
   if(!BuildJob(job, err)) { Say("Cannot generate: " + err); return; }
   bool custom, exists = TF_SymbolExists(job.name, custom);
   if(exists && !custom) { Say("'" + job.name + "' is a real broker symbol - choose another name."); return; }
   if(exists && m_confirm != job.name)
     {
      m_confirm = job.name;
      m_btnGo.Text("CONFIRM OVERWRITE");
      Say("Custom symbol '" + job.name + "' already exists.", "Press the button again to overwrite all of its bars and ticks, or change the name.");
      return;
     }
   ClearConfirm();
   m_btnGo.Text("Working...");
   Say("Starting...");
   m_jname = job.name;
   if(!m_eng.Begin(job, m_res))
     {
      m_btnGo.Text("GENERATE SYMBOL");
      Say("FAILED: " + m_res.err, "Nothing was changed.");
      return;
     }
   m_running = true;
  }

//--- audit set: control + calendar shifts + price level + mirror, one confirmed click ---------------
string g_audit_sfx[] = {"_C", "_S7", "_S14", "_S28", "_L50", "_L200", "_MIR"};
string g_audit_lbl[] = {"control (no change)", "shifted +7 days", "shifted +14 days", "shifted +28 days", "prices x0.5", "prices x2", "mirrored moves"};
string g_audit_fn[]  = {"p", "p", "p", "p", "p*0.5", "p*2", "p0*p0/p"};
int    g_audit_day[] = {0, 7, 14, 28, 0, 0, 0};

void CTickForgeDlg::AuditButtonsReset()
  {
   m_btnAudit.Text("Audit set (7 symbols)");
   m_btnDel.Text("Delete audit set");
  }

void CTickForgeDlg::OnClickAudit()
  {
   if(m_running || m_scanning) return;
   CTFJob job; string err;
   if(!BuildJob(job, err)) { Say("Cannot build the audit set: " + err); return; }
   if(StringLen(job.name) > 25) { Say("Cannot build the audit set: the name must be 25 characters or less (suffixes are added)."); return; }
   const int n = ArraySize(g_audit_sfx);
   int existing = 0;
   for(int i = 0; i < n; i++)
     {
      bool custom, ex = TF_SymbolExists(job.name + g_audit_sfx[i], custom);
      if(ex && !custom) { Say("'" + job.name + g_audit_sfx[i] + "' is a real broker symbol - choose another base name."); return; }
      if(ex) existing++;
     }
   const string key = "AUDIT:" + job.name;
   if(m_confirm != key)
     {
      ClearConfirm();
      m_confirm = key;
      m_btnAudit.Text("CONFIRM AUDIT SET");
      const int days = (int)((job.to - job.from) / 86400) + 1;
      Say(StringFormat("Audit set: %d symbols (%s_C, _S7, _S14, _S28, _L50, _L200, _MIR), %d days of %s each.", n, job.name, days,
                       job.mode == TF_MODE_TICKS ? "real ticks" : "M1 bars"),
          (existing > 0 ? StringFormat("%d already exist and will be overwritten. ", existing) : "") +
          ((long)job.to + 86400 + 28 * 86400 > (long)TimeCurrent() ? "NOTE: the +14/+28 day symbols end after today; the tester only uses data up to today, so end the range earlier for a full comparison. " : "") +
          "Each symbol uses the disk space of one generated symbol. Press again to create; 'Delete audit set' removes them.");
      return;
     }
   ClearConfirm();
   m_ajob = job; m_abase = job.name; m_ai = 0; m_audit = true;
   StartAuditJob();
  }

bool CTickForgeDlg::StartAuditJob()
  {
   CTFJob job = m_ajob;
   job.name = m_abase + g_audit_sfx[m_ai];
   job.offset_sec = (long)g_audit_day[m_ai] * 86400;
   job.expr = g_audit_fn[m_ai];
   m_jname = job.name;
   m_btnAudit.Text(StringFormat("Audit %d/%d...", m_ai + 1, ArraySize(g_audit_sfx)));
   Say(StringFormat("Audit set %d/%d: %s - %s", m_ai + 1, ArraySize(g_audit_sfx), job.name, g_audit_lbl[m_ai]));
   if(!m_eng.Begin(job, m_res))
     {
      Say("FAILED at " + job.name + ": " + m_res.err, "Symbols made so far stay. Fix the cause and press Audit set again.");
      m_audit = false; m_running = false;
      AuditButtonsReset();
      return false;
     }
   m_running = true;
   return true;
  }

bool CTickForgeDlg::WriteManifest()
  {
   FolderCreate("TickForge");                      // inside MQL5\Files
   const string fn = "TickForge\\audit_" + m_abase + ".json";
   const int h = FileOpen(fn, FILE_WRITE | FILE_TXT | FILE_ANSI);
   if(h == INVALID_HANDLE) return false;
   const int n = ArraySize(g_audit_sfx);
   FileWriteString(h, "{\n  \"tool\": \"Tick Forge\",\n  \"version\": \"1.04\",\n");
   FileWriteString(h, "  \"source\": \"" + m_ajob.src + "\",\n");
   FileWriteString(h, "  \"from\": \"" + TimeToString(m_ajob.from, TIME_DATE) + "\",\n");
   FileWriteString(h, "  \"to\": \"" + TimeToString(m_ajob.to, TIME_DATE) + "\",\n");
   FileWriteString(h, StringFormat("  \"mode\": %d,\n  \"scale_spread\": %s,\n  \"symbols\": [\n", m_ajob.mode, m_ajob.scale_spread ? "true" : "false"));
   for(int i = 0; i < n; i++)
      FileWriteString(h, StringFormat("    {\"name\": \"%s\", \"label\": \"%s\", \"offset_sec\": %d, \"expr\": \"%s\"}%s\n",
                                      m_abase + g_audit_sfx[i], g_audit_lbl[i], g_audit_day[i] * 86400, g_audit_fn[i], i < n - 1 ? "," : ""));
   FileWriteString(h, "  ]\n}\n");
   FileClose(h);
   return true;
  }

void CTickForgeDlg::OnClickDeleteAudit()
  {
   if(m_running || m_scanning) return;
   CTFJob job; string err;
   if(!BuildJob(job, err)) { Say("Cannot delete: " + err); return; }
   const int n = ArraySize(g_audit_sfx);
   int found = 0;
   for(int i = 0; i < n; i++)
     {
      const string nm = job.name + g_audit_sfx[i];
      bool custom;
      if(!TF_SymbolExists(nm, custom) || !custom) continue;
      SymbolSelect(nm, true);
      if(StringFind(SymbolInfoString(nm, SYMBOL_PATH), "Tick Forge") == 0) found++;
     }
   if(found == 0) { Say("No audit-set symbols named " + job.name + "_C, _S7 ... were found."); return; }
   const string key = "DEL:" + job.name;
   if(m_confirm != key)
     {
      ClearConfirm();
      m_confirm = key;
      m_btnDel.Text("CONFIRM DELETE");
      Say(StringFormat("%d symbol(s) named %s_... and all their bars and ticks will be deleted.", found, job.name),
          "Only symbols created by Tick Forge are touched. Press again to delete.");
      return;
     }
   ClearConfirm();
   int gone = 0, failed = 0;
   for(int i = 0; i < n; i++)
     {
      const string nm = job.name + g_audit_sfx[i];
      bool custom;
      if(!TF_SymbolExists(nm, custom) || !custom) continue;
      SymbolSelect(nm, true);
      if(StringFind(SymbolInfoString(nm, SYMBOL_PATH), "Tick Forge") != 0) continue;
      SymbolSelect(nm, false);
      CustomRatesDelete(nm, 0, LONG_MAX);
      CustomTicksDelete(nm, 0, LONG_MAX);
      if(CustomSymbolDelete(nm)) gone++; else failed++;
     }
   FileDelete("TickForge\\audit_" + job.name + ".json");
   Say(StringFormat("Deleted %d symbol(s).", gone), failed > 0 ? StringFormat("%d could not be deleted (open in a chart or the tester?). Close them and try again.", failed) : "");
  }

void CTickForgeDlg::Tick()
  {
   if(m_scanning) { ScanStep(); return; }
   if(!m_running) return;
   if(!m_eng.Step(m_res))
     {
      m_running = false;
      const bool was_audit = m_audit;
      m_audit = false;
      m_btnGo.Text("GENERATE SYMBOL");
      AuditButtonsReset();
      Say("FAILED: " + m_res.err, was_audit ? "Symbols made so far stay. Press Audit set again after fixing the cause."
                                             : "The partly written symbol '" + m_jname + "' can be regenerated (it will ask before overwriting).");
      return;
     }
   if(!m_eng.Done()) return;
   SymbolSelect(m_jname, true);
   Print("TickForge DONE ", m_jname, " ticks=", m_res.ticks, " bars=", m_res.bars, " digits=", m_res.digits, " p0=", m_res.p0);
   if(m_audit)
     {
      m_ai++;
      if(m_ai < ArraySize(g_audit_sfx)) { StartAuditJob(); return; }
      m_audit = false; m_running = false;
      AuditButtonsReset();
      const bool wrote = WriteManifest();
      Say(StringFormat("DONE: audit set %s_C ... %s_MIR (%d symbols).", m_abase, m_abase, ArraySize(g_audit_sfx)),
          wrote ? "Manifest written to MQL5\\Files\\TickForge. Test your EA on each symbol, control first." : "Could not write the manifest file.");
      RefreshPaths();
      return;
     }
   m_running = false;
   m_btnGo.Text("GENERATE SYMBOL");
   Say(StringFormat("DONE: %s  ticks %I64d, M1 bars %I64d, digits %d", m_jname, m_res.ticks, m_res.bars, m_res.digits),
       "In the Strategy Tester choose symbol " + m_jname + ". Data lives in the folders above.");
   RefreshPaths();
  }

// ---- end TF_Gui.mqh ----

int OnInit()
  {
   PrintFormat("Tick Forge v1.04 | chart %s", _Symbol);
   if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION))
     {
      Print("Tick Forge is a utility for a live chart (it creates symbols); it does nothing in the Strategy Tester.");
      return INIT_SUCCEEDED;
     }
   g_dlg = new CTickForgeDlg();
   if(!g_dlg.Create(0, "Tick Forge 1.04", 0, 20, 20, 20 + TF_W, 20 + TF_H))
     {
      const string need = StringFormat("Tick Forge needs a chart of at least %d x %d pixels (enlarge the window or maximise the chart).", TF_W + 40, TF_H + 40);
      Print(need);
      Comment(need);
      delete g_dlg; g_dlg = NULL;
      return INIT_SUCCEEDED;
     }
   g_dlg.Run();
   EventSetMillisecondTimer(30);
   return INIT_SUCCEEDED;
  }

void OnDeinit(const int reason)
  {
   EventKillTimer();
   if(g_dlg != NULL) { g_dlg.Destroy(reason); delete g_dlg; g_dlg = NULL; }
   Comment("");
  }

void OnTick() {}

void OnTimer()
  {
   if(g_dlg == NULL) return;
   g_dlg.Tick();                       // one day / one month of work per call, so the window stays responsive
   if(g_dlg.Closed()) ExpertRemove();
  }

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   if(g_dlg != NULL) g_dlg.ChartEvent(id, lparam, dparam, sparam);
  }
//+------------------------------------------------------------------+