local_hedging_bot_copier_in_mt5/master/localHedgingMasterCopierMt5.mq5

//+------------------------------------------------------------------+
//|                                  localHedgingMasterCopierMt5.mq5 |
//|                                  Copyright 2025, MQL Development |
//|                                  https://www.mqldevelopment.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MQL Development"
#property link      "https://www.mqldevelopment.com/"
#property version   "1.00"
#include <Trade\Trade.mqh>
CTrade  trade;
#define orderCount 2000
#define count1 50
#define testCounter 50
#define MaxOrders 20000
#define daysOfTradesToAdd 20

#property description "Control Panels and Dialogs. Demonstration class CLabel"
#include <Controls\Dialog.mqh>
#include <Controls\Label.mqh>
#include <Controls\Button.mqh>
#include <Controls\RadioButton.mqh>
#include <Controls\RadioGroup.mqh>
#include <Controls\CheckBox.mqh>
#include  <Controls\ComboBox.mqh>
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
struct historyTradesClientSide
  {
   ulong             ticket;
   ulong             magic;
                     historyTradesClientSide()
     {
      ticket = -1;
      magic  = 0;
     }
  };
historyTradesClientSide historyTradeStore[MaxOrders];

struct masterOrder
  {
   datetime          opentime;
   string            symbol;
   ulong             ordertype;
   double            price;
   double            lots;
   double            stoploss;
   double            takeprofit;
   ulong             ticket;

   int               magic;
   double            accountBalance;
   int               contractSize;
   string            comment;


                     masterOrder()
     {
      ticket=-1;
      price=-1;
      symbol=Symbol();
      ordertype=-1;
      lots=0;
      stoploss=0;
      takeprofit=0;
     }
  };
masterOrder mod1[orderCount];

enum operation_mode
  {
   Master,  //Master
   Slave,   //Slave
  };
enum lotcalculator
  {
   fix, //Fixed Lot Size
   rsk, //Risk Percentage
  };

sinput       string                  string_0                  = "<><><><><><> General SETTINGS <><><><><><>";   //__
input        int                     magic_no                  = 333;             // Magic no
input        string                  suffix                    = "";              // Suffix
input        string                  prefix                    = "";              // Prefix
input        bool                    useMinimumLot             = false;           // Use Minimum Lot Threshold
input        double                  takeprofitTrade           = 10;              // Fixed Take Profit in Pips
input        double                  stoplossTrade             = 10;              // Fixed Stop Loss in Pips
input        double                  inpPips                   = 0.2;             // Pips To Start Copy
input        double                  minimumLot                = 0.01;            // Minimum Lot
input        bool                    useMaximumLot             = false;           // Use Maximum Lot Threshold
input        double                  maximumLot                = 0.01;            // Maximum Lot

input        string                  string_0_3                 = "<><><><><><> Lot Management<><><><><><>";   //__
input        double                  lot_size                   = 0.1;             // Lot Size
input        lotcalculator           lot_calculator             = fix;             // Lot Size Calculator
input        double                  risk                       = 0.1;             // Risk in Percentage %

// Heart Beat
sinput       string                  string_1                  = "<><><><><><> HeartBeat Setting <><><><><><>";   //__
input        string                  slaveServer               = "";              // Slave Server
input        string                  slaveId                   = "";              // Slave Login ID
input        string                  masterServer              = "";              // Master Server
input        string                  slaveVersion              = "4";             // Slave Version
input        string                  localApiKey               = "U2FsdGVkX18vBY4H1uzQiZwuh8B++8VBtCGJ3yGr2XPII0qCodmfuhjssKu5oug1J4e97bkwPtDQLi4py1OODQ=="; // Local API Key
input        string                  localHB_req_link          = "http://localhost/api/mlastConnected"; // Request Link For LastConnected

input        string                  dashboardSettings         = "<><><><><><> Dashboard Settings<><><><><><>";
input        int                     DashHeight                = 115;             // Enter Height of Dashboard
input        int                     DashWidth                 = 490;             // Enter Width  of Dashboard
input        int                     FontSize                  = 10;              // Text Font Size

// Global Variables
int filehandle;
int gmtDifference = 0;
bool doReversal = true; // Reverse Trades
bool auth = false;
datetime last_check_expiry;
ENUM_TIMEFRAMES check_expiry_timeframe = PERIOD_H1;
int orderTotal=0;

bool fileLastEmpty=false;
bool fileHandlerIssue=false;
int counter = 0, testCounterVar = 0;

