Trade line Close

ÿþ//+------------------------------------------------------------------+

//|                                             Trade line Close.mq5 |

//|                           Copyright © 2021, Aleksandr Klapatyuk. |

//|                            https://www.mql5.com/ru/users/sanalex |

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

#property copyright   "Copyright © 2021, Aleksandr Klapatyuk"

#property link        "https://www.mql5.com/ru/users/sanalex"

#property description "Copyright © 2021, Vladimir Karputov"

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

#property version     "1.006"

#define   UNO_MAGIC   0

//---

#include <Trade\Trade.mqh>

#include <Trade\SymbolInfo.mqh>

#include <Trade\PositionInfo.mqh>

#include <Trade\AccountInfo.mqh>

//---

double            m_adjusted_point;      // : point value adjusted for 3 or 5 points

CTrade            m_trade;               // : trading object

CSymbolInfo       m_symbol;              // : symbol info object

CPositionInfo     m_position;            // : trade position object

CAccountInfo      m_account;             // : account info wrapper

//---

input group  "---- : Parameters:  ----"

input double MaximumRisk             = 0.02;        // : Maximum Risk in percentage

input double DecreaseFactor          = 3;           // : Descrease factor

input uint   InpStopLoss             = 120;         // : Stop Loss (in pips) --> (Zero is not allowed)

input uint   InpTakeProfit           = 50;          // : Take Profit (in pips) --> (Zero is not allowed)

input group  "---- : Parameters Open:  ----"

input string InpObjUpName_op         = "opensell";  // : Obj: Follows the price down (Horizontal Line)

input string InpObjDownName_op       = "openbuy";   // : Obj: Follows the price up (Horizontal Line)

input ushort InpObjTrailingStop_op   = 50;          // : Obj: Trailing Stop (distance from price to object, in pips)

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

input group  "---- : Parameters Close:  ----"

input string InpObjUpName            = "closesell"; // : Obj: Follows the price down (Horizontal Line)

input string InpObjDownName          = "closebuy";  // : Obj: Follows the price up (Horizontal Line)

input ushort InpObjTrailingStop      = 0;           // : Obj: Trailing Stop (distance from price to object, in pips)

input ushort InpObjTrailingStep      = 0;           // : Obj: Trailing Step, in pips (1.00045-1.00055=1 pips)

input group  "---- : Auto trade:  ----"

input bool   InpAuto_trade           = false;       // : Auto trade

input bool   InpRevers               = false;       // : Revers

//---

double   m_stop_loss            = 0.0; // : Stop Loss

double   m_take_profit          = 0.0; // : Take Profit

double   m_obj_trailing_stop_op = 0.0; // : Obj: Trailing Stop

double   m_obj_trailing_step_op = 0.0; // : Obj: Trailing Step

datetime m_prev_bars_op         = D'1970.01.01 00:00';

datetime m_obj_last_trailing_op = D'1970.01.01 00:00';

datetime m_ExtPrevBars_op       = D'1970.01.01 00:00';

datetime m_ExtLastSignals_op    = D'1970.01.01 00:00';

datetime m_ExtPrevBars_x_op     = D'1970.01.01 00:00';

datetime m_ExtLastSignals_x_op  = D'1970.01.01 00:00';

//---

double   m_obj_trailing_stop    = 0.0; // : Obj: Trailing Stop

double   m_obj_trailing_step    = 0.0; // : Obj: Trailing Step

datetime m_prev_bars            = D'1970.01.01 00:00';

datetime m_obj_last_trailing    = D'1970.01.01 00:00';

datetime m_ExtPrevBars          = D'1970.01.01 00:00';

datetime m_ExtLastSignals       = D'1970.01.01 00:00';

datetime m_ExtPrevBars_x        = D'1970.01.01 00:00';

datetime m_ExtLastSignals_x     = D'1970.01.01 00:00';

string   m_name_but[]           = {"CB","B","Del","S","CS"};

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

//| Calculate optimal lot size                                       |

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

