Если пошло теперь дальше можно смотреть, что добавить, но это после выходных.

Вот отладил вариант когда новой позе ставится отложенник:

//+------------------------------------------------------------------+
//|                                                      Trailer.mq4 |
//|                                              Copyright 2016, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property strict

//--- Inputs
extern double Lots       = 0.1;      // лот
extern int StopLoss      = 500;      // лось
extern int Delta         = 300;      // расстояние для отложки
extern int TakeProfit    = 500;      // язь
extern int BULevel       = 0;        // уровень БУ
extern int BUPoint       = 30;       // пункты БУ
extern int TrailingStop  = 0;        // 1-трал
extern int BuySell       = 0;        // 1-buy 2-sell 0-off
extern int Slip          = 30;       // реквот
extern int Magic         = 123;      // магик
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0;
   color clr=Green;
   double sl=0,tp=0;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
     }

   r=OrderSend(NULL,type,Lots,NormalizeDouble(price,Digits),Slip,0,0,"",Magic,TimeCurrent()+3600*10,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutStopOrder()
  {
   if(OrderSelect(OrdersTotal()-1,SELECT_BY_POS,MODE_TRADES))
     {
      if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
        {
         if(OrderType()==OP_BUY)
           {
            if(NormalizeDouble(OrderPrice(),Digits)!=NormalizeDouble(OrderOpenPrice()-Delta*Point,Digits)) PutOrder(5,OrderOpenPrice()-Delta*Point);
           }

         if(OrderType()==OP_SELL)
           {
            if(NormalizeDouble(OrderPrice(),Digits)!=NormalizeDouble(OrderOpenPrice()+Delta*Point,Digits)) PutOrder(4,OrderOpenPrice()+Delta*Point);
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double OrderPrice()
  {
   double pr=0;
   if(OrderSelect(OrdersTotal()-1,SELECT_BY_POS,MODE_TRADES))
     {
      if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
        {
         if(OrderType()>3)
           {
            pr=OrderOpenPrice();
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Mode()
  {
   bool m;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderStopLoss()==0 || OrderTakeProfit()==0)
              {
               if(OrderType()==0) m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-StopLoss*Point,OrderOpenPrice()+TakeProfit*Point,0,Blue);
               if(OrderType()==1) m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+StopLoss*Point,OrderOpenPrice()-TakeProfit*Point,0,Blue);
              }
           }
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()<2) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trailing()
  {
   bool mod;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(NormalizeDouble(Low[1],Digits)>OrderOpenPrice() && Bid>NormalizeDouble(Low[1],Digits))
                 {
                  if(OrderStopLoss()!=NormalizeDouble(Low[1],Digits))
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Low[1],Digits),OrderTakeProfit(),0,Yellow);
                     return;
                    }
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(NormalizeDouble(High[1],Digits)<OrderOpenPrice() && Ask<NormalizeDouble(High[1],Digits))
                 {
                  if(OrderStopLoss()!=NormalizeDouble(High[1],Digits))
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(High[1],Digits),OrderTakeProfit(),0,Yellow);
                     return;
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void BU()
  {
   bool m;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(OrderOpenPrice()<=(Bid-(BULevel+BUPoint)*Point) && OrderOpenPrice()>OrderStopLoss())
                 {
                  m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+BUPoint*Point,OrderTakeProfit(),0,Yellow);
                  return;
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(OrderOpenPrice()>=(Ask+(BULevel+BUPoint)*Point) && (OrderOpenPrice()<OrderStopLoss() || OrderStopLoss()==0))
                 {
                  m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-BUPoint*Point,OrderTakeProfit(),0,Yellow);
                  return;
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   Mode();
   PutStopOrder();
   if(BULevel>0) BU();
   if(TrailingStop>0) Trailing();
   if(CountTrades()<1 && BuySell==1) PutOrder(0,Ask);
   if(CountTrades()<1 && BuySell==2) PutOrder(1,Bid);

   Comment("\n Price: ");
  }
//+------------------------------------------------------------------+

Давайте попробуем здесь упростить ТЗ, может тогда и получится. Вам ведь не надо столько плюшек сколько в этом советнике.

Есть коммент: www.opentraders.ru/downloads/1169/

Смотрите программно цену открытия рыночного ордера, проверяйте есть ли установленный отложенник на указанном расстоянии от рыночного, если нет тогда ставим, набросок есть, доводите до ума, а мне заморачиваться не интересно больно то.

Я пробовал переделать пару раз, нет это долго, советник сложный, не берусь.

Это только набросок нужно время чтобы доработать. Обратитесь лучше к платному. Делаю только то что можно быстро сделать.

У меня новые условия работы здесь на сайте. Кризис сами понимаете  

Сейчас все только по самому минимуму.

Я сейчас делаю все только по самому минимуму.

Там у меня ещё один заказ завис.

Если завис значит не получилось быстро сделать а это уже не ко мне  

Cегодня с утра смотрел еще вечером посмотрю, логику надо перекраивать.

Каждый заказ я пробую сделать если быстро не получается, это сразу к платному. Здесь получилось набросать вот такой код, но нужно еще сидеть и дорабатывать.

//+------------------------------------------------------------------+
//|                                                      Poshnik.mq4 |
//|                                              Copyright 2016, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+

#property copyright "Copyright 2016, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property strict

//--- Inputs
extern double Lots       = 0.1;      // лот
extern int StopLoss      = 500;      // лось
extern int Delta         = 300;      // расстояние для отложки
extern int TakeProfit    = 500;      // язь
extern int BULevel       = 0;        // уровень БУ
extern int BUPoint       = 30;       // пункты БУ
extern int TrailingStop  = 0;        // 1-трал
extern int BuySell       = 0;        // 1-buy 2-sell 0-off
extern int Slip          = 30;       // реквот
extern int Magic         = 123;      // магик
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0;
   color clr=Green;
   double sl=0,tp=0;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
     }

   r=OrderSend(NULL,type,Lots,NormalizeDouble(price,Digits),Slip,0,0,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutStopOrder()
  {
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(OrderInPrice(OrderOpenPrice()-Delta*Point)) PutOrder(5,OrderOpenPrice()-Delta*Point);
              }

            if(OrderType()==OP_SELL)
              {
               if(OrderInPrice(OrderOpenPrice()+Delta*Point)) PutOrder(4,OrderOpenPrice()+Delta*Point);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool OrderInPrice(double price)
  {
   double pr=0;
   bool p=true;

   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()>1)
              {
               pr=OrderOpenPrice();
              }
           }
        }
     }

   if(NormalizeDouble(pr,Digits)==NormalizeDouble(price,Digits)) p=false;
   return(p);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Mode()
  {
   bool m;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderStopLoss()==0 || OrderTakeProfit()==0)
              {
               if(OrderType()==0) m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-StopLoss*Point,OrderOpenPrice()+TakeProfit*Point,0,Blue);
               if(OrderType()==1) m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+StopLoss*Point,OrderOpenPrice()-TakeProfit*Point,0,Blue);
              }
           }
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()<2) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trailing()
  {
   bool mod;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(NormalizeDouble(Low[1],Digits)>OrderOpenPrice() && Bid>NormalizeDouble(Low[1],Digits))
                 {
                  if(OrderStopLoss()!=NormalizeDouble(Low[1],Digits))
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Low[1],Digits),OrderTakeProfit(),0,Yellow);
                     return;
                    }
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(NormalizeDouble(High[1],Digits)<OrderOpenPrice() && Ask<NormalizeDouble(High[1],Digits))
                 {
                  if(OrderStopLoss()!=NormalizeDouble(High[1],Digits))
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(High[1],Digits),OrderTakeProfit(),0,Yellow);
                     return;
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void BU()
  {
   bool m;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(OrderOpenPrice()<=(Bid-(BULevel+BUPoint)*Point) && OrderOpenPrice()>OrderStopLoss())
                 {
                  m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+BUPoint*Point,OrderTakeProfit(),0,Yellow);
                  return;
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(OrderOpenPrice()>=(Ask+(BULevel+BUPoint)*Point) && (OrderOpenPrice()<OrderStopLoss() || OrderStopLoss()==0))
                 {
                  m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-BUPoint*Point,OrderTakeProfit(),0,Yellow);
                  return;
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   Mode();
   PutStopOrder();
   if(BULevel>0) BU();
   if(TrailingStop>0) Trailing();
   if(CountTrades()<1 && BuySell==1) PutOrder(0,Ask);
   if(CountTrades()<1 && BuySell==2) PutOrder(1,Bid);

  }
