.....
                  if(OrderType() == OP_BUY)
                  {
                     calcaverage[INDEX_OPENALL]   += (OrderOpenPrice()+spread()) * OrderLots();
                     calcaverage[INDEX_COUNTBUY]  += OrderLots();
                     calcaverage[INDEX_COUNTLOTS] += OrderLots();
                  }
      
                  if(OrderType() == OP_SELL)
                  {
                     calcaverage[INDEX_OPENALL]   -= (OrderOpenPrice()-spread()) * OrderLots();
                     calcaverage[INDEX_COUNTSELL] += OrderLots();
                     calcaverage[INDEX_COUNTLOTS] -= OrderLots();
                  }
      
                  if(calcaverage[INDEX_COUNTLOTS] != 0)
                  {
                     calcaverage[INDEX_AVERAGE] = NormalizeDouble(calcaverage[INDEX_OPENALL] / calcaverage[INDEX_COUNTLOTS], Digits);   
                  }

if(MACD[i+] < 0 && MACD[i] > 0) PushNotifications("LONG",i);
if(MACD[i+] > 0 && MACD[i] < 0) PushNotifications("SHORT",i);


//+------------------------------------------------------------------+
//| Custom indicator iteration function PUSH_NOTIFICATION            |
//+------------------------------------------------------------------+  

void PushNotifications(string PUSHTYPE ,int y)
{
 static datetime Zeitstempel = Time[y];
 
 if ( Zeitstempel != Time[0] )  // hier erfasst der EA, dass gerade eine neue Chartperiode begonnen hat.
      {
      Zeitstempel = Time[0]; // Angleichung der Variable, damit wieder die nächste Chartperiode erkannt werden kann.
       if(PUSHTYPE == "LONG")
       {
       SendNotification("SIGNAL:  " + PUSHTYPE + " - " + Symbol() + " - " +TIMESTRING(Period()));}
      }
}



void PushNotifications(string PUSHTYPE, int shift)
{
   int TimeCheck = 0;
   int TimeMark = iBarShift(Symbol(),PERIOD_CURRENT,lastAlertTime,0);
    if(shift <= 2 && TimeCheck != TimeMark)
    {
        TimeCheck = TimeMark;
        SendNotification("SIGNAL:  " + PUSHTYPE + " - " + Symbol() + " - " +TIMESTRING(Period()));;
        Print("PushNotification send");
        
    }
    
}

Gesamtkapital (GK) geteilt durch 28 = X
und diesen X Wert geteilt durch das Ergebnis von Kurswert (KW) der Aktie
geteilt durch 100

also
GK/28=X
KW/100=Y
Einsatz je Aktie = X/Y
Ist allerdings X/Y multipliziert mit der Strecke zwische Einstieg und SL größer
als GK/Gesamtanzahl an Aktien

dann setze ich als EInsatzgröße = GK/Gesamtanzahl an Aktien

double AktienKapital=AccountInfoDouble(ACCOUNT_BALANCE);
  KapitalJeAktie=NormalizeDouble((StartKapital/AnzahlAnAktien),1);
  Gewinn=NormalizeDouble((AktienKapital-StartKapital),1);
double Grundlage=KapitalJeAktie+Gewinn;
double Abstand=NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_BID)-aa,1);
double Kurs=NormalizeDouble(SymbolInfoDouble(NULL,SYMBOL_BID),1);
        
      double NeuCFDLot1=NormalizeDouble((Grundlage/28),1);
      double NeuCFDLot2=NormalizeDouble((Kurs/100),1);
      NeuCFDLot=NormalizeDouble((NeuCFDLot1/NeuCFDLot2),1);
       if(Abstand*NeuCFDLot>(Gewinn+KapitalJeAktie))NeuCFDLot=NormalizeDouble((Gewinn+KapitalJeAktie)/Abstand,NACHKOMMA);

drawtline("high",Time[5],high,TimeCurrent()+PeriodSeconds()*2,clrYellow,2,1);

/*=============================================================================================================
// N O T I Z E N   U N D   I N F O S
//=============================================================================================================




 //=============================================================================================================
// P R O P E R T Y
//============================================================================================================*/
//#property strict

// #property strict sorgt anscheinend dafür,
// dass Kommentare im Konfig-Fenster im MT4 sichtbar sind.