double TradeSizeOptimized(void)

  {

   double price=0.0;

   double margin=0.0;

//--- select lot size

   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))

      return(0.0);

   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin))

      return(0.0);

   if(margin<=0.0)

      return(0.0);

   double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_MARGIN_FREE)*MaximumRisk/margin,2);

//--- calculate number of losses orders without a break

   if(DecreaseFactor>0)

     {

      //--- select history for access

      HistorySelect(0,TimeCurrent());

      //---

      int    orders=HistoryDealsTotal();  // total history deals

      int    losses=0;                    // number of losses orders without a break

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

        {

         ulong ticket=HistoryDealGetTicket(i);

         if(ticket==0)

           {

            Print("HistoryDealGetTicket failed, no trade history");

            break;

           }

         //--- check symbol

         if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)

            continue;

         //--- check Expert Magic number

         if(HistoryDealGetInteger(ticket,DEAL_MAGIC)!=UNO_MAGIC)

            continue;

         //--- check profit

         double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);

         if(profit>0.0)

            break;

         if(profit<0.0)

            losses++;

        }

      //---

      if(losses>1)

         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);

     }

//--- normalize and check limits

   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);

   lot=stepvol*NormalizeDouble(lot/stepvol,0);

   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);

   if(lot<minvol)

      lot=minvol;

   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);

   if(lot>maxvol)

      lot=maxvol;

//--- return trading volume

   return(lot);

  }

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

//| Expert initialization function                                   |

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

int OnInit(void)

  {

//--- initialize common information

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

      return(false);

   RefreshRates();

   m_trade.SetExpertMagicNumber(UNO_MAGIC); // magic

   m_trade.SetMarginMode();

   m_trade.SetTypeFillingBySymbol(Symbol());

//--- tuning for 3 or 5 digits

   int digits_adjust=1;

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

      digits_adjust=10;

   m_adjusted_point=m_symbol.Point()*digits_adjust;

//--- set default deviation for trading in adjusted points

   m_stop_loss            = InpStopLoss*m_adjusted_point;

   m_take_profit          = InpTakeProfit*m_adjusted_point;

   m_obj_trailing_stop_op = InpObjTrailingStop_op*m_adjusted_point;

   m_obj_trailing_step_op = InpObjTrailingStep_op*m_adjusted_point;

   m_obj_trailing_stop    = InpObjTrailingStop*m_adjusted_point;

   m_obj_trailing_step    = InpObjTrailingStep*m_adjusted_point;

//--- set default deviation for trading in adjusted points

   m_trade.SetDeviationInPoints(3*digits_adjust);

//---

   int but_y=5;

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

     {

      ButtonCreate(m_name_but[i],but_y,17,30,15,8);

      but_y=but_y+30;

     }

   return(INIT_SUCCEEDED);

  }

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

//| Expert deinitialization function                                 |

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

void OnDeinit(const int reason)

  {

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

     {

      ObjectDelete(0,Symbol()+m_name_but[i]);

     }

  }

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

//| Expert tick function                                             |

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

void OnTick(void)

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

      return;

   OnTickObjTrailing_op();

   OnTickObjTrailing();

//---

   if(ProcessingClosBuy() || ProcessingClosSell() || ProcessingOpenBuy() || ProcessingOpenSell() || ButtonOnTick())

     {

      return;

     }

  }

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

//| Check for open position conditions                               |

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

void CheckForOpenBuy(void)

  {

   double price=m_symbol.Ask();

   double tp   =m_symbol.Ask()+m_take_profit;

   double sl   =m_symbol.Ask()-m_stop_loss;

   double BY_1 =m_symbol.Bid()-m_take_profit;

//--- check for free money

   if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,TradeSizeOptimized(),price)<0.0)

      printf("We have no money. Free Margin = %f",m_account.FreeMargin());

   else

     {

      //--- open position

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,TradeSizeOptimized(),price,0.0,0.0))

         printf("Position by %s to be opened",Symbol());

      else

        {

         printf("Error opening BUY position by %s : '%s'",Symbol(),m_trade.ResultComment());

         printf("Open parameters : price=%f,TP=%f",price,0.0);

        }

      PlaySound("ok.wav");

      ObjectsDeleteAll(0,InpObjDownName_op);

      CreateHline(0,0,InpObjDownName,tp,clrGreen,0,0,1,1,1,1,2);

      CreateHline(0,0,InpObjUpName_op,sl,clrGreen,0,0,1,1,1,1,2);

      if(InpAuto_trade)

        {

         if(!InpRevers)

            CreateHline(0,0,InpObjDownName_op,BY_1,clrGold,0,0,1,1,1,1,2);

         else

            CreateHline(0,0,InpObjDownName_op,tp,clrGold,0,0,1,1,1,1,2);

        }

     }

  }

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

