New Day New Pending Order

Author: Copyright © 2019, Vladimir Karputov
Price Data Components
Series array that contains tick volumes of each bar
Orders Execution
Checks for the total of open orders
Miscellaneous
It issuies visual alerts to the screen
0 Views
0 Downloads
0 Favorites
New Day New Pending Order 
ÿþ//+------------------------------------------------------------------+

//|                                    New Day New Pending Order.mq5 |

//|                              Copyright © 2019, Vladimir Karputov |

//|                                           http://wmua.ru/slesar/ |

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

#property copyright "Copyright © 2019, Vladimir Karputov"

#property link      "http://wmua.ru/slesar/"

#property version   "1.000"

/*

   barabashkakvn Trading engine 3.024

*/

#include <Trade\PositionInfo.mqh>

#include <Trade\Trade.mqh>

#include <Trade\SymbolInfo.mqh>  

#include <Trade\AccountInfo.mqh>

#include <Trade\DealInfo.mqh>

#include <Trade\OrderInfo.mqh>

#include <Expert\Money\MoneyFixedMargin.mqh>

CPositionInfo  m_position;                   // trade position object

CTrade         m_trade;                      // trading object

CSymbolInfo    m_symbol;                     // symbol info object

CAccountInfo   m_account;                    // account info wrapper

CDealInfo      m_deal;                       // deals object

COrderInfo     m_order;                      // pending orders object

CMoneyFixedMargin *m_money;

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

//| Enum Lor or Risk                                                 |

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

enum ENUM_LOT_OR_RISK

  {

   lots_min=0, // Lots Min

   lot=1,      // Constant lot

   risk=2,     // Risk in percent for a deal

  };

//--- input parameters

input ushort   InpStopLoss          = 45;          // Stop Loss, in pips (1.00045-1.00055=1 pips)

input ushort   InpTakeProfit        = 15;          // Take Profit, in pips (1.00045-1.00055=1 pips)

input ushort   InpTrailingFrequency = 9;           // Trailing, in seconds (< "10" -> only on a new bar)

input ushort   InpSignalsFrequency  = 10;          // Search signals, in seconds (< "10" -> only on a new bar)

input ushort   InpTrailingStop      = 0;           // Trailing Stop (min distance from price to Stop Loss, in pips

input ushort   InpTrailingStep      = 5;           // Trailing Step, in pips (1.00045-1.00055=1 pips)

input ENUM_LOT_OR_RISK InpLotOrRisk = lots_min;    // Money management: Lot OR Risk

input double   InpVolumeLotOrRisk   = 3.0;         // The value for "Money management"

input ushort   InpIndent            = 5;           // Indent, in pips (1.00045-1.00055=1 pips)

//--- Monday

input datetime InpMonday_1    = D'1980.07.19 10:00:00';  // Monday time 1 (use only HH::MM) (00::00 -> off)

input datetime InpMonday_2    = D'1980.07.19 15:00:00';  // Monday time 2 (use only HH::MM) (00::00 -> off)

input datetime InpMonday_3    = D'1980.07.19 18:00:00';  // Monday time 3 (use only HH::MM) (00::00 -> off)

//--- Tuesday

input datetime InpTuesday_1   = D'1980.07.19 10:00:00';  // Tuesday time 1 (use only HH::MM) (00::00 -> off)

input datetime InpTuesday_2   = D'1980.07.19 15:00:00';  // Tuesday time 2 (use only HH::MM) (00::00 -> off)

input datetime InpTuesday_3   = D'1980.07.19 18:00:00';  // Tuesday time 3 (use only HH::MM) (00::00 -> off)

//--- Wednesday

input datetime InpWednesday_1 = D'1980.07.19 10:00:00';  // Wednesday time 1 (use only HH::MM) (00::00 -> off)

input datetime InpWednesday_2 = D'1980.07.19 15:00:00';  // Wednesday time 2 (use only HH::MM) (00::00 -> off)

input datetime InpWednesday_3 = D'1980.07.19 18:00:00';  // Wednesday time 3 (use only HH::MM) (00::00 -> off)

//--- Thursday

input datetime InpThursday_1  = D'1980.07.19 10:00:00';  // Thursday time 1 (use only HH::MM) (00::00 -> off)

input datetime InpThursday_2  = D'1980.07.19 15:00:00';  // Thursday time 2 (use only HH::MM) (00::00 -> off)

input datetime InpThursday_3  = D'1980.07.19 18:00:00';  // Thursday time 3 (use only HH::MM) (00::00 -> off)

//--- Thursday

input datetime InpFriday_1    = D'1980.07.19 10:00:00';  // Friday time 1 (use only HH::MM) (00::00 -> off)

input datetime InpFriday_2    = D'1980.07.19 15:00:00';  // Friday time 2 (use only HH::MM) (00::00 -> off)

input datetime InpFriday_3    = D'1980.07.19 18:00:00';  // Friday time 3 (use only HH::MM) (00::00 -> off)

//---

input bool     InpPrintLog          = false;       // Print log

input ulong    InpMagic             = 245953200;   // Magic number

//---

ulong  ExtSlippage=10;              // Slippage



double ExtStopLoss      = 0.0;      // Stop Loss      -> double

double ExtTakeProfit    = 0.0;      // Take Profit    -> double

double ExtTrailingStop  = 0.0;      // Trailing Stop  -> double

