Open Chart_v1

Author: Copyright 2018, MetaQuotes Software Corp.
0 Views
0 Downloads
0 Favorites
Open Chart_v1 
ÿþ//+------------------------------------------------------------------+

//|                                                           op.mq4 |

//|                        Copyright 2018, MetaQuotes Software Corp. |

//|                                             https://www.mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2018, MetaQuotes Software Corp."

#property link      "https://www.mql5.com"

#property version   "1.00"

#property strict

#property indicator_chart_window



#define GWL_STYLE         -16

#define WS_VSCROLL        0x00200000

#define nWS_VSCROLL       0xFFDFFFFF

#define SB_VERT           0x00000001

#define RDW_FRAME         1024

#define RDW_UPDATENOW     256

#define RDW_ERASE         4



#define WS_CAPTION        0x00C00000

#define WS_BORDER         0x00800000

#define WS_SIZEBOX        0x00040000

#define WS_DLGFRAME       0x00400000

#define SWP_NOSIZE        0x0001

#define SWP_NOMOVE        0x0002

#define SWP_NOZORDER      0x0004

#define SWP_NOACTIVATE    0x0010

#define SWP_FRAMECHANGED  0x0020

#define GW_CHILD          0x0005

#define GW_HWNDNEXT       0x0002

#define WM_MDIRESTORE     0x0223



string aSymbols[];



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

extern string Symbols = "AUDCAD;AUDCHF;AUDJPY;AUDNZD;AUDUSD;CADCHF;CADJPY;CHFJPY;"

                        "EURAUD;EURCAD;EURCHF;EURGBP;EURJPY;EURNZD;EURUSD;GBPAUD;"

                        "GBPCAD;GBPCHF;GBPJPY;GBPNZD;GBPUSD;NZDCAD;NZDCHF;NZDJPY;"

                        "NZDUSD;USDCAD;USDCHF;USDJPY;XAUUSD;XAGUSD";//List of Symbols (separate ;)



extern string KeyQuit = "Q";// Key Quit



extern int Hight = 100;//Hight Panel in Pixels



extern string D = "Minut;M5;M15;M30;H1;H4;M30*M15;M15;H1;H4;W1;M5;M30*High;H4;D1;W1;MN1;M5;M30";//Sets of TF (Name;TF1;TF2;...(separete *)) TF1 - first TF,TF2 - second TF,...



extern string B = "Two;1;1.5;3;0.4;0;0.2*One;1;2.5;1;0.2;2;0.2*Three;1;2.5;1;0.25;1;0.25";//Sets of Charts (Name;N1;N2;...(separete *)) See Web Site



extern string Temp = "Main;Minut;Two;;tmp1;tmp2;tmp3;tmp4*Big TF;High;One;;tmp1;tmp2;tmp3;tmp4;tmp";//Sets of Template (Name;TF Name;Chart Name;tmp1;tmp2;..)



extern string C = "AUD;AUDCAD;AUDCHF;AUDNZD;AUDUSD;EURAUD;GBPAUD;AUDJPY*"

                  "CAD;AUDCAD;CADCHF;CADJPY;EURCAD;GBPCAD;NZDCAD;USDCAD*"

                  "NZD;AUDNZD;EURNZD;GBPNZD;NZDCAD;NZDCHF;NZDJPY;NZDUSD*"

                  "USD;AUDUSD;EURUSD;GBPUSD;NZDUSD;USDCAD;USDCHF;USDJPY";//First String Basket Symbols



extern string E =  "CHF;AUDCHF;CADCHF;EURCHF;GBPCHF;CADCHF;NZDCHF;USDCHF*"

                   "EUR;EURAUD;EURCAD;EURCHF;EURGBP;EURJPY;EURNZD;EURUSD*"

                   "GBP;EURGBP;GBPAUD;GBPCAD;GBPCHF;GBPJPY;GBPNZD;GBPUSD*"

                   "JPY;AUDJPY;CADJPY;CHFJPY;EURJPY;GBPJPY;NZDJPY;USDJPY";//Second String Basket Symbols



extern string F =  "CF&UD;AUDCHF;CADCHF;EURCHF;GBPCHF;CADCHF;NZDCHF;"

                   "AUDUSD;EURUSD;GBPUSD;NZDUSD;USDCAD;USDCHF;USDJPY";//Third String Basket Symbols



int PrevY, CurrentProfile, CurrentCharts, CurrentBasket, CurrentTemplate;