//| Check for open position conditions                               |

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

void CheckForOpenSell(void)

  {

   double price=m_symbol.Bid();

   double tp   =m_symbol.Bid()-m_take_profit;

   double sl   =m_symbol.Bid()+m_stop_loss;

   double SL_1 =m_symbol.Ask()+m_take_profit;

//--- check for free money

   if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,TradeSizeOptimized(),price)<0.0)

      printf("We have no money. Free Margin = %f",m_account.FreeMargin());

   else

     {

      //--- open position

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,TradeSizeOptimized(),price,0.0,0.0))

         printf("Position by %s to be opened",Symbol());

      else

        {

         printf("Error opening SELL position by %s : '%s'",Symbol(),m_trade.ResultComment());

         printf("Open parameters : price=%f,TP=%f",price,0.0);

        }

      PlaySound("ok.wav");

      ObjectsDeleteAll(0,InpObjUpName_op);

      CreateHline(0,0,InpObjUpName,tp,clrGreen,0,0,1,1,1,1,2);

      CreateHline(0,0,InpObjDownName_op,sl,clrGreen,0,0,1,1,1,1,2);

      if(InpAuto_trade)

        {

         if(!InpRevers)

            CreateHline(0,0,InpObjUpName_op,SL_1,clrGold,0,0,1,1,1,1,2);

         else

            CreateHline(0,0,InpObjUpName_op,tp,clrGold,0,0,1,1,1,1,2);

        }

     }

  }

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

//| Check for close position conditions                              |

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

void CheckForCloseBuy(void)

  {

//--- close position

   ClosePositions(POSITION_TYPE_BUY);

   ObjectsDeleteAll(0,InpObjDownName);

  }

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

//| Check for close position conditions                              |

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

void CheckForCloseSell(void)

  {

//--- close position

   ClosePositions(POSITION_TYPE_SELL);

   ObjectsDeleteAll(0,InpObjUpName);

  }

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

//| Refreshes the symbol quotes data                                 |

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

bool RefreshRates()

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

     {

      return(false);

     }

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

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

     {

      return(false);

     }

   return(true);

  }

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

//| Check Freeze and Stops levels                                    |

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

void FreezeStopsLevels(double &freeze,double &stops)

  {

//--- check Freeze and Stops levels

   double coeff=(double)1;

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

      return;

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

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

   if(freeze_level==0.0)

      if(1>0)

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

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

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

   if(stop_level==0.0)

      if(1>0)

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

//---

   freeze=freeze_level;

   stops=stop_level;

   return;

  }

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

//| Close positions                                                  |

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

void ClosePositions(const ENUM_POSITION_TYPE pos_type)

  {

   double freeze=0.0,stops=0.0;

   FreezeStopsLevels(freeze,stops);

   int total=PositionsTotal();

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

      if(m_position.SelectByIndex(i))

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

            if(m_position.PositionType()==pos_type)

              {

               if(m_position.PositionType()==POSITION_TYPE_BUY)

                 {

                  bool take_profit_level=((m_position.TakeProfit()!=0.0 && m_position.TakeProfit()-m_position.PriceCurrent()>=freeze) || m_position.TakeProfit()==0.0);

                  bool stop_loss_level=((m_position.StopLoss()!=0.0 && m_position.PriceCurrent()-m_position.StopLoss()>=freeze) || m_position.StopLoss()==0.0);

                  if(take_profit_level && stop_loss_level)

                     if(!m_trade.PositionClose(m_position.Ticket()))

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","BUY PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());

                 }

               if(m_position.PositionType()==POSITION_TYPE_SELL)

                 {

                  bool take_profit_level=((m_position.TakeProfit()!=0.0 && m_position.PriceCurrent()-m_position.TakeProfit()>=freeze) || m_position.TakeProfit()==0.0);

                  bool stop_loss_level=((m_position.StopLoss()!=0.0 && m_position.StopLoss()-m_position.PriceCurrent()>=freeze) || m_position.StopLoss()==0.0);

                  if(take_profit_level && stop_loss_level)

                     if(!m_trade.PositionClose(m_position.Ticket()))

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","SELL PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());

                 }

               PlaySound("ok.wav");

              }

  }

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