#property copyright"LoShDistV3.mq4"
#property copyright"daniel-rudloff@web.de"
//=============================================================================================================
// B E S C H R E I B U N G
//=============================================================================================================
extern string TOY="true  = on / yes";
extern string FON="false = off / no";
//=============================================================================================================
// E I N S T E L L U N G E N
//=============================================================================================================
extern string esMN="Magic Numbers";
extern int MN_FirstSel=2;
extern int MN_FirstBuy=4;
extern int MN_NextSel=6;
extern int MN_NextBuy=8;
//-----------------------------------------------------------------------------------------------------------*/
extern string OOO1="Open Orders";
extern string OOO2="from/till Hour";
extern string OOO3="(Server Time)";
extern int OpenFromHour=5;  // Zum Testen ab 5 Uhr Orders öffnen lassen.
extern int OpenTillHour=22; // Zum Testen bis einschließlich 22 Uhr öffnen lassen.
//-----------------------------------------------------------------------------------------------------------*/
extern int Slippage=12345;
//-----------------------------------------------------------------------------------------------------------*/
extern int SL=275; // ?
//-----------------------------------------------------------------------------------------------------------*/
extern int TP=425; // ?
//-----------------------------------------------------------------------------------------------------------*/
extern string esIITCBSMS1="if IsTradeContexBusy()";
extern string esIITCBSMS2="sleep Milli Seconds";
extern int slMS=16; // Zum Testen 16 MS
//-----------------------------------------------------------------------------------------------------------*/
extern string esDOONO1="Dist to OrderOpenPrice()";
extern string esDOONO2="open next Order";
extern int Dist_ONO = 25; // ?
//-----------------------------------------------------------------------------------------------------------*/
extern string esDOCAO1="Dist to OrderOpenPrice()";
extern string esDOCAO2="close all Orders";
extern int Dist_CAO = 65; // Zum Testen 65. Weniger als ... ist wahrscheinlich nicht ausreichend?
//-----------------------------------------------------------------------------------------------------------*/
extern int OrdersNeed_Multi = 2;
//-----------------------------------------------------------------------------------------------------------*/
extern double Lots=0.01;
extern double LotsPlus=0.01; // ?
//=============================================================================================================
// G L O B A L E   D E K L A R A T I O N E N
//=============================================================================================================
bool
fiSH,fiLO,
neSH,neLO,
OCsel,OCbuy
;
//-----------------------------------------------------------------------------------------------------------*/
double
SL_Sel,SL_Buy,TP_Sel,TP_Buy,MSL,
FiSelOOP_DistONO,FiBuyOOP_DistONO,
NeSelOOP_DistONO,NeBuyOOP_DistONO,
FiSelOOP_DistCAO,FiBuyOOP_DistCAO
;
//-----------------------------------------------------------------------------------------------------------*/
int
TI_FiSel,TI_FiBuy,TI_NeSel,TI_NeBuy,
i,j,k,l,m,n,o,p,q,
FL_opSel,FL_neSel,FL_opBuy,FL_neBuy, // Temporäre Opened/Need-Werte, nur für forLoops ( ? )
Opened_Sel,Opened_Buy,
Need_Sel,Need_Buy
;
//=============================================================================================================
// I N I T
//=============================================================================================================
void OnInit(){}
//=============================================================================================================
// D E I N I T ?
//=============================================================================================================
void OnDeinit(const int reason){}// ?
//=============================================================================================================
// E A   F U N K T I O N E N   S T A R T
//=============================================================================================================int 
void OnTick(){
//=============================================================================================================
// S T O P   L O S S
//=============================================================================================================
//SL auf 0 stellen, wenn oben <1,
//um irgendwelche Missverständnisse zu vermeiden.
if(SL<1){
  SL_Sel=0.0;
  SL_Buy=0.0;}
else{
  SL_Sel=NormalizeDouble(Bid+SL*_Point,_Digits);
  SL_Buy=NormalizeDouble(Ask-SL*_Point,_Digits);}
//SL genauso groß wie Minstoplevels machen, wenn er kleiner ist:
MSL=MarketInfo(Symbol(),MODE_STOPLEVEL);
if(SL_Sel<MSL)SL_Sel=MSL;
if(SL_Buy<MSL)SL_Buy=MSL;
//=============================================================================================================
// T A K E   P R O F I T
//=============================================================================================================
//TP auf 0 stellen, wenn oben <1,
//um irgendwelche Missverständnisse zu vermeiden.
if(TP<1){
  TP_Sel=0.0;
  TP_Buy=0.0;}
else{
  TP_Sel=NormalizeDouble(Bid-TP*_Point,_Digits);
  TP_Buy=NormalizeDouble(Ask+TP*_Point,_Digits);}
//=============================================================================================================
// C H E C K   H O U R
//=============================================================================================================
// Prüfen, ob zur Zeit Orders geöffnet werden dürfen.
if(

    (Hour()>=OpenFromHour&&Hour()<=OpenTillHour)||

    (Hour()>OpenTillHour&&Hour()<OpenFromHour && Opened_Sel>=1 && Opened_Buy>=1 )
      
  ){

//=============================================================================================================
// 1 . O R D E R   S E A R C H   
//=============================================================================================================// Prüfen, überhaupt Orders offen sind.
fiSH=false;
neSH=false;
fiLO=false;
neLO=false;
for(i=OrdersTotal()-1;i>=0;i--){
if(OrderSelect(i,SELECT_BY_POS)){
if(OrderSymbol()==Symbol()){
if(OrderMagicNumber()==MN_FirstSel)fiSH=true;
if(OrderMagicNumber()==MN_NextSel )neSH=true;
if(OrderMagicNumber()==MN_FirstBuy)fiLO=true;
if(OrderMagicNumber()==MN_NextBuy )neLO=true;}}}
//=============================================================================================================
// O P E N   F I R S T   S E L L / O P E N   F I R S T   B U Y
//=============================================================================================================// Prüfen, überhaupt Orders offen sind.
// Wenn gar keine Orders offen sind...
if(fiSH==false&&neSH==false&&fiLO==false&&neLO==false){
//-----------------------------------------------------------------------------------------------------------*/
//...Zähler auf 0 setzen.  
  Opened_Sel=0;
  Opened_Buy=0;
  Need_Sel  =0;
  Need_Buy  =0;
//-----------------------------------------------------------------------------------------------------------*/

// ...FirstSell öffnen:
  if(IsTradeAllowed()==true){
    TI_FiSel=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,SL_Sel,TP_Sel,NULL,MN_FirstSel,clrBlue);
    if(IsTradeContextBusy()==true)Sleep(slMS);} // ?

// ...FirstBuy öffnen:
  if(IsTradeAllowed()==true){
    TI_FiBuy=OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage,SL_Buy,TP_Buy,NULL,MN_FirstBuy,clrBlue);
    if(IsTradeContextBusy()==true)Sleep(slMS);} // ?

}
//=============================================================================================================
// 2 . O R D E R   S E A R C H 
//=============================================================================================================
// Prüfen, ob 1.Sell und 1.Buy geöffnet wurden,
// und ob next Sell und next Buy schon geöffnet wurden.
for(j=OrdersTotal()-1;j>=0;j--){
if(OrderSelect(j,SELECT_BY_POS)){
if(OrderSymbol()==Symbol()){
if(OrderMagicNumber()==MN_FirstSel)fiSH=true;
if(OrderMagicNumber()==MN_NextSel )neSH=true;
if(OrderMagicNumber()==MN_FirstBuy)fiLO=true;
if(OrderMagicNumber()==MN_NextBuy )neLO=true;}}}
//=============================================================================================================
// O P E N   F I R S T   N E X T   O R D E R S
//=============================================================================================================
// Wenn nur FirstSell und FirstBuy offen sind,
// bei entsprechenden Bedingungen
// next Sel / next Buy öffnen.
if(fiSH==true&&fiLO==true&&neSH==false&&neLO==false){
//-----------------------------------------------------------------------------------------------------------*/

// Wenn FirstSell Bedingungen erfüllt, next Sell öffnen.
if(OrderSelect(TI_FiSel,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){ // ?
      
    FiSelOOP_DistONO=NormalizeDouble( OrderOpenPrice() - Dist_ONO*_Point,_Digits);

    if(Bid <= FiSelOOP_DistONO){

      for( k=OrdersNeed_Multi ; k>0 ; k--){
        if(IsTradeAllowed()==true)TI_NeSel=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,SL_Sel,TP_Sel,NULL,MN_NextSel,clrBlue);
        if(IsTradeContextBusy()==true)Sleep(slMS);

        Opened_Sel++;

        Need_Sel = Opened_Sel * OrdersNeed_Multi;

        Need_Buy = Need_Sel * OrdersNeed_Multi;} // ?

} } }

