SmartMoneyConcept Order Block

#property version   "3.0"
#include <Trade\SymbolInfo.mqh>  
#include <Trade\OrderInfo.mqh>
#include <Trade\Trade.mqh> CTrade trade;                      // trading object
#include <Trade/Trade.mqh>
CTrade   Trade;
CTrade         m_trade;                      // trading object
CSymbolInfo    m_symbol;                     // symbol info object
COrderInfo     m_order;                      // object of COrderInfo class

input group                "Parameters For Order Block Trading "
input bool             DrawAnnOrderBlock       =true;//Draw ANN Order Block
input bool             DrawSMCOrderBlock       =true;//Draw SMC Order Block
input bool             TradeAnn       =true;//Execute Ann Order Block Trades
input bool             TradeSmc       =true;//Execute SMC Order Block Trades
input  ENUM_TIMEFRAMES BigAnnOBtimeframe = PERIOD_H1;   //Higher TimeFrame of ANN OB
input  ENUM_TIMEFRAMES BigSMCOBtimeframe = PERIOD_H1;   //Higher TimeFrame of SMC OB
input  ENUM_TIMEFRAMES TinyOBtimeframe = PERIOD_M5;   //Lower TimeFrame of OB
input  int showlder = 4;   //Shoulder
input  int startbar = 5;   //StartBar
input  int PeaksLookBack = 199;   //Look Back How Far To Find Order Block

input group                "Parameters For Open Trades With No SL TP Or Trail "
input int               InpTakeProfitPoints         = 2520;     // TakeProfit points Added to open Trade with NO TP
input int               InpStopLossPoints           = 150;     // StopLoss points Added to open Trade with NO SL
input int               InpTriggerBEStopLossPoints  = 210;     // TriggerBEStopLossPoints
input int               InpBEStopLossPoints         = 50;      // BEStopLossPoints
input int               InpTrailStopLossPoints      = 320;     // TrailPoints
input double            TrailMultiplier             = 1.1;     // TrailMultiplier
input group                "Enter the Price at which you want A Pending Order To Open "
input group                "Pending parameters Either Sell Stop is Zero or BuyStop"
input double            Lots                        = 0.01;    // Lots
input uchar             InpBuySellQuantity          = 5;       // Max Buy Or Sell u want
input uchar             InpUpQuantity               = 1;       // Pending quantity How many Pending u want
input ushort            InpUpStep                   = 10;      // Step/Gap between orders (in points)Distance Between Order's'
input ENUM_TIMEFRAMES   TS_period                   =PERIOD_M10;// Pend Price Trig Timeframe
input group                "When the market moves near the pending order price above you put a grid of pending can be sent "

input int               InpMagicNumber              = 0;
input int               PositionOpenWithin          = 300;     // Open Within Seconds Applies 2 SL

input group                "Time Filter"
input string            StartTradingi              = "07:00";
input string            EndTradingi              = "11:00";
input string            StartTradingii              = "13:00";
input string            EndTradingii              = "17:00";
input bool              OrderTest                   = false;   //Enable Tester Order (in Backtest Only)
input int               Slippage                    = 10;      //Slippage
input group                "Equity parameters Based on 0.01 Lot. Then EA ratio's on your Lot Size"
input bool              EquityManager       =true;//Turn Euity Manager On True Off False
input double            MaxFloatLoss                = 1.3;      //Money Equity Loss Stop
input double            EquityBEStopLoss            = 2.5;       //Money Equity BE Stop
input double            EquityTrigBEStop            = 7;       //Money To Trig BE Stop
input double            EquityTrail                 = 10;      //Money To Trail After BE

bool Stop, Profit;
double Percentage;
double EquitySL;
double         TakeProfit;
double         StopLoss;
double         BETrail;
double         BETrigger;
double         BESL;
string CurrentTime;
bool  TradingIsAllowed= false;
double                           m_adjusted_point;                   // point value adjusted for 3 or 5 points
ulong                            m_slippage=30;                      // slippage                            

int OnInit(void)
  {
      // код доступен только после оплаты
   }

void OnDeinit(const int reason)
  {

   ObjectDelete(0,"Background");
   ObjectDelete(0,"Profit");
   ObjectDelete(0,"Percent");
   ObjectDelete(0,"Equity HL");
   return;

  }