struct SCROLLINFO

  {

   int               cbSize, fMask, nMin, nMax, nPage, nPos, nTrackPos;

  };



struct Template

  {

   int               TF, Chr;

   string            TemplateName[];

   string            A;

  };



Template Templates[];



struct Presets

  {

   int               NumberElement,TF[];

   string            A;

  };



Presets Profile[];



struct BaseChart

  {

   string            A;

   double            Metrix[6];

  };

BaseChart Charts[];



struct Basket

  {

   string            A,Basket[];

  };

Basket Baskets[];

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int TerminalY()

  {

   int iMainWindowRect[4];

   GetWindowRect(GetParent(GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE))),iMainWindowRect);

   return iMainWindowRect[3]-iMainWindowRect[1];

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int TerminalX()

  {

   int iMainWindowRect[4];

   GetWindowRect(GetParent(GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE))),iMainWindowRect);

   return iMainWindowRect[2]-iMainWindowRect[0];

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void SetScroll(int i,bool Draw)

  {

   int hWindow =  GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE));

   int iNewStyle = GetWindowLongA(hWindow, GWL_STYLE) | (WS_VSCROLL);

   if(hWindow>0 && iNewStyle>0)

     {

      SetWindowLongA(hWindow, GWL_STYLE, iNewStyle);

      SetScrollRange(hWindow, SB_VERT, 0, i, true);

      SetScrollPos(hWindow, SB_VERT, 0, true);

     }

   if(!Draw)

      return;

   int IK[4];

   GetWindowRect(hWindow,IK);

   MoveWindow(hWindow, 0, 0, IK[2]=IK[2]-IK[0], (IK[3]=IK[3]-IK[1])-1,true);

   MoveWindow(hWindow, 0, 0, IK[2], IK[3],true);

  }



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void OnTimer()

  {

   int NextY = TerminalY();

   if(PrevY != NextY)

     {

      int hWnd=GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE));

      MoveWindow(hWnd,0,0,Hight,NextY-5,true);

      PrevY = NextY;

      SortChartsAndSetScroll();

     }

   SCROLLINFO Inf;

   Inf.cbSize = sizeof(SCROLLINFO);

   Inf.fMask = 23;

   int hWindow = GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE));



   if(hWindow>0)

     {

      GetScrollInfo(hWindow, SB_VERT, Inf);

      if(Inf.nPos!=Inf.nTrackPos)

        {

         int PrevRect[4],iMainWindowRect[4];

         GetWindowRect(GetParent(GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE))),PrevRect);



         long currChart=ChartFirst();

         while(true)

           {

            if(currChart!=ChartID())

              {

               int hWnd=GetParent((int)ChartGetInteger(currChart,CHART_WINDOW_HANDLE));

               GetWindowRect(hWnd,iMainWindowRect);

               int X=iMainWindowRect[2]-iMainWindowRect[0];

               int Y=iMainWindowRect[3]-iMainWindowRect[1];



               MoveWindow(hWnd,

                          iMainWindowRect[0]-PrevRect[0]-2,

                          iMainWindowRect[1]-PrevRect[1]-2 - Inf.nTrackPos + Inf.nPos, X, Y,true);



               ChartRedraw(currChart);

              }

            if(ChartNext(currChart)<0)

               break;

            else

               currChart=ChartNext(currChart);

           }

         SetScrollPos(hWindow, SB_VERT, Inf.nTrackPos, true);

        }

     }

  }



#import "user32.dll"

int SetWindowLongA(int hWnd,int nIndex, int dwNewLong);

int GetWindowLongA(int hWnd,int nIndex);

int GetParent(int hWnd);

int GetTopWindow(int hWnd);

int GetWindow(int hWnd, int wCmd);

int SetScrollPos(int hWnd, int  nBar, int  nPos, bool bRedraw);

bool SetScrollRange(int hWnd, int  nBar, int  nMinPos, int  nMaxPos, bool bRedraw);

bool GetScrollInfo(int hWnd, int nBar, SCROLLINFO & lpsi);

bool MoveWindow(int hWnd, int x, int y, int nWidth, int nHeight, bool bRepaint);

bool GetWindowRect(int hWnd,int &Pos[4]);

bool RedrawWindow(int hWnd,int &Pos[4],int &iPos[4],int flag);

int  SetWindowPos(int hWnd,int hWndInsertAfter,int X,int Y,int cx,int cy,int uFlags);

int  SendMessageW(int hWnd,int Msg,int wParam,int lParam);

int  PostMessageA(int hWnd,int Msg,int wParam,int lParam);