//-----------------------------------------------------------------------------------------------------------*/

// Wenn 1.Buy Bedingungen erfüllt,
// next Buy öffnen.
if(OrderSelect(TI_FiBuy,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){
       
    FiBuyOOP_DistONO=NormalizeDouble( OrderOpenPrice() + Dist_ONO*_Point,_Digits);

    if(Ask>=FiBuyOOP_DistONO){

      for( l=OrdersNeed_Multi ; l>0 ; l--){
        if(IsTradeAllowed()==true)TI_NeBuy=OrderSend(Symbol(),OP_BUY,Lots,Bid,Slippage,SL_Buy,TP_Buy,NULL,MN_NextBuy,clrBlue);
        if(IsTradeContextBusy()==true)Sleep(slMS);
          
        Opened_Buy++;
      
        Need_Buy = Opened_Buy * OrdersNeed_Multi;
          
        Need_Sel = Need_Buy * OrdersNeed_Multi;}

} } }
//-----------------------------------------------------------------------------------------------------------*/
}
//=============================================================================================================
// 3 . O R D E R   S E A R C H 
//=============================================================================================================
// 1.Sell und 1.Buy müssen offen sein.
// nextSell und/oder nextBuy müssen offen sein.
for(m=OrdersTotal()-1;m>=0;m--){
  if(OrderSelect(m,SELECT_BY_POS)){
    if(OrderSymbol()==Symbol()){
      if(OrderMagicNumber()==MN_FirstSel)fiSH=true;
      if(OrderMagicNumber()==MN_NextSel )neSH=true;
      if(OrderMagicNumber()==MN_FirstBuy)fiLO=true;
      if(OrderMagicNumber()==MN_NextBuy )neLO=true;}}}