double ExtTrailingStep  = 0.0;      // Trailing Step  -> double

double ExtIndent        = 0.0;      // Indent         -> double



double   ExtAdjustedPoint;                   // point value adjusted for 3 or 5 points

datetime ExtLastTrailing         = 0;        // "0" -> D'1970.01.01 00:00';

datetime ExtLastSignals          = 0;        // "0" -> D'1970.01.01 00:00';

datetime ExtPrevBars             = 0;        // "0" -> D'1970.01.01 00:00';

bool     ExtNeedDeleteAll=false;             // delete all pending orders

bool     ExtWaitingPendingOrder=false;       // waiting for a pending order

//--- Monday

long ExtMonday_1     = 0;

long ExtMonday_2     = 0;

long ExtMonday_3     = 0;

//--- Tuesday

long ExtTuesday_1    = 0;

long ExtTuesday_2    = 0;

long ExtTuesday_3    = 0;

//--- Wednesday

long ExtWednesday_1  = 0;

long ExtWednesday_2  = 0;

long ExtWednesday_3  = 0;

//--- Thursday

long ExtThursday_1   = 0;

long ExtThursday_2   = 0;

long ExtThursday_3   = 0;

//--- Thursday

long ExtFriday_1     = 0;

long ExtFriday_2     = 0;

long ExtFriday_3     = 0;

//--- B0:B8:0 B0:0O: ***

//---    0 >B;>65==K5 >@45@0 (5A;8 ?@>H;0 ?@>25@:0 ?> A?@54C) 

//---    ?@>AB> 2KAB@5;8205< 8 >1=C;O5< <0AA82K AB@C:BC@

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

//| Structure Need Pending                                           |

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

struct STRUCT_NEED_PENDING

  {

   ENUM_ORDER_TYPE   pending_type;           // pending type

   double            volume;                 // volume

   double            price;                  // price

   ulong             magic;                  // magic

   //--- Constructor 

                     STRUCT_NEED_PENDING()

     {

      pending_type               = WRONG_VALUE;

      volume                     = 0.0;

      price                      = 0.0;

      magic                      = 0;

     }

  };

STRUCT_NEED_PENDING SNeedPending[];

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

//| Expert initialization function                                   |

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

int OnInit()

  {

//---

   if(InpTrailingStop!=0 && InpTrailingStep==0)

     {

      string err_text=(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")?

                      ""@59;8=3 =52>7<>65=: ?0@0<5B@ \"Trailing Step\" @025= =C;N!":

                      "Trailing is not possible: parameter \"Trailing Step\" is zero!";

      //--- when testing, we will only output to the log about incorrect input parameters

      if(MQLInfoInteger(MQL_TESTER))

        {

         Print(__FUNCTION__,", ERROR: ",err_text);

         return(INIT_FAILED);

        }

      else // if the Expert Advisor is run on the chart, tell the user about the error

        {

         Alert(__FUNCTION__,", ERROR: ",err_text);

         return(INIT_PARAMETERS_INCORRECT);

        }

     }

//---

   if(!m_symbol.Name(Symbol())) // sets symbol name

      return(INIT_FAILED);

   RefreshRates();

//---

   m_trade.SetExpertMagicNumber(InpMagic);

   m_trade.SetMarginMode();

   m_trade.SetTypeFillingBySymbol(m_symbol.Name());

   m_trade.SetDeviationInPoints(ExtSlippage);

//--- tuning for 3 or 5 digits

   int digits_adjust=1;

   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)

      digits_adjust=10;

   ExtAdjustedPoint=m_symbol.Point()*digits_adjust;



   ExtStopLoss       = InpStopLoss        * ExtAdjustedPoint;

   ExtTakeProfit     = InpTakeProfit      * ExtAdjustedPoint;

   ExtTrailingStop   = InpTrailingStop    * ExtAdjustedPoint;

   ExtTrailingStep   = InpTrailingStep    * ExtAdjustedPoint;

   ExtIndent         = InpIndent          * ExtAdjustedPoint;

//--- check the input parameter "Lots"

   string err_text="";

   if(InpLotOrRisk==lot)

     {

      if(!CheckVolumeValue(InpVolumeLotOrRisk,err_text))

        {

         //--- when testing, we will only output to the log about incorrect input parameters

         if(MQLInfoInteger(MQL_TESTER))

           {

            Print(__FUNCTION__,", ERROR: ",err_text);

            return(INIT_FAILED);

           }

         else // if the Expert Advisor is run on the chart, tell the user about the error

           {

            Alert(__FUNCTION__,", ERROR: ",err_text);

            return(INIT_PARAMETERS_INCORRECT);

           }

        }

     }

   else if(InpLotOrRisk==risk)

     {

      if(m_money!=NULL)

         delete m_money;

      m_money=new CMoneyFixedMargin;

      if(m_money!=NULL)

        {

         if(InpVolumeLotOrRisk<1 || InpVolumeLotOrRisk>100)

           {

            Print("The value for \"Money management\" (",DoubleToString(InpVolumeLotOrRisk,2),") -> invalid parameters");

            Print("   parameter must be in the range: from 1.00 to 100.00");

            return(INIT_FAILED);

           }

         if(!m_money.Init(GetPointer(m_symbol),Period(),m_symbol.Point()*digits_adjust))

            return(INIT_FAILED);

         m_money.Percent(InpVolumeLotOrRisk);

        }

      else

        {

         Print(__FUNCTION__,", ERROR: Object CMoneyFixedMargin is NULL");

         return(INIT_FAILED);

        }

     }

//---

   MqlDateTime STime;

//--- Monday     

   TimeToStruct(InpMonday_1,STime); ExtMonday_1=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpMonday_2,STime); ExtMonday_2=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpMonday_3,STime); ExtMonday_3=STime.hour*60*60+STime.min*60;