void OnTick(void)
  {
      // код доступен только после оплаты
   }

void PendCond()
  {//a5
  datetime time = TimeLocal();
  CurrentTime = TimeToString(time,TIME_MINUTES);

   int StopsLevel=m_symbol.StopsLevel();
   if(StopsLevel==0)
      StopsLevel=m_symbol.Spread()*3;

     for(int i=1; i<=InpUpQuantity; i++)
     {//a4
      string   symbol         =  PositionGetString(POSITION_SYMBOL);
   int        digits   =  (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
   double   Spred    =  NormalizeDouble(Ask() - Bid(), digits);
      if(InpUpStep*i>StopsLevel)
        {//a3
         if(Lots>0.0)if(CheckTradingTime() == true)
           {//a2
           if(IsPositionExisting(ORDER_TYPE_BUY) < InpBuySellQuantity)
      if( CountPendingOrder(ORDER_TYPE_BUY_STOP) < InpUpQuantity)  if( buySignal() )
                    {//a1
 double price_ask    = (Ask() + (Spred * 2) ) + (double)CountPendingOrders()* (double)(InpUpStep) * SymbolInfoDouble(symbol, SYMBOL_POINT);

               double sl=0;              double tp=0;
               m_trade.BuyStop(Lots,price_ask,m_symbol.Name(),sl,tp);
              }//a1
           if(IsPositionExisting(ORDER_TYPE_SELL) < InpBuySellQuantity)              
      if( CountPendingOrder(ORDER_TYPE_SELL_STOP) < InpUpQuantity) if( sellSignal() )
               {//aa1
 double price_bid    = ( Bid() - (Spred*2) ) - (double)CountPendingOrders()* (double)(InpUpStep + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);

               double sl=0;               double tp=0;
               m_trade.SellStop(Lots,price_bid,m_symbol.Name(),sl,tp);
              }//aa1
           }//a2
        }//a3
     }//a4
  }//a5

bool buySignal()
{   bool ReturnValue = false;
   double Maximum = iHigh(NULL,PERIOD_M20,PikBar(PERIOD_M20,MODE_LOW,2,5,1)+1);
   double Minimum = iLow(NULL,PERIOD_M20,PikBar(PERIOD_M20,MODE_LOW,2,5,1));
   double Fifty = ((Maximum - Minimum ) * 5 / 100 ) + Minimum;
int xbar20= barscasmc(BigSMCOBtimeframe,MODE_LOW,showlder,startbar);
int xbar20i= barscasmc(TinyOBtimeframe,MODE_LOW,showlder,startbar);
int bar19= barscann(BigAnnOBtimeframe,MODE_HIGH,showlder,startbar);
int scabar= OBbarann(BigAnnOBtimeframe,MODE_HIGH,showlder,startbar,bar19);

         if(TradeAnn )  
         if( iClose(Symbol(),TinyOBtimeframe,1) > OBlowann(BigAnnOBtimeframe,MODE_HIGH,showlder,startbar,bar19) &&
        ( iLow(Symbol(),TinyOBtimeframe,1) < OBhighann(BigAnnOBtimeframe,MODE_HIGH,showlder,startbar,bar19)  ||
         iLow(Symbol(),TinyOBtimeframe,1) < OBhighann(BigAnnOBtimeframe,MODE_HIGH,showlder,startbar,bar19) ) &&
          EngulfBuy(TinyOBtimeframe,8,105) 
                )   { ReturnValue = true;  } //schematic 25 BUY

         if(TradeSmc)   
         if( iClose(Symbol(),TinyOBtimeframe,1) > OBlowsmc(BigSMCOBtimeframe,MODE_LOW,showlder,startbar,xbar20) &&
        ( iLow(Symbol(),TinyOBtimeframe,1) < OBhighsmc(BigSMCOBtimeframe,MODE_LOW,showlder,startbar,xbar20)  ||
         iLow(Symbol(),TinyOBtimeframe,1) < OBhighsmc(BigSMCOBtimeframe,MODE_LOW,showlder,startbar,xbar20) ) &&
          EngulfBuy(TinyOBtimeframe,8,105) 
                )   { ReturnValue = true;  } //schematic 25 BUY

   return ReturnValue;
}

bool sellSignal()
{   //SymbolInfoDouble(_Symbol, SYMBOL_POINT)*300
   bool ReturnValue = false;
   double Maximum = iHigh(NULL,PERIOD_M20,PikBar(PERIOD_M20,MODE_HIGH,2,5,1));
   double Minimum = iLow(NULL,PERIOD_M20,PikBar(PERIOD_M20,MODE_HIGH,2,5,1)+1);
   double Fifty = ((Maximum - Minimum ) * 5 / 100 ) + Minimum;
int bar20= barscasmc(BigSMCOBtimeframe,MODE_HIGH,showlder,startbar);
int bar20i= barscasmc(TinyOBtimeframe,MODE_HIGH,showlder,startbar);
int xbar19= barscann(BigAnnOBtimeframe,MODE_LOW,showlder,startbar);
int xbar19i= OBbarann(BigAnnOBtimeframe,MODE_LOW,showlder,startbar,xbar19);

         if(TradeAnn )         
         if( iClose(Symbol(),TinyOBtimeframe,1) < OBhighann(BigAnnOBtimeframe,MODE_LOW,showlder,showlder,xbar19) &&
        ( iHigh(Symbol(),TinyOBtimeframe,1) > OBlowann(BigAnnOBtimeframe,MODE_LOW,showlder,showlder,xbar19) ||
         iHigh(Symbol(),BigAnnOBtimeframe,1) > OBlowann(BigAnnOBtimeframe,MODE_LOW,showlder,showlder,xbar19)  )  &&
          EngulfSell(TinyOBtimeframe,8,105) 
                       )   { ReturnValue = true;  } //schematic 25 SELL

         if(TradeSmc)   
         if( iClose(Symbol(),TinyOBtimeframe,1) < OBhighsmc(BigSMCOBtimeframe,MODE_HIGH,showlder,showlder,bar20) &&
        ( iHigh(Symbol(),TinyOBtimeframe,1) > OBlowsmc(BigSMCOBtimeframe,MODE_HIGH,showlder,showlder,bar20) ||
         iHigh(Symbol(),BigSMCOBtimeframe,1) > OBlowsmc(BigSMCOBtimeframe,MODE_HIGH,showlder,showlder,bar20) )   &&
          EngulfSell(TinyOBtimeframe,8,105) 
                       )   { ReturnValue = true;  } //schematic 25 SELL

 return ReturnValue;
}

bool CheckTradingTime()
   {
   if( StringSubstr(CurrentTime,0,5) == StartTradingi )
   TradingIsAllowed =true;

   if( StringSubstr(CurrentTime,0,5) == EndTradingi )
   TradingIsAllowed =false;

   if( StringSubstr(CurrentTime,0,5) == StartTradingii )
   TradingIsAllowed = true;

   if( StringSubstr(CurrentTime,0,5) == EndTradingii )
   TradingIsAllowed = false;

   return TradingIsAllowed;
   }

void  ApplyTakeProfit(string symbol, int magicNumber, double takeprofit) {
   static int     digits   =  (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
    double tp = 0;
    double tpb = 0;
    double tps = 0;
    double tpi = 0;
    double tpbi = 0;
    double tpii = 0;
    double tpsii = 0;
   double   Spred    =  NormalizeDouble(Ask() - Bid(), digits);
   datetime checkTime = TimeCurrent() -PositionOpenWithin;

   int      count          =  PositionsTotal();
   for (int i=count-1; i>=0; i--) {
      ulong ticket   =  PositionGetTicket(i);
      if (ticket>0) {
         if (PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_MAGIC)==magicNumber) 
         if (PositionGetInteger(POSITION_TIME)>checkTime)
         {
                 if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetDouble(POSITION_TP)==0)
                {
                    tp = PositionGetDouble(POSITION_PRICE_OPEN) + (InpTakeProfitPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    tpb = NormalizeDouble(tp, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    tpi = Ask() + (InpTakeProfitPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    tpbi = NormalizeDouble(tpi, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    if( tpb > Ask() )
            Trade.PositionModify(ticket, PositionGetDouble(POSITION_SL), tpb);
               else     if( tpb < Ask() )
            Trade.PositionModify(ticket, PositionGetDouble(POSITION_SL), tpbi);
                }    
                else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetDouble(POSITION_TP)==0)
                {
                    tp = PositionGetDouble(POSITION_PRICE_OPEN) - (InpTakeProfitPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    tps = NormalizeDouble(tp, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    tpii = Bid() - (InpStopLossPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    tpsii = NormalizeDouble(tpii, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    if( tps < Bid() )
            Trade.PositionModify(ticket, PositionGetDouble(POSITION_SL), tps);
                else    if( tps > Bid() )
            Trade.PositionModify(ticket, PositionGetDouble(POSITION_SL), tpsii);
                }    
        }
      }
   }

}

void  ApplyStopLoss(string symbol, int magicNumber, double stopLoss) {
   static int     digits   =  (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
    double sl = 0;
    double slb = 0;
    double sls = 0;
    double sli = 0;
    double slbi = 0;
    double slii = 0;
    double slsii = 0;
   double   Spred    =  NormalizeDouble(Ask() - Bid(), digits);
   datetime checkTime = TimeCurrent() -PositionOpenWithin;

   int      count          =  PositionsTotal();
   for (int i=count-1; i>=0; i--) {
      ulong ticket   =  PositionGetTicket(i);
      if (ticket>0) {
         if (PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_MAGIC)==magicNumber) 
         if (PositionGetInteger(POSITION_TIME)>checkTime)
         {
                 if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetDouble(POSITION_SL)==0)
                {
                    sl = PositionGetDouble(POSITION_PRICE_OPEN) - (InpStopLossPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    slb = NormalizeDouble(sl, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    sli = Bid() - (InpStopLossPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    slbi = NormalizeDouble(sli, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    if( slb < Bid() )
            Trade.PositionModify(ticket, slb, PositionGetDouble(POSITION_TP));
               else     if( slb > Bid() )
            Trade.PositionModify(ticket, slbi, PositionGetDouble(POSITION_TP));
                }    
                else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetDouble(POSITION_SL)==0)
                {
                    sl = PositionGetDouble(POSITION_PRICE_OPEN) + (InpStopLossPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    sls = NormalizeDouble(sl, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    slii = Ask() + (InpStopLossPoints + Spred) * SymbolInfoDouble(symbol, SYMBOL_POINT);
                    slsii = NormalizeDouble(slii, (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
                    if( sls > Ask() )
            Trade.PositionModify(ticket, sls, PositionGetDouble(POSITION_TP));
                else    if( sls < Ask() )
            Trade.PositionModify(ticket, slsii, PositionGetDouble(POSITION_TP));
                }    
        }
      }
   }

}

void  ApplyBE( ) {
   int      count          =  PositionsTotal();
   for (int i=count-1; i>=0; i--) {
      ulong ticket   =  PositionGetTicket(i);
      if (ticket>0) {
         if (PositionGetInteger(POSITION_MAGIC)==InpMagicNumber) {
             string   symbol         =  PositionGetString(POSITION_SYMBOL);
   int        digits   =  (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);

   BETrigger =  SymbolInfoDouble(symbol, SYMBOL_POINT)*InpTriggerBEStopLossPoints;   
   BESL =  SymbolInfoDouble(symbol, SYMBOL_POINT)*InpBEStopLossPoints;   
   double   Spred    =  NormalizeDouble(Ask() - Bid(), digits);
   double   buyStopLoss    =  NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_BID), digits);
   double   sellStopLoss   =  NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_ASK), digits);
   double   Trigger    =  NormalizeDouble(BETrigger + Spred, digits);
   double   BEStopLoss    =  NormalizeDouble(BESL + Spred, digits);

            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY 
            && PositionGetDouble(POSITION_PRICE_CURRENT)>PositionGetDouble(POSITION_PRICE_OPEN) + Trigger 
            && (PositionGetDouble(POSITION_SL)==0 || PositionGetDouble(POSITION_PRICE_OPEN) > PositionGetDouble(POSITION_SL))) {
               Trade.PositionModify(ticket, PositionGetDouble(POSITION_PRICE_OPEN) + BEStopLoss, PositionGetDouble(POSITION_TP));
            } else
            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL 
            && PositionGetDouble(POSITION_PRICE_CURRENT) < PositionGetDouble(POSITION_PRICE_OPEN) - Trigger 
            && (PositionGetDouble(POSITION_SL)==0 || PositionGetDouble(POSITION_PRICE_OPEN) < PositionGetDouble(POSITION_SL))) {
               Trade.PositionModify(ticket,PositionGetDouble(POSITION_PRICE_OPEN) -  BEStopLoss, PositionGetDouble(POSITION_TP));
            }
         }
      }
   }

}

void  ApplyTrailingStop( ) {
   int      count          =  PositionsTotal();
   for (int i=count-1; i>=0; i--) {
      ulong ticket   =  PositionGetTicket(i);
      if (ticket>0) {
         if (PositionGetInteger(POSITION_MAGIC)==InpMagicNumber) {
             string   symbol         =  PositionGetString(POSITION_SYMBOL);
   int        digits   =  (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);

   BETrail =  SymbolInfoDouble(symbol, SYMBOL_POINT)*InpTrailStopLossPoints;   
   BETrigger =  SymbolInfoDouble(symbol, SYMBOL_POINT)*InpTriggerBEStopLossPoints;   
   BESL =  SymbolInfoDouble(symbol, SYMBOL_POINT)*InpBEStopLossPoints;   
   double   buyStopLoss    =  NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_BID), digits);
   double   sellStopLoss   =  NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_ASK), digits);
   double   Trigger    =  NormalizeDouble(BETrigger, digits);
   double   BEStopLoss    =  NormalizeDouble(BESL, digits);

            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY 
            && PositionGetDouble(POSITION_PRICE_CURRENT)>PositionGetDouble(POSITION_SL) + (BETrail * TrailMultiplier) 
            && PositionGetDouble(POSITION_PRICE_OPEN) < PositionGetDouble(POSITION_SL)) {
               Trade.PositionModify(ticket, PositionGetDouble(POSITION_PRICE_CURRENT) - BETrail, PositionGetDouble(POSITION_TP));
            } else
            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL 
            && PositionGetDouble(POSITION_PRICE_CURRENT) < PositionGetDouble(POSITION_SL) - (BETrail * TrailMultiplier) 
            && PositionGetDouble(POSITION_PRICE_OPEN) > PositionGetDouble(POSITION_SL)) {
               Trade.PositionModify(ticket,PositionGetDouble(POSITION_PRICE_CURRENT) +  BETrail, PositionGetDouble(POSITION_TP));
            }
         }
      }
   }

}

bool IsPendingOrderExist(ENUM_ORDER_TYPE type)
  {
   for(int i=OrdersTotal()-1; i>=0; i--) // returns the number of current orders
      if(m_order.SelectByIndex(i))     // selects the pending order by index for further access to its properties
         if(m_order.Symbol()==m_symbol.Name() )
            if (OrderGetInteger(ORDER_TYPE)==type ) 
            return(true);

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

bool IsPendingOrdersExists(void)
  {
   for(int i=OrdersTotal()-1; i>=0; i--) // returns the number of current orders
      if(m_order.SelectByIndex(i))     // selects the pending order by index for further access to its properties
         if(m_order.Symbol()==m_symbol.Name() )
            return(true);

   return(false);
  }

double PendingSLPrice( ENUM_ORDER_TYPE type)
  {
double open_price = -1;

for(int i=0; i<=OrdersTotal(); i++)
 {//a
      OrderSelect(OrderGetTicket(i));
      string OrderSymbol = OrderGetString(ORDER_SYMBOL);
      if(OrderSymbol == Symbol())
  {//b
        ENUM_ORDER_TYPE typeB=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
        if(typeB==type )
   {//c

        open_price =  NormalizeDouble((OrderGetDouble(ORDER_PRICE_OPEN)),_Digits);                
}//a
}//b
}//c
   return(open_price);
}  //}

int IsPositionExisting( ENUM_ORDER_TYPE type)
  {
   int count = 0;
   for(int i=PositionsTotal()-1; i>=0; i--)
      if(PositionGetTicket(i))
         if(PositionGetString(POSITION_SYMBOL)==Symbol())
            if (PositionGetInteger(POSITION_TYPE)==type ) 
           {
            count++;
           }

   return(count);
  }

int IsPositionExists()
  {
   int count = 0;
   for(int i=PositionsTotal()-1; i>=0; i--)
      if(PositionGetTicket(i))
         if(PositionGetString(POSITION_SYMBOL)==Symbol())
           {
            count++;
           }

   return(count);
  }

int CountPendingOrders()

{
   int TodayslimitedOrders = 0;

   for(int i=0; i<OrdersTotal(); i++)
   if(OrderSelect(OrderGetTicket(i)) 
   && OrderGetString(ORDER_SYMBOL) == _Symbol )   
      {
         TodayslimitedOrders += 1;
      }
   return(TodayslimitedOrders);
}

int CountPendingOrder(ENUM_ORDER_TYPE type)

{
   int TodayslimitedOrders = 0;

   for(int i=0; i<OrdersTotal(); i++)
   if(OrderSelect(OrderGetTicket(i)) 
   && OrderGetString(ORDER_SYMBOL) == _Symbol )   
            if (OrderGetInteger(ORDER_TYPE)==type ) 
      {
         TodayslimitedOrders += 1;
      }
   return(TodayslimitedOrders);
}

  void DeletePendingOrders()
  {//zi
  for(int i= OrdersTotal()-1;i>=0;i--)
  {//yi
  ulong OrderTicket = OrderGetTicket(i);
  trade.OrderDelete(OrderTicket);
  }//yi
  }//zi

void DeletePendingOrder(ENUM_ORDER_TYPE type)
{
    for (int i = OrdersTotal() - 1; i >= 0; i--)
    {
        long order_ticket = OrderGetTicket(i);

     if (   OrderGetString(ORDER_SYMBOL) == Symbol() && OrderGetInteger(ORDER_TYPE) == type)
        {
            MqlTradeResult result;
            MqlTradeRequest request;
            request.order = order_ticket;
            request.action = TRADE_ACTION_REMOVE;
            OrderSend(request, result);
        }
    }
}

double   HLineSLprice() 
   {
   return( ObjectGetDouble(0,"HLineSL",OBJPROP_PRICE));
   }

double Bid()
  {
   return (SymbolInfoDouble(Symbol(), SYMBOL_BID));
  }

double Ask()
  {
   return (SymbolInfoDouble(Symbol(), SYMBOL_ASK));
  }

double PikHii(ENUM_TIMEFRAMES timeframe,int mode, int shoulder, int startBar,int peakNo)
 { double High=iHigh(_Symbol,timeframe,PikBar(timeframe,MODE_HIGH,shoulder,startBar,peakNo));
  return High;}

double PikLoo(ENUM_TIMEFRAMES timeframe,int mode, int shoulder, int startBar,int peakNo)
 { double Low=iLow(_Symbol,timeframe,PikBar(timeframe,MODE_LOW,shoulder,startBar,peakNo));
  return Low;}

int   PikBar(ENUM_TIMEFRAMES timeframe,int mode, int shoulder, int startBar,int peakNo) 
   {
  int barIndex=0;
int ar[]; // Array
ArrayResize(ar,PeaksLookBack+1); // Prepare the array
      for(int y=3; y<=PeaksLookBack; y++)
{
   ar[0]=0; // Set the values
   ar[1]=FindPeak(timeframe,mode,shoulder,startBar ); 

   ar[2]=FindPeak(timeframe,mode,shoulder,ar[1]+1 ); // Set the value for the new array element
   ar[y]=FindPeak(timeframe,mode,shoulder,ar[y-1]+1 );; // Set the value for the new array element
}

      for(int x=1; x<=PeaksLookBack; x++)
{
if(peakNo ==x)   barIndex = ar[x];
 }
      return barIndex;
   }

 int FindPeak(ENUM_TIMEFRAMES timeframe,int mode, int shoulder, int startBar)
 {//a1
 if(mode!= MODE_HIGH && mode!= MODE_LOW) return(-1);
 int currentBar = startBar;
 int foundBar = FindNextPeak(timeframe,mode,shoulder*2+1, currentBar - shoulder);
 while (foundBar!= currentBar){//while1
 currentBar = FindNextPeak(timeframe,mode, shoulder, currentBar+1);
 foundBar   = FindNextPeak(timeframe,mode, shoulder*2+1,currentBar-shoulder);
 }//while1
 return(currentBar);
}//a1 

 int FindNextPeak(ENUM_TIMEFRAMES timeframe, int mode, int shoulder, int startBar)
 {//a2
 if(startBar < 0) {//a3
 shoulder += startBar;
 startBar = 0 ;
 }//a3
 return( (mode == MODE_HIGH) ?
        iHighest(Symbol() , timeframe, (ENUM_SERIESMODE)mode, shoulder, startBar) : 
        iLowest(Symbol() , timeframe, (ENUM_SERIESMODE)MODE_LOW, shoulder, startBar)  
            );
 }//a2

double PikHi(int shoulder, ENUM_TIMEFRAMES timeframe){// PikHi
double HighestHigh=0;
for( int i= 0; i<200; i++){
double High=iHigh(_Symbol,timeframe,i);
if( i > shoulder &&
   iHighest(_Symbol,timeframe,MODE_HIGH,shoulder*2+1,i-shoulder)==i){//Is it highest of prev & Following Shoulder

if(High > HighestHigh){
return High;
}//if(High)
}//if(Highest)
HighestHigh=MathMax(High,HighestHigh);
}//for
return -1;
}//PikHi/

double PikLo(int shoulder, ENUM_TIMEFRAMES timeframe){// PikLo
double LowestLow=DBL_MAX;
for( int i= 0; i<200; i++){
double Low=iLow(_Symbol,timeframe,i);
if(i > shoulder &&
   iLowest(_Symbol,timeframe,MODE_LOW,shoulder*2+1,i-shoulder)==i){//Is it lowest of prev & Following Shoulder
if(Low < LowestLow){
return Low;
}//if(Lowh)
}//if(Lowest)
LowestLow=MathMin(Low,LowestLow);
}//for
return -1;
}//PikHi/

double hiclo(ENUM_TIMEFRAMES timeFrame,int count,  int startBar)
  {
  int hiBar = iHighest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_CLOSE, count, startBar);
  double eLow = NormalizeDouble( iClose(Symbol(),timeFrame,hiBar), _Digits) ;
   return (eLow) ;
  }

double lowclo(ENUM_TIMEFRAMES timeFrame, int count, int startBar)
  {
  int loBar =  iLowest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_CLOSE, count, startBar) ;
  double eHigh = NormalizeDouble( iClose(Symbol(),timeFrame,loBar), _Digits) ;
   return (eHigh) ;
  }