//=============================================================================================================
// C H E C K   F I R S T   O R D E R S   A N D   N E X T   O R D E R S
//=============================================================================================================
// Wenn FirstSell und FirstBuy offen sind...
if(fiSH==true&&fiLO==true){

// ...und nextSell oder nextBuy offen sind,
  if(neSH==true||neLO==true){

// Weitere nextOrders öffnen,
// wenn Bedingungen erfüllt sind.
//=============================================================================================================
// C H E C K   F I R S T   A N D   N E X T   S E L L   O R D E R S
//=============================================================================================================// Letzten next Sell über Ticket auswählen.     

// Letzten NextSell auswählen.
if(OrderSelect(TI_NeSel,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){

//  Prüfen, ob letzter NextSell OpenNextOrder-Dist erreicht hat.
    NeSelOOP_DistONO=NormalizeDouble( OrderOpenPrice() - Dist_ONO*_Point,_Digits );
    if(Bid <= NeSelOOP_DistONO){

//    Wenn ja, FirstSell über Ticket auswählen.
      if(OrderSelect(TI_FiSel,SELECT_BY_TICKET)){
        if(OrderSymbol()==Symbol()){

//=============================================================================================================
// O P E N   N E W   S E L L   O R D E R S   B Y   D I S T
//=============================================================================================================

//        Wenn FirstSell Gewinn-Distanz nicht erreicht hat, weitere Sell-Orders öffnen.
          if( Ask > FiSelOOP_DistCAO ){

            FL_opSel=Opened_Sel; // ?
            FL_neSel=Need_Sel;  // ?
            for( n=FL_neSel ; n>0 ; n--){
              if(IsTradeAllowed()==true)TI_NeSel=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,SL_Sel,TP_Sel,NULL,MN_NextSel,clrYellow);
              if(IsTradeContextBusy()==true)Sleep(slMS);

              Opened_Sel++;

              Need_Sel = Opened_Sel * OrdersNeed_Multi;

              Need_Buy = Need_Sel * OrdersNeed_Multi;} }

//=============================================================================================================
// C L O S E   A L L   O R D E R S   B Y   S E L L   D I S T
//=============================================================================================================

//        Wenn FirstSell Gewinn-Dist doch erreicht hat... 
          if( Ask <= FiSelOOP_DistCAO ){
          
//          ...Lots erhöhen...
            Lots = OrderLots() + LotsPlus; // ?

//          ...und alle Orders schließen.
            for(p=OrdersTotal()-1;p>=0;p--){
              if(OrderSelect(p,SELECT_BY_POS)){
                if(OrderSymbol()==Symbol()){

                  if(OrderMagicNumber()==MN_NextBuy){
                    if(IsTradeAllowed()==true)OCbuy=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

                  if(OrderMagicNumber()==MN_FirstBuy){
                    if(IsTradeAllowed()==true)OCbuy=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

                  if(OrderMagicNumber()==MN_NextSel){
                    if(IsTradeAllowed()==true)OCsel=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

                  if(OrderMagicNumber()==MN_FirstSel){
                    if(IsTradeAllowed()==true)OCsel=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

} } } }
//-----------------------------------------------------------------------------------------------------------*/
} } } } }
//=============================================================================================================
// C H E C K   F I R S T   A N D   N E X T   B U Y   O R D E R S
//=============================================================================================================

// Letzten NextBuy über Ticket auswählen.
if(OrderSelect(TI_NeBuy,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){

//  Prüfen, ob NextBuy OpenNextOrder-Dist erreicht hat.
    NeBuyOOP_DistONO=NormalizeDouble(OrderOpenPrice() + Dist_ONO*_Point,_Digits);
    if(Ask >= NeBuyOOP_DistONO){

//    Wenn ja, FirstBuy über Ticket auswählen.
      if(OrderSelect(TI_FiBuy,SELECT_BY_TICKET)){
        if(OrderSymbol()==Symbol()){

//        Prüfen, ob 1.Buy Gewinn-Distanz erreicht hat.   
          FiBuyOOP_DistCAO=NormalizeDouble( OrderOpenPrice() + Dist_CAO*_Point,_Digits);
//=============================================================================================================
// O P E N   N E W   B U Y   O R D E R S   B Y   D I S T
//=============================================================================================================

// Wenn 1.Buy Gewinn-Distanz nicht erreicht hat weitere Buy-Orders öffnen.       
            if(Bid < FiBuyOOP_DistCAO){

              FL_opBuy=Opened_Buy; // ?
              FL_neBuy=Need_Buy;  // ?
              for( o=FL_neBuy ; o>0 ; o--){
                if(IsTradeAllowed()==true)TI_NeBuy=OrderSend(Symbol(),OP_BUY,Lots,Bid,Slippage,SL_Buy,TP_Buy,NULL,MN_NextBuy,clrYellow);
                if(IsTradeContextBusy()==true)Sleep(slMS);
          
                Opened_Buy++;
      
                Need_Buy = Opened_Buy * OrdersNeed_Multi;
          
                Need_Sel = Need_Buy * OrdersNeed_Multi;} }

//=============================================================================================================
// C L O S E   A L L   O R D E R S   B Y   B U Y   D I S T
//=============================================================================================================

//        Wenn FirstBuy Gewinn-Dist doch erreicht hat...
          if( Bid >= FiBuyOOP_DistCAO ){
          
//          ...Lots erhöhen...
            Lots = OrderLots() + LotsPlus; // ?

//          ...und alle Orders schließen.
            for(q=OrdersTotal()-1;q>=0;q--){
              if(OrderSelect(q,SELECT_BY_POS)){
                if(OrderSymbol()==Symbol()){

                  if(OrderMagicNumber()==MN_NextSel){
                    if(IsTradeAllowed()==true)OCsel=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}
    
                  if(OrderMagicNumber()==MN_FirstSel){
                    if(IsTradeAllowed()==true)OCsel=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

                  if(OrderMagicNumber()==MN_NextBuy){
                    if(IsTradeAllowed()==true)OCbuy=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

                  if(OrderMagicNumber()==MN_FirstBuy){
                    if(IsTradeAllowed()==true)OCbuy=OrderClose(NULL,OrderLots(),NULL,Slippage,clrRed);
                    if(IsTradeContextBusy()==true)Sleep(slMS);}

} } } }
//-----------------------------------------------------------------------------------------------------------*/
} } } } }
//-----------------------------------------------------------------------------------------------------------*/
} }
//-----------------------------------------------------------------------------------------------------------*/
} // Öffnende Klammer nach Hour Check
//=============================================================================================================
// E A   F U N K T I O N E N   B E E N D E N
//=============================================================================================================
}//(void OnTick)

   for(int i=0;i<signalList.Total();i++)
     {
         CandlePattern *o=signalList.GetNodeAtIndex(i);  
         MakeSH(o.wert,GetPeriodEnum(o.signalTF));  

         Print("Symbol:--  > "+o.patternName+"     Wert:--  > "+o.wert+"   TF:--  > "+o.signalTF+"    Time:--  > "+o.signalTime);
         delete o;
         
     }
      signalList.Clear();
      delete signalList;



     //+------------------------------------------------------------------+
      //| Macht einen Screenshot des aktuellen Charts und speichert diesen |
      //+------------------------------------------------------------------+
         bool MakeSH(string wert, ENUM_TIMEFRAMES tf )
         {
         
            PrepareChartForScreenshot(wert,tf);   
            string chartSymbol = ChartSymbol(0);
            ENUM_TIMEFRAMES period = ChartPeriod(0);
            if(chartSymbol != wert && period != tf)
              {
                PrepareChartForScreenshot(wert,tf);   
              }

            
            ENUM_ALIGN_MODE  align_mode = ALIGN_RIGHT;
            long width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS,0);
            long height = ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS,0);
            string fileName=wert+GetPeriodString(tf)+".gif";
            //--- Show the name on the chart as a comment
            //  Comment(name);
            if(!ChartScreenShot(0,fileName,(int)width,(int)height,align_mode))
              {
                  Print("ScreenShot failed: "+IntegerToString(GetLastError()));
                  return false;
              }      
            return true;
         }  
     
     //+------------------------------------------------------------------+
     //|  Wählt den Chart + TF  aus mit speziellen Settings               |
     //+------------------------------------------------------------------+     
     void PrepareChartForScreenshot(string wert, ENUM_TIMEFRAMES tf )
     {
         
         ChartSetSymbolPeriod(0,wert,tf);
         ChartSetInteger(0,CHART_SHOW_GRID,false);
         ChartSetInteger(0,CHART_MODE,CHART_CANDLES);         
         ChartSetInteger(0,CHART_SCALE,3);         
         ChartSetInteger(0,CHART_AUTOSCROLL,true);         
         ChartSetInteger(0,CHART_SHIFT,true);
         ChartSetInteger(0,CHART_COLOR_BACKGROUND,clrBlack);       
         ChartSetInteger(0,CHART_COLOR_CANDLE_BULL,clrLimeGreen);
         ChartSetInteger(0,CHART_COLOR_CANDLE_BEAR,clrRed);      
         ChartSetInteger(0,CHART_COLOR_CHART_UP,clrLimeGreen);
         ChartSetInteger(0,CHART_COLOR_CHART_DOWN,clrRed);                     
         ChartSetInteger(0,CHART_COLOR_BID,clrWhite);           
     }

     //+------------------------------------------------------------------+
     //| Gibt den TF als ENUM zurück                                      |
     //+------------------------------------------------------------------+     
     ENUM_TIMEFRAMES GetPeriodEnum(string val)
     {
                        
         if(val == "M1")
           {
               return PERIOD_M1;
           }
         if(val == "M5")
           {
               return PERIOD_M5;
           }
         if(val == "M15")
           {
               return PERIOD_M15;
           }
         if(val == "H1")
           {
               return PERIOD_H1;
           }
         if(val == "H4")
           {
               return PERIOD_H4;
           }
         if(val == "D1")
           {
               return PERIOD_D1;
           }               
         return -1;
     }
   //+------------------------------------------------------------------+
   //| Klasse um ein ChartPattern Signal abzubilden                     |
   //+------------------------------------------------------------------+

   class CandlePattern : public CObject
     {
   public:
         string patternName;
         string wert;
         datetime signalTime;
         string   signalTF;
         
                        CandlePattern(void){};
                       ~CandlePattern(void){};
     };

int ClosePositions(string symbol)
{
    int orderstotal = OrdersTotal();
    int orders      = 0;
    int ordticket[100][2];
    
    for (int i = 0; i < orderstotal; i++) 
    {
        OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        
        if (OrderMagicNumber() != Expert_Magic || OrderSymbol() != symbol)
            continue;
        
        int orderType = OrderType();
        if (orderType != OP_BUY && orderType != OP_SELL)
            continue;
        
        ordticket[orders][0] = OrderOpenTime();          // casting of datetime -> int, should work fine...
        ordticket[orders][1] = OrderTicket();
        orders++;
    }
    
    ArrayResize(ordticket,orders);                       // we have to remove rest of array otherwise it's contents will be sorted as well
    ArraySort(ordticket);                                // sorts ascending by first dimension -> by OrderOpenTime()

    for (i = 0; i < orders; i++) 
        ClosePositionByTicket(ordticket[i][1]);
}

iClose(NULL,0,i)

iMA(NULL,PERIOD_W1,LevyWochen,i,MODE_EMA,PRICE_CLOSE);

#property indicator_separate_window
#property indicator_buffers 1
#property indicator_plots   1
#property indicator_level1  2
#property indicator_level2 -2
#property indicator_type1   DRAW_LINE
#property indicator_color1  LightSeaGreen
#property indicator_label1  "Levy"

//--- input params
input int LevyWochen=9;
//---- buffers
double DPCBuffer[];
double A,C,X,Levy,iMa1;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   IndicatorSetString(INDICATOR_SHORTNAME,"Levy");
//---- index buffer
   SetIndexBuffer(0,DPCBuffer,INDICATOR_DATA);
   ArraySetAsSeries(DPCBuffer,true);
//   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,100);
   return(INIT_SUCCEEDED);

//---- OnInit done
  }