//| ProcessingOpenSell                                               |

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

bool ProcessingOpenSell(void)

  {

   bool rv=false;

   datetime time_current=TimeCurrent();

   if(time_current-m_ExtLastSignals_op>10)

     {

      MqlRates rates[];

      int start_pos=0,count=1;

      if(CopyRates(m_symbol.Name(),Period(),start_pos,count,rates)!=count)

        {

         m_ExtPrevBars_op=0;

         return(true);

        }

      double price_line=0.0;

      if(ObjectFind(0,InpObjUpName_op)>=0)

        {

         long object_type=ObjectGetInteger(0,InpObjUpName_op,OBJPROP_TYPE);

         if(object_type==OBJ_HLINE)

            price_line=ObjectGetDouble(0,InpObjUpName_op,OBJPROP_PRICE);

         if(price_line>0.0)

           {

            if((rates[0].open>price_line && rates[0].close<price_line) ||

               (rates[0].open<price_line && rates[0].close>price_line))

              {

               CheckForOpenSell();

              }

           }

        }

     }

   return(rv);

  }

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

//| ProcessingOpenBuy                                                |

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

bool ProcessingOpenBuy(void)

  {

   bool rv=false;

   datetime time_current=TimeCurrent();

   if(time_current-m_ExtLastSignals_x_op>10)

     {

      MqlRates rates[];

      //ArraySetAsSeries(rates,true);

      int start_pos=0,count=1;

      if(CopyRates(m_symbol.Name(),Period(),start_pos,count,rates)!=count)

        {

         m_ExtPrevBars_x_op=0;

         return(true);

        }

      double price_line=0.0;

      if(ObjectFind(0,InpObjDownName_op)>=0)

        {

         long object_type=ObjectGetInteger(0,InpObjDownName_op,OBJPROP_TYPE);

         if(object_type==OBJ_HLINE)

            price_line=ObjectGetDouble(0,InpObjDownName_op,OBJPROP_PRICE);

         if(price_line>0.0)

           {

            if((rates[0].open>price_line && rates[0].close<price_line) ||

               (rates[0].open<price_line && rates[0].close>price_line))

              {

               CheckForOpenBuy();

              }

           }

        }

     }

   return(rv);

  }

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

//| Expert tick function                                             |

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

void OnTickObjTrailing_op(void)

  {

   datetime time_current=TimeCurrent();

   if(time_current-m_obj_last_trailing_op>10)

     {

      if(RefreshRates())

         ObjTrailing_op();

      else

         return;

      m_obj_last_trailing_op=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==m_prev_bars_op)

      return;

   m_prev_bars_op=time_0;

   if(RefreshRates())

      ObjTrailing_op();

  }

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

//| Object Trailing                                                  |

//|   InpObjTrailingStop: min distance from price to object          |

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