#import



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

class SymbolCharts

  {

protected:

   long              Arr[];

   int               Count;

   string            Symb;

   int               Xposition, Yposition;

public:

                     SymbolCharts() { }

   void              Resize(int All,string symbol)

     {

      ArrayFree(Arr);

      ArrayResize(Arr,All);

      Symb = symbol;

      Count = 0;

     }

   void              Update(int Position,long Number)

     {

      Arr[Position]=Number;

      Count = Position + 1;

     }

   long              GetID(int Position)

     {

      return Arr[Position];

     }

   int               GetPosition()

     {

      return Count;

     }

   string            GetSymbol()

     {

      return Symb;

     }

   void              SetPosition(int x,int y)

     {

      Xposition = x;

      Yposition = y;

     }

   int               GetX()

     {

      return Xposition;

     }

   int               GetY()

     {

      return Yposition;

     }

  };

SymbolCharts Koor[];

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int  GetIndex(SymbolCharts & FCharts[], string symbol, int ChartAll)

  {

   int FindIndex = -1;

   for(int i = ArraySize(FCharts)-1; i >= 0; i--)

      if(FCharts[i].GetSymbol()==symbol)

         return i;

   ArrayResize(FCharts,ArraySize(FCharts)+1);

   FCharts[ArraySize(FCharts)-1].Resize(ChartAll,symbol);

   return ArraySize(FCharts)-1;

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool ReChangeTemplate;

void SortChartsAndSetScroll()

  {

   if(CurrentTemplate>-1 && ReChangeTemplate)

     {

      CurrentCharts = Templates[CurrentTemplate].Chr;

      CurrentProfile = Templates[CurrentTemplate].TF;

      ReChangeTemplate = false;

     }



   int Key = (int)Charts[CurrentCharts].Metrix[0],

       FKeyYLev = (int)Charts[CurrentCharts].Metrix[2],

       SKeyYLev = (int)Charts[CurrentCharts].Metrix[4],ChartAll = FKeyYLev + SKeyYLev + 1;

   double KeyY = Charts[CurrentCharts].Metrix[1],

          FKeyXLev = FKeyYLev!=0?Charts[CurrentCharts].Metrix[3]:0,

          SKeyXLev = SKeyYLev!=0?Charts[CurrentCharts].Metrix[5]:0;



   int object = 0, TY = TerminalY(), KeyTX = (TerminalX()-Hight)/Key, Widht = int(((double)TY)/KeyY), Levels = 1;



   ArrayFree(Koor);



   for(int j = 0; j < ObjectsTotal(); j++)

      if(ObjectGetInteger(0,ObjectName(j),OBJPROP_COLOR)==clrYellow && "Sym"==StringSubstr(ObjectName(j),0,3))

        {

         long currChart=ChartFirst();

         string CurrentSymbol = ObjectGetString(0,ObjectName(j),OBJPROP_TEXT);

         int I = GetIndex(Koor, CurrentSymbol, ChartAll);

         while(true)

           {

            if(currChart!=ChartID() && ChartSymbol(currChart)==CurrentSymbol)

              {

               if(Koor[I].GetPosition() < ChartAll)

                  Koor[I].Update(Koor[I].GetPosition(),currChart);

               else

                  ChartClose(currChart);

              }



            if(ChartNext(currChart)<0)

               break;

            else

               currChart=ChartNext(currChart);

           }



         Koor[I].SetPosition(Hight + KeyTX*(object % Key),(object/Key)*Widht);

         object++;

        }



   if(object<1)

      return;



   int Shift[][4],dxf=(int)(FKeyXLev*(double)KeyTX),dxs = (int)(SKeyXLev*(double)KeyTX),

                  dyf=FKeyYLev!=0?(int)((double)Widht/FKeyYLev):0,dys = SKeyYLev!=0?(int)((double)Widht/SKeyYLev):0;



   ArrayFree(Shift);

   ArrayResize(Shift,ChartAll);



   Shift[0][0]=0;

   Shift[0][1]=0;

   Shift[0][2]=KeyTX-dxf-dxs;

   Shift[0][3]=Widht;



   for(; Levels <= FKeyYLev; Levels ++)

     {

      Shift[Levels][0]=KeyTX - dxf - dxs;

      Shift[Levels][1]=(Levels-1)*dyf;

      Shift[Levels][2]=dxf;

      Shift[Levels][3]=dyf;

     }



   for(; Levels < ChartAll; Levels ++)

     {

      Shift[Levels][0] = KeyTX - dxs;

      Shift[Levels][1] = (Levels-FKeyYLev-1) * dys;

      Shift[Levels][2] = dxs;

      Shift[Levels][3] = dys;

     }



   for(int i = 0; i < object; i++)

      for(int j = 0; j < ChartAll; j ++)

        {

         if(Koor[i].GetPosition() <= j)

           {

            Koor[i].Update(j,ChartOpen(Koor[i].GetSymbol(),_Period));

            ManageBorderByWindowHandle(GetParent((int)ChartGetInteger(Koor[i].GetID(j),CHART_WINDOW_HANDLE)),true);

           }

         MoveWindow(GetParent((int)ChartGetInteger(Koor[i].GetID(j),CHART_WINDOW_HANDLE)),

                    Koor[i].GetX()+Shift[j][0], Koor[i].GetY()+Shift[j][1], Shift[j][2], Shift[j][3], true);



         if(Profile[CurrentProfile].TF[j]!=ChartPeriod(Koor[i].GetID(j)))

            ChartSetSymbolPeriod(Koor[i].GetID(j),ChartSymbol(Koor[i].GetID(j)),Profile[CurrentProfile].TF[j]);



         if(CurrentTemplate>-1)

            if(Templates[CurrentTemplate].TemplateName[j]!="")

               ChartApplyTemplate(Koor[i].GetID(j),Templates[CurrentTemplate].TemplateName[j]);

        }



   int SP = (((object-1)/Key)+1) * Widht;

   if(TY >= SP||object<1)

      SetScroll(0,true);

   else

      SetScroll(SP-TY,true);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int GetIndexTFByName(string str)

  {

   for(int i = 0; i < ArraySize(Profile); i++)

      if(Profile[i].A==str)

         return i;

   return -1;

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int GetIndexChartByName(string str)

  {

   for(int i = 0; i < ArraySize(Charts); i++)

      if(Charts[i].A==str)

         return i;

   return -1;

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int OnInit()

  {

   string result[], Prev[];

   ArrayFree(Koor);

   ChartsDelete();

   CurrentProfile = 0;

   CurrentCharts = 0;

   CurrentBasket = -1;

   CurrentTemplate = -1;

   ReChangeTemplate = false;

   int keys=StringSplit(D,StringGetCharacter("*",0),result);

   ArrayFree(Profile);

   ArrayResize(Profile,keys);

   for(int i = 0; i<keys; i++)

     {

      Profile[i].NumberElement = StringSplit(result[i],StringGetCharacter(";",0),Prev);

      ArrayResize(Profile[i].TF,Profile[i].NumberElement-1);

      Profile[i].A = Prev[0];

      for(int j = Profile[i].NumberElement-1; j>0; j--)

         Profile[i].TF[j-1]=Prev[j]!="M1"?Prev[j]!="M5"?Prev[j]!="M15"?Prev[j]!="M30"?

                            Prev[j]!="H1"?Prev[j]!="H4"?Prev[j]!="D1"?Prev[j]!="W1"?43200:10080:1440:240:60:30:15:5:1;

     }



   keys=StringSplit(B,StringGetCharacter("*",0),result);

   ArrayFree(Charts);

   ArrayResize(Charts,keys);

   for(int i = 0; i<keys; i++)

     {

      StringSplit(result[i],StringGetCharacter(";",0),Prev);

      Charts[i].A = Prev[0];

      for(int j = 6; j>0; j--)

         Charts[i].Metrix[j-1]=StrToDouble(Prev[j]);

     }



   keys=StringSplit(Temp,StringGetCharacter("*",0),result);

   ArrayFree(Templates);

   ArrayResize(Templates,keys);

   for(int i = 0; i<keys; i++)

     {

      int tmp = StringSplit(result[i],StringGetCharacter(";",0),Prev) - 3;

      Templates[i].A = Prev[0];

      Templates[i].TF = GetIndexTFByName(Prev[1]);

      Templates[i].Chr = GetIndexChartByName(Prev[2]);

      ArrayResize(Templates[i].TemplateName,tmp);

      for(int j = 0; j < tmp; j++)

         Templates[i].TemplateName[j]=Prev[j+3];

     }



   keys=StringSplit(C,StringGetCharacter("*",0),result);



   ArrayFree(Baskets);

   ArrayResize(Baskets,keys);

   for(int i = 0; i<keys; i++)

     {

      int key=StringSplit(result[i],StringGetCharacter(";",0),Prev);

      ArrayResize(Baskets[i].Basket,key-1);

      Baskets[i].A = Prev[0];

      for(int j = 1; j<key; j++)

         Baskets[i].Basket[j-1] =  Prev[j];

     }

   keys=StringSplit(E,StringGetCharacter("*",0),result);

   int  prevkeys = ArraySize(Baskets);

   ArrayResize(Baskets,keys+prevkeys);

   for(int i = 0; i<keys; i++)

     {

      int key=StringSplit(result[i],StringGetCharacter(";",0),Prev);

      ArrayResize(Baskets[i+prevkeys].Basket,key-1);

      Baskets[i+prevkeys].A = Prev[0];

      for(int j = 1; j<key; j++)

         Baskets[i+prevkeys].Basket[j-1] =  Prev[j];

     }

   keys=StringSplit(F,StringGetCharacter("*",0),result);

   prevkeys = ArraySize(Baskets);

   ArrayResize(Baskets,keys+prevkeys);

   for(int i = 0; i<keys; i++)

     {

      int key=StringSplit(result[i],StringGetCharacter(";",0),Prev);

      ArrayResize(Baskets[i+prevkeys].Basket,key-1);

      Baskets[i+prevkeys].A = Prev[0];

      for(int j = 1; j<key; j++)

         Baskets[i+prevkeys].Basket[j-1] =  Prev[j];

     }



   StringSplit(Symbols,StringGetCharacter(";",0),aSymbols);



   SetScroll(0,false);



   long currChart=ChartID();



   int hWnd=GetParent((int)ChartGetInteger(currChart,CHART_WINDOW_HANDLE));

   WindowRestore(hWnd);

   ManageBorderByWindowHandle(hWnd,true);

   MoveWindow(hWnd,0,0,Hight,TerminalY()-5,true);





   ChartShowPeriodSepapatorSet(false);

   ChartShowGridSet(false);

   ChartShowPriceScaleSet(false);

   ChartShowDateScaleSet(false);



   ChartSetInteger(0,CHART_SHOW_ONE_CLICK,false);

   ChartSetInteger(0,CHART_SHOW_OHLC,false);

   ChartSetInteger(0,CHART_SHOW_BID_LINE,false);

   ChartSetInteger(0,CHART_SHOW_ASK_LINE,false);

   ChartSetInteger(0,CHART_COLOR_BACKGROUND,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_FOREGROUND,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_GRID,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_VOLUME,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_CHART_UP,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_CHART_DOWN,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_CHART_LINE,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_CANDLE_BULL,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_CANDLE_BEAR,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_BID,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_ASK,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_LAST,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_COLOR_STOP_LEVEL,ChartGetInteger(0,CHART_COLOR_BACKGROUND));

   ChartSetInteger(0,CHART_SHOW_TRADE_LEVELS,ChartGetInteger(0,false));

   ChartSetInteger(0,CHART_DRAG_TRADE_LEVELS,ChartGetInteger(0,false));



   for(int i = 0; i < ArraySize(aSymbols); i++)

      LabelCreate(0, "Sym"+(string)i, 0, 0, i*15, CORNER_LEFT_UPPER, aSymbols[i],"Arial", 12, ANCHOR_LEFT_UPPER,clrBrown);



   LabelCreate(0, "TF", 0, 18, 5, CORNER_LEFT_LOWER, "TF","Arial", 12, ANCHOR_LEFT_LOWER,clrBrown, 90);

   LabelCreate(0, "CH", 0, 34, 5, CORNER_LEFT_LOWER, "Chr","Arial", 12, ANCHOR_LEFT_LOWER,clrBrown, 90);

   LabelCreate(0, "TM", 0, 52, 5, CORNER_LEFT_LOWER, "Tmp","Arial", 12, ANCHOR_LEFT_LOWER,clrBrown, 90);

   LabelCreate(0, "BS", 0, 70, 5, CORNER_LEFT_LOWER, "Bsk","Arial", 12, ANCHOR_LEFT_LOWER,clrBrown, 90);



   ChartRedraw(0);

   PrevY = TerminalY();

   SortChartsAndSetScroll();

   EventSetMillisecondTimer(25);

   return(INIT_SUCCEEDED);

  }



//+------------------------------------------------------------------+

//| Custom indicator iteration function                              |

//+------------------------------------------------------------------+

void DeleteMarkers()

  {

   ObjectsDeleteAll(0,"CH_");

   ObjectSetInteger(0,"CH",OBJPROP_COLOR,clrBrown);

   ObjectsDeleteAll(0,"TF_");

   ObjectSetInteger(0,"TF",OBJPROP_COLOR,clrBrown);

   ObjectsDeleteAll(0,"BS_");

   ObjectSetInteger(0,"BS",OBJPROP_COLOR,clrBrown);

   ObjectsDeleteAll(0,"TM_");

   ObjectSetInteger(0,"TM",OBJPROP_COLOR,clrBrown);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool Find(int Element)

  {

   for(int Index = 0; Index < ArraySize(Baskets[CurrentBasket].Basket); Index++)

      if(aSymbols[Element]==Baskets[CurrentBasket].Basket[Index])

         return true;

   return false;

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void OnChartEvent(const int id,

                  const long &lparam,

                  const double &dparam,

                  const string &sparam)

  {

   if(id==CHARTEVENT_KEYDOWN)

     {



      if((int)lparam==StringGetChar(KeyQuit,0))

        {

         ChartsDelete();

         ChartClose();

        }

     }



   if(id==CHARTEVENT_OBJECT_CLICK)

     {

      for(int i = 0; i < ArraySize(aSymbols); i++)

        {

         if(sparam == ("Sym"+(string)i))

           {

            if(ObjectGetInteger(0,"Sym"+(string)i,OBJPROP_COLOR)==clrBrown)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_COLOR,clrYellow);

            else

              {

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_COLOR,clrBrown);

               ChartsDelete(aSymbols[i]);

              }

            SortChartsAndSetScroll();

           }

        }



      if(StringSubstr((string)sparam,0,3) == "TF_")

        {

         CurrentProfile = StrToInteger(StringSubstr((string)sparam,3,StringLen((string)sparam)-3));

         for(int i = 0; i < ArraySize(aSymbols); i++)

            ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

         DeleteMarkers();

         SortChartsAndSetScroll();

        }



      if(sparam == "TF")

        {

         if(ObjectGetInteger(0,"TF",OBJPROP_COLOR)==clrBrown)

           {

            DeleteMarkers();

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,EMPTY);

            for(int i = 0; i < ArraySize(Profile); i++)

               LabelCreate(0, "TF_"+(string)i, 0, 10, 40 + 20*i, CORNER_LEFT_LOWER, Profile[i].A,"Arial", 12, ANCHOR_LEFT_LOWER,CurrentProfile!=i?clrBrown:clrYellow);

            ObjectSetInteger(0,"TF",OBJPROP_COLOR,clrYellow);

           }

         else

           {

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

            DeleteMarkers();

           }

        }



      if(StringSubstr((string)sparam,0,3) == "BS_")

        {

         CurrentBasket = StrToInteger(StringSubstr((string)sparam,3,StringLen((string)sparam)-3));

         for(int i = 0; i < ArraySize(aSymbols); i++)

           {

            ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

            bool CloseChart = Find(i);

            if(!CloseChart && ObjectGetInteger(0,"Sym"+(string)i,OBJPROP_COLOR)==clrYellow)

               ChartsDelete(aSymbols[i]);

            ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_COLOR,CloseChart?clrYellow:clrBrown);

           }

         DeleteMarkers();

         SortChartsAndSetScroll();

        }



      if(sparam == "BS")

        {

         if(ObjectGetInteger(0,"BS",OBJPROP_COLOR)==clrBrown)

           {

            DeleteMarkers();

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,EMPTY);

            for(int i = 0; i < ArraySize(Baskets); i++)

               LabelCreate(0, "BS_"+(string)i, 0, 10, 40+20*i, CORNER_LEFT_LOWER, Baskets[i].A,"Arial", 12, ANCHOR_LEFT_LOWER,CurrentBasket!=i?clrBrown:clrYellow);

            ObjectSetInteger(0,"BS",OBJPROP_COLOR,clrYellow);

           }

         else

           {

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

            DeleteMarkers();

           }

        }



      if(StringSubstr((string)sparam,0,3) == "CH_")

        {

         CurrentCharts = StrToInteger(StringSubstr((string)sparam,3,StringLen((string)sparam)-3));

         for(int i = 0; i < ArraySize(aSymbols); i++)

            ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

         DeleteMarkers();

         SortChartsAndSetScroll();

        }



      if(sparam == "CH")

        {

         if(ObjectGetInteger(0,"CH",OBJPROP_COLOR)==clrBrown)

           {

            DeleteMarkers();

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,EMPTY);

            for(int i = 0; i < ArraySize(Charts); i++)

               LabelCreate(0, "CH_"+(string)i, 0, 10, 40+20*i, CORNER_LEFT_LOWER, Charts[i].A,"Arial", 12, ANCHOR_LEFT_LOWER,CurrentCharts!=i?clrBrown:clrYellow);

            ObjectSetInteger(0,"CH",OBJPROP_COLOR,clrYellow);

           }

         else

           {

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

            DeleteMarkers();

           }

        }



      if(StringSubstr((string)sparam,0,3) == "TM_")

        {

         CurrentTemplate = StrToInteger(StringSubstr((string)sparam,3,StringLen((string)sparam)-3));

         for(int i = 0; i < ArraySize(aSymbols); i++)

            ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

         ReChangeTemplate = true;

         DeleteMarkers();

         SortChartsAndSetScroll();

        }



      if(sparam == "TM")

        {

         if(ObjectGetInteger(0,"TM",OBJPROP_COLOR)==clrBrown)

           {

            DeleteMarkers();

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,EMPTY);

            for(int i = 0; i < ArraySize(Templates); i++)

               LabelCreate(0, "TM_"+(string)i, 0, 10, 40+20*i, CORNER_LEFT_LOWER, Templates[i].A,"Arial", 12, ANCHOR_LEFT_LOWER,CurrentTemplate!=i?clrBrown:clrYellow);

            ObjectSetInteger(0,"TM",OBJPROP_COLOR,clrYellow);

           }

         else

           {

            for(int i = 0; i < ArraySize(aSymbols); i++)

               ObjectSetInteger(0,"Sym"+(string)i,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

            DeleteMarkers();

           }

        }

     }

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[])

  {

//---



//--- return value of prev_calculated for next call

   return(rates_total);

  }