//+------------------------------------------------------------------+
//| Calculation                                        |
//+------------------------------------------------------------------+
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[])
  {

//--- check for bars count
   if(rates_total<7200/Period())
      return(0); //exit with zero result

//--- prevent total recalculation
   int i=rates_total-1;
   if(prev_calculated>0)
      i=rates_total-prev_calculated -1;

//--- current value should be recalculated
   if(i<0)
      i=0;
//---
   while(i>=0)
     {
      datetime date=iTime(NULL,0,i);
      int Hour=TimeHourMQL4(date);
      int Minute=TimeMinuteMQL4(date); 
       
         A=iClose(NULL,0,i); 
         iMa1=iMA(NULL,PERIOD_W1,LevyWochen,i,MODE_EMA,PRICE_CLOSE);
         Levy=NormalizeDouble(A/iMa1,1);   
         DPCBuffer[i]=Levy; 
       i--;

     }

//----
   return(rates_total);
  }
//+------------------ Functions -----------------------------------------------+

int TimeHourMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.hour);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int TimeMinuteMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.min);
  }
//+------------------------------------------------------------------+

//--------------------------------------------------------------------
#property strict
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 clrYellow
//--------------------------------------------------------------------
input string               Indicator                  = "MACD";      /*--/ MACD*/
input int                  MACD_fast_ema_period       = 12;          /*. fast_ema_period*/ //12
input int                  MACD_slow_ema_period       = 26;          /*. slow_ema_period*/ //26
input int                  MACD_signal_period         = 9;           /*. signal_period*/
input ENUM_APPLIED_PRICE   MACD_applied_price         = 0;           /*. applied_price*/ // PRICE_CLOSE,PRICE_OPEN,PRICE_HIGH,PRICE_LOW,PRICE_MEDIAN,PRICE_TYPICAL(HLC/3),PRICE_WEIGHTED(HLCC/4)
//--------------------------------------------------------------------
double buf[];
//====================================================================
//• OnInit -----------------------------------------------------------
void OnInit()
   {
   SetIndexBuffer(0,buf);
   SetIndexStyle(0,DRAW_LINE);
   IndicatorDigits(0);
   }
