...........................................................Индикатор.................................................................

#property  copyright "whoever"
#property  link      "whatever"

#property  indicator_separate_window
#property  indicator_buffers 5
#property  indicator_color1  LimeGreen
#property  indicator_color2  Red
#property  indicator_color3  Gold
#property  indicator_color4  LimeGreen
#property  indicator_color5  Red
#property  indicator_width3  2
#property  indicator_width4  2
#property  indicator_width5  2
 
extern int period=35;
extern int smooth=10; 
extern bool DoAlert=true;
extern bool alertMail=false;
datetime lastAlertTime;


double         ExtBuffer0[];
double         ExtBuffer1[];
double         ExtBuffer2[];
double         ExtBuffer3[];
double         ExtBuffer4[];
double         ExtBuffer5[];
double         ExtBufferh1[];
double         ExtBufferh2[];

#define LinesIdentifier "signalLines"
int init()
{
   IndicatorBuffers(8);
   SetIndexBuffer(0,ExtBufferh1); SetIndexStyle(0,DRAW_HISTOGRAM);
   SetIndexBuffer(1,ExtBufferh2); SetIndexStyle(1,DRAW_HISTOGRAM);
   SetIndexBuffer(2,ExtBuffer3);
   SetIndexBuffer(3,ExtBuffer4);
   SetIndexBuffer(4,ExtBuffer5);
   SetIndexBuffer(5,ExtBuffer0);
   SetIndexBuffer(6,ExtBuffer1);
   SetIndexBuffer(7,ExtBuffer2);

   lastAlertTime = Time[1];

   IndicatorShortName("Solar wind joy :)");
   return(0);
}
int deinit()
{
   int lookForLength = StringLen(LinesIdentifier);
   for (int i=ObjectsTotal(); i>=0; i--)
      {
         string name = ObjectName(i);
         if (StringSubstr(name,0,lookForLength)==LinesIdentifier) ObjectDelete(name);
      }
   return(0);
}


int start()
{
   //int     period=10;
   int    limit;
   double prev,current,old;
   double Value=0,Value1=0,Value2=0,Fish=0,Fish1=0,Fish2=0;
   double price;
   double MinL=0;
   double MaxH=0;  
   
   int counted_bars=IndicatorCounted();
   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
   limit=Bars-counted_bars;
   string sAlertMsg;
      
   //limit=Bars-1;


   for(int i=0; i<limit; i++)
    {  MaxH = High[Highest(NULL,0,MODE_HIGH,period,i)];
       MinL = Low[Lowest(NULL,0,MODE_LOW,period,i)];
      price = (High[i]+Low[i])/2;
      Value = 0.33*2*((price-MinL)/(MaxH-MinL)-0.5) + 0.67*Value1;     
      Value=MathMin(MathMax(Value,-0.999),0.999); 
      ExtBuffer0[i]=0.5*MathLog((1+Value)/(1-Value))+0.5*Fish1;
      Value1=Value;
      Fish1=ExtBuffer0[i];
         if (ExtBuffer0[i]>0) ExtBuffer1[i]=10; else ExtBuffer1[i]=-10;      
    }

   for(i=limit; i>=0; i--)
   {
      double sum  = 0;
      double sumw = 0;

      for(int k=0; k<smooth && (i+k)<Bars; k++)
      {
         double weight = smooth-k;
                sumw  += weight;
                sum   += weight*ExtBuffer1[i+k];  
      }             
      if (sumw!=0)
            ExtBuffer2[i] = sum/sumw;
      else  ExtBuffer2[i] = 0;
   }      
   for(i=0; i<=limit; i++)
   {
      sum  = 0;
      sumw = 0;

      for(k=0; k<smooth && (i-k)>=0; k++)
      {
         weight = smooth-k;
                sumw  += weight;
                sum   += weight*ExtBuffer2[i-k];
      }             
      if (sumw!=0)
            ExtBuffer3[i] = sum/sumw;
      else  ExtBuffer3[i] = 0;
   }      
   for(i=limit; i>=0; i--)
   {
      ExtBuffer4[i]=EMPTY_VALUE;
      ExtBuffer5[i]=EMPTY_VALUE;
      ExtBufferh1[i]=EMPTY_VALUE;
      ExtBufferh2[i]=EMPTY_VALUE;
      if (ExtBuffer3[i]>0) { ExtBuffer4[i]=ExtBuffer3[i]; ExtBufferh1[i]=ExtBuffer3[i]; }
      if (ExtBuffer3[i]<0) { ExtBuffer5[i]=ExtBuffer3[i]; ExtBufferh2[i]=ExtBuffer3[i]; }
      
      if (ExtBuffer3[i+1] < 0 && ExtBuffer3[i] > 0)
      {
         if (DoAlert && i<5 && lastAlertTime!=Time[0])
         {
            sAlertMsg="Solar Wind - "+Symbol()+" "+TF2Str(Period())+": cross UP";
            if (DoAlert)     Alert(sAlertMsg);
            lastAlertTime = Time[0];  
            if (alertMail)   SendMail(sAlertMsg, "MT4 Alert!\n" + TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS )+"\n"+sAlertMsg);   
         }
      }
      else if( ExtBuffer3[i+1] > 0 && ExtBuffer3[i] < 0)
      {
         if (i<5 && lastAlertTime!=Time[0])
         {
            sAlertMsg="Solar Wind - "+Symbol()+" "+TF2Str(Period())+": cross DOWN";
            if (DoAlert)     Alert(sAlertMsg);
            lastAlertTime = Time[0];  
            if (alertMail)   SendMail(sAlertMsg, "MT4 Alert!\n" + TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS )+"\n"+sAlertMsg);   
         }
                     
      }
      
      
   }
   return(0);
}
// function: TF2Str()
// Description: Convert time-frame to a string
//-----------------------------------------------------------------------------
string TF2Str(int iPeriod) {
  switch(iPeriod) {
    case PERIOD_M1: return("M1");
    case PERIOD_M5: return("M5");
    case PERIOD_M15: return("M15");
    case PERIOD_M30: return("M30");
    case PERIOD_H1: return("H1");
    case PERIOD_H4: return("H4");
    case PERIOD_D1: return("D1");
    case PERIOD_W1: return("W1");
    case PERIOD_MN1: return("MN1");
    default: return("M"+iPeriod);
  }
}
//+------------------------------------------------------------------+