//+------------------------------------------------------------------+

Привет. Андрей, а на чем мы застряли.?
Надо всего то сделать: установка противоположного отложенного ордера на уже открытый ордер.

Такие индивидуальные заказы реализовывать в разы сложнее чем просто советник с индикаторами. В этом случае делаю только то что можно быстро сделать.

Посмотрел там открытие позы на новой свече идет если время ставить вся логика просто улетает  

Сейчас гляну.

Индикатор выставляет линии при инициализации, а при смене тф как раз она и происходит. Нельзя дергать туда сюда график или закомментировать создание линий в коде и ставить на график вручную с теми же именами или вот еще такой вариант:

//+------------------------------------------------------------------+
//|                                                    MailLines.mq4 |
//|                                              Copyright 2016, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property strict
#property indicator_chart_window

extern color  LineColor = Red;     // цвет линии
extern string Line1Name = "Line1"; // имя линии
extern string Line2Name = "Line2"; // имя линии
extern string Line3Name = "Line3"; // имя линии
extern int    Delta     = 30;      // отступ от линии 
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   //ObjectsDeleteAll(0,OBJ_HLINE);
   PutHLine(Line1Name,Ask+200*Point);
   PutHLine(Line2Name,Ask+400*Point);
   PutHLine(Line3Name,Ask+600*Point);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Горизонтальная линия                                             |