//====================================================================
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[])
   {
   int limit=rates_total-prev_calculated;
   for(int i=0;i<limit;i++)
      {
      double iMACDmain_0=iMACD(NULL,PERIOD_CURRENT,MACD_fast_ema_period,MACD_slow_ema_period,MACD_signal_period,MACD_applied_price,MODE_MAIN,i),
             iMACDmain_1=iMACD(NULL,PERIOD_CURRENT,MACD_fast_ema_period,MACD_slow_ema_period,MACD_signal_period,MACD_applied_price,MODE_MAIN,i+1),
             iMACDmain_2=iMACD(NULL,PERIOD_CURRENT,MACD_fast_ema_period,MACD_slow_ema_period,MACD_signal_period,MACD_applied_price,MODE_MAIN,i+2),
             iMACDmain_3=iMACD(NULL,PERIOD_CURRENT,MACD_fast_ema_period,MACD_slow_ema_period,MACD_signal_period,MACD_applied_price,MODE_MAIN,i+3),
             iMACDmain_4=iMACD(NULL,PERIOD_CURRENT,MACD_fast_ema_period,MACD_slow_ema_period,MACD_signal_period,MACD_applied_price,MODE_MAIN,i+4),
             XB=(iMACDmain_1+iMACDmain_3+iMACDmain_2),
             XA=(iMACDmain_1+iMACDmain_0+iMACDmain_2),
             XC,XD;
             if(XA>XC)XC=XA;
             if(XA<XD)XD=XA;
      //buf[i]=(XB<XA?1:0);
      buf[i]=(XC?1:0);
      }
   //---
   return(rates_total);
   }