.............................................Шаблон с вписаным индикатором.........................................................

//+------------------------------------------------------------------+
//|                                   Шаблон для написания советника |
//|                                      Copyright 2012, expforex    |
//|                                       http://www.expforex.com    |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2012,  www.expforex.com"
#property link      "www.expforex.com"
// ==========================================================================================================================================================================================================
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// 
//                             В Н Е Ш Н И Е    П Е Р Е М Е Н Н Ы Е
// 
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// ==========================================================================================================================================================================================================
extern int shift=1;
extern string Indicators_=" Настройки индикатора";
/* Здесь прописываем настройки Вашего индикатора\индикаторов */
extern int period=35;
extern int smooth=10; 
extern bool DoAlert=true;
extern bool alertMail=false;
/* Стандартные переменные для шаблона НЕ ИЗМЕНЯТЬ!!! */
extern string In_=" Настройки входа";
extern bool ReverseSignal=true; // true - Переворачивать сигнал стратегии. 
extern string trade_="Настройки торговли";
extern int Magic=777;                     // Магический номер
extern int StopLoss=0;                    // Стоплосс, 0 - не используется
extern int TakeProfit=0;                  // Тейкпрофит , 0 - не используется
extern int Slippage=3;                    // Проскальзывание
extern bool MarketWatch=false;            // Режим торговли по MarketWatch true  = сначала выставляются позиции/ордера без стопов, потом происходит модификация - для некоторых брокеров
extern bool ClosePosifChange=true;        // Закрывать позиции при обратном сигнале
extern bool ONlyOnePosbySignal=true;      // Играть только или бай и / или селл 1 позицией
extern string autolot_="Настройки автолота";
extern double Lots=0.1;                   // Фиксирвоанный лот 
extern bool DynamicLot=false;             // Динамический лот
extern double LotBalancePcnt=20;          // % от депозита
extern double MinLot = 0.1;               // Минимальный лот при расчете
extern double MaxLot = 5;                 // Максимальный лот при расчете
extern double Martin=1; // Если 1 то не используется, Коэффициент мартина на следующую сделку после убытончой

extern string timetrade_="Настройки времени торговли";
extern int OpenHour=0;                    // Час открытия торгов
extern int OpenMinute=0;                  // Минута открытия торгов
extern int CloseHour=23;                  // Час закрытия торгов
extern int CloseMinute=59;                // Минута закрытия торгов
extern string Trailing_="Настройки трейлингстопа";
extern bool TrailingStopUSE=false;        // Использовать трейлингстоп 
extern bool IfProfTrail=false;            // Использовать только дял профитных позиций - режим безубытка
extern int TrailingStop=0;                // Дистанция трейлинга = 0 - минимально допустимый
extern int TrailingStep=1;                // Шаг дистанции
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// ==========================================================================================================================================================================================================
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// 
//                             Ф У Н К Ц И Я      Определения сигналов   
// 
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// ==========================================================================================================================================================================================================

/* Блок управления сигналом от Вашего индикатора
Создаем переменные для сигналов индикатора
 */
int IndicatorSignal()
  {
   int Sig=0;
   

   double ExampleCustom=iCustom(Symbol(),0,"Solar wind joy",DRAW_HISTOGRAM,0,shift); // Пример вызова пользовательского индикатора
   double ExampleCustom2=iCustom(Symbol(),0,"Solar wind joy",DRAW_HISTOGRAM,1,shift); // Пример вызова пользовательского индикатора
  
   
   //Указываем Сигналы:
   
   if( ExampleCustom!=DRAW_HISTOGRAM)Sig=1; // Если МА ниже цены БИД - открываемся в бай
   if( ExampleCustom2!=DRAW_HISTOGRAM)Sig=2; // Если МА выше цены БИД - открываемся в селл

  // 1 - бай  2 - селл
   return(Sig);
  }