void ObjTrailing_op(void)

  {

   if(InpObjTrailingStop_op==0)

      return;

   double m_obj_up_price     = 0.0;

   double m_obj_down_price   = 0.0;

   if(!InpRevers)

     {

      double current_up_price   = ObjectGetDouble(0,InpObjUpName_op,OBJPROP_PRICE);

      double current_down_price = ObjectGetDouble(0,InpObjDownName_op,OBJPROP_PRICE);

      if(current_up_price>0.0)

        {

         if(current_up_price>(m_symbol.Ask()+(m_obj_trailing_stop_op+m_obj_trailing_step_op)))

           {

            m_obj_up_price=m_symbol.NormalizePrice(m_symbol.Ask()+m_obj_trailing_stop_op);

            HLineMove(0,InpObjUpName_op,m_obj_up_price);

           }

        }

      if(current_down_price>0.0)

        {

         if(current_down_price<m_symbol.Bid()-(m_obj_trailing_stop_op+m_obj_trailing_step_op))

           {

            m_obj_down_price=m_symbol.NormalizePrice(m_symbol.Bid()-m_obj_trailing_stop_op);

            HLineMove(0,InpObjDownName_op,m_obj_down_price);

           }

        }

     }

   if(InpRevers)

     {

      double current_up_price   = ObjectGetDouble(0,InpObjDownName_op,OBJPROP_PRICE);

      double current_down_price = ObjectGetDouble(0,InpObjUpName_op,OBJPROP_PRICE);

      if(current_up_price>0.0)

        {

         if(current_up_price>(m_symbol.Ask()+(m_obj_trailing_stop_op+m_obj_trailing_step_op)))

           {

            m_obj_up_price=m_symbol.NormalizePrice(m_symbol.Ask()+m_obj_trailing_stop_op);

            HLineMove(0,InpObjDownName_op,m_obj_up_price);

           }

        }

      if(current_down_price>0.0)

        {

         if(current_down_price<m_symbol.Bid()-(m_obj_trailing_stop_op+m_obj_trailing_step_op))

           {

            m_obj_down_price=m_symbol.NormalizePrice(m_symbol.Bid()-m_obj_trailing_stop_op);

            HLineMove(0,InpObjUpName_op,m_obj_down_price);

           }

        }

     }

  }

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

//| ProcessingClosSell                                               |

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

bool ProcessingClosSell(void)

  {

   bool rv=false;

   datetime time_current=TimeCurrent();

   if(time_current-m_ExtLastSignals>10)

     {

      MqlRates rates[];

      int start_pos=0,count=1;

      if(CopyRates(m_symbol.Name(),Period(),start_pos,count,rates)!=count)

        {

         m_ExtPrevBars=0;

         return(true);

        }

      double price_line=0.0;

      if(ObjectFind(0,InpObjUpName)>=0)

        {

         long object_type=ObjectGetInteger(0,InpObjUpName,OBJPROP_TYPE);

         if(object_type==OBJ_HLINE)

            price_line=ObjectGetDouble(0,InpObjUpName,OBJPROP_PRICE);

         if(price_line>0.0)

           {

            if((rates[0].open>price_line && rates[0].close<price_line) ||

               (rates[0].open<price_line && rates[0].close>price_line))

              {

               CheckForCloseSell();

              }

           }

        }

     }

   return(rv);

  }

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

//| ProcessingClosBuy                                                |

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

bool ProcessingClosBuy(void)

  {

   bool rv=false;

   datetime time_current=TimeCurrent();

   if(time_current-m_ExtLastSignals_x>10)

     {

      MqlRates rates[];

      //ArraySetAsSeries(rates,true);

      int start_pos=0,count=1;

      if(CopyRates(m_symbol.Name(),Period(),start_pos,count,rates)!=count)

        {

         m_ExtPrevBars_x=0;

         return(true);

        }

      double price_line=0.0;

      if(ObjectFind(0,InpObjDownName)>=0)

        {

         long object_type=ObjectGetInteger(0,InpObjDownName,OBJPROP_TYPE);

         if(object_type==OBJ_HLINE)

            price_line=ObjectGetDouble(0,InpObjDownName,OBJPROP_PRICE);

         if(price_line>0.0)

           {

            if((rates[0].open>price_line && rates[0].close<price_line) ||

               (rates[0].open<price_line && rates[0].close>price_line))

              {

               CheckForCloseBuy();

              }

           }

        }

     }

   return(rv);

  }

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

//| Expert tick function                                             |

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

void OnTickObjTrailing(void)

  {

   datetime time_current=TimeCurrent();

   if(time_current-m_obj_last_trailing>10)

     {

      if(RefreshRates())

         ObjTrailing();

      else

         return;

      m_obj_last_trailing=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==m_prev_bars)

      return;

   m_prev_bars=time_0;

   if(RefreshRates())

      ObjTrailing();

  }

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