//+------------------------------------------------------------------+
void PutHLine(string name,double price)
  {
   ObjectCreate(0,name,OBJ_HLINE,0,0,price);
//--- установим цвет линии
   ObjectSetInteger(0,name,OBJPROP_COLOR,LineColor);
//--- установим толщину линии
   ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double LinePrice(string name)
  {
   double pr=0;
   for(int i=ObjectsTotal()-1;i>=0;i--)
     {
      pr=ObjectGetDouble(0,name,OBJPROP_PRICE);
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   if(Bid<LinePrice(Line1Name)+Delta*Point && Bid>LinePrice(Line1Name)-Delta*Point)
     {
      SendMail("Сообщение индикатора: ","Цена у линии "+(string)LinePrice(Line1Name));
      Print("Сообщение индикатора: ","Цена у линии "+(string)LinePrice(Line1Name));
     }

   if(Bid<LinePrice(Line2Name)+Delta*Point && Bid>LinePrice(Line2Name)-Delta*Point)
     {
      SendMail("Сообщение индикатора: ","Цена у линии "+(string)LinePrice(Line2Name));
      Print("Сообщение индикатора: ","Цена у линии "+(string)LinePrice(Line2Name));
     }
     
   if(Bid<LinePrice(Line3Name)+Delta*Point && Bid>LinePrice(Line3Name)-Delta*Point)
     {
      SendMail("Сообщение индикатора: ","Цена у линии "+(string)LinePrice(Line3Name));
      Print("Сообщение индикатора: ","Цена у линии "+(string)LinePrice(Line3Name));
     }

   Comment("\n Line1 Price: ",LinePrice(Line1Name),
           "\n Line2 Price: ",LinePrice(Line2Name),
           "\n Line3 Price: ",LinePrice(Line3Name));

//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Набросал только что функцию для подсчета свечей, вроде похоже на правду  

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count=0;

   for(int i=1;i<100;i++)
     {
      if(Open[i]<Close[i] && type==0)
        {
         count++;
        }
      else if(Open[i]>Close[i] && type==0) break;
      
      if(Open[i]>Close[i] && type==1)
        {
         count++;
        }
      else if(Open[i]<Close[i] && type==1) break;
     }

   return(count);
  }

Для меня проще и быстрее написать советник чем индикатор.

Так примерно  

count+=OrderLots();
all+=OrderOpenPrice()*OrderLots();

all=NormalizeDouble(all/count,Digits);
tp=NormalizeDouble(all+TakeProfit*Point,Digits);