//+------------------------------------------------------------------+

int WindowRestore(long hWnd)

  {

   int Parent=GetParent((int)hWnd);

   return SendMessageW(GetParent(Parent), 0x0223, Parent, 0);

  }



//+------------------------------------------------------------------+

#import "user32.dll"

int  SetWindowLongA(int hWnd,int nIndex,int dwNewLong);

int  GetWindowLongA(int hWnd,int nIndex);

int  SetWindowPos(int hWnd,int hWndInsertAfter,int X,int Y,int cx,int cy,int uFlags);

int  GetParent(int hWnd);

int  GetTopWindow(int hWnd);

int  GetWindow(int hWnd,int wCmd);

int  SendMessageW(int hWnd,int Msg,int wParam,int lParam);

bool MoveWindow(int hWnd,int x,int y,int nWidth,int nHeight,bool bRepaint);

bool GetWindowRect(int hWnd,int &Pos[4]);

int  PostMessageA(int hWnd,int Msg,int wParam,int lParam);

#import

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void ManageBorderByWindowHandle(int hWindow,bool state)

  {

   int iNewStyle;

   if(state)

      iNewStyle=(int)(GetWindowLongA(hWindow,GWL_STYLE) &(~(WS_BORDER|WS_DLGFRAME|WS_SIZEBOX)));

   else

      iNewStyle=GetWindowLongA(hWindow,GWL_STYLE)|((WS_BORDER|WS_DLGFRAME|WS_SIZEBOX));

   if(hWindow>0 && iNewStyle>0)

     {

      SetWindowLongA(hWindow,GWL_STYLE,iNewStyle);

      SetWindowPos(hWindow,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_FRAMECHANGED);

     }

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool ChartShowGridSet(const bool value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

//+------------------------------------------------------------------+

bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

//+------------------------------------------------------------------+

//| $C=:F8O 2:;NG05B/2K:;NG05B @568< >B>1@065=8O H:0;K F5=K =0       |

//| 3@0D8:5.                                                         |

//+------------------------------------------------------------------+

bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool LabelCreate(const long              chart_ID=0,               // ID 3@0D8:0

                 const string            name="Label",             // 8<O <5B:8

                 const int               sub_window=0,             // =><5@ ?>4>:=0

                 const int               x=0,                      // :>>@48=0B0 ?> >A8 X

                 const int               y=0,                      // :>>@48=0B0 ?> >A8 Y

                 const ENUM_BASE_CORNER  corner=CORNER_LEFT_UPPER, // C3>; 3@0D8:0 4;O ?@82O7:8

                 const string            text="Label",             // B5:AB

                 const string            font="Arial",             // H@8DB

                 const int               font_size=10,             // @07<5@ H@8DB0

                 const ENUM_ANCHOR_POINT anchor=ANCHOR_LEFT_UPPER, // A?>A>1 ?@82O7:8

                 const color             clr=clrRed,               // F25B

                 const double            angle=0.0,                // =0:;>= B5:AB0

                 const bool              back=false,               // =0 704=5< ?;0=5

                 const bool              selection=false,          // 2K45;8BL 4;O ?5@5<5I5=89

                 const bool              hidden=true,              // A:@KB 2 A?8A:5 >1J5:B>2

                 const long              z_order=0)                // ?@8>@8B5B =0 =060B85 <KHLN

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- A>74048< B5:AB>2CN <5B:C

   if(ObjectFind(chart_ID,name)<0)

      if(!ObjectCreate(chart_ID,name,OBJ_LABEL,sub_window,0,0))

        {

         Print(__FUNCTION__,

               ": =5 C40;>AL A>740BL B5:AB>2CN <5B:C! >4 >H81:8 = ",GetLastError());

         return(false);

        }

//--- CAB0=>28< :>>@48=0BK <5B:8

   ObjectSetInteger(chart_ID,name,OBJPROP_XDISTANCE,x);

   ObjectSetInteger(chart_ID,name,OBJPROP_YDISTANCE,y);

//--- CAB0=>28< C3>; 3@0D8:0, >B=>A8B5;L=> :>B>@>3> 1C4CB >?@545;OBLAO :>>@48=0BK B>G:8

   ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner);

//--- CAB0=>28< B5:AB

   ObjectSetString(chart_ID,name,OBJPROP_TEXT,text);

//--- CAB0=>28< H@8DB B5:AB0

   ObjectSetString(chart_ID,name,OBJPROP_FONT,font);

//--- CAB0=>28< @07<5@ H@8DB0

   ObjectSetInteger(chart_ID,name,OBJPROP_FONTSIZE,font_size);

//--- CAB0=>28< C3>; =0:;>=0 B5:AB0

   ObjectSetDouble(chart_ID,name,OBJPROP_ANGLE,angle);

//--- CAB0=>28< A?>A>1 ?@82O7:8

   ObjectSetInteger(chart_ID,name,OBJPROP_ANCHOR,anchor);

//--- CAB0=>28< F25B

   ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);