double highestlo(ENUM_TIMEFRAMES timeFrame,int count,  int startBar)
  {
  int hiBar = iHighest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_LOW, count, startBar);
  double eLow = NormalizeDouble( iLow(Symbol(),timeFrame,hiBar), _Digits) ;
   return (eLow) ;
  }

double lowesthi(ENUM_TIMEFRAMES timeFrame, int count, int startBar)
  {
  int loBar =  iLowest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_HIGH, count, startBar) ;
  double eHigh = NormalizeDouble( iHigh(Symbol(),timeFrame,loBar), _Digits) ;
   return (eHigh) ;
  }

double high(ENUM_TIMEFRAMES timeFrame,int count,  int startBar)
  {
  int hiBar = iHighest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_HIGH, count, startBar);
  double eHigh = NormalizeDouble( iHigh(Symbol(),timeFrame,hiBar), _Digits) ;
   return (eHigh) ;
  }

double low(ENUM_TIMEFRAMES timeFrame, int count, int startBar)
  {
  int loBar =  iLowest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_LOW, count, startBar) ;
  double eLow = NormalizeDouble( iLow(Symbol(),timeFrame,loBar), _Digits) ;
   return (eLow) ;
  }

int highestBar(ENUM_TIMEFRAMES timeFrame, int count, int startBar)
{
    return (    iHighest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_HIGH, count, startBar) ); 
}

int lowestBar(ENUM_TIMEFRAMES timeFrame, int count, int startBar)
{
    return (    iLowest(Symbol() , timeFrame, (ENUM_SERIESMODE)MODE_LOW, count, startBar) ); 
}

Показано первые 50% кода (символов: 61023)