//| Object Trailing                                                  |

//|   InpObjTrailingStop: min distance from price to object          |

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

void ObjTrailing(void)

  {

   if(InpObjTrailingStop==0)

      return;

   double m_obj_up_price     = 0.0;

   double m_obj_down_price   = 0.0;

   if(!InpRevers)

     {

      double current_up_price   = ObjectGetDouble(0,InpObjUpName,OBJPROP_PRICE);

      double current_down_price = ObjectGetDouble(0,InpObjDownName,OBJPROP_PRICE);

      if(current_up_price>0.0)

        {

         if(current_up_price>(m_symbol.Ask()+(m_obj_trailing_stop+m_obj_trailing_step)))

           {

            m_obj_up_price=m_symbol.NormalizePrice(m_symbol.Ask()+m_obj_trailing_stop);

            HLineMove(0,InpObjUpName,m_obj_up_price);

           }

        }

      if(current_down_price>0.0)

        {

         if(current_down_price<m_symbol.Bid()-(m_obj_trailing_stop+m_obj_trailing_step))

           {

            m_obj_down_price=m_symbol.NormalizePrice(m_symbol.Bid()-m_obj_trailing_stop);

            HLineMove(0,InpObjDownName,m_obj_down_price);

           }

        }

     }

   if(InpRevers)

     {

      double current_up_price   = ObjectGetDouble(0,InpObjDownName,OBJPROP_PRICE);

      double current_down_price = ObjectGetDouble(0,InpObjUpName,OBJPROP_PRICE);

      if(current_up_price>0.0)

        {

         if(current_up_price>(m_symbol.Ask()+(m_obj_trailing_stop+m_obj_trailing_step)))

           {

            m_obj_up_price=m_symbol.NormalizePrice(m_symbol.Ask()+m_obj_trailing_stop);

            HLineMove(0,InpObjDownName,m_obj_up_price);

           }

        }

      if(current_down_price>0.0)

        {

         if(current_down_price<m_symbol.Bid()-(m_obj_trailing_stop+m_obj_trailing_step))

           {

            m_obj_down_price=m_symbol.NormalizePrice(m_symbol.Bid()-m_obj_trailing_stop);

            HLineMove(0,InpObjUpName,m_obj_down_price);

           }

        }

     }

  }

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

//| Move horizontal line                                             |

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

bool HLineMove(const long   chart_ID=0,   // chart's ID

               const string name="HLine", // line name

               double       price=0)      // line price

  {

//--- if the line price is not set, move it to the current Bid price level

   if(!price)

      price=SymbolInfoDouble(Symbol(),SYMBOL_BID);

//--- reset the error value

   ResetLastError();

//--- move a horizontal line

   if(!ObjectMove(chart_ID,name,0,0,price))

     {

      Print(__FUNCTION__,

            ": failed to move the horizontal line! Error code = ",GetLastError());

      return(false);

     }

//--- successful execution

   return(true);

  }

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

//|  Creating a horizontal price level                               |

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

int CreateHline(long ch_id,int sub_window,

                string name,double price,

                color clr,ENUM_LINE_STYLE style,

                int width,bool back,

                bool selectable,bool selected,

                bool hidden,long z_order)

  {

   int    err = GetLastError();

   string lnName = name;

   err = 0;

   if(ObjectFind(0,lnName)!=-1)

      ObjectDelete(0,lnName);

   if(!ObjectCreate(ch_id,lnName,OBJ_HLINE,sub_window,0,price))

     {

      err = GetLastError();

      Print("Can't create object #", lnName, "# Error(",err,"):", err);

      return(err);

     }

   ObjectSetInteger(ch_id,lnName,OBJPROP_COLOR,clr);

   ObjectSetInteger(ch_id,lnName,OBJPROP_STYLE,style);

   ObjectSetInteger(ch_id,lnName,OBJPROP_WIDTH,width);

   ObjectSetInteger(ch_id,lnName,OBJPROP_BACK,back);

   ObjectSetInteger(ch_id,lnName,OBJPROP_SELECTABLE,selectable);

   ObjectSetInteger(ch_id,lnName,OBJPROP_SELECTED,selected);

   ObjectSetInteger(ch_id,lnName,OBJPROP_HIDDEN,hidden);

   ObjectSetInteger(ch_id,lnName,OBJPROP_ZORDER,z_order);

   return(true);

  }

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