//--- Tuesday

   TimeToStruct(InpTuesday_1,STime); ExtTuesday_1=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpTuesday_2,STime); ExtTuesday_2=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpTuesday_3,STime); ExtTuesday_3=STime.hour*60*60+STime.min*60;

//--- Wednesday

   TimeToStruct(InpWednesday_1,STime); ExtWednesday_1=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpWednesday_2,STime); ExtWednesday_2=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpWednesday_3,STime); ExtWednesday_3=STime.hour*60*60+STime.min*60;

//--- Thursday

   TimeToStruct(InpThursday_1,STime); ExtThursday_1=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpThursday_2,STime); ExtThursday_2=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpThursday_3,STime); ExtThursday_3=STime.hour*60*60+STime.min*60;

//--- Friday

   TimeToStruct(InpFriday_1,STime); ExtFriday_1=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpFriday_2,STime); ExtFriday_2=STime.hour*60*60+STime.min*60;

   TimeToStruct(InpFriday_3,STime); ExtFriday_3=STime.hour*60*60+STime.min*60;

//---

   return(INIT_SUCCEEDED);

  }

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

//| Expert deinitialization function                                 |

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

void OnDeinit(const int reason)

  {

//---

   if(m_money!=NULL)

      delete m_money;

  }

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

//| Expert tick function                                             |

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

void OnTick()

  {

   if(ExtNeedDeleteAll)

     {

      if(IsPendingOrdersExists())

        {

         double level;

         if(FreezeStopsLevels(level))

           {

            DeleteAllPendingOrders(level);  return;

           }

         else

            return;

        }

      else

         ExtNeedDeleteAll=false;

     }

//---

   int size_need_pending=ArraySize(SNeedPending);

   if(size_need_pending>0)

     {

      if(!ExtWaitingPendingOrder)

         for(int i=size_need_pending-1;i>=0;i--)

           {

            double level;

            if(FreezeStopsLevels(level))

              {

               ExtWaitingPendingOrder=true;

               PlaceOrders(i,SNeedPending[i].pending_type,level,SNeedPending[i].magic);

              }

           }

      return;

     }

//---

   if(InpTrailingFrequency>=10) // trailing no more than once every 10 seconds

     {

      datetime time_current=TimeCurrent();

      if(time_current-ExtLastTrailing>10)

        {

         double level;

         if(FreezeStopsLevels(level))

            Trailing(level);

         else

            return;

         ExtLastTrailing=time_current;

        }

     }

   if(InpSignalsFrequency>=10) // search for trading signals no more than once every 10 seconds

     {

      datetime time_current=TimeCurrent();

      if(time_current-ExtLastSignals>10)

        {

         //--- search for trading signals

         if(!RefreshRates())

           {

            ExtPrevBars=0; return;

           }

         if(!SearchTradingSignals())

           {

            ExtPrevBars=0; return;

           }

         ExtLastSignals=time_current;

        }

     }

//--- we work only at the time of the birth of new bar

   datetime time_0=iTime(m_symbol.Name(),Period(),0);

   if(time_0==ExtPrevBars)

      return;

   ExtPrevBars=time_0;

   if(InpTrailingFrequency<10) // trailing only at the time of the birth of new bar

     {

      double level;

      if(FreezeStopsLevels(level))

         Trailing(level);

     }

   if(InpSignalsFrequency<10) // search for trading signals only at the time of the birth of new bar

     {

      if(!RefreshRates())

        {

         ExtPrevBars=0; return;

        }

      //--- search for trading signals

      if(!SearchTradingSignals())

        {

         ExtPrevBars=0; return;

        }

     }

//---

  }

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

//| TradeTransaction function                                        |

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

void OnTradeTransaction(const MqlTradeTransaction &trans,

                        const MqlTradeRequest &request,

                        const MqlTradeResult &result)

  {

//---



  }

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

//| Refreshes the symbol quotes data                                 |

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

bool RefreshRates(void)

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

     {

      Print("RefreshRates error");

      return(false);

     }

//--- protection against the return value of "zero"

   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)

      return(false);

//---

   return(true);

  }

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

//| Check the correctness of the position volume                     |

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