//+------------------------------------------------------------------+
//|                                                      MACD3er.mq5 |
//|                        Copyright 2019, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_plots   1
#property indicator_color1 clrYellow

input string               Indicator                  = "MACD";      /*--/ MACD*/
input int                  MACD_fast_ema_period       = 12;          /*. fast_ema_period*/ //12
input int                  MACD_slow_ema_period       = 26;          /*. slow_ema_period*/ //26
input int                  MACD_signal_period         = 9;           /*. signal_period*/
input ENUM_APPLIED_PRICE   MACD_applied_price         = PRICE_CLOSE;           /*. applied_price*/ // PRICE_CLOSE,PRICE_OPEN,PRICE_HIGH,PRICE_LOW,PRICE_MEDIAN,PRICE_TYPICAL(HLC/3),PRICE_WEIGHTED(HLCC/4)


double buf[];
int macd_handle;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {

   SetIndexBuffer(0,buf,INDICATOR_DATA);
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE);
   IndicatorSetInteger(INDICATOR_DIGITS,0);
   ArraySetAsSeries(buf,true);
   
   macd_handle = iMACD(NULL,PERIOD_CURRENT,MACD_fast_ema_period,MACD_slow_ema_period,MACD_signal_period,MACD_applied_price);
             
      
   return(INIT_SUCCEEDED);
  }
  