//    buttoncreate                                                   |

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

bool ButtonCreate(string name,int Xdist,

                  int Ydist,int Xsize,int Ysize,int FONTSIZE=12)

  {

   if(ObjectFind(0,Symbol()+name)<0)

      ObjectCreate(0,Symbol()+name,OBJ_BUTTON,0,100,100);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_COLOR,clrWhite);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_BGCOLOR,clrDimGray);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_XDISTANCE,Xdist);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_YDISTANCE,Ydist);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_XSIZE,Xsize);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_YSIZE,Ysize);

   ObjectSetString(0,Symbol()+name,OBJPROP_FONT,"Sans Serif");

   ObjectSetString(0,Symbol()+name,OBJPROP_TEXT,name);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_FONTSIZE,FONTSIZE);

   ObjectSetInteger(0,Symbol()+name,OBJPROP_SELECTABLE,false);

   return(true);

  }

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

//    ButtonOnTick                                                   |

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

bool ButtonOnTick(void)

  {

   bool res=false;

   double BY_1=m_symbol.Bid()-m_take_profit;

   double SL_1=m_symbol.Ask()+m_take_profit;

//---

   if(ObjectGetInteger(0,Symbol()+"B",OBJPROP_STATE)!=0)

     {

      ObjectSetInteger(0,Symbol()+"B",OBJPROP_STATE,0);

      if(!InpRevers)

         CreateHline(0,0,InpObjDownName_op,BY_1,clrBlue,0,0,1,1,1,1,2);

      else

         CreateHline(0,0,InpObjDownName_op,SL_1,clrBlue,0,0,1,1,1,1,2);

      PlaySound("tick.wav");

     }

   if(ObjectGetInteger(0,Symbol()+"CB",OBJPROP_STATE)!=0)

     {

      ObjectSetInteger(0,Symbol()+"CB",OBJPROP_STATE,0);

      if(!InpRevers)

         CreateHline(0,0,InpObjDownName,SL_1,clrBlue,0,0,1,1,1,1,2);

      else

         CreateHline(0,0,InpObjDownName,SL_1+m_take_profit,clrBlue,0,0,1,1,1,1,2);

      PlaySound("tick.wav");

     }

   if(ObjectGetInteger(0,Symbol()+"S",OBJPROP_STATE)!=0)

     {

      ObjectSetInteger(0,Symbol()+"S",OBJPROP_STATE,0);

      if(!InpRevers)

         CreateHline(0,0,InpObjUpName_op,SL_1,clrBlue,0,0,1,1,1,1,2);

      else

         CreateHline(0,0,InpObjUpName_op,BY_1,clrBlue,0,0,1,1,1,1,2);

      PlaySound("tick.wav");

     }

   if(ObjectGetInteger(0,Symbol()+"CS",OBJPROP_STATE)!=0)

     {

      ObjectSetInteger(0,Symbol()+"CS",OBJPROP_STATE,0);

      if(!InpRevers)

         CreateHline(0,0,InpObjUpName,BY_1,clrBlue,0,0,1,1,1,1,2);

      else

         CreateHline(0,0,InpObjUpName,BY_1-m_take_profit,clrBlue,0,0,1,1,1,1,2);

      PlaySound("tick.wav");

     }

   if(ObjectGetInteger(0,Symbol()+"Del",OBJPROP_STATE)!=0)

     {

      ObjectSetInteger(0,Symbol()+"Del",OBJPROP_STATE,0);

      ObjectsDeleteAll(0,InpObjUpName);

      ObjectsDeleteAll(0,InpObjDownName);

      ObjectsDeleteAll(0,InpObjUpName_op);

      ObjectsDeleteAll(0,InpObjDownName_op);

      PlaySound("tick.wav");

     }

   return(res);

  }

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