//--- >B>1@078< =0 ?5@54=5< (false) 8;8 704=5< (true) ?;0=5

   ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);

//--- 2:;NG8< (true) 8;8 >B:;NG8< (false) @568< ?5@5<5I5=8O <5B:8 <KHLN

   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);

   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);

//--- A:@>5< (true) 8;8 >B>1@078< (false) 8<O 3@0D8G5A:>3> >1J5:B0 2 A?8A:5 >1J5:B>2

   ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);

//--- CAB0=>28< ?@8>@8B5B =0 ?>;CG5=85 A>1KB8O =060B8O <KH8 =0 3@0D8:5

   ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order);

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

//+------------------------------------------------------------------+

void ChartsDelete(string Symb = "")

  {

   int iPrevCount = 1;

   long Chart[1], loMainID=ChartID(), currChart=ChartFirst();

   Chart[0] = currChart;



   while(true)

     {

      if(ChartNext(currChart)<0)

         break;

      else

        {

         ArrayResize(Chart,ArraySize(Chart)+1);

         currChart=ChartNext(currChart);

         Chart[iPrevCount]=currChart;

         iPrevCount=iPrevCount+1;

        }

     }



   if(Symb!="")



      for(int k = iPrevCount - 1; k >= 0; k --)

        {

         if(ChartSymbol(Chart[k]) == Symb)

            continue;

         Chart[k]=loMainID;

        }



   for(int k = iPrevCount - 1; k >= 0; k --)

     {

      if(Chart[k] == loMainID)

         continue;

      ChartClose(Chart[k]);

     }

   ChartRedraw(loMainID);

  }

//+------------------------------------------------------------------+

Similar scripts

all_pivot_points

Order_SL

Order_TP

cm_manual_grid

cm close X

iChartsSwitchSymbol

Corel

EA_OBJPROP_CHART_ID

Murrey_Math_Lv_Arr_r_v1

Murrey_Math_Lv

Murrey_Math_Lv_Arr_r

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element Markdown Syntax
Heading # H1
## H2
### H3
Bold **bold text**
Italic *italicized text*
Link [title](https://www.example.com)
Image ![alt text](image.jpg)
Code `code`
Code Block ```
code block
```
Quote > blockquote
Unordered List - Item 1
- Item 2
Ordered List 1. First item
2. Second item
Horizontal Rule ---