e-ScreenShot

Author: ��� ����� �. aka KimIV
Orders Execution
Checks for the total of open orders
0 Views
0 Downloads
0 Favorites
e-ScreenShot
//+----------------------------------------------------------------------------+
//|                                                          e-ScreenShot.mq4  |
//|                                                                            |
//+----------------------------------------------------------------------------+
#property copyright "Êèì Èãîðü Â. aka KimIV"
#property link      "http://www.kimiv.ru"

//+------ Âíåøíèå ïàðàìåòðû ñîâåòíèêà -----------------------------------------+
extern bool FolderSymbol = True;  // Ñîçäàâàòü ïàïêó ñ èìåíåì òåêóùåãî ñèìâîëà
extern bool FolderForTF  = True;  // Ñîçäàâàòü ïàïêó ñ èìåíåì òåêóùåãî òàéìôðåéìà
extern int  size_x       = 640;
extern int  size_y       = 320;
extern int  Interval     = 5;     // Èíòåðâàë ñîçäàíèÿ ñêðèíøîòîâ, êîëè÷åñòâî ñåêóíä:
                                  //  -1 - â íà÷àëå áàðà
//   0 - íà êàæäîì òèêå
//  >0 - ÷åðåç çàäàííîå êîëè÷åñòâî ñåêóíä
extern bool byEvents     = True;  // Äåëàòü ñêðèíøîòû ïî òîðãîâûì ñîáûòèÿì

//+------ Ãëîáàëüíûå ïåðåìåííûå ñîâåòíèêà -------------------------------------+
int prevTimeBar;

//------- Îáúÿâëåíèå êîíñòàíò -------------------------------------------------+
#define OPEN_BUY                       0
#define OPEN_SELL                      1
#define SET_BUYLIMIT                   2
#define SET_SELLLIMIT                  3
#define SET_BUYSTOP                    4
#define SET_SELLSTOP                   5
#define MODIFY_OPENPRICE_BUYLIMIT      6
#define MODIFY_OPENPRICE_SELLLIMIT     7
#define MODIFY_OPENPRICE_BUYSTOP       8
#define MODIFY_OPENPRICE_SELLSTOP      9
#define MODIFY_STOPLOSS_BUY            10
#define MODIFY_STOPLOSS_SELL           11
#define MODIFY_STOPLOSS_BUYLIMIT       12
#define MODIFY_STOPLOSS_SELLLIMIT      13
#define MODIFY_STOPLOSS_BUYSTOP        14
#define MODIFY_STOPLOSS_SELLSTOP       15
#define MODIFY_TAKEPROFIT_BUY          16
#define MODIFY_TAKEPROFIT_SELL         17
#define MODIFY_TAKEPROFIT_BUYLIMIT     18
#define MODIFY_TAKEPROFIT_SELLLIMIT    19
#define MODIFY_TAKEPROFIT_BUYSTOP      20
#define MODIFY_TAKEPROFIT_SELLSTOP     21
#define MODIFY_EXPIRATION_BUYLIMIT     22
#define MODIFY_EXPIRATION_SELLLIMIT    23
#define MODIFY_EXPIRATION_BUYSTOP      24
#define MODIFY_EXPIRATION_SELLSTOP     25
#define CLOSE_BUY                      26
#define CLOSE_BUY_BY_STOPLOSS          27
#define CLOSE_BUY_BY_TAKEPROFIT        28
#define CLOSE_SELL                     29
#define CLOSE_SELL_BY_STOPLOSS         30
#define CLOSE_SELL_BY_TAKEPROFIT       31
#define DELETE_BUYLIMIT                32
#define DELETE_SELLLIMIT               33
#define DELETE_BUYSTOP                 34
#define DELETE_SELLSTOP                35
#define DELETE_BUYLIMIT_BY_EXPIRATION  36
#define DELETE_SELLLIMIT_BY_EXPIRATION 37
#define DELETE_BUYSTOP_BY_EXPIRATION   38
#define DELETE_SELLSTOP_BY_EXPIRATION  39
#define WORKED_BUYLIMIT                40
#define WORKED_SELLLIMIT               41
#define WORKED_BUYSTOP                 42
#define WORKED_SELLSTOP                43