int yAxisGlobal = 5;
int  dashHeight;                 //  Height of Dashboard
int  dashWidth;                  //  Width  of Dashboard
long accountNumber = AccountInfoInteger(ACCOUNT_LOGIN);
operation_mode mode1=Master; //Working Mode
int OnInit()
  {
//---
   trade.SetExpertMagicNumber(magic_no);
   trade.SetDeviationInPoints(10);
   trade.SetTypeFilling(ORDER_FILLING_IOC);
   trade.LogLevel(LOG_LEVEL_ALL);
   trade.SetAsyncMode(false);

   if(!ObjectFind(0,"mode") || ObjectGetString(0,"mode",OBJPROP_TEXT,0)!=EnumToString(mode1)+" Account")
     {
      ObjectDelete(0,"mode");
      ObjectCreate(0,"mode",OBJ_LABEL,0,0,0);
      ObjectSetInteger(0,"mode",OBJPROP_XDISTANCE,10);
      ObjectSetInteger(0,"mode",OBJPROP_YDISTANCE,25);
      ObjectSetInteger(0,"mode",OBJPROP_CORNER,CORNER_RIGHT_UPPER);
      ObjectSetInteger(0,"mode",OBJPROP_ANCHOR,ANCHOR_RIGHT_UPPER);
      ObjectSetInteger(0,"mode",OBJPROP_COLOR,clrLightBlue);
      ObjectSetString(0,"mode",OBJPROP_TEXT,EnumToString(mode1)+" Account");
      ObjectSetInteger(0,"mode",OBJPROP_FONTSIZE,14);
     }

   dashHeight = DashHeight;
   dashWidth  = DashWidth;
   double width  = double(ChartGetInteger(0,CHART_WIDTH_IN_PIXELS));
   double height = double(ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS));

   double minHeight = (110/height) * (height);
   double minWidth  = (480.0/width) * (width);

   Print(" Minimum Required minHeight = ",minHeight," minWidth ",minWidth);

   if(dashWidth < minWidth)
     {
      dashWidth = (int)minWidth;
      Print(" Dashboard width is updated because user input is less than required width ");
     }
   if(dashHeight < minHeight)
     {
      dashHeight = (int)minHeight;
      Print(" Dashboard Height is updated because user input is less than required Height ");
     }

   if(!ExtDialog.Create(0,"Local Hedge Master",10,10,40,dashWidth,dashHeight))      // the panel position
      return(INIT_FAILED);
   ExtDialog.Run();

   gmtDifference = (int)TimeCurrent() - (int)TimeGMT();
   Print("GMT Difference(sec): ",gmtDifference);

   EventSetMillisecondTimer(500);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   ExtDialog.Destroy(reason);
   EventKillTimer();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTimer()
  {
   gmtDifference = (int)TimeCurrent() - (int)TimeGMT();

   dashboard_data();

   remove_old_tickets_from_store();
   store_live_and_history_tickets();

   writeData();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   ExtDialog.ChartEvent(id,lparam,dparam,sparam);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void writeData()
  {
   if(PositionsTotal()==0 && OrdersTotal() == 0 && !fileLastEmpty && TerminalInfoInteger(TERMINAL_CONNECTED)) // && IsConnected()
     {
      filehandle=FileOpen("COF.csv",FILE_WRITE|FILE_CSV|FILE_COMMON);
      if(filehandle!=INVALID_HANDLE)
        {
         Print("Writing file to empty");
         FileWrite(filehandle,"");
         FileClose(filehandle);
         fileLastEmpty=true;
         emptyStruct();
        }
      else
        {
         Print("File handler issue:",GetLastError());
        }

     }
   else
     {
      bool updationReq=checkOrderUpdate();
      if(updationReq || fileHandlerIssue)
        {
         filehandle=FileOpen("COF.csv",FILE_WRITE|FILE_CSV|FILE_COMMON);
         if(filehandle!=INVALID_HANDLE)
           {
            fileHandlerIssue=false;
            for(int i = PositionsTotal()-1 ; i >= 0 ; i--)
              {
               ulong ticket = PositionGetTicket(i);
               if(PositionSelectByTicket(ticket))
                 {
                  if(((useMinimumLot && (PositionGetDouble(POSITION_VOLUME) > minimumLot))||!useMinimumLot) &&
                     ((useMaximumLot && (PositionGetDouble(POSITION_VOLUME) < maximumLot)) || !useMaximumLot))
                    {
                     string time = TimeToString(PositionGetInteger(POSITION_TIME)-gmtDifference,TIME_DATE|TIME_SECONDS);
                     string symbol = PositionGetString(POSITION_SYMBOL);
                     double digits=getDoubleSymbolInfo(symbol,"digits");

                     int symbolContractSize=(int)getDoubleSymbolInfo(symbol,"contract");

                     ulong tempTicket = PositionGetInteger(POSITION_TICKET);

                     if(suffix != "")
                        symbol = StringSubstr(symbol, 0, StringFind(symbol, suffix, 0));
                     if(prefix != "")
                        StringReplace(symbol, prefix, "");


                     long orderType = PositionGetInteger(POSITION_TYPE);
                     double takeProfit = PositionGetDouble(POSITION_TP), stopLoss = PositionGetDouble(POSITION_SL);
                     if(doReversal)
                       {
                        if(orderType == POSITION_TYPE_BUY)
                           orderType = POSITION_TYPE_SELL;
                        else
                           if(orderType == POSITION_TYPE_SELL)
                              orderType = POSITION_TYPE_BUY;

                        takeProfit = PositionGetDouble(POSITION_SL);
                        stopLoss = PositionGetDouble(POSITION_TP);
                       }

                     string OrderToWrite = time+","+symbol+","+IntegerToString(orderType)+","+DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN), (int)digits)+","+DoubleToString(PositionGetDouble(POSITION_VOLUME),2)+","+DoubleToString(stopLoss,(int) digits)+","+DoubleToString(takeProfit, (int) digits)+","+IntegerToString(PositionGetInteger(POSITION_TICKET))+","+IntegerToString(PositionGetInteger(POSITION_MAGIC))+","+(string)AccountInfoDouble(ACCOUNT_BALANCE)+","+(string)SymbolInfoDouble(PositionGetString(POSITION_SYMBOL),SYMBOL_TRADE_CONTRACT_SIZE)+PositionGetString(POSITION_COMMENT)+"\r\n";

                     FileWrite(filehandle,OrderToWrite);
                    }
                 }
              }

            for(int i = OrdersTotal()-1 ; i >= 0 ; i--)
              {
               ulong ticket = OrderGetTicket(i);
               if(OrderSelect(ticket))
                 {
                  if(((useMinimumLot && (OrderGetDouble(ORDER_VOLUME_CURRENT) > minimumLot))||!useMinimumLot) &&
                     ((useMaximumLot && (OrderGetDouble(ORDER_VOLUME_CURRENT) < maximumLot))||!useMaximumLot))
                    {
                     string time = TimeToString(OrderGetInteger(ORDER_TIME_SETUP)-gmtDifference,TIME_DATE|TIME_SECONDS);
                     string symbol = OrderGetString(ORDER_SYMBOL);
                     double digits=getDoubleSymbolInfo(symbol,"digits");

                     int symbolContractSize=(int)getDoubleSymbolInfo(symbol,"contract");

                     ulong tempTicket = OrderGetInteger(ORDER_TICKET);

                     if(suffix != "")
                        symbol = StringSubstr(symbol, 0, StringFind(symbol, suffix, 0));
                     if(prefix != "")
                        StringReplace(symbol, prefix, "");

                     long orderType = OrderGetInteger(ORDER_TYPE);
                     double takeProfit = OrderGetDouble(ORDER_TP), stopLoss = OrderGetDouble(ORDER_SL);

                     if(doReversal)
                       {
                        if(orderType == ORDER_TYPE_BUY_STOP)
                           orderType = ORDER_TYPE_SELL_LIMIT;
                        else
                           if(orderType == ORDER_TYPE_SELL_STOP)
                              orderType = ORDER_TYPE_BUY_LIMIT;
                           else
                              if(orderType == ORDER_TYPE_BUY_LIMIT)
                                 orderType = ORDER_TYPE_SELL_STOP;
                              else
                                 if(orderType == ORDER_TYPE_SELL_LIMIT)
                                    orderType = ORDER_TYPE_BUY_STOP;

                        takeProfit = OrderGetDouble(ORDER_SL);
                        stopLoss = OrderGetDouble(ORDER_TP);
                       }


                     string OrderToWrite = time+","+symbol+","+IntegerToString(orderType)+","+DoubleToString(OrderGetDouble(ORDER_PRICE_OPEN), (int)digits)+","+DoubleToString(OrderGetDouble(ORDER_VOLUME_CURRENT),2)+","+DoubleToString(stopLoss,(int) digits)+","+DoubleToString(takeProfit, (int) digits)+","+IntegerToString(OrderGetInteger(ORDER_TICKET))+","+IntegerToString(OrderGetInteger(ORDER_MAGIC))+","+(string)AccountInfoDouble(ACCOUNT_BALANCE)+","+(string)SymbolInfoDouble(OrderGetString(ORDER_SYMBOL),SYMBOL_TRADE_CONTRACT_SIZE)+OrderGetString(ORDER_COMMENT)+"\r\n";
                     Print("Writing Pending Order Block.");
                     FileWrite(filehandle,OrderToWrite);
                    }
                 }
              }
            FileClose(filehandle);
            fileLastEmpty=false;
            Print("File Updated:",TimeCurrent());
           }
         else
           {
            Print("File Handle Issue: ", GetLastError());
           }
        }
      else
        {
         if(counter>=count1 && TerminalInfoInteger(TERMINAL_CONNECTED))
           {

            if(testCounterVar>=testCounter)
              {
               testCounterVar=0;
              }
            adminHeartBeat();
            counter=0;

           }
         counter++;
         testCounterVar++;
        }

     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void adminHeartBeat()
  {

   string headers = "apikey:"+localApiKey+"\r\naccept: */* \r\nContent-Type: application/json\r\nUser-Agent: MetaTraderApi";

   string url =localHB_req_link;// Request_link+(string)accountNumber;

   bool isPost;
   int timeout = 100000;
   string lastConnected=TimeToString(TimeCurrent());

   StringReplace(lastConnected,".","-");
   StringReplace(lastConnected," ","T");
   string gmtTime=TimeToString(TimeGMT());

   string jsonData="{\"mLogin\":\""+(string)accountNumber+"\",\"mServer\":\""+masterServer+"\",\"mVersion\":\"5\" ,\"sLogin\":\""+slaveId+"\",\"sServer\":\""+slaveServer+"\",\"sVersion\":\""+slaveVersion+"\" ,\"mLastConnected\":\""+gmtTime+"\"}";//\",\"url\":"+"\""+url+"\""+headers+"}";

   uchar data[];
   StringToCharArray(jsonData, data, 0, StringLen(jsonData));


// Print("Making the heart beat request to the local host");
   POST_function(url,headers,timeout,data,isPost);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool POST_function(string url, string headers, int timeout, uchar &data[], bool &IsPost)
  {
   ResetLastError();              // clear previous error
   static int lastErrorPrinted = 0;
   uchar result[];                // use uchar for WebRequest result
   string resultHeaders;

   int res = WebRequest("POST", url, headers, timeout, data, result, resultHeaders);

   if(res == 200 || res == 201)
     {
      Print("***Request success. HTTP response code POST: ", res);
      string result_string = CharArrayToString(result);
      Print("content POST: ", result_string);
      lastErrorPrinted = 0;       // reset remembered error on success
      IsPost = true;
      return true;
     }
   else
     {
      int err = GetLastError();   // read the error once
      // only print when there's a real error and it's different from last time
      if(err != 0 && err != lastErrorPrinted)
        {
         Print("Get last error: ", err);
         Print("***Request failed. HTTP response code: ", res);
         string result_string = CharArrayToString(result);
         Print("content: ", result_string);
         lastErrorPrinted = err;  // remember this error so we don't spam it
        }
      IsPost = false;
      return false;
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void removeDeleteOrderMaster()
  {
   for(int i=0; i<orderCount; i++)
     {
      bool isPresent=false;
      if(mod1[i].ticket!=-1)
        {
         for(int j = PositionsTotal()-1; j>=0; j--)
           {
            ulong ticket = PositionGetTicket(j);
            if(PositionSelectByTicket(ticket))
              {
               if(ticket==mod1[i].ticket)
                 {
                  isPresent=true;
                 }
              }
           }
         if(!isPresent)
           {
            Print("The order ticket:",mod1[i].ticket," found no more");
            //delete from list
            mod1[i].ticket=-1;
           }
        }


     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool checkorderpips(double openPrice,int type,string symbol)
  {
   double points = inpPips*10*SymbolInfoDouble(symbol,SYMBOL_POINT);
   if(type == 0)
     {
      if(SymbolInfoDouble(symbol,SYMBOL_ASK) - openPrice > points)
        {
         return true;
        }
     }
   else
     {
      if(openPrice - SymbolInfoDouble(symbol,SYMBOL_BID) > points)
        {
         return true;
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool isOrderThere(ulong ticket,int &index)
  {
   for(int i=0; i<ArraySize(mod1); i++)
     {
      if(ticket != -1)
        {
         if(mod1[i].ticket==ticket)
           {
            index=i;
            return true;
           }
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool addOrderMaster(ulong ticket, string calledBy)
  {
   for(int i=0; i<ArraySize(mod1); i++)
     {
      if(mod1[i].ticket==-1)
        {

         if(calledBy == "Market")
           {
            //ulong ticket = PositionGetTicket(orderTicket);
            if(PositionSelectByTicket(ticket))
              {
               //Symbol Updation
               string symbol=PositionGetString(POSITION_SYMBOL);
               if(suffix!="")
                  symbol = StringSubstr(symbol,0,StringFind(PositionGetString(POSITION_SYMBOL),suffix,0));
               if(prefix!="")
                  StringReplace(symbol,prefix,"");

               //Digits
               double digits=getDoubleSymbolInfo(PositionGetString(POSITION_SYMBOL),"digits");

               //time
               datetime time = (datetime)(PositionGetInteger(POSITION_TIME)-gmtDifference);

               mod1[i].opentime=time;
               mod1[i].symbol=symbol;
               mod1[i].ordertype=PositionGetInteger(POSITION_TYPE);
               mod1[i].price=NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN),(int)digits);
               mod1[i].lots=NormalizeDouble(PositionGetDouble(POSITION_VOLUME),2);
               mod1[i].stoploss=NormalizeDouble(PositionGetDouble(POSITION_SL),(int)digits);
               mod1[i].takeprofit=NormalizeDouble(PositionGetDouble(POSITION_TP),(int)digits);
               mod1[i].ticket=PositionGetInteger(POSITION_TICKET);
               mod1[i].magic=(int)PositionGetInteger(POSITION_MAGIC);
               mod1[i].comment=PositionGetString(POSITION_COMMENT);
               Print("Ticket:",PositionGetInteger(POSITION_TICKET)," stored in index:",i);
               return true;
              }
           }
         if(calledBy == "Pending")
           {
            if(OrderSelect(ticket))
              {
               string symbol = OrderGetString(ORDER_SYMBOL);
               if(suffix!="")
                  symbol = StringSubstr(symbol,0,StringFind(OrderGetString(ORDER_SYMBOL),suffix,0));
               if(prefix!="")
                  StringReplace(symbol,prefix,"");

               //Digits
               double digits=getDoubleSymbolInfo(OrderGetString(ORDER_SYMBOL),"digits");

               //time
               datetime time = (datetime)(OrderGetInteger(ORDER_TIME_SETUP) - gmtDifference);

               mod1[i].opentime=time;
               mod1[i].symbol=symbol;
               mod1[i].ordertype=OrderGetInteger(ORDER_TYPE);
               mod1[i].price=NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN),(int)digits);
               mod1[i].lots=NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT),2);
               mod1[i].stoploss=NormalizeDouble(OrderGetDouble(ORDER_SL),(int)digits);
               mod1[i].takeprofit=NormalizeDouble(OrderGetDouble(ORDER_TP),(int)digits);
               mod1[i].ticket=OrderGetInteger(ORDER_TICKET);
               mod1[i].magic=(int)OrderGetInteger(ORDER_MAGIC);
               mod1[i].comment=OrderGetString(ORDER_COMMENT);
               Print("Ticket: ",OrderGetInteger(ORDER_TICKET)," stored in index by pending order:",i);
               return true;
              }
           }
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void emptyStruct()
  {
   for(int i = 0 ; i < orderCount ; i++)
     {
      if(mod1[i].ticket != -1)
        {
         mod1[i].ticket=-1;
         mod1[i].price=-1;
         mod1[i].symbol="";
         mod1[i].ordertype=-1;
         mod1[i].lots=0;
         mod1[i].stoploss=0;
         mod1[i].takeprofit=0;
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool checkOrderUpdate()
  {
   bool updationRequired=false,currCheck=false;
   for(int i = PositionsTotal()-1 ; i >= 0 ; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
        {
         int orderIndex=-1;
         bool alreadyAdded=isOrderThere(ticket, orderIndex);
         if(!alreadyAdded)
           {
            currCheck=false;
            currCheck=addOrderMaster(ticket, "Market");
            if(!updationRequired)
               updationRequired=currCheck;
           }
         else
           {
            if(orderIndex!=-1)
              {
               currCheck=false;
               currCheck=IsOrderChanged(PositionGetInteger(POSITION_TICKET),orderIndex, "Market");
               if(!updationRequired)
                 {
                  updationRequired=currCheck;
                 }
              }
           }
        }
     }


   for(int i = OrdersTotal()-1 ; i >= 0 ; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(OrderSelect(ticket))
        {
         if(OrderGetInteger(ORDER_TYPE) != ORDER_TYPE_BUY && OrderGetInteger(ORDER_TYPE) != ORDER_TYPE_SELL && OrderGetInteger(ORDER_TYPE) != ORDER_TYPE_CLOSE_BY)
           {
            int orderIndex=-1;
            bool alreadyAdded=isOrderThere(ticket, orderIndex);
            if(!alreadyAdded)
              {
               Print("Inside pending Adding to master order: ",ticket," type: ",OrderGetInteger(ORDER_TYPE)," ",OrdersTotal()," ",ORDER_TYPE_CLOSE_BY);
               currCheck=false;
               currCheck=addOrderMaster(ticket, "Pending");
               if(!updationRequired)
                  updationRequired=currCheck;
              }
            else
              {
               if(orderIndex!=-1)
                 {
                  currCheck=false;

                  currCheck=IsOrderChanged(OrderGetInteger(ORDER_TICKET), orderIndex, "Pending");
                  if(!updationRequired)
                    {
                     updationRequired=currCheck;
                    }
                 }
              }
           }
        }
     }

   for(int i=0; i<ArraySize(mod1); i++)
     {
      bool isPresent=false;
      if(mod1[i].ticket !=-1)
        {
         for(int j = PositionsTotal()-1; j>=0; j--)
           {
            ulong ticket = PositionGetTicket(j);
            if(PositionSelectByTicket(ticket))
              {
               if(ticket==mod1[i].ticket)
                 {
                  isPresent=true;
                  break;
                 }
              }
           }
         // Pending Order
         for(int j = OrdersTotal()-1; j>=0; j--)
           {
            ulong ticket = OrderGetTicket(j);
            if(OrderSelect(ticket))
              {
               if(ticket==mod1[i].ticket)
                 {
                  isPresent=true;
                  break;
                 }
              }
           }

         if(!isPresent)
           {
            Print("Ticket is closed so removed from struct: ",mod1[i].ticket);
            mod1[i].ticket=-1;
            mod1[i].price=-1;
            mod1[i].symbol="";
            mod1[i].ordertype=-1;
            mod1[i].lots=0;
            mod1[i].stoploss=0;
            mod1[i].takeprofit=0;
            currCheck=true;
            //currCheck=clearStructIndex(mod1[i].ticket);
            if(!updationRequired)
               updationRequired=currCheck;
           }
        }
     }
   return updationRequired;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool clearStructIndex(ulong ticket)
  {
   for(int index=0; index<ArraySize(mod1); index++)
     {
      if(mod1[index].ticket == ticket)
        {
         mod1[index].ticket=-1;
         mod1[index].price=-1;
         mod1[index].symbol="";
         mod1[index].ordertype=-1;
         mod1[index].lots=0;
         mod1[index].stoploss=0;
         mod1[index].takeprofit=0;
         Print("Clear Structure Called. ");
         return true;
        }
     }

   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsOrderChanged(ulong orderTicket, int index, string calledBy)
  {
   if(mod1[index].ticket!=-1)
     {
      if(calledBy == "Market")
        {

         if(PositionSelectByTicket(orderTicket))
           {
            //Digits
            double digits=getDoubleSymbolInfo(PositionGetString(POSITION_SYMBOL),"digits");

            double tp=NormalizeDouble(PositionGetDouble(POSITION_TP), (int)digits),
                   sl=NormalizeDouble(PositionGetDouble(POSITION_SL),(int)digits),
                   lot=NormalizeDouble(PositionGetDouble(POSITION_VOLUME),2);

            if(mod1[index].takeprofit!=tp || mod1[index].stoploss != sl || mod1[index].lots!=lot || mod1[index].ordertype!=PositionGetInteger(POSITION_TYPE) || mod1[index].price != PositionGetDouble(POSITION_PRICE_OPEN))
              {
               Print(" Inside IsOrderChanged() ",mod1[index].lots," lot: ",lot," calledBy: ",calledBy," mod1 ticket ",mod1[index].ticket," orderTicket: ",orderTicket);
               // Time
               datetime time = (datetime)(PositionGetInteger(POSITION_TIME) - gmtDifference);
               mod1[index].opentime=time;
               mod1[index].lots=lot;
               mod1[index].stoploss=sl;
               mod1[index].takeprofit=tp;
               mod1[index].comment=PositionGetString(POSITION_COMMENT);
               mod1[index].ordertype=PositionGetInteger(POSITION_TYPE);
               mod1[index].price=PositionGetDouble(POSITION_PRICE_OPEN);
               return true;
              }

           }
        }
      if(calledBy == "Pending")
        {
         if(OrderSelect(orderTicket))
           {
            double digits=getDoubleSymbolInfo(OrderGetString(ORDER_SYMBOL),"digits");

            double tp=NormalizeDouble(OrderGetDouble(ORDER_TP), (int)digits),
                   sl=NormalizeDouble(OrderGetDouble(ORDER_SL),(int)digits),
                   lot=NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT),2);

            if(mod1[index].takeprofit!=tp || mod1[index].stoploss != sl || mod1[index].lots!=lot || mod1[index].ordertype!=OrderGetInteger(ORDER_TYPE) || mod1[index].price != OrderGetDouble(ORDER_PRICE_OPEN))
              {
               //time
               datetime time = (datetime)(OrderGetDouble(ORDER_PRICE_OPEN) - gmtDifference);
               mod1[index].opentime=time;
               mod1[index].lots=lot;
               mod1[index].stoploss=sl;
               mod1[index].takeprofit=tp;
               mod1[index].comment=OrderGetString(ORDER_COMMENT);
               mod1[index].ordertype=OrderGetInteger(ORDER_TYPE);
               mod1[index].price=OrderGetDouble(ORDER_PRICE_OPEN);
               return true;
              }
           }
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double getlot(double stop_loss)
  {
   Print("Tick Value: ",SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE));
   Print("Tick Size: ",SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE));
   double modeTickV=SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE)
                    ,modeTickS=SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE);
// Print("Pip value: ", NormalizeDouble(((SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE)/(SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE)/Point))*10),2));
   double pipvalue = NormalizeDouble(((SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE)/(SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE)/Point()))*10),2);
// pipvalue=NormalizeDouble((modeTickV/modeTickS/Point()),)
// pipvalue=
   pipvalue = pipvalue / 10;
   double lotSize = lot_size;
   if(lot_calculator==rsk) //calculating risk
     {
      double riskamount=(risk/100)*AccountInfoDouble(ACCOUNT_BALANCE);
      double pipvalue_required=riskamount/stop_loss;
      lotSize = pipvalue_required/pipvalue;
      //sl=riskamount/pipValuelot
      int roundDigit=0;
      double step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);

      while(step<1)
        {
         roundDigit++;
         step=step*10;
        }
      Print("Round Digits:",roundDigit);
      lotSize = NormalizeDouble(lotSize,roundDigit);
      //
     }
   Print("Lot Size: ",lotSize);

   if(lotSize > SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX))
     {
      lotSize=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
     }
   else
      if(lotSize<SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN))
        {
         lotSize=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
        }

//---
   return lotSize;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double getDoubleSymbolInfo(string symbol,string info)
  {
   long digits=8;
//Symbol without the suffix and prefix
   string updatedSymbol=symbol;
   if(suffix!="")
      updatedSymbol = StringSubstr(updatedSymbol,0,StringFind(updatedSymbol,suffix,0));
   if(prefix!="")
      StringReplace(updatedSymbol,prefix,"");

//Digits calculation could be used in other calculations
   digits = SymbolInfoInteger(symbol,SYMBOL_DIGITS);
   if(digits==0)
     {
      digits=SymbolInfoInteger(updatedSymbol,SYMBOL_DIGITS);
      if(digits==0)
         digits=8;
     }

   if(info=="digits")
     {
      return (double)digits;
     }
   else
      if(info=="point" || info=="points")
        {
         double points=SymbolInfoDouble(symbol, SYMBOL_POINT);
         if(points==0)
           {
            points=SymbolInfoDouble(updatedSymbol,SYMBOL_POINT);
            if(points==0)
               points=0.00001;


           }
         return points;
        }
      else
         if(info=="ask")
           {
            double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
            if(ask==0)
              {
               ask=SymbolInfoDouble(updatedSymbol,SYMBOL_ASK);
              }
            return NormalizeDouble(ask,(int)digits);
           }
         else
            if(info=="bid")
              {
               double bid=SymbolInfoDouble(symbol, SYMBOL_BID);
               if(bid==0)
                 {
                  bid=SymbolInfoDouble(updatedSymbol,SYMBOL_BID);
                 }
               return NormalizeDouble(bid,(int)digits);
              }
            else
               if(info=="contract"||info=="contractSize")
                 {
                  double contract=SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE);
                  if(contract==0)
                    {
                     contract=SymbolInfoDouble(updatedSymbol,SYMBOL_TRADE_CONTRACT_SIZE);
                    }
                  return contract;
                 }

   return 0;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void placeBuyTrade()
  {

   double buySL = 0, buyTp=0;
//openPrice = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
   double Ask = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
   double Bid = SymbolInfoDouble(Symbol(),SYMBOL_BID);

   if(stoplossTrade != 0)
     {
      buySL = Ask - (stoplossTrade * 10 * Point());
     }
   if(takeprofitTrade != 0)
     {
      buyTp = Ask + (takeprofitTrade * 10 * Point());
     }

   double sl_distance = ((Ask - buySL) / Point());
   if(trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,getlot(sl_distance),Ask,buySL,buyTp,"Buy Trade Placed"))
     {
      Print("Buy Trade Placed: ",trade.ResultOrder());
     }
   else
     {
      Print("Error in placing Buy: "+Symbol()+"  ",GetLastError());
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void placeSellTrade()
  {

   double sellSL = 0, sellTp = 0;
//openPrice = SymbolInfoDouble(Symbol(),SYMBOL_BID);
   double Ask = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
   double Bid = SymbolInfoDouble(Symbol(),SYMBOL_BID);

   if(stoplossTrade != 0)
     {
      sellSL = Bid + (stoplossTrade * 10 * Point());
     }
   if(takeprofitTrade != 0)
     {
      sellTp = Bid - (takeprofitTrade * 10 * Point());
     }
   double sl_distance  = ((sellSL - Bid) / Point());
   if(trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,getlot(sl_distance),Bid,sellSL,sellTp,"Sell Trade Placed"))
     {
      Print("Sell Trade PLaced: ",trade.ResultOrder());
     }
   else
     {
      Print("Error in placing Sell: "+Symbol()+"  ",GetLastError());
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void dashboard_data()
  {
   ExtDialog.m_label0.Text(" Master Trades Lots Calc: " + DoubleToString(totalLiveLots(), 2));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double totalLiveLots()
  {
   double total_lots = 0.0;

   for(int i = 0; i < PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
        {
         //if(PositionGetInteger(POSITION_MAGIC) == magic_no)
           {
            //if(PositionGetString(POSITION_SYMBOL) == Symbol())
              {
               int type = (int)PositionGetInteger(POSITION_TYPE);
               if(type == POSITION_TYPE_BUY || type == POSITION_TYPE_SELL)
                 {
                  total_lots += PositionGetDouble(POSITION_VOLUME);
                 }
              }
           }
        }
     }
   return total_lots;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void store_live_and_history_tickets()
  {
// cutoff time = now - N days
   datetime cutoff = (datetime)(TimeCurrent() - (datetime)daysOfTradesToAdd * 86400);

// --- history orders loop (closed / cancelled / executed orders) ---
// select history for the required period
   if(HistorySelect(cutoff, TimeCurrent()))
     {
      int deals_count = (int)HistoryDealsTotal();
      for(int j = deals_count - 1; j >= 0; --j)
        {
         ulong deal_ticket = HistoryDealGetTicket(j);
         if(deal_ticket == 0)
            continue;

         // deal execution time
         long dealTime = (long)HistoryDealGetInteger(deal_ticket, DEAL_TIME);
         if((datetime)dealTime < cutoff)
            continue; // older than cutoff, skip

         // position id related to this deal (the stored "ticket" you track)
         long position_id = (long)HistoryDealGetInteger(deal_ticket, DEAL_POSITION_ID);
         if(position_id <= 0)
            continue; // no position id to store

         if(HistoryDealGetInteger(deal_ticket, DEAL_ENTRY) != DEAL_ENTRY_IN)
            continue;

         ulong ticket = position_id;
         ulong magic  = HistoryDealGetInteger(deal_ticket, DEAL_MAGIC);
         double dealInLot = HistoryDealGetDouble(deal_ticket, DEAL_VOLUME);

         double dealOutLot = dealOutLotsCheck(cutoff, position_id);
         if(dealInLot == dealOutLot)
            if(!history_ticket_present(ticket))
              {
               Print(" Position Id: ", position_id," Deal In Lot: ", dealInLot, " Deal Out Lot: ", dealOutLot);
               add_history_ticket(ticket, magic);
              }
        }
     }
   else
     {
      // optional: failed to select history — you may handle/log if needed
      // Print("HistorySelect failed. LastError=", GetLastError());
     }

   int ordersTotal=HistoryOrdersTotal();
   ulong orderTicket=0;
   for(int j=0; j<ordersTotal; j++)
     {
      orderTicket=HistoryOrderGetTicket(j);
      long type=HistoryOrderGetInteger(orderTicket,ORDER_TYPE);
      if(type==ORDER_TYPE_BUY_LIMIT || type==ORDER_TYPE_SELL_LIMIT || type==ORDER_TYPE_BUY_STOP
         || type==ORDER_TYPE_SELL_STOP ||type==ORDER_TYPE_BUY_STOP_LIMIT || type==ORDER_TYPE_SELL_STOP_LIMIT)
        {
         long state=HistoryOrderGetInteger(orderTicket,ORDER_STATE);
         if(state==ORDER_STATE_CANCELED || state==ORDER_STATE_REJECTED || state==ORDER_STATE_EXPIRED || state==ORDER_STATE_REQUEST_CANCEL)
           {
            datetime openTime = (datetime)HistoryOrderGetInteger(orderTicket, ORDER_TIME_SETUP);

            if(openTime >= cutoff)
              {
               ulong magic  = HistoryOrderGetInteger(orderTicket, ORDER_MAGIC);

               if(!history_ticket_present(orderTicket))
                 {
                  add_history_ticket(orderTicket, magic);
                 }
              }
           }
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double dealOutLotsCheck(datetime cutOffTimeIs, ulong positionId)
  {
   double sumOfLots = 0.0;

   if(HistorySelect(cutOffTimeIs, TimeCurrent()))
     {
      int totalDeals = HistoryDealsTotal();

      for(int i = 0; i < totalDeals; i++)
        {
         ulong dealTicket      = HistoryDealGetTicket(i);
         ulong dealPositionID  = (ulong)HistoryDealGetInteger(dealTicket, DEAL_POSITION_ID);

         if(HistoryDealGetInteger(dealTicket, DEAL_ENTRY) == DEAL_ENTRY_OUT
            && dealPositionID == positionId)
           {
            sumOfLots += HistoryDealGetDouble(dealTicket, DEAL_VOLUME);
           }
        }
     }

   return sumOfLots;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool history_ticket_present(ulong ticket)
  {
   for(int i = 0 ; i < MaxOrders ; i++)
     {
      if(historyTradeStore[i].ticket == ticket)
         return true;
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void add_history_ticket(ulong ticket, ulong magicIs)
  {
   for(int i = 0; i < MaxOrders; i++)
     {
      if(historyTradeStore[i].ticket == -1)
        {
         historyTradeStore[i].ticket = ticket;
         historyTradeStore[i].magic  = magicIs;
         Print("Ticket Added to History Structure. Ticket: ", ticket, " Magic: ", magicIs);
         save_history_store("add_history_ticket()");
         return;
        }
     }
   Print("historyTradeStore full, cannot add ticket: ", ticket);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void clear_history_store()
  {
   for(int i = 0; i < MaxOrders; i++)
     {
      historyTradeStore[i].ticket = -1;
      historyTradeStore[i].magic  = 0;
     }
   Print("History store cleaned");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void save_history_store(string calledBy)
  {
   string file_nameIs = "history_trades.csv";
   int fileHandle = FileOpen(file_nameIs, FILE_WRITE | FILE_CSV | FILE_COMMON);

   if(fileHandle != INVALID_HANDLE)
     {
      for(int i = 0; i < MaxOrders; i++)
        {
         if(historyTradeStore[i].ticket != -1)
           {
            string data_to_store = IntegerToString(historyTradeStore[i].ticket) + "," + IntegerToString(historyTradeStore[i].magic) + "\r\n";
            FileWriteString(fileHandle, data_to_store);
           }
        }

      //Print("save_history_store() called by: ", calledBy, " Time: ", TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS));
      FileClose(fileHandle);
     }
   else
     {
      Print("Error opening file save_history_store(): ", GetLastError());
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void remove_old_tickets_from_store()
  {
   datetime cutoff = TimeCurrent() - (datetime)daysOfTradesToAdd * 86400;
// Print("remove_old_tickets_from_store: cutoff = ", TimeToString(cutoff, TIME_DATE|TIME_SECONDS));

// Prepare history selection ranges once (for deals we limit by cutoff; for orders we select full history)

   for(int i = 0; i < MaxOrders; i++)
     {
      ulong tk = historyTradeStore[i].ticket;
      if(tk == -1) // empty slot
         continue;

      bool found = false;
      ulong pos_ticket = (ulong)tk;

      if(HistorySelect(cutoff, TimeCurrent()))
        {
         int deals_count = (int)HistoryDealsTotal();
         for(int j = deals_count - 1; j >= 0; --j)
           {
            ulong deal_ticket = HistoryDealGetTicket(j);
            if(deal_ticket == 0)
               continue;

            // deal execution time
            long dealTime = (long)HistoryDealGetInteger(deal_ticket, DEAL_TIME);
            if((datetime)dealTime < cutoff)
               continue; // older than cutoff, skip

            if(HistoryDealGetInteger(deal_ticket, DEAL_ENTRY) != DEAL_ENTRY_IN)
               continue;

            // position id related to this deal (the stored "ticket" you track)
            long position_id = (long)HistoryDealGetInteger(deal_ticket, DEAL_POSITION_ID);
            if(position_id <= 0)
               continue; // no position id to store
            double dealInLot = HistoryDealGetDouble(deal_ticket, DEAL_VOLUME);

            double dealOutLot = dealOutLotsCheck(cutoff, position_id);
            if(dealInLot == dealOutLot)
               if(position_id == pos_ticket)
                 {
                  found = true;
                  break;
                 }
           }
        }
      else
        {
         // optional: failed to select history — you may handle/log if needed
         // Print("HistorySelect failed. LastError=", GetLastError());
        }

      if(!found)
        {
         int ordersTotal = HistoryOrdersTotal();
         for(int j = 0; j < ordersTotal; j++)
           {
            ulong orderTicket = HistoryOrderGetTicket(j);
            if(orderTicket == 0)
               continue;

            long type = HistoryOrderGetInteger(orderTicket, ORDER_TYPE);
            if(type != ORDER_TYPE_BUY_LIMIT && type != ORDER_TYPE_SELL_LIMIT &&
               type != ORDER_TYPE_BUY_STOP  && type != ORDER_TYPE_SELL_STOP)
               continue;

            datetime openTime = (datetime)HistoryOrderGetInteger(orderTicket, ORDER_TIME_SETUP);
            long state=HistoryOrderGetInteger(orderTicket,ORDER_STATE);
            if(state==ORDER_STATE_CANCELED || state==ORDER_STATE_REJECTED || state==ORDER_STATE_EXPIRED || state==ORDER_STATE_REQUEST_CANCEL)
              {
               if(orderTicket == pos_ticket)
                 {
                  if(openTime > cutoff)
                    {
                     found = true;
                     break;
                    }
                 }
              }
           }
        }


      // 3) Final action: remove if not found
      if(!found)
        {
         Print("Ticket not found, removing from store: ", tk, " index=", i);
         historyTradeStore[i].ticket = -1;
         historyTradeStore[i].magic  = 0;
         // (optionally clear other fields if your struct has them)
        }
     } // for i
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//================================================ Dashboard ====================================
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CControlsDialog : public CAppDialog
  {
public:

   CLabel            m_label0;

   CButton           m_button;
   CButton           m_button1;

                     CControlsDialog(void);
                    ~CControlsDialog(void);
   //--- create
   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);

   bool              CreateLabel0(void);

   bool              CreateButton(void);
   bool              CreateButton1(void);

   void              OnClickButton(void);
   void              OnClickButton1(void);

   bool              CreatePanel(void);

  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
EVENT_MAP_BEGIN(CControlsDialog)
ON_EVENT(ON_CLICK,m_button,OnClickButton)
ON_EVENT(ON_CLICK,m_button1,OnClickButton1)
EVENT_MAP_END(CAppDialog)
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CControlsDialog::CControlsDialog(void)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CControlsDialog::~CControlsDialog(void)
  {
  }

//+------------------------------------------------------------------+
//| Create                                                           |
//+------------------------------------------------------------------+
bool CControlsDialog::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,20,20,dashWidth,dashHeight))
      return(false);
//--- create dependent controls

   if(!CreatePanel())
      return(false);

   if(!CreateLabel0())
      return(false);

   if(!CreateButton())
      return(false);
   if(!CreateButton1())
      return(false);

//--- succeed
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CControlsDialog::CreateLabel0(void)  //Trend Info
  {
//--- coordinates
   int x1 = (dashWidth/2) - 235;
   int y1 = yAxisGlobal + 15;
   int x2 = 0;
   int y2 = 0;
//--- create
   if(!m_label0.Create(m_chart_id,m_name+"Label0",m_subwin,x1,y1,x2,y2))
      return(false);
   if(!m_label0.Text(" Master Trades Lots Calc: 0.00"))
      return(false);
   if(!m_label0.Color(clrBlack))
      return(false);
   if(!m_label0.Font("Calibri"))
      return(false);
   if(!m_label0.FontSize(FontSize))
      return(false);
   if(!Add(m_label0))
      return(false);
//--- succeed
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CControlsDialog::CreateButton(void)
  {
//--- coordinates
// Buy
   int x1 = (dashWidth/2) + 14;
   int y1 = yAxisGlobal + 10;
   int x2 = x1 + 70;
   int y2 = y1 + 30;
//--- create
   if(!m_button.Create(m_chart_id,"button",m_subwin,x1,y1,x2,y2))
      return(false);
   if(!m_button.ColorBackground(clrSlateGray))
      return(false);
   if(!m_button.Text("Sell"))
      return(false);
   if(!m_button.FontSize(FontSize))
      return(false);
   if(!m_button.ColorBackground(clrRed))
      return(false);
   if(!m_button.Font("Calibri Bold"))
      return(false);
   if(!m_button.Color(clrWhiteSmoke))
      return(false);
   if(!m_button.ColorBorder(clrRed))
      return(false);
   if(!Add(m_button))
      return(false);
   m_button.Locking(true);
   m_button.BringToTop();
//--- succeed
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CControlsDialog::CreateButton1(void)
  {
//--- coordinates
// Sell
   int x1 = (dashWidth/2) + 100;
   int y1 = yAxisGlobal + 10;
   int x2 = x1 + 70;
   int y2 = y1 + 30;
//--- create
   if(!m_button1.Create(m_chart_id,"button1",m_subwin,x1,y1,x2,y2))
      return(false);
   if(!m_button1.ColorBackground(clrBlue))
      return(false);
   if(!m_button1.Text("Buy"))
      return(false);
   if(!m_button1.FontSize(FontSize))
      return(false);
   if(!m_button1.Font("Calibri Bold"))
      return(false);
   if(!m_button1.Color(clrWhiteSmoke))
      return(false);
   if(!m_button1.ColorBorder(clrBlack))
      return(false);
   if(!Add(m_button1))
      return(false);
   m_button1.Locking(true);
   m_button1.BringToTop();
//--- succeed
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CControlsDialog::OnClickButton(void)
  {
   if(m_button.Pressed())
     {
      Print(" Clicked on Button");
      m_button.Pressed(false);
      placeSellTrade();
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CControlsDialog::OnClickButton1(void)
  {
   if(m_button1.Pressed())
     {
      Print(" Clicked on Button 1");
      m_button1.Pressed(false);
      placeBuyTrade();
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CControlsDialog::CreatePanel(void)
  {
//--- coordinates
   int x1=0;
   int y1=0;
   int x2=dashWidth;
   int y2=dashHeight;
//--- create
   if(!backgroundPanel.Create(0,ExtDialog.Name()+"backPanel",m_subwin,x1,y1,x2,y2))
      return(false);
   if(!backgroundPanel.ColorBackground(clrWhiteSmoke))
      return(false);
   if(!backgroundPanel.ColorBorder(00128))
      return(false);
   if(!ExtDialog.Add(backgroundPanel))
      return(false);
   ExtDialog.Minimized(false);


   backgroundPanel.Alignment(WND_ALIGN_CLIENT,0,0,0,0);
//--- succeed
   return(true);
  }

CControlsDialog ExtDialog;
CPanel   backgroundPanel;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+