void OnDeinit(const int reason){
 IndicatorRelease(macd_handle); 
}   
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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[])
  {
   double iMACDmain_0;
   double iMACDmain_1;
   double iMACDmain_2;
   double iMACDmain_3;
   double iMACDmain_4;
   double XA;
   double XB;
   double XC=0;
   double XD=0;
   int limit=rates_total-prev_calculated;
  
  
     for(int i=0;i<limit;i++)
  
   
      {
        iMACDmain_0= macd(i);
        iMACDmain_1= macd(i+1);
        iMACDmain_2= macd(i+2);
        iMACDmain_3= macd(i+3);
        iMACDmain_4= macd(i+4);
        
        XB=(iMACDmain_1+iMACDmain_3+iMACDmain_2);
        XA=(iMACDmain_1+iMACDmain_0+iMACDmain_2);
        if(XA>XC)XC=XA;
        if(XA<XD)XD=XA;
        //buf[i]=(XB<XA?1:0);
        //xxbuf[i]=(XC!=0?1:0);
            buf[i]=(XC?1:0);
     }   

   return(rates_total);
  }
//+------------------------------------------------------------------+


double macd( int shift) {
   double value[];
   if( macd_handle!=INVALID_HANDLE ) {
      if( CopyBuffer(macd_handle,0,shift,1,value)>0 ) 
         return(value[0]);
   }
   return(WRONG_VALUE);
}