//------- Ïîêëþ÷åíèå âíåøíèõ ìîäóëåé ------------------------------------------+
#import "user32.dll"
int GetAsyncKeyState(int Kod_Key);   // 19-Pause/Break, 27-Escape
//+----------------------------------------------------------------------------+
//|                                                                            |
//|  ÏÐÅÄÎÏÐÅÄÅ˨ÍÍÛÅ ÔÓÍÊÖÈÈ                                                  |
//|                                                                            |
//+----------------------------------------------------------------------------+
//|  expert initialization function                                            |
//+----------------------------------------------------------------------------+
void init() 
  {
   if(IsExpertEnabled()) 
     {
      if(Interval>0) start();
      else Message("Ñîâåòíèê áóäåò çàïóùåí ñëåäóþùèì òèêîì...");
     }
   else Message("Îòæàòà êíîïêà \"Ðàçðåøèòü çàïóñê ñîâåòíèêîâ\"");
  }

//+----------------------------------------------------------------------------+
//|  expert deinitialization function                                          |
//+----------------------------------------------------------------------------+
void deinit() { if(!IsTesting()) Comment(""); }
//+----------------------------------------------------------------------------+
//|  expert start function                                                     |
//+----------------------------------------------------------------------------+
void start() 
  {
   if(Interval<=0) 
     {
      if(Interval==0) Main();
      else if(prevTimeBar>0 && prevTimeBar<Time[0]) 
        {
         Main();
        }
      prevTimeBar=Time[0];
        } else {
      while(IsExpertEnabled() && !IsStopped() && !GetAsyncKeyState(19)) 
        {
         Comment("");
         Main();
         Sleep(1000*Interval);
        }
     }
  }
//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 31.10.2008                                                     |
//|  Îïèñàíèå : Âûïîëíÿåò âñòàâêó ýëåìåíòà ìàññèâà ñ çàäàííûì èíäåêñîì.        |
//|             Âîçâðàùàåò ðàçìåð íîâîãî ìàññèâà.                              |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    m - ìàññèâ ýëåìåíòîâ òèïà int                                           |
//|    e - çíà÷åíèå ýëåìåíòà                                                   |
//|    i - èíäåêñ ýëåìåíòà                  (-1 - äîáàâèòü â êîíåö ìàññèâà)    |
//+----------------------------------------------------------------------------+
int ArrayInsertInt(int &m[],int e,int i=-1) 
  {
   int j,k=ArraySize(m);

   ArrayResize(m,k+1);
   if(i>=0 && i<k) 
     {
      for(j=k; j>i; j--) m[j]=m[j-1];
      m[i]=e;
     }
   else m[k]=e;

   return(k+1);
  }
//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 01.09.2005                                                     |
//|  Îïèñàíèå : Âûïîëíÿåò ïîèñê ýëåìåíòà ìàññèâà ïî çíà÷åíèþ                   |
//|             è âîçâðàùàåò èíäåêñ íàéäåííîãî ýëåìåíòà èëè -1.                |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    m - ìàññèâ ýëåìåíòîâ                                                    |
//|    e - çíà÷åíèå ýëåìåíòà                                                   |
//+----------------------------------------------------------------------------+
int ArraySearchInt(int& m[], int e) 
  {
   for(int i=0; i<ArraySize(m); i++) 
     {
      if(m[i]==e) return(i);
     }
   return(-1);
  }