bool CheckVolumeValue(double volume,string &error_description)

  {

//--- minimal allowed volume for trade operations

   double min_volume=m_symbol.LotsMin();

   if(volume<min_volume)

     {

      if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")

         error_description=StringFormat("1J5< <5=LH5 <8=8<0;L=> 4>?CAB8<>3> SYMBOL_VOLUME_MIN=%.2f",min_volume);

      else

         error_description=StringFormat("Volume is less than the minimal allowed SYMBOL_VOLUME_MIN=%.2f",min_volume);

      return(false);

     }

//--- maximal allowed volume of trade operations

   double max_volume=m_symbol.LotsMax();

   if(volume>max_volume)

     {

      if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")

         error_description=StringFormat("1J5< 1>;LH5 <0:A8<0;L=> 4>?CAB8<>3> SYMBOL_VOLUME_MAX=%.2f",max_volume);

      else

         error_description=StringFormat("Volume is greater than the maximal allowed SYMBOL_VOLUME_MAX=%.2f",max_volume);

      return(false);

     }

//--- get minimal step of volume changing

   double volume_step=m_symbol.LotsStep();

   int ratio=(int)MathRound(volume/volume_step);

   if(MathAbs(ratio*volume_step-volume)>0.0000001)

     {

      if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")

         error_description=StringFormat("1J5< =5 :@0B5= <8=8<0;L=><C H03C SYMBOL_VOLUME_STEP=%.2f, 1;8609H89 ?@028;L=K9 >1J5< %.2f",

                                        volume_step,ratio*volume_step);

      else

         error_description=StringFormat("Volume is not a multiple of the minimal step SYMBOL_VOLUME_STEP=%.2f, the closest correct volume is %.2f",

                                        volume_step,ratio*volume_step);

      return(false);

     }

   error_description="Correct volume value";

   return(true);

  }

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

//| Lot Check                                                        |

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

double LotCheck(double lots)

  {

//--- calculate maximum volume

   double volume=NormalizeDouble(lots,2);

   double stepvol=m_symbol.LotsStep();

   if(stepvol>0.0)

      volume=stepvol*MathFloor(volume/stepvol);

//---

   double minvol=m_symbol.LotsMin();

   if(volume<minvol)

      volume=0.0;

//---

   double maxvol=m_symbol.LotsMax();

   if(volume>maxvol)

      volume=maxvol;

   return(volume);

  }

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

//| Check Freeze and Stops levels                                    |

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

bool FreezeStopsLevels(double &level)

  {

//--- check Freeze and Stops levels

/*

   Type of order/position  |  Activation price  |  Check

   ------------------------|--------------------|--------------------------------------------

   Buy Limit order         |  Ask               |  Ask-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

   Buy Stop order          |  Ask	            |  OpenPrice-Ask  >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell Limit order        |  Bid	            |  OpenPrice-Bid  >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell Stop order	      |  Bid	            |  Bid-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

   Buy position            |  Bid	            |  TakeProfit-Bid >= SYMBOL_TRADE_FREEZE_LEVEL 

                           |                    |  Bid-StopLoss   >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell position           |  Ask	            |  Ask-TakeProfit >= SYMBOL_TRADE_FREEZE_LEVEL

                           |                    |  StopLoss-Ask   >= SYMBOL_TRADE_FREEZE_LEVEL

                           

   Buying is done at the Ask price                 |  Selling is done at the Bid price

   ------------------------------------------------|----------------------------------

   TakeProfit        >= Bid                        |  TakeProfit        <= Ask

   StopLoss          <= Bid	                     |  StopLoss          >= Ask

   TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

   Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

*/

   if(!RefreshRates() || !m_symbol.Refresh())

      return(false);

//--- FreezeLevel -> for pending order and modification

   double freeze_level=m_symbol.FreezeLevel()*m_symbol.Point();

   if(freeze_level==0.0)

      freeze_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;

//--- StopsLevel -> for TakeProfit and StopLoss

   double stop_level=m_symbol.StopsLevel()*m_symbol.Point();

   if(stop_level==0.0)

      stop_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;



   if(freeze_level<=0.0 || stop_level<=0.0)

      return(false);



   level=(freeze_level>stop_level)?freeze_level:stop_level;



   double spread=m_symbol.Spread()*ExtAdjustedPoint;

   level=(level>spread)?level:spread;

//---

   return(true);

  }

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

//| Print CTrade result                                              |

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

void PrintResultTrade(CTrade &trade,CSymbolInfo &symbol)

  {

   Print("File: ",__FILE__,", symbol: ",symbol.Name());

   Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));

   Print("code of request result as a string: "+trade.ResultRetcodeDescription());

   Print("Deal ticket: "+IntegerToString(trade.ResultDeal()));

   Print("Order ticket: "+IntegerToString(trade.ResultOrder()));

   Print("Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));

   Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits()));

   Print("Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits()));

   Print("Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));

   Print("Broker comment: "+trade.ResultComment());

  }

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

//| Trailing                                                         |

//|   InpTrailingStop: min distance from price to Stop Loss          |

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

void Trailing(const double stop_level)

  {

/*

     Buying is done at the Ask price                 |  Selling is done at the Bid price

   ------------------------------------------------|----------------------------------

   TakeProfit        >= Bid                        |  TakeProfit        <= Ask

   StopLoss          <= Bid	                     |  StopLoss          >= Ask

   TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

   Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

*/

   if(InpTrailingStop==0)

      return;

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions

      if(m_position.SelectByIndex(i))

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

              {

               if(m_position.PriceCurrent()-m_position.PriceOpen()>ExtTrailingStop+ExtTrailingStep)

                  if(m_position.StopLoss()<m_position.PriceCurrent()-(ExtTrailingStop+ExtTrailingStep))

                     if(ExtTrailingStop>=stop_level)

                       {

                        if(!m_trade.PositionModify(m_position.Ticket(),

                           m_symbol.NormalizePrice(m_position.PriceCurrent()-ExtTrailingStop),

                           m_position.TakeProfit()))

                           Print("Modify ",m_position.Ticket(),

                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),

                                 ", description of result: ",m_trade.ResultRetcodeDescription());

                        RefreshRates();

                        m_position.SelectByIndex(i);

                        PrintResultModify(m_trade,m_symbol,m_position);

                        continue;

                       }

              }

            else

              {

               if(m_position.PriceOpen()-m_position.PriceCurrent()>ExtTrailingStop+ExtTrailingStep)

                  if((m_position.StopLoss()>(m_position.PriceCurrent()+(ExtTrailingStop+ExtTrailingStep))) || 

                     (m_position.StopLoss()==0))

                     if(ExtTrailingStop>=stop_level)

                       {

                        if(!m_trade.PositionModify(m_position.Ticket(),

                           m_symbol.NormalizePrice(m_position.PriceCurrent()+ExtTrailingStop),

                           m_position.TakeProfit()))

                           Print("Modify ",m_position.Ticket(),

                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),

                                 ", description of result: ",m_trade.ResultRetcodeDescription());

                        RefreshRates();

                        m_position.SelectByIndex(i);

                        PrintResultModify(m_trade,m_symbol,m_position);

                       }

              }



           }

  }

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