// ==========================================================================================================================================================================================================
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// 
//                             Ф У Н К Ц И И      С О В Е Т Н И К А   
// 
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// ==========================================================================================================================================================================================================




double Prof,Loss;

int timeCheckSignal; // Время открытия позиции
double sl,tp; // Для вычисления стопов 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+


// ==========================================================================================================================================================================================================
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// 
//                             Ф У Н К Ц И Я      S T A R T ( )   
// 
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// ==========================================================================================================================================================================================================

int start()
  {

   int Signal; // Сигнал к открытию
//+------------------------------------------------------------------+
//Проверяем наличие торгового времени(разрешения на торговлю)
//+------------------------------------------------------------------+
   bool Traiding=TDt(DoubleToStr(CloseHour,0),DoubleToStr(CloseMinute,0),DoubleToStr(OpenHour,0),DoubleToStr(OpenMinute,0));
//+------------------------------------------------------------------+
// Включение трейлингстопа:
//+------------------------------------------------------------------+
   if(TrailingStopUSE)SimpleTrailing(Symbol(),-1,Magic);
// ==========================================================================================================================================================================================================
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// 
//                             СТАРТ --- Г Л А В Н Ы Й   Б Л О К   И С П О Л Ь З О В А Н И Я    Ш А Б Л О Н А  
// 
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// ==========================================================================================================================================================================================================
   Signal=IndicatorSignal();

   if(ReverseSignal)
     {
      if(Signal==1)Signal=2;
      else if(Signal==2)Signal=1;
     }

//+------------------------------------------------------------------+
// Если время торговли не истекло и мы не открывали позицию на этом баре: 
//+------------------------------------------------------------------+

   if(Traiding && timeCheckSignal!=Time[0])

     {
      //+------------------------------------------------------------------+
      // Если сигнал на бай:
      //+------------------------------------------------------------------+
      if(Signal==1)// buy
        {
         //Вычисляем стоплосс
         if(StopLoss!=0)sl=Bid-StopLoss*Point; else sl=0;
         // ВЫчисляем тейкпрофит
         if(TakeProfit!=0)tp=Ask+TakeProfit*Point; else tp=0;
         //+------------------------------------------------------------------+
         //Закрываем противоположную позицию
         //+------------------------------------------------------------------+
         if(ClosePosifChange)CPD(Symbol(),OP_SELL,Magic);
         //+------------------------------------------------------------------+
         //Открываем позицию
         //+------------------------------------------------------------------+
         if((ONlyOnePosbySignal && !EPs(Symbol(),OP_BUY,Magic)) || !ONlyOnePosbySignal)
           {
            OPs(Symbol(),OP_BUY,GetSizeLot(),sl,tp,Magic,"Templates www.expforex.com");
            timeCheckSignal=Time[0];
           }

        }

      //+------------------------------------------------------------------+
      // Если сигнал на селл:
      //+------------------------------------------------------------------+
      if(Signal==2)// селл
        {
         //Вычисляем стоплосс
         if(StopLoss!=0)sl=Ask+StopLoss*Point; else sl=0;
         // ВЫчисляем тейкпрофит
         if(TakeProfit!=0)tp=Bid-TakeProfit*Point; else tp=0;
         //Закрываем противоположную позицию
         if(ClosePosifChange)CPD(Symbol(),OP_BUY,Magic);
         //+------------------------------------------------------------------+
         //Открываем позицию
         //+------------------------------------------------------------------+
         if((ONlyOnePosbySignal && !EPs(Symbol(),OP_SELL,Magic)) || !ONlyOnePosbySignal)
           {
            OPs(Symbol(),OP_SELL,GetSizeLot(),sl,tp,Magic,"Templates www.expforex.com");
            timeCheckSignal=Time[0];
           }

        }

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

     }

   return(0);
  }
// ==========================================================================================================================================================================================================
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// 
//                             Ф У Н К Ц И И    Э К С П Е Р Т А  
// 
// ЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖЖ
// ==========================================================================================================================================================================================================

//+------------------------------------------------------------------+
//|                          Работа по времени                       |
//+------------------------------------------------------------------+
bool TDt(string CloseHour,string CloseMinute,string OpenHour,string OpenMinute) //   Функция проверяет со скольки до скольки можно
  {
   string Autor=" Автор функции для шаблона : www.expforex.com";
//   торговать. Если удовлетворяет условиям
   int TradingTime=false;                                    //   Возвращает ""можно""
   if(StrToTime(CloseHour+":"+CloseMinute)>StrToTime(OpenHour+":"+OpenMinute))
     {
      if(TimeCurrent()<StrToTime(CloseHour+":"+CloseMinute) && TimeCurrent()>=StrToTime(OpenHour+":"+OpenMinute)) //
         TradingTime=true;
     }
   if(StrToTime(CloseHour+":"+CloseMinute)<StrToTime(OpenHour+":"+OpenMinute))
     {
      if(TimeCurrent()<StrToTime(CloseHour+":"+CloseMinute) || TimeCurrent()>=StrToTime(OpenHour+":"+OpenMinute)) //
         TradingTime=true;
     }                                     //
   return(TradingTime);                                  //
  }