//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 08.04.2013                                                     |
//|  Îïèñàíèå : Ôîðìèðóåò ìàññèâ òîðãîâûõ ñîáûòèé, ïðîèçîøåäøèõ ñ ìîìåíòà      |
//|             ïîñëåäíåãî âûçîâà ôóíêöèè.                                     |
//|             Âîçâðàùàåò êîëè÷åñòâî îáíàðóæåííûõ ñîáûòèé.                    |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    te - ìàññèâ òîðãîâûõ ñîáûòèé                                            |
//|    sy - íàèìåíîâàíèå èíñòðóìåíòà   ( ""   - ëþáîé ñèìâîë,                  |
//|                                     NULL - òåêóùèé ñèìâîë)                 |
//|    op - îïåðàöèÿ                   ( -1   - ëþáîé îðäåð)                   |
//|    mn - MagicNumber                ( -1   - ëþáîé ìàãèê)                   |
//+----------------------------------------------------------------------------+
int GetTradeEvents(int &te[],string sy="",int op=-1,int mn=-1) 
  {
   static int      toti[];    // OrderTicket()
   static int      toty[];    // OrderType()
   static double   toop[];    // OrderOpenPrice()
   static datetime toot[];    // OrderOpenTime()
   static double   tosl[];    // OrderStopLoss()
   static double   totp[];    // OrderTakeProfit()
   static datetime toex[];    // OrderExpiration()
   static bool     isArraysFilled=False;     // Ìàññèâû çàïîëíåíû
   double pm, po;             // Öåíû èç ìàññèâà è îðäåðîâ
   int    d;                  // Êîëè÷åñòâî äðîáíûõ çíàêîâ
   int    i, k;               // Ñ÷¸ò÷èê è êîëè÷åñòâî òîðãîâûõ îïåðàöèé
   int    in;                 // Èíäåêñ íàéäåííîãî ýëåìåíòå ìàññèâà
   int    r;                  // Ðàçìåð ìàññèâîâ òîðãîâûõ îïåðàöèé

   ArrayResize(te,0);
   if(sy=="0") sy=Symbol();
   if(isArraysFilled) 
     {
      // Âûÿâëåíèå íîâûõ òîðãîâûõ îïåðàöèé
      // Âûÿâëåíèå èçìåíåíèé â ñóùåñòâóþùèõ òîðãîâûõ îïåðàöèÿõ
      k=OrdersTotal();
      for(i=0; i<k; i++) 
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) 
           {
            if(OrderSymbol()==sy || sy=="") 
              {
               if((op<0 || OrderType()==op) && OrderType()<6) 
                 {
                  if(mn<0 || OrderMagicNumber()==mn) 
                    {
                     d=MarketInfo(OrderSymbol(),MODE_DIGITS);
                     in=ArraySearchInt(toti,OrderTicket());
                     if(in<0) 
                       {              //--------------- Íîâàÿ òîðãîâàÿ îïåðàöèÿ
                        switch(OrderType()) 
                          {
                           case OP_BUY      : ArrayInsertInt(te, OPEN_BUY); break;
                           case OP_SELL     : ArrayInsertInt(te, OPEN_SELL); break;
                           case OP_BUYLIMIT : ArrayInsertInt(te, SET_BUYLIMIT); break;
                           case OP_SELLLIMIT: ArrayInsertInt(te, SET_SELLLIMIT); break;
                           case OP_BUYSTOP  : ArrayInsertInt(te, SET_BUYSTOP); break;
                           case OP_SELLSTOP : ArrayInsertInt(te, SET_SELLSTOP); break;
                          }
                          } else {                 //--------- Ñóùåñòâóåò, ñìîòðèì èçìåíåíèÿ
                        switch(OrderType()) 
                          {
                           case OP_BUY:
                              pm=NormalizeDouble(tosl[in], d);
                              po=NormalizeDouble(OrderStopLoss(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_STOPLOSS_BUY);
                              pm=NormalizeDouble(totp[in], d);
                              po=NormalizeDouble(OrderTakeProfit(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_TAKEPROFIT_BUY);
                              if(toty[in]==OP_BUYLIMIT) ArrayInsertInt(te, WORKED_BUYLIMIT);
                              if(toty[in]==OP_BUYSTOP ) ArrayInsertInt(te, WORKED_BUYSTOP);
                              break;
                           case OP_SELL:
                              pm=NormalizeDouble(tosl[in], d);
                              po=NormalizeDouble(OrderStopLoss(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_STOPLOSS_SELL);
                              pm=NormalizeDouble(totp[in], d);
                              po=NormalizeDouble(OrderTakeProfit(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_TAKEPROFIT_SELL);
                              if(toty[in]==OP_SELLLIMIT) ArrayInsertInt(te, WORKED_SELLLIMIT);
                              if(toty[in]==OP_SELLSTOP ) ArrayInsertInt(te, WORKED_SELLSTOP);
                              break;
                           case OP_BUYLIMIT:
                              pm=NormalizeDouble(toop[in], d);
                              po=NormalizeDouble(OrderOpenPrice(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_OPENPRICE_BUYLIMIT);
                              pm=NormalizeDouble(tosl[in], d);
                              po=NormalizeDouble(OrderStopLoss(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_STOPLOSS_BUYLIMIT);
                              pm=NormalizeDouble(totp[in], d);
                              po=NormalizeDouble(OrderTakeProfit(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_TAKEPROFIT_BUYLIMIT);
                              if(toex[in]!=OrderExpiration()) ArrayInsertInt(te,MODIFY_EXPIRATION_BUYLIMIT);
                              break;
                           case OP_SELLLIMIT:
                              pm=NormalizeDouble(toop[in], d);
                              po=NormalizeDouble(OrderOpenPrice(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_OPENPRICE_SELLLIMIT);
                              pm=NormalizeDouble(tosl[in], d);
                              po=NormalizeDouble(OrderStopLoss(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_STOPLOSS_SELLLIMIT);
                              pm=NormalizeDouble(totp[in], d);
                              po=NormalizeDouble(OrderTakeProfit(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_TAKEPROFIT_SELLLIMIT);
                              if(toex[in]!=OrderExpiration()) ArrayInsertInt(te,MODIFY_EXPIRATION_SELLLIMIT);
                              break;
                           case OP_BUYSTOP:
                              pm=NormalizeDouble(toop[in], d);
                              po=NormalizeDouble(OrderOpenPrice(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_OPENPRICE_BUYSTOP);
                              pm=NormalizeDouble(tosl[in], d);
                              po=NormalizeDouble(OrderStopLoss(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_STOPLOSS_BUYSTOP);
                              pm=NormalizeDouble(totp[in], d);
                              po=NormalizeDouble(OrderTakeProfit(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_TAKEPROFIT_BUYSTOP);
                              if(toex[in]!=OrderExpiration()) ArrayInsertInt(te,MODIFY_EXPIRATION_BUYSTOP);
                              break;
                           case OP_SELLSTOP:
                              pm=NormalizeDouble(toop[in], d);
                              po=NormalizeDouble(OrderOpenPrice(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_OPENPRICE_SELLSTOP);
                              pm=NormalizeDouble(tosl[in], d);
                              po=NormalizeDouble(OrderStopLoss(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_STOPLOSS_SELLSTOP);
                              pm=NormalizeDouble(totp[in], d);
                              po=NormalizeDouble(OrderTakeProfit(), d);
                              if(pm!=po) ArrayInsertInt(te,MODIFY_TAKEPROFIT_SELLSTOP);
                              if(toex[in]!=OrderExpiration()) ArrayInsertInt(te,MODIFY_EXPIRATION_SELLSTOP);
                              break;
                          }
                       }
                    }
                 }
              }
           }
        }
      // Âûÿâëåíèå çàêðûòûõ/óäàë¸ííûõ òîðãîâûõ îïåðàöèé
      k=ArraySize(toti);
      for(i=0; i<k; i++) 
        {
         if(OrderSelect(toti[i],SELECT_BY_TICKET) && OrderCloseTime()>0) 
           {
            d=MarketInfo(OrderSymbol(),MODE_DIGITS);
            switch(toty[i]) 
              {
               case OP_BUY:
                  ArrayInsertInt(te,CLOSE_BUY);
                  pm=NormalizeDouble(OrderClosePrice(), d);
                  po=NormalizeDouble(OrderStopLoss(), d);
                  if(pm==po) ArrayInsertInt(te,CLOSE_BUY_BY_STOPLOSS);
                  pm=NormalizeDouble(OrderClosePrice(), d);
                  po=NormalizeDouble(OrderTakeProfit(), d);
                  if(pm==po) ArrayInsertInt(te,CLOSE_BUY_BY_TAKEPROFIT);
                  break;
               case OP_SELL:
                  ArrayInsertInt(te,CLOSE_SELL);
                  pm=NormalizeDouble(OrderClosePrice(), d);
                  po=NormalizeDouble(OrderStopLoss(), d);
                  if(pm==po) ArrayInsertInt(te,CLOSE_SELL_BY_STOPLOSS);
                  pm=NormalizeDouble(OrderClosePrice(), d);
                  po=NormalizeDouble(OrderTakeProfit(), d);
                  if(pm==po) ArrayInsertInt(te,CLOSE_SELL_BY_TAKEPROFIT);
                  break;
               case OP_BUYLIMIT:
                  ArrayInsertInt(te,DELETE_BUYLIMIT);
                  if(MathAbs(OrderCloseTime()-OrderExpiration())<60) 
                    {
                     ArrayInsertInt(te,DELETE_BUYLIMIT_BY_EXPIRATION);
                    }
                  break;
               case OP_SELLLIMIT:
                  ArrayInsertInt(te,DELETE_SELLLIMIT);
                  if(MathAbs(OrderCloseTime()-OrderExpiration())<60) 
                    {
                     ArrayInsertInt(te,DELETE_SELLLIMIT_BY_EXPIRATION);
                    }
                  break;
               case OP_BUYSTOP:
                  ArrayInsertInt(te,DELETE_BUYSTOP);
                  if(MathAbs(OrderCloseTime()-OrderExpiration())<60) 
                    {
                     ArrayInsertInt(te,DELETE_BUYSTOP_BY_EXPIRATION);
                    }
                  break;
               case OP_SELLSTOP:
                  ArrayInsertInt(te,DELETE_SELLSTOP);
                  if(MathAbs(OrderCloseTime()-OrderExpiration())<60) 
                    {
                     ArrayInsertInt(te,DELETE_SELLSTOP_BY_EXPIRATION);
                    }
                  break;
              }
           }
        }
     }

// Çàïîëíåíèå ñòàòè÷åñêèõ ìàññèâîâ ñâåäåíèÿìè î òåêóùèõ ïîçèöèÿõ è îðäåðàõ
   ArrayResize(toti, 0);      // OrderTicket()
   ArrayResize(toty, 0);      // OrderType()
   ArrayResize(toop, 0);      // OrderOpenPrice()
   ArrayResize(toot, 0);      // OrderOpenTime()
   ArrayResize(tosl, 0);      // OrderStopLoss()
   ArrayResize(totp, 0);      // OrderTakeProfit()
   ArrayResize(toex, 0);      // OrderExpiration()
   k=OrdersTotal();
   for(i=0; i<k; i++) 
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) 
        {
         if(OrderSymbol()==sy || sy=="") 
           {
            if((op<0 || OrderType()==op) && OrderType()<6) 
              {
               if(mn<0 || OrderMagicNumber()==mn) 
                 {
                  r=ArraySize(toti);
                  ArrayResize(toti, r+1);    // OrderTicket()
                  ArrayResize(toty, r+1);    // OrderType()
                  ArrayResize(toop, r+1);    // OrderOpenPrice()
                  ArrayResize(toot, r+1);    // OrderOpenTime()
                  ArrayResize(tosl, r+1);    // OrderStopLoss()
                  ArrayResize(totp, r+1);    // OrderTakeProfit()
                  ArrayResize(toex, r+1);    // OrderExpiration()
                  toti[r]=OrderTicket();
                  toty[r]=OrderType();
                  toop[r]=OrderOpenPrice();
                  toot[r]=OrderOpenTime();
                  tosl[r]=OrderStopLoss();
                  totp[r]=OrderTakeProfit();
                  toex[r]=OrderExpiration();
                 }
              }
           }
        }
     }
   isArraysFilled=True;

   return(ArraySize(te));
  }
//+----------------------------------------------------------------------------+
//|  Ãëàâíàÿ ôóíêöèÿ.                                                          |
//+----------------------------------------------------------------------------+
void Main() 
  {
   int    k=0,te[];
   string st;

   if(byEvents) k=GetTradeEvents(te);
   if(!byEvents || k>0) 
     {
      st=TimeToStr(TimeLocal(), TIME_DATE|TIME_SECONDS);
      st=StrTran(st, ":", ".");
      if(FolderForTF) st=Period()+"\\"+st;
      if(FolderSymbol) st=Symbol()+"\\"+st;
      WindowScreenShot(st+".gif",size_x,size_y);
      Message("Ïîñëåäíèé ScreenShot ñôîðìèðîâàí â: "+st);
     }
   else Message("Æäó òîðãîâîå ñîáûòèå...");
  }
//+----------------------------------------------------------------------------+
//|  Âûâîä ñîîáùåíèÿ â êîììåíò è â æóðíàë                                      |
//+----------------------------------------------------------------------------+
void Message(string m) 
  {
   Comment(m);
   if(StringLen(m)>0) Print(m);
  }
//+----------------------------------------------------------------------------+
//|  Çàìåíà ïîäñòðîêè                                                          |
//|  Ïàðàìåòðû:                                                                |
//|    str     - òåêñòîâàÿ ñòðîêà, â êîòîðîé ïðîèçâîäèòñÿ çàìåíà               |
//|    strfrom - çàìåíÿåìàÿ ïîäñòðîêà                                          |
//|    strto   - çàìåíÿþùàÿ ïîäñòðîêà                                          |
//+----------------------------------------------------------------------------+
string StrTran(string str,string strfrom,string strto) 
  {
   int    n;
   string outstr="",tempstr;

   for(n=0; n<StringLen(str); n++) 
     {
      tempstr=StringSubstr(str,n,StringLen(strfrom));
      if(tempstr==strfrom) 
        {
         outstr=outstr+strto;
         n=n+StringLen(strfrom)-1;
        }
      else outstr=outstr+StringSubstr(str,n,1);
     }
   return(outstr);
  }
//+----------------------------------------------------------------------------+

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 ---