//| Print CTrade result                                              |

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

void PrintResultModify(CTrade &trade,CSymbolInfo &symbol,CPositionInfo &position)

  {

   Print("File: ",__FILE__,", symbol: ",symbol.Name());

   Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));

   Print("code of request result as a string: "+trade.ResultRetcodeDescription());

   Print("Deal ticket: "+IntegerToString(trade.ResultDeal()));

   Print("Order ticket: "+IntegerToString(trade.ResultOrder()));

   Print("Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));

   Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits()));

   Print("Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits()));

   Print("Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));

   Print("Broker comment: "+trade.ResultComment());

   Print("Freeze Level: "+DoubleToString(symbol.FreezeLevel(),0),", Stops Level: "+DoubleToString(symbol.StopsLevel(),0));

   Print("Price of position opening: "+DoubleToString(position.PriceOpen(),symbol.Digits()));

   Print("Price of position's Stop Loss: "+DoubleToString(position.StopLoss(),symbol.Digits()));

   Print("Price of position's Take Profit: "+DoubleToString(position.TakeProfit(),symbol.Digits()));

   Print("Current price by position: "+DoubleToString(position.PriceCurrent(),symbol.Digits()));

  }

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

//| Search trading signals                                           |

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

bool SearchTradingSignals(void)

  {

   MqlDateTime STimeCurrent;

   TimeToStruct(TimeCurrent(),STimeCurrent);

   long time_current=STimeCurrent.hour*60*60+STimeCurrent.min*60+STimeCurrent.sec;

   switch(STimeCurrent.day_of_week)

     {

      case  1: // Monday

         if(ExtMonday_1==0 && ExtMonday_2==0 && ExtMonday_3==0)

         return(true);

         //--- Monday time 1

         if(ExtMonday_1!=0 && (time_current>=ExtMonday_1 && time_current<ExtMonday_1+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==1 && (time_last_setup>=ExtMonday_1 && time_last_setup<ExtMonday_1+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Monday time 2

         if(ExtMonday_2!=0 && (time_current>=ExtMonday_2 && time_current<ExtMonday_2+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==1 && (time_last_setup>=ExtMonday_2 && time_last_setup<ExtMonday_2+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Monday time 3

         if(ExtMonday_3!=0 && (time_current>=ExtMonday_3 && time_current<ExtMonday_3+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==1 && (time_last_setup>=ExtMonday_3 && time_last_setup<ExtMonday_3+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }



         break;

      case  2: // Tuesday

         if(ExtTuesday_1==0 && ExtTuesday_2==0 && ExtTuesday_3==0)

         return(true);

         //--- Tuesday time 1

         if(ExtTuesday_1!=0 && (time_current>=ExtTuesday_1 && time_current<ExtTuesday_1+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==1 && (time_last_setup>=ExtTuesday_1 && time_last_setup<ExtTuesday_1+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Tuesday time 2

         if(ExtTuesday_2!=0 && (time_current>=ExtTuesday_2 && time_current<ExtTuesday_2+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==2 && (time_last_setup>=ExtTuesday_2 && time_last_setup<ExtTuesday_2+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Tuesday time 3

         if(ExtTuesday_3!=0 && (time_current>=ExtTuesday_3 && time_current<ExtTuesday_3+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==2 && (time_last_setup>=ExtTuesday_3 && time_last_setup<ExtTuesday_3+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }



         break;

      case  3: // Wednesday

         if(ExtWednesday_1==0 && ExtWednesday_2==0 && ExtWednesday_3==0)

         return(true);

         //--- Wednesday time 1

         if(ExtWednesday_1!=0 && (time_current>=ExtWednesday_1 && time_current<ExtWednesday_1+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==3 && (time_last_setup>=ExtWednesday_1 && time_last_setup<ExtWednesday_1+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Wednesday time 2

         if(ExtWednesday_2!=0 && (time_current>=ExtWednesday_2 && time_current<ExtWednesday_2+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==3 && (time_last_setup>=ExtWednesday_2 && time_last_setup<ExtWednesday_2+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Wednesday time 3

         if(ExtWednesday_3!=0 && (time_current>=ExtWednesday_3 && time_current<ExtWednesday_3+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==3 && (time_last_setup>=ExtWednesday_3 && time_last_setup<ExtWednesday_3+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }



         break;

      case  4: // Thursday

         if(ExtThursday_1==0 && ExtThursday_2==0 && ExtThursday_3==0)

         return(true);

         //--- Thursday time 1

         if(ExtThursday_1!=0 && (time_current>=ExtThursday_1 && time_current<ExtThursday_1+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==4 && (time_last_setup>=ExtThursday_1 && time_last_setup<ExtThursday_1+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Thursday time 2

         if(ExtThursday_2!=0 && (time_current>=ExtThursday_2 && time_current<ExtThursday_2+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==4 && (time_last_setup>=ExtThursday_2 && time_last_setup<ExtThursday_2+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Thursday time 3

         if(ExtThursday_3!=0 && (time_current>=ExtThursday_3 && time_current<ExtThursday_3+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==4 && (time_last_setup>=ExtThursday_3 && time_last_setup<ExtThursday_3+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }



         break;

      default: // Friday

         if(ExtFriday_1==0 && ExtFriday_2==0 && ExtFriday_3==0)

         return(true);

         //--- Friday time 1

         if(ExtFriday_1!=0 && (time_current>=ExtFriday_1 && time_current<ExtFriday_1+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==5 && (time_last_setup>=ExtFriday_1 && time_last_setup<ExtFriday_1+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Friday time 2

         if(ExtFriday_2!=0 && (time_current>=ExtFriday_2 && time_current<ExtFriday_2+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==5 && (time_last_setup>=ExtFriday_2 && time_last_setup<ExtFriday_2+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }

         //--- Friday time 3

         if(ExtFriday_3!=0 && (time_current>=ExtFriday_3 && time_current<ExtFriday_3+60))

           {

            datetime last_setup=LastPendingOrderTimeSetup();

            MqlDateTime SLastSetup;

            TimeToStruct(last_setup,SLastSetup);

            long time_last_setup=SLastSetup.hour*60*60+SLastSetup.min*60+SLastSetup.sec;

            if(SLastSetup.day_of_week==5 && (time_last_setup>=ExtFriday_3 && time_last_setup<ExtFriday_3+60))

               return(true);

            ExtNeedDeleteAll=true;

            int size_need_pending=ArraySize(SNeedPending);

            ArrayResize(SNeedPending,size_need_pending+2);

            SNeedPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

            SNeedPending[size_need_pending].price=m_symbol.Ask()+ExtIndent;

            SNeedPending[size_need_pending].magic=InpMagic;

            SNeedPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

            SNeedPending[size_need_pending+1].price=m_symbol.Bid()-ExtIndent;

            SNeedPending[size_need_pending+1].magic=InpMagic;

            return(true);

           }



         break;

     }

//---

   return(true);

  }

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

//| Delete all pending orders                                        |

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

void DeleteAllPendingOrders(const double level)

  {

   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() && m_order.Magic()==InpMagic)

           {

            if(m_order.OrderType()==ORDER_TYPE_BUY_LIMIT)

              {

               if(m_symbol.Ask()-m_order.PriceOpen()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_BUY_STOP)

              {

               if(m_order.PriceOpen()-m_symbol.Ask()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_SELL_LIMIT)

              {

               if(m_order.PriceOpen()-m_symbol.Bid()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_SELL_STOP)

              {

               if(m_symbol.Bid()-m_order.PriceOpen()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

           }

  }

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

//| Is pendinf orders exists                                         |

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

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() && m_order.Magic()==InpMagic)

            return(true);

//---

   return(false);

  }

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

//| Place Orders                                                     |

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

void PlaceOrders(const int index_in_structure,const ENUM_ORDER_TYPE order_type,

                 const double level,const ulong magic)

  {

//--- check Freeze and Stops levels

/*

   Type of order/position  |  Activation price  |  Check

   ------------------------|--------------------|--------------------------------------------

   Buy Limit order         |  Ask               |  Ask-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

   Buy Stop order          |  Ask	            |  OpenPrice-Ask  >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell Limit order        |  Bid	            |  OpenPrice-Bid  >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell Stop order	      |  Bid	            |  Bid-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

   Buy position            |  Bid	            |  TakeProfit-Bid >= SYMBOL_TRADE_FREEZE_LEVEL 

                           |                    |  Bid-StopLoss   >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell position           |  Ask	            |  Ask-TakeProfit >= SYMBOL_TRADE_FREEZE_LEVEL

                           |                    |  StopLoss-Ask   >= SYMBOL_TRADE_FREEZE_LEVEL

                           

   Buying is done at the Ask price                 |  Selling is done at the Bid price

   ------------------------------------------------|----------------------------------

   TakeProfit        >= Bid                        |  TakeProfit        <= Ask

   StopLoss          <= Bid	                     |  StopLoss          >= Ask

   TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

   Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

*/

   double price=0.0,sl=0.0,tp=0.0;

//--- buy limit

   if(order_type==ORDER_TYPE_BUY_LIMIT)

     {

      price=SNeedPending[index_in_structure].price;

      if(m_symbol.Ask()-price<level) // check price

         price=m_symbol.Ask()-level;



      sl=(InpStopLoss==0)?0.0:price-ExtStopLoss;

      if(sl!=0.0 && ExtStopLoss<level)// check sl

         sl=price-level;



      tp=(InpTakeProfit==0)?0.0:price+ExtTakeProfit;

      if(tp!=0.0 && ExtTakeProfit<level) // check price

         tp=price+level;



      PendingOrder(ORDER_TYPE_BUY_LIMIT,price,sl,tp,magic);

      ArrayRemove(SNeedPending,index_in_structure,1);

      ExtWaitingPendingOrder=false;

     }

//--- sell limit

   if(order_type==ORDER_TYPE_SELL_LIMIT)

     {

      price=SNeedPending[index_in_structure].price;

      if(price-m_symbol.Bid()<level) // check price

         price=m_symbol.Bid()+level;



      sl=(InpStopLoss==0)?0.0:price+ExtStopLoss;

      if(sl!=0.0 && ExtStopLoss<level) // check sl

         sl=price+level;



      tp=(InpTakeProfit==0)?0.0:price-ExtTakeProfit;

      if(tp!=0.0 && ExtTakeProfit<level) // check tp

         tp=price-level;



      PendingOrder(ORDER_TYPE_SELL_LIMIT,price,sl,tp,magic);

      ArrayRemove(SNeedPending,index_in_structure,1);

      ExtWaitingPendingOrder=false;

     }

//--- buy stop

   if(order_type==ORDER_TYPE_BUY_STOP)

     {

      price=SNeedPending[index_in_structure].price;

      if(price-m_symbol.Ask()<level) // check price

         price=m_symbol.Ask()+level;



      sl=(InpStopLoss==0)?0.0:price-ExtStopLoss;

      if(sl!=0.0 && ExtStopLoss<level)// check sl

         sl=price-level;



      tp=(InpTakeProfit==0)?0.0:price+ExtTakeProfit;

      if(tp!=0.0 && ExtTakeProfit<level) // check price

         tp=price+level;



      PendingOrder(ORDER_TYPE_BUY_STOP,price,sl,tp,magic);

      ArrayRemove(SNeedPending,index_in_structure,1);

      ExtWaitingPendingOrder=false;

     }

//--- sell stop

   if(order_type==ORDER_TYPE_SELL_STOP)

     {

      price=SNeedPending[index_in_structure].price;

      if(m_symbol.Bid()-price<level) // check price

         price=m_symbol.Bid()-level;



      sl=(InpStopLoss==0)?0.0:price+ExtStopLoss;

      if(sl!=0.0 && ExtStopLoss<level) // check sl

         sl=price+level;



      tp=(InpTakeProfit==0)?0.0:price-ExtTakeProfit;

      if(tp!=0.0 && ExtTakeProfit<level) // check tp

         tp=price-level;



      PendingOrder(ORDER_TYPE_SELL_STOP,price,sl,tp,magic);

      ArrayRemove(SNeedPending,index_in_structure,1);

      ExtWaitingPendingOrder=false;

     }

  }

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

//| Pending order                                                    |

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

bool PendingOrder(const ENUM_ORDER_TYPE order_type,double price,

                  double sl,double tp,const ulong magic)

  {

   sl=m_symbol.NormalizePrice(sl);

   tp=m_symbol.NormalizePrice(tp);

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   ENUM_ORDER_TYPE check_order_type=-1;

   switch(order_type)

     {

      case  ORDER_TYPE_BUY:

         check_order_type=ORDER_TYPE_BUY;

         break;

      case ORDER_TYPE_SELL:

         check_order_type=ORDER_TYPE_SELL;

         break;

      case ORDER_TYPE_BUY_LIMIT:

         check_order_type=ORDER_TYPE_BUY;

         break;

      case ORDER_TYPE_SELL_LIMIT:

         check_order_type=ORDER_TYPE_SELL;

         break;

      case ORDER_TYPE_BUY_STOP:

         check_order_type=ORDER_TYPE_BUY;

         break;

      case ORDER_TYPE_SELL_STOP:

         check_order_type=ORDER_TYPE_SELL;

         break;

      default:

         return(false);

         break;

     }

//---

   double long_lot=0.0;

   double short_lot=0.0;

   if(InpLotOrRisk==risk)

     {

      bool error=false;

      long_lot=m_money.CheckOpenLong(m_symbol.Ask(),sl);

      if(InpPrintLog)

         Print("sl=",DoubleToString(sl,m_symbol.Digits()),

               ", CheckOpenLong: ",DoubleToString(long_lot,2),

               ", Balance: ",    DoubleToString(m_account.Balance(),2),

               ", Equity: ",     DoubleToString(m_account.Equity(),2),

               ", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));

      if(long_lot==0.0)

        {

         if(InpPrintLog)

            Print(__FUNCTION__,", ERROR: method CheckOpenLong returned the value of \"0.0\"");

         error=true;

        }

      //---

      short_lot=m_money.CheckOpenShort(m_symbol.Bid(),sl);

      if(InpPrintLog)

         Print("sl=",DoubleToString(sl,m_symbol.Digits()),

               ", CheckOpenLong: ",DoubleToString(short_lot,2),

               ", Balance: ",    DoubleToString(m_account.Balance(),2),

               ", Equity: ",     DoubleToString(m_account.Equity(),2),

               ", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));

      if(short_lot==0.0)

        {

         if(InpPrintLog)

            Print(__FUNCTION__,", ERROR: method CheckOpenShort returned the value of \"0.0\"");

         error=true;

        }

      //---

      if(error)

         return(false);

     }

   else if(InpLotOrRisk==lot)

     {

      long_lot=InpVolumeLotOrRisk;

      short_lot=InpVolumeLotOrRisk;

     }

   else if(InpLotOrRisk==lots_min)

     {

      long_lot=m_symbol.LotsMin();

      short_lot=m_symbol.LotsMin();

     }

   else

      return(false);

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   double check_price=0;

   double check_lot=0;

   if(check_order_type==ORDER_TYPE_BUY)

     {

      check_price=m_symbol.Ask();

      check_lot=long_lot;

     }

   else

     {

      check_price=m_symbol.Bid();

      check_lot=short_lot;

     }

//---

   if(m_symbol.LotsLimit()>0.0)

     {

      double volume_buys        = 0.0;   double volume_sells       = 0.0;

      double volume_buy_limits  = 0.0;   double volume_sell_limits = 0.0;

      double volume_buy_stops   = 0.0;   double volume_sell_stops  = 0.0;

      CalculateAllVolumes(volume_buys,volume_sells,

                          volume_buy_limits,volume_sell_limits,

                          volume_buy_stops,volume_sell_stops);

      if(volume_buys+volume_sells+

         volume_buy_limits+volume_sell_limits+

         volume_buy_stops+volume_sell_stops+check_lot>m_symbol.LotsLimit())

        {

         if(InpPrintLog)

            Print("#0 ,",EnumToString(order_type),", ",

                  "Volume Buy's (",DoubleToString(volume_buys,2),")",

                  "Volume Sell's (",DoubleToString(volume_sells,2),")",

                  "Volume Buy limit's (",DoubleToString(volume_buy_limits,2),")",

                  "Volume Sell limit's (",DoubleToString(volume_sell_limits,2),")",

                  "Volume Buy stops's (",DoubleToString(volume_buy_stops,2),")",

                  "Volume Sell stops's (",DoubleToString(volume_sell_stops,2),")",

                  "Check lot (",DoubleToString(check_lot,2),")",

                  " > Lots Limit (",DoubleToString(m_symbol.LotsLimit(),2),")");

         return(false);

        }

     }

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   double free_margin_check= m_account.FreeMarginCheck(m_symbol.Name(),check_order_type,check_lot,check_price);

   double margin_check     = m_account.MarginCheck(m_symbol.Name(),check_order_type,check_lot,price);

   if(free_margin_check>margin_check)

     {

      if(m_trade.OrderOpen(m_symbol.Name(),order_type,check_lot,0.0,

         m_symbol.NormalizePrice(price),m_symbol.NormalizePrice(sl),m_symbol.NormalizePrice(tp)))

        {

         if(m_trade.ResultOrder()==0)

           {

            if(InpPrintLog)

               Print("#1 ",EnumToString(order_type)," -> false. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

            return(false);

           }

         else

           {

            if(InpPrintLog)

               Print("#2 ",EnumToString(order_type)," -> true. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

            return(true);

           }

        }

      else

        {

         if(InpPrintLog)

            Print("#3 ",EnumToString(order_type)," -> false. Result Retcode: ",m_trade.ResultRetcode(),

                  ", description of result: ",m_trade.ResultRetcodeDescription());

         if(InpPrintLog)

            PrintResultTrade(m_trade,m_symbol);

         return(false);

        }

     }

   else

     {

      if(InpPrintLog)

         Print(__FUNCTION__,", ERROR: method CAccountInfo::FreeMarginCheck returned the value ",DoubleToString(free_margin_check,2));

      return(false);

     }

//---

   return(false);

  }

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

//| Calculate all volumes                                            |

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

void CalculateAllVolumes(double &volumne_buys,double &volumne_sells,

                         double &volumne_buy_limits,double &volumne_sell_limits,

                         double &volumne_buy_stops,double &volumne_sell_stops)

  {

   volumne_buys         = 0.0;   volumne_sells        = 0.0;

   volumne_buy_limits   = 0.0;   volumne_sell_limits  = 0.0;

   volumne_buy_stops    = 0.0;   volumne_sell_stops   = 0.0;



   for(int i=PositionsTotal()-1;i>=0;i--)

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

         if(m_position.Symbol()==m_symbol.Name())

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

               volumne_buys+=m_position.Volume();

            else if(m_position.PositionType()==POSITION_TYPE_SELL)

               volumne_sells+=m_position.Volume();

           }



   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(m_order.OrderType()==ORDER_TYPE_BUY_LIMIT)

               volumne_buy_limits+=m_order.VolumeInitial();

            else if(m_order.OrderType()==ORDER_TYPE_SELL_LIMIT)

               volumne_sell_limits+=m_order.VolumeInitial();

            else if(m_order.OrderType()==ORDER_TYPE_BUY_STOP)

               volumne_buy_stops+=m_order.VolumeInitial();

            else if(m_order.OrderType()==ORDER_TYPE_SELL_STOP)

               volumne_sell_stops+=m_order.VolumeInitial();

           }

  }

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

//| Last Pending Order Time Setup                                    |

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

datetime LastPendingOrderTimeSetup(void)

  {

   datetime last_time=0;

   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() && m_order.Magic()==InpMagic)

            if(m_order.TimeSetup()>last_time)

               last_time=m_order.TimeSetup();

//---

   return(last_time);

  }

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

Similar scripts

Elder iForce Strategy Pending 2

Elder iForce Strategy Pending

Two MA one StdDev EA

SAR and Pending order

Two iMA Pending

iDeMarker Pending iMA Filter

iSAR Pending Stop

iCCI Pending Stop

Min Max for N Bars Martingale

ModStopReverse Alligator

High Low MA Channel

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