//+------------------------------------------------------------------+
//|                           Удаление отложенных ордеров            |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+

bool DxO(string sy="",int op=-1,int mn=-1,datetime ot=0)
  {
   int i,k=OrdersTotal(),ty;
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(sy=="0") sy=Symbol();
   for(i=k-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         ty=OrderType();
         if(ty>1 && ty<6)
           {
            if((OrderSymbol()==sy || sy=="") && (op<0 || ty==op))
              {
               if(mn<0 || OrderMagicNumber()==mn)
                 {
                  if(ot<=OrderOpenTime()) {OrderDelete(OrderTicket(),0);}
                 }
              }
           }
        }
     }
   return(False);
  }
//+------------------------------------------------------------------+
//|                              Модификация позиций/ордеров         |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                
//|    pp - Цена модификация (для отложенных ордеров)  
//|                                                    
//|    sl - Стоплосс - или 0                                     
//|    tp - Тейкпрофит - или 0               
//|    ex - Дата истечения отложенного ордера или 0
//+----------------------------------------------------------------------------+

void ModifyOrder(double pp=-1,double sl=0,double tp=0,datetime ex=0)
  {
   bool   fm;
   double op,pa,pb,os,ot;
   int    dg=MarketInfo(OrderSymbol(),MODE_DIGITS),er,it;
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(pp<=0) pp=OrderOpenPrice();
   if(sl<0 ) sl=OrderStopLoss();
   if(tp<0 ) tp=OrderTakeProfit();

   pp=NormalizeDouble(pp, dg);
   sl=NormalizeDouble(sl, dg);
   tp=NormalizeDouble(tp, dg);
   op=NormalizeDouble(OrderOpenPrice() , dg);
   os=NormalizeDouble(OrderStopLoss()  , dg);
   ot=NormalizeDouble(OrderTakeProfit(), dg);

   if(pp!=op || sl!=os || tp!=ot)
     {
      for(it=1; it<=3; it++)
        {
         if(!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
         while(!IsTradeAllowed()) Sleep(5000);
         RefreshRates();
         fm=OrderModify(OrderTicket(),pp,sl,tp,ex);
         if(fm)
           {
            break;
              } else {
            er=GetLastError();
            pa=MarketInfo(OrderSymbol(), MODE_ASK);
            pb=MarketInfo(OrderSymbol(), MODE_BID);
            //Alert("Error(",er,") modifying order: ",ErrorDescription(er),", try ",it);
            //Alert("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
            //       "  op="+OrderType(),"  pp=",pp,"  sl=",sl,"  tp=",tp);
            Sleep(1000*10);
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                         Наличие отложенных ордеров               |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+

bool ExO(string sy="",int op=-1,int mn=-1,datetime ot=0)
  {
   int i,k=OrdersTotal(),ty;
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(sy=="0") sy=Symbol();
   for(i=0;i<k;i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         ty=OrderType();
         if(ty>1 && ty<6)
           {
            if((OrderSymbol()==sy || sy=="") && (op<0 || ty==op))
              {
               if(mn<0 || OrderMagicNumber()==mn)
                 {
                  if(ot<=OrderOpenTime()) return(True);
                 }
              }
           }
        }
     }
   return(False);
  }
//+------------------------------------------------------------------+
//|              Установка отложенного ордера                        |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    op - операция                                                           |
//|    ll - лот                                                                |
//|    pp - цена                                                               |
//|    sl - уровень стоп                                                       |
//|    tp - уровень тейк                                                       |
//|    mn - Magic Number                                                       |
//|    ex - Срок истечения                                                     |
//+----------------------------------------------------------------------------+
int SetOrder(string sy,int op,double ll,double pp,
             double sl=0,double tp=0,int mn=0,datetime ex=0,string lsComm="")
  {
   color    clOpen;
   datetime ot;
   double   pa,pb,mp;
   int      err,it,ticket,msl;
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(sy=="" || sy=="0") sy=Symbol();
   msl=MarketInfo(sy,MODE_STOPLEVEL);
   if(ex>0 && ex<TimeCurrent()) ex=0;
   for(it=1; it<=5; it++)
     {
      if(!IsTesting() && (!IsExpertEnabled() || IsStopped()))
        {
         Print("SetOrder(): Остановка работы функции");
         break;
        }
      while(!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      ot=TimeCurrent();
      if(!MarketWatch)ticket=OrderSend(sy,op,ll,NormalizeDouble(pp,MarketInfo(sy,MODE_DIGITS)),Slippage,NormalizeDouble(sl,MarketInfo(sy,MODE_DIGITS)),NormalizeDouble(tp,MarketInfo(sy,MODE_DIGITS)),lsComm,mn,ex,clOpen);
      if(MarketWatch)

        {
         ticket=OrderSend(sy,op,ll,NormalizeDouble(pp,MarketInfo(sy,MODE_DIGITS)),Slippage,0,0,lsComm,mn,ex,clOpen);
         if(SBT(ticket)) ModifyOrder(-1,sl,tp);
        }

      if(ticket>0)
        {

         return(ticket);
         break;
           } else {
         err=GetLastError();
         if(err==128 || err==142 || err==143)
           {
            Sleep(1000*66);

            continue;
           }
         mp=MarketInfo(sy, MODE_POINT);
         pa=MarketInfo(sy, MODE_ASK);
         pb=MarketInfo(sy, MODE_BID);
         if(pa==0 && pb==0) Alert("SetOrder(): Проверьте в обзоре рынка наличие символа "+sy);
         // Неправильные стопы
         if(err==130)
           {
            switch(op)
              {
               case OP_BUYLIMIT:
                  if(pp>pa-msl*mp) pp=pa-msl*mp;
                  if(sl>pp-(msl+1)*mp) sl=pp-(msl+1)*mp;
                  if(tp>0 && tp<pp+(msl+1)*mp) tp=pp+(msl+1)*mp;
                  break;
               case OP_BUYSTOP:
                  if(pp<pa+(msl+1)*mp) pp=pa+(msl+1)*mp;
                  if(sl>pp-(msl+1)*mp) sl=pp-(msl+1)*mp;
                  if(tp>0 && tp<pp+(msl+1)*mp) tp=pp+(msl+1)*mp;
                  break;
               case OP_SELLLIMIT:
                  if(pp<pb+msl*mp) pp=pb+msl*mp;
                  if(sl>0 && sl<pp+(msl+1)*mp) sl=pp+(msl+1)*mp;
                  if(tp>pp-(msl+1)*mp) tp=pp-(msl+1)*mp;
                  break;
               case OP_SELLSTOP:
                  if(pp>pb-msl*mp) pp=pb-msl*mp;
                  if(sl>0 && sl<pp+(msl+1)*mp) sl=pp+(msl+1)*mp;
                  if(tp>pp-(msl+1)*mp) tp=pp-(msl+1)*mp;
                  break;
              }
            Alert("SetOrder(): Скорректированы ценовые уровни"+sy+"--op-"+op+"--ll-"+ll+"--pp-"+pp+"---"+Slippage+"--sl-"+sl+"--tp-"+tp+"---"+lsComm+"---"+mn+"---"+ex+"---"+clOpen);
           }
         // Блокировка работы советника
         if(err==2 || err==64 || err==65 || err==133)
           {
            break;
           }
         // Длительная пауза
         if(err==4 || err==131 || err==132)
           {
            Sleep(1000*300); break;
           }
         // Слишком частые запросы (8) или слишком много запросов (141)
         if(err==8 || err==141) Sleep(1000*100);
         if(err==139 || err==140 || err==148) break;
         // Ожидание освобождения подсистемы торговли
         if(err==146) while(IsTradeContextBusy()) Sleep(1000*11);
         // Обнуление даты истечения
         if(err==147)
           {
            ex=0; continue;
           }
         if(err!=135 && err!=138) Sleep(1000*7.7);
        }
     }
  }
//+------------------------------------------------------------------+
//|               Возвращает флаг удачного выбора позиции по тикету  |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    ti - наименование тикета                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+


bool SBT(int ti,string sy="",int op=-1,int mn=-1)
  {
   int i,k=OrdersTotal();
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(sy=="0") sy=Symbol();
   for(i=0;i<k;i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op))
           {
            if((mn<0 || OrderMagicNumber()==mn) && OrderTicket()==ti) return(True);
           }
        }
     }
   return(False);
  }
//+------------------------------------------------------------------+
//|               Открытие позиции по рынку                          |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ("" или NULL - текущий символ)          |
//|    op - операция                                                           |
//|    ll - лот                                                                |
//|    sl - уровень стоп                                                       |
//|    tp - уровень тейк                                                       |
//|    mn - MagicNumber                                                        |
//+----------------------------------------------------------------------------+
int OPs(string sy,int op,double ll,double sl=0,double tp=0,int mn=0,string coomment="")
  {
   color    clOpen;
   datetime ot;
   double   pp,pa,pb;
   int      dg,err,it,ticket=0;
   string   lsComm="";
   if(sy=="" || sy=="0") sy=Symbol();
   if(op==OP_BUY) clOpen=Green; else clOpen=Red;
   string Autor=" Автор функции для шаблона : www.expforex.com";

   for(it=1;it<=3;it++)
     {
      if(!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while(!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      dg=MarketInfo(sy, MODE_DIGITS);
      pa=MarketInfo(sy, MODE_ASK);
      pb=MarketInfo(sy, MODE_BID);
      if(op==OP_BUY) pp=pa; else pp=pb;
      pp=NormalizeDouble(pp, dg);
      ot=TimeCurrent();
      if(!MarketWatch) ticket=OrderSend(sy,op,ll,pp,1,sl,tp,coomment,mn,0,clOpen);
      if(MarketWatch)

        {
         ticket=OrderSend(sy,op,ll,pp,1,0,0,coomment,mn,0,clOpen);
         if(SBT(ticket)) ModifyOrder(-1,sl,tp);
        }

      if(ticket>0)
        {
         break;
           } else {
         err=GetLastError();
         if(err==128 || err==142 || err==143)
           {
            Sleep(1000*66.666);
           }
         // Вывод сообщения об ошибке
         Alert("Error(",err,") opening position: ",ErrorDescription(err),", try ",it);
         Alert("Ask=",pa," Bid=",pb," sy=",sy," ll=",ll," op=",op,
               " pp=",pp," sl=",sl," tp=",tp," mn=",mn);
         if(pa==0 && pb==0) Alert("Проверьте в Обзоре рынка наличие символа "+sy);
         // Блокировка работы советника
         if(err==2 || err==64 || err==65 || err==133)
           {
            break;
           }
         // Длительная пауза
         if(err==4 || err==131 || err==132)
           {
            Sleep(1000*300); break;
           }
         if(err==140 || err==148 || err==4110 || err==4111) break;
         if(err==141) Sleep(1000*100);
         if(err==145) Sleep(1000*17);
         if(err==146) while(IsTradeContextBusy()) Sleep(1000*11);
         if(err!=135) Sleep(1000*7.7);
        }
     }
   return(ticket);
  }
//+------------------------------------------------------------------+
//|                Наличие позиций по рынку                          |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+

bool EPs(string sy="",int op=-1,int mn=-1,int ticket=0)
  {
   string Autor=" Автор функции для шаблона : www.expforex.com";

   int i,k=OrdersTotal();

   if(sy=="0") sy=Symbol();
   for(i=0;i<k;i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==sy || sy=="")
           {
            if(OrderType()==OP_BUY || OrderType()==OP_SELL)
              {
               if(op<0 || OrderType()==op)
                 {
                  if(mn<0 || OrderMagicNumber()==mn)
                    {
                     if(ticket==OrderTicket() || ticket==0) return(True);
                    }
                 }
              }
           }
        }
     }
   return(False);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                 Автолот                                          |
//+------------------------------------------------------------------+
double lastlot;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetSizeLot(double ll=1) //Функция возвращает значение лотов, 
  {
   string Autor=" Автор функции для шаблона : www.expforex.com";

   string Valdepo=AccountCurrency();
//если включен ММ то значение лотов, 
   double Lot2,MinLots,MaxLots;
   int lotdig;
   if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.01)lotdig=2; else lotdig=1;
   if(Valdepo=="USD")
     {
      if(StringSubstr(Symbol(),0,3)=="USD")Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
      else if(StringSubstr(Symbol(),3,3)=="USD")Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()/Ask/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
      else
        {
         double pr=MarketInfo(StringSubstr(Symbol(),0,3)+"USD",MODE_ASK);
         if(pr!=0)Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()/pr/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
         else Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
        }
     }
   if(Valdepo=="EUR")
     {
      if(StringSubstr(Symbol(),0,3)=="EUR")Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
      else
        {
         pr=MarketInfo("EUR"+StringSubstr(Symbol(),0,3),MODE_BID);
         if(pr!=0)Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()*pr/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
         else Lot2=NormalizeDouble(AccountFreeMargin()*LotBalancePcnt*AccountLeverage()/100/MarketInfo(Symbol(),MODE_LOTSIZE),lotdig);
        }
     }
   MinLots=MarketInfo(Symbol(),MODE_MINLOT);
   MaxLots=MaxLot;
   if(!DynamicLot)Lot2=Lots;
   if(lastlot<Lot2)lastlot=Lot2;
   if(isCloseLastPosByStop(Symbol(),-1,Magic))lastlot=lastlot*Martin;
   if(!isCloseLastPosByStop(Symbol(),-1,Magic))lastlot=Lot2;

   Lot2=lastlot;
   if(Lot2 < MinLots) Lot2 = MinLots;
   if(Lot2 > MaxLots) Lot2 = MaxLots;
   return(NormalizeDouble(Lot2,2));
  }
//+------------------------------------------------------------------+

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

//+------------------------------------------------------------------+
//|                    Удаление 1 предварительно выбранной позиции   |
//+------------------------------------------------------------------+

void CPBS()
  {
   bool   fc;
   color  clClose;
   double ll,pa,pb,pp;
   int    err,it;
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(OrderType()==OP_BUY || OrderType()==OP_SELL)
     {
      for(it=1; it<=5; it++)
        {
         if(!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
         while(!IsTradeAllowed()) Sleep(5000);
         RefreshRates();
         pa=MarketInfo(OrderSymbol(), MODE_ASK);
         pb=MarketInfo(OrderSymbol(), MODE_BID);
         if(OrderType()==OP_BUY)
           {
            pp=pb;
              } else {
            pp=pa;
           }
         ll=OrderLots();
         fc=OrderClose(OrderTicket(), ll, pp, 1, clClose);
         if(fc)
           {
            break;
              } else {
            err=GetLastError();
            if(err==146) while(IsTradeContextBusy()) Sleep(1000*11);
            Sleep(1000*5);
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|              Удаление позиций по рынку                           |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+

void CPD(string sy="",int op=-1,int mn=-1)
  {
   int i,k=OrdersTotal();
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(sy=="0") sy=Symbol();
   for(i=k-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op))
           {
            if(OrderType()==OP_BUY || OrderType()==OP_SELL)
              {
               if(mn<0 || OrderMagicNumber()==mn) CPBS();
              }
           }
        }
     }
  }
//+----------------------------------------------------------------------------+
//|  Описание : Сопровождение позиций простым тралом                           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void SimpleTrailing(string sy="",int op=-1,int mn=-1)
  {
   double po,pp;
   int    i,k=OrdersTotal();
   string Autor=" Автор функции для шаблона : www.expforex.com";

   if(sy=="0") sy=Symbol();
   if(TrailingStop==0)TrailingStop=MarketInfo(Symbol(),MODE_STOPLEVEL);
   for(i=0;i<k;i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op))
           {
            po=MarketInfo(OrderSymbol(),MODE_POINT);
            if(mn<0 || OrderMagicNumber()==mn)
              {
               if(OrderType()==OP_BUY)
                 {
                  pp=MarketInfo(OrderSymbol(),MODE_BID);
                  if((!IfProfTrail && OrderProfit()>0) || pp-OrderOpenPrice()>TrailingStop*po)
                    {
                     if(OrderStopLoss()<pp-(TrailingStop+TrailingStep-1)*po)
                       {
                        ModifyOrder(-1,pp-TrailingStop*po,-1);
                       }
                    }
                 }
               if(OrderType()==OP_SELL)
                 {
                  pp=MarketInfo(OrderSymbol(),MODE_ASK);
                  if((!IfProfTrail && OrderProfit()>0) || OrderOpenPrice()-pp>TrailingStop*po)
                    {
                     if(OrderStopLoss()>pp+(TrailingStop+TrailingStep-1)*po || OrderStopLoss()==0)
                       {
                        ModifyOrder(-1,pp+TrailingStop*po,-1);
                       }
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   Stamp();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Stamp()
  {
   ObjectCreate("Original",OBJ_LABEL,0,0,0);
   ObjectSetText("Original"," Сделано при помощи шаблона : www.expforex.com ",12,"Arial Bold",Chartreuse);
   ObjectSet("Original",OBJPROP_CORNER,0);
   ObjectSet("Original",OBJPROP_XDISTANCE,0);
   ObjectSet("Original",OBJPROP_YDISTANCE,10);

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

bool isCloseLastPosByStop(string sy="",int op=-1,int mn=-1)
  {
   datetime t;
   double   ocp,osl;
   int      dg,i,j=-1,k=OrdersHistoryTotal();

   if(sy=="0") sy=Symbol();
   for(i=0; i<k; i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
        {
         if(OrderSymbol()==sy || sy=="")
           {
            if(OrderType()==OP_BUY || OrderType()==OP_SELL)
              {
               if(op<0 || OrderType()==op)
                 {
                  if(mn<0 || OrderMagicNumber()==mn)
                    {
                     if(t<OrderCloseTime())
                       {
                        t=OrderCloseTime();
                        j=i;
                       }
                    }
                 }
              }
           }
        }
     }
   if(OrderSelect(j,SELECT_BY_POS,MODE_HISTORY))
     {
      dg=MarketInfo(OrderSymbol(),MODE_DIGITS);
      if(dg==0) if(StringFind(OrderSymbol(),"JPY")<0) dg=4; else dg=2;
      ocp=NormalizeDouble(OrderClosePrice(), dg);
      osl=NormalizeDouble(OrderStopLoss(), dg);
      if(OrderProfit()<0) return(True);
     }
   return(False);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string ErrorDescription(int error_code)
  {
   string error_string;
//----
   switch(error_code)
     {
      //---- codes returned from trade server
      case 0:
      case 1:   error_string="no error";                                                  break;
      case 2:   error_string="common error";                                              break;
      case 3:   error_string="invalid trade parameters";                                  break;
      case 4:   error_string="trade server is busy";                                      break;
      case 5:   error_string="old version of the client terminal";                        break;
      case 6:   error_string="no connection with trade server";                           break;
      case 7:   error_string="not enough rights";                                         break;
      case 8:   error_string="too frequent requests";                                     break;
      case 9:   error_string="malfunctional trade operation (never returned error)";      break;
      case 64:  error_string="account disabled";                                          break;
      case 65:  error_string="invalid account";                                           break;
      case 128: error_string="trade timeout";                                             break;
      case 129: error_string="invalid price";                                             break;
      case 130: error_string="invalid stops";                                             break;
      case 131: error_string="invalid trade volume";                                      break;
      case 132: error_string="market is closed";                                          break;
      case 133: error_string="trade is disabled";                                         break;
      case 134: error_string="not enough money";                                          break;
      case 135: error_string="price changed";                                             break;
      case 136: error_string="off quotes";                                                break;
      case 137: error_string="broker is busy (never returned error)";                     break;
      case 138: error_string="requote";                                                   break;
      case 139: error_string="order is locked";                                           break;
      case 140: error_string="long positions only allowed";                               break;
      case 141: error_string="too many requests";                                         break;
      case 145: error_string="modification denied because order too close to market";     break;
      case 146: error_string="trade context is busy";                                     break;
      case 147: error_string="expirations are denied by broker";                          break;
      case 148: error_string="amount of open and pending orders has reached the limit";   break;
      case 149: error_string="hedging is prohibited";                                     break;
      case 150: error_string="prohibited by FIFO rules";                                  break;
      //---- mql4 errors
      case 4000: error_string="no error (never generated code)";                          break;
      case 4001: error_string="wrong function pointer";                                   break;
      case 4002: error_string="array index is out of range";                              break;
      case 4003: error_string="no memory for function call stack";                        break;
      case 4004: error_string="recursive stack overflow";                                 break;
      case 4005: error_string="not enough stack for parameter";                           break;
      case 4006: error_string="no memory for parameter string";                           break;
      case 4007: error_string="no memory for temp string";                                break;
      case 4008: error_string="not initialized string";                                   break;
      case 4009: error_string="not initialized string in array";                          break;
      case 4010: error_string="no memory for array\' string";                             break;
      case 4011: error_string="too long string";                                          break;
      case 4012: error_string="remainder from zero divide";                               break;
      case 4013: error_string="zero divide";                                              break;
      case 4014: error_string="unknown command";                                          break;
      case 4015: error_string="wrong jump (never generated error)";                       break;
      case 4016: error_string="not initialized array";                                    break;
      case 4017: error_string="dll calls are not allowed";                                break;
      case 4018: error_string="cannot load library";                                      break;
      case 4019: error_string="cannot call function";                                     break;
      case 4020: error_string="expert function calls are not allowed";                    break;
      case 4021: error_string="not enough memory for temp string returned from function"; break;
      case 4022: error_string="system is busy (never generated error)";                   break;
      case 4050: error_string="invalid function parameters count";                        break;
      case 4051: error_string="invalid function parameter value";                         break;
      case 4052: error_string="string function internal error";                           break;
      case 4053: error_string="some array error";                                         break;
      case 4054: error_string="incorrect series array using";                             break;
      case 4055: error_string="custom indicator error";                                   break;
      case 4056: error_string="arrays are incompatible";                                  break;
      case 4057: error_string="global variables processing error";                        break;
      case 4058: error_string="global variable not found";                                break;
      case 4059: error_string="function is not allowed in testing mode";                  break;
      case 4060: error_string="function is not confirmed";                                break;
      case 4061: error_string="send mail error";                                          break;
      case 4062: error_string="string parameter expected";                                break;
      case 4063: error_string="integer parameter expected";                               break;
      case 4064: error_string="double parameter expected";                                break;
      case 4065: error_string="array as parameter expected";                              break;
      case 4066: error_string="requested history data in update state";                   break;
      case 4099: error_string="end of file";                                              break;
      case 4100: error_string="some file error";                                          break;
      case 4101: error_string="wrong file name";                                          break;
      case 4102: error_string="too many opened files";                                    break;
      case 4103: error_string="cannot open file";                                         break;
      case 4104: error_string="incompatible access to a file";                            break;
      case 4105: error_string="no order selected";                                        break;
      case 4106: error_string="unknown symbol";                                           break;
      case 4107: error_string="invalid price parameter for trade function";               break;
      case 4108: error_string="invalid ticket";                                           break;
      case 4109: error_string="trade is not allowed in the expert properties";            break;
      case 4110: error_string="longs are not allowed in the expert properties";           break;
      case 4111: error_string="shorts are not allowed in the expert properties";          break;
      case 4200: error_string="object is already exist";                                  break;
      case 4201: error_string="unknown object property";                                  break;
      case 4202: error_string="object is not exist";                                      break;
      case 4203: error_string="unknown object type";                                      break;
      case 4204: error_string="no object name";                                           break;
      case 4205: error_string="object coordinates error";                                 break;
      case 4206: error_string="no specified subwindow";                                   break;
      default:   error_string="unknown error";
     }
//----
   return(error_string);
  }