//+------------------------------------------------------------------+
//|                                                       FISHINGBOT |
//|               MAX888 && PavelG && Pavka69 && Barrel && UserUserov|
//|             http://forum.tradelikeapro.ru/index.php?topic=4731.0 |
//|                                                          v. 2.08 |
//+------------------------------------------------------------------+
//
// v. 2.08
// - фильтр для входа по i_Alex_Activity_v02
// - фильтр для входа по !EntropyMathMCD
// v. 2.07
// - фильтр по BetterVolume v1.4
// - реверсивное открытие
// - возможность работать в тестере без визуализации
// v. 2.06
// - исправлены найденные ошибки
//   - защита от переползания
// - открытие по закрытию свечи
// - трал по МА
// - открытие нескольких поз в одном направлении
// - продолжение работы по открытию на текущей свече после открытия
// - дельта в фильтре по 2-м МА
// v. 2.051
// - доработка для работы на автономном графике (ренко)
// v. 2.05
// - добавлен фильтр на открытие по двум МА
// - ограничение кол-ва открытых позиций при доливках
// - коэффициент для лота для доливок
// v. 2.04
// - добавлен фильтр на открытие по МА
//
// v. 2.03
// - добавлен выход по двум МА и по CCI
//
// v. 2.02
// - добавлены тралы по ATR, по фракталам
// - добавлено управление возможностья открыти, не выключая бота через внешние переменные
//

#property copyright "MAX888 && PavelG && Pavka69 && Barrel && UserUserov"
#property link      "http://forum.tradelikeapro.ru/index.php?topic=4731.0"

//--- input parameters
//==================================================================================
extern string  pausa_ = "Задержка инициализации";
extern int     pausa = 10000; //Пауза в инициализации в миллисекундах
//==================================================================================
extern string  lotst_ = "Параметры расчета лота (Использование ММ)";
extern int     typelot = 1;   // 1 - фиксированный лот из Lot
                              // 2 - реинвестиция + %% риска на возможный СЛ
                              // 3 - DDSMM (как считается, не знаю :))) )
extern double  Lot=0.1;//минимальный лот
extern double  risk=10;// процент риска на возможный СЛ
extern int     rpip=1000;// величина возможного СЛ в пунктах
extern int     MeansType=3;// Тип средств, используемых при расчете размера лота:
                           // 1 Депозит
                           // 2 Свободные средства
                           // 3 максимальное между Депозит и Свободные средства
//==================================================================================
extern string  posa_       = "Параметры открытия поз";
extern bool    glopenpos   = false;//открывать несколько поз в одном направлении
                                 //false - открывается только 1 поза
extern int     maxkolorder = 3;//максимальное кол-во поз в одном направлении (используется только при использовании фильтра открытия по МА)
extern double  dopkoeflot  = 1.0;//коэффициент для расчета лота в случае открытия доливочных поз. (используется только при использовании фильтра открытия по МА)
//==================================================================================
extern string  reversopen_ = "Реверсивное открытие поз";
extern bool    reversopen  = false;
//==================================================================================
extern bool    usewinlot = true;//показывать окно с информацией о лоте и другая информация
extern color   FontColor = Silver;
extern string  note3 = "Font Size";
extern int     FontSize = 9;
extern string  note4 = "Font Type";
extern string  FontType = "Calibri";//"Comic Sans MS";
extern string  note5 = "Display the price in what corner?";
extern string  note6 = "Upper left=0; Upper right=1";
extern string  note7 = "Lower left=2; Lower right=3";
extern int     WhatCorner = 2;
extern int     Win = 0;//в каком окне отображать
extern double  xx = 5;//позиция окна
extern double  yy = 5;//позиция окна
//==================================================================================
extern string  otst_ = "Отступ";
extern int     delta = 3;
//==================================================================================
extern string  stops_ = "Стопы";
extern int     TP = 700;//тейкпрофит, если 0 то не изменяется
extern int     SL = 450;//стоплосс, если 0 то не изменяется
//extern bool   MarketWatch=true;  //
//==================================================================================
extern string  inverse_ = "Противоположные позиции";
extern bool    closeinversebuy = true; //закрытие противоположных позиций
extern bool    closeinversesell = true; //закрытие противоположных позиций
//==================================================================================
extern string  noopen_ = "Неотработка первых ордеров";
extern bool    noopenfirstbuy = true;//не открывать первый buy после начала работы
extern bool    noopenfirstsell = true;//не открывать первый sell после начала работы
//==================================================================================
extern string  slugeb_ = "Служебное";
extern int     slip = 30;//величина допустимого проскальзывания при открытии позиции
extern int     MaxAttempts = 5;//количество попыток открытия позиции
extern int     MAGIC = 123;//магик
extern bool    UseSound = false;   //использование звуков при операциях с ордерами
extern string  SoundError = "alert.wav";
extern string  SoundSuccess = "ok.wav";
extern bool    Usecurrtime = true; //false - продолжение работы по открытию на текущей свече после открытия...
                                   //true - на текущей свече больше не происходит проверка на открытие и закрытие противоположных поз
//==================================================================================
extern string  tral = "Параметры трала";
extern bool    useTS        = false;          // Использование трала
extern int     typets       = 1;              // тип используемого тара
                                             // 1 - кимивский трал с шагом (какой был изначально)
                                             // 2 - трал по ATR
                                             // 3 - трал по фракталам из системы
                                             // 4 - трал по MA
extern string  tral1 = "Обычный трал с шагом КимIV";
extern bool    TSProfitOnly = true;           // Тралить только профит
extern int     TStop.Buy    = 300;            // Размер трала в пунктах для покупок
extern int     TStop.Sell   = 300;            // Размер трала в пунктах для продаж
extern int     TStop.All    = 300;            // Если больше 0, берется и для покупок, и для продаж
extern int     TrailingStep = 30;             // Шаг трала в пунктах

extern string  tral2 = "Трал по ATR";
extern int     iAtr_timeframe;      // период графика, на котором считается ATR (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     iAtr1_period = 5;    // период первого ATR
extern int     iAtr1_shift = 1;     // сдвиг первого ATR
extern int     iAtr2_period = 36;   // период второго ATR
extern int     iAtr2_shift = 1;     // сдвиг второго ATR
extern double  dCoeff = 1;          // коэффициент, на который множим ATR, чтобы получить стоплосс (при coeff=1 стоп будер размещен на расстоянии в 1 ATR, при coeff=1.5 - на расстоянии в полтора ATR и т.д.)
extern int     iAtrstep = 30;       // шаг изменения стопа
extern bool    bTrlinloss = false;  // следует ли тралить на участке лоссов (между курсом стоплосса и открытия)

extern string  tral3 = "Трал по фракталам";
extern int     iTmfrm;              // период графика, на котором определяются фракталы (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     iIndent = 3;         // отступ от тени бара, на котором размещается стоплосс
extern bool    bTrlinloss1 = false; // следует ли тралить на участке лоссов (между курсом стоплосса и открытия)

extern string  tral4 = "Трал по MA";
extern int     giMATmFrme = 0;              // период графика, на котором строится МА (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     giMAPeriod = 21;      // период МА (не меньше 2)
extern int     giMAShift = 0;        // сдвиг индикатора относительно ценового графика
extern int     giMAMethod = 0;       // метод усреднения (0 - MODE_SMA, 1 - MODE_EMA, 2 - MODE_SMMA, 3 - MODE_LWMA);
extern int     giApplPrice = 0;      // используемая цена (0 - PRICE_CLOSE, 1 - PRICE_OPEN, 2 - PRICE_HIGH, 3 - PRICE_LOW, 4 - PRICE_MEDIAN, 5 - PRICE_TYPICAL, 6 - PRICE_WEIGHTED)
extern int     giShift = 1;          // индекс получаемого значения из индикаторного буфера (сдвиг относительно текущего бара на указанное количество периодов назад)
extern int     giIndent = 30;        // отступ от MA, на котором размещается стоплосс
extern int     giMAstep = 30;        // шаг изменения стопа
extern bool    bTrlMAinloss = false;// следует ли тралить на участке лоссов (между курсом стоплосса и открытия)

//==================================================================================
extern string  usebu_ = "Параметры безубытка";
extern bool    useBU            = false;          // Использование переноса в БУ
extern int     LevelProfit         = 200;            // - Уровень профита в пунктах, которого должна достигнуть позиция для того, чтобы её стоп был перенесён на уровень безубытка.
extern int     LevelWLoss          = 15;             // - Уровень безубытка в пунктах, на который будет перенесён стоп позиции после того, как её профит достигнет уровня LevelProfit в пунктах.
//==================================================================================
extern string  useexitma_  = "Параметры выхода по МА";
extern bool    useexitma  = false;//использование выхода по пересечению МА
extern bool    usecurrma   = false;//по закрытию (true - по текущему значению)
extern double  madelta     = 0;//число в пунктах, когда пересечение есть, но оно не считается :))) ...
extern string  useexitma1_  = "Параметры быстрой МА";
extern int     ma1tf       = 0;//период графика, на котором считается ma1 (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     ma1per      = 2;//период ма1
extern int     ma1shif     = 0;//сдвиг
extern int     ma1met      = 0;//метод вычисления (0-простая, 1-експ, ...)
extern int     ma1price    = 0;//цена (0-Close, 1-Open, 2-High, 3-Low, ...)
extern string  useexitma2_  = "Параметры медленной МА";
//extern int     ma2tf       = 0;//период графика, на котором считается ma2 (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     ma2per      = 2;//период ма1
extern int     ma2shif     = 0;//сдвиг
extern int     ma2met      = 0;//метод вычисления (0-простая, 1-експ, ...)
extern int     ma2price    = 1;//цена (0-Close, 1-Open, 2-High, 3-Low, ...)

extern string  useexitcci_  = "Параметры выхода по CCI";
extern bool    useexitcci  = false;//использование выхода по CCI
extern int     ccitf       = 0;//период графика, на котором считается ma1 (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     cciper      = 2;//период CCI
extern int     cciprice    = 0;//цена (0-Close, 1-Open, 2-High, 3-Low, ...)
//==================================================================================
extern string  useHL_ = "Определение пробития линии";
extern int     useHL  = 1;  //Определение пробития линии 
                            //1 - по High Low
                            //2 - по Bid Ask
                            //3 - Close предыдущей свечи
//==================================================================================
extern string  pline_ = "Параметры линий";
extern int     lineupw = 2;//ширина линии вверх
extern color   lineupc = Blue;//цвет линии вверх
extern int     linednw = 2;//ширина линии вниз
extern color   linednc = Red;//цвет линии вниз
//==================================================================================
extern string  filtr_ = "Параметры фильтра открытия поз по МА";
extern bool    glfiltr  = false;//использование фильтра открытия по МА
extern int     gntypefiltr = 1;//1 - 1 MA, 2 - 2MA
extern bool    glcloserev   = false;//не закрывать открытые позы в нужном направлении, если
                                 //появился противоположный сигнал и он НЕ ДОЛЖЕН отработать
                                 //true - закрывать

extern string  filtr1_ = "Для быстрой МА или когда одна МА";
extern int     gnmatf       = 0;//период графика, на котором считается ma (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     gnmaper      = 21;//период ма
extern int     gnmashif     = 0;//сдвиг
extern int     gnmamet      = 0;//метод вычисления (0-простая, 1-експ, ...)
extern int     gnmaprice    = 0;//цена (0-Close, 1-Open, 2-High, 3-Low, ...)
extern double  gnmadelta = 0;//число в пунктах, когда закрытие выше/ниже МА, но оно не считается :))) ...
                            //и для двух МА, когда разница между МА меньше дельта

extern string  filtr2_ = "Для медленной МА когда две МА";
extern int     gnma2tf       = 0;//период графика, на котором считается ma (0-текущий, 1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern int     gnma2per      = 89;//период ма
extern int     gnma2shif     = 0;//сдвиг
extern int     gnma2met      = 0;//метод вычисления (0-простая, 1-експ, ...)
extern int     gnma2price    = 0;//цена (0-Close, 1-Open, 2-High, 3-Low, ...)

extern string  filtr3_ = "Фильтр по BetterVolume";
extern bool    glusebv = false;//использование фильтра открытия по BetterValue
extern int     NumberOfBars = 500;
extern string  Note = "";
extern int     MAPeriod = 100;
extern int     LookBack = 20;

extern string  filtr4_ = "Фильтр по i_Alex_Activity_v02_light";
extern bool    gl4usef4 = false;//использование фильтра открытия по i_Alex_Activity_v02_light
extern int     gl4BARS_Period = 4;// период
extern int     gl4Levels = 10;// уровни в пунктах
extern int     gl4nbarswait = 3;// сколько баров ждать пробития

extern string  filtr5_ = "Фильтр по !EntropyMathMCD";
extern bool    gl5usef5 = false;//использование фильтра открытия по !EntropyMathMCD
extern int     gl5numbars=14;
extern int     gl5SignalSMA=5;
extern double  gl5Levels = 0.0001;// уровни в пунктах
extern int     gl5nbarswait = 3;// сколько баров ждать пробития

//==================================================================================
extern string  nobreak_ = "Защита от переползания линии ценой";
extern string  nobreak1_ = "Работает только при открытии по закрытию!!!";
extern int     gldeltaclose = 0;//дельта... например для бай, если цена закрытия выше, но оно не считается :))) ...
extern bool    glnobreak   = false;//не использовать защиту от переползания линии
extern bool    glclosenobreakrev   = false;//не закрывать открытые позы в нужном направлении, если
                                          //появился противоположный сигнал и он НЕ ДОЛЖЕН отработать
                                          //true - закрывать
//==================================================================================
extern string  ptime_ = "время работы";
extern bool    tiuse = false;
extern string  tbeg  = "00:00";//начало работы
extern string  tend  = "23:59";//окончание работы
extern bool    noopensleepbuy = true;//не открывать первый buy после начала работы
extern bool    noopensleepsell = true;//не открывать первый sell после начала работы
//==================================================================================
extern string  test_ = "Для тестера";
extern bool    usetest = false;//true - для работы в тестере без визуализации
extern int     gltypeind = 0;//  0 - fishingind_v2_03
                             //  1 - fishingZZ_v1_1
//----------------------------------------------------------------------------------
extern string  ind1_ = "Параметры для fishingind";
extern int     glotstup1 = 50;//отступ от High Low в пунктах для рисования фрактала и линии
extern int     glkolshow1 = 50;////количество свечей для расчета фракталов на графике
//----------------------------------------------------------------------------------
extern string  ind2_ = "Параметры для fishingZZ";
extern int     glExtDepth1 = 12;
extern int     glExtDeviation = 5;
extern int     glExtBackstep = 3;
extern int     glotstup2 = 50;//отступ от High Low в пунктах для рисования фрактала и линии
extern bool    glshowrline = false;//показ линий неправильного направления
//==================================================================================

#include <stdlib.mqh>        	// Стандартная библиотека МТ4

int buy=0,sell=0,round;
static datetime prevtime;
static datetime prevtimema;
static datetime prevtimecci;
static int firstload = 1;
bool   gbDisabled               = False;         // Флаг блокировки советника
bool   gbNoInit                 = False;         // Флаг неудачной инициализации
string f3noopenbuy, f3noopensell;
int    timelastup = 0, timecurrup = 0, timelastdn = 0, timecurrdn = 0;
int    usebarf4prev = 0, usebarf4 = 0, usebarf5prev = 0, usebarf5 = 0;
double usebarf4prevval,usebarf5prevval;
int    sigprev=-100;
string gcComm = "Fishing_v_2_08";


//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
//----
  if (!IsTradeAllowed()) {
  Message("Для нормальной работы советника необходимо\n"+
            "Разрешить советнику торговать");
    gbNoInit=True; return;
  }
  if (!IsLibrariesAllowed()) {
    Message("Для нормальной работы советника необходимо\n"+
            "Разрешить импорт из внешних экспертов");
    gbNoInit=True; return;
  }
  if (!IsTesting()) {
    if (!IsConnected())
    {
      Message("Ожидание соединения");
      while (true)
      {
         if (IsConnected()) break;
      }
    }
    if (pausa>0) {Message("Пауза в инициализации "+DoubleToStr(pausa/1000,0)+" секунд"); Sleep(pausa);}
    if (!IsConnected())
    {
      Message("Ожидание соединения");
      while (true)
      {
         if (IsConnected()) break;
      }
    }
    if (IsExpertEnabled()) { Message("Советник будет запущен следующим тиком");  }
    else { Message("Отжата кнопка \"Разрешить запуск советников\""); }
  }

  if (usewinlot)
  {
      ObjectCreate("LabelMM1", OBJ_LABEL, Win, 0, 0);
      ObjectSet("LabelMM1", OBJPROP_CORNER, WhatCorner);
      ObjectSet("LabelMM1", OBJPROP_XDISTANCE, xx);
      ObjectSet("LabelMM1", OBJPROP_YDISTANCE, yy);
  }

//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   Comment("");
   if(ObjectFind("LabelMM1")>-1) ObjectDelete("LabelMM1");
   if (GlobalVariableCheck("FBOTbuy"+Symbol()+Period()+MAGIC) && GlobalVariableGet("FBOTbuy"+Symbol()+Period()+MAGIC)<=0.0 )
      GlobalVariableDel("FBOTbuy"+Symbol()+Period()+MAGIC);
   if (GlobalVariableCheck("FBOTsell"+Symbol()+Period()+MAGIC) && GlobalVariableGet("FBOTsell"+Symbol()+Period()+MAGIC)<=0.0 )
      GlobalVariableDel("FBOTsell"+Symbol()+Period()+MAGIC);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
   if (!IsTesting()) { Comment(""); }
   if (gbDisabled) 
   {
      Message("Критическая ошибка! Советник ОСТАНОВЛЕН!"); return;
   }
   if (gbNoInit) 
   {
      Message("Не удалось инициализировать советник!"); return;
   }

//----
   if (firstload==1)
   {
      if (noopenfirstbuy == true)
      {
         linednto1();
         if (usetest && IsTesting())
         {
            getvalline(gltypeind,0,0);
            timelastdn = timecurrdn;
         }
      }
      if (noopenfirstsell == true)
      {
         lineupto1();
         if (usetest && IsTesting())
         {
            getvalline(gltypeind,1,0);
            timelastup = timecurrup;
         }
      }
      firstload=0;
   }   

   double lnlot;
   int aadop;
   int mper, cper;
   
   f3noopenbuy = "FBOTbuy"+Symbol()+Period()+MAGIC;
   f3noopensell = "FBOTsell"+Symbol()+Period()+MAGIC;

   GetLot(typelot, 1);
   if (useexitma || useexitcci) SimpleExit(Symbol(),MAGIC);
   if (useBU) MovingInWL(Symbol(), -1, MAGIC);
   if (useTS) SimpleTrailing(Symbol(), -1, MAGIC);

   if (Usecurrtime)
   {
      if (iTime(Symbol(), 0, 0) == prevtime)
      {
         return;
      }
   }

   if (tiuse)
   {
      if (StrToTime(tbeg) <= StrToTime(tend))
      {
         if ((TimeCurrent() < StrToTime(tbeg)) || (TimeCurrent() >= StrToTime(tend)))
         {
            if (noopensleepbuy == true)
            {
               linednto1();
               if (usetest && IsTesting())
               {
                  getvalline(gltypeind,0,0);
                  timelastdn = timecurrdn;
               }
            }
            if (noopensleepsell == true)
            {
               lineupto1();
               if (usetest && IsTesting())
               {
                  getvalline(gltypeind,1,0);
                  timelastup = timecurrup;
               }
            }
            return;
         }  
      }
      else
      {
         if (((TimeCurrent() > StrToTime(tbeg)) && (TimeCurrent() >= StrToTime(tend))) || ((TimeCurrent() < StrToTime(tbeg)) && (TimeCurrent() <= StrToTime(tend))))
         {
            if (noopensleepbuy == true)
            {
               linednto1();
               if (usetest && IsTesting())
               {
                  getvalline(gltypeind,0,0);
                  timelastdn = timecurrdn;
               }
            }
            if (noopensleepsell == true)
            {
               lineupto1();
               if (usetest && IsTesting())
               {
                  getvalline(gltypeind,1,0);
                  timelastup = timecurrup;
               }
            }
            return;                  
         }
      }
   }
   
   countOpenPosition(MAGIC);

   int sig = SIG();

   if(sig == 1 || sig == 2 || sig == 3)//buy+sell == 0
   {
      if ((glfiltr && sig == 2))
      { 
         if(glcloserev) ClosePositions(Symbol(), OP_SELL, MAGIC);
      }
      else
      {
         if ((glnobreak && sig == 3))
         {
            if(glclosenobreakrev) ClosePositions(Symbol(), OP_SELL, MAGIC);
         }
         else
         {
            if (closeinversesell==true) ClosePositions(Symbol(), OP_SELL, MAGIC);
         }
      }
      
      if ( sig==1 && ((glopenpos && maxkolorder > buy) || buy==0) )
//      if (((glfiltr == false && buy == 0) || (glfiltr && (glopenpos || buy==0) && maxkolorder > buy)) && sig == 1) 
      {
         if (GetFrozenBool(OP_BUY))
         {
            lnlot = GetLot(typelot,-1,OP_BUY);
            if (lnlot>0.0)
            {
               Buy(normlot(lnlot), SL, TP, gcComm, slip, MAGIC, MaxAttempts, Blue);
               if (ma1tf==0) mper=Period();
               if (ccitf==0) cper=Period();
               if (usecurrma == false) prevtimema = iTime(Symbol(),mper,0);
               prevtimecci = iTime(Symbol(),cper,0);
            }
         }
      }
      linednto1();
      prevtime = iTime(Symbol(),0,0);
      return;
   }
   if(sig == -1 || sig == -2 || sig == -3)// +buy
   {
      if (glfiltr && sig == -2)
      { 
         if(glcloserev) ClosePositions(Symbol(), OP_BUY, MAGIC);
      }
      else
      {
         if ((glnobreak && sig == -3))
         {
            if(glclosenobreakrev) ClosePositions(Symbol(), OP_BUY, MAGIC);
         }
         else
         {
            if (closeinversebuy==true) ClosePositions(Symbol(), OP_BUY, MAGIC);
         }
      }
      if ( sig==-1 && ((glopenpos && maxkolorder > sell) || sell==0) )
//      if (((glfiltr == false && sell == 0) || (glfiltr && (glopenpos || sell==0) && maxkolorder > sell)) && sig == -1) 
      {
         if (GetFrozenBool(OP_SELL))
         {
            lnlot = GetLot(typelot,-1,OP_SELL);
            if (lnlot>0.0)
            {
               Sell(normlot(lnlot), SL, TP, gcComm, slip, MAGIC, MaxAttempts, Red);
               if (ma1tf==0) mper=Period();
               if (ccitf==0) cper=Period();
               if (usecurrma == false) prevtimema = iTime(Symbol(),mper,0);
               prevtimecci = iTime(Symbol(),cper,0);
            }
         }
      }
      lineupto1();
      prevtime = iTime(Symbol(),0,0);
      return;
   }

//----
   return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int SIG()
{
   double prRed,prRed1;
   double prBlue,prBlue1;
   int lnret=0;
   if (usetest && IsTesting())
   {
         prRed  = getvalline(gltypeind,0,0);
         if (prRed>0.0) prRed1  = getvalline(gltypeind,0,1); else prRed1=100000000.0;
         prBlue = getvalline(gltypeind,1,0);
         if (prBlue>0.0) prBlue1 = getvalline(gltypeind,1,1); else prBlue1  = -1.0;
         if (prRed==0.0) prRed  = 100000000.0;
         if (prRed1==0.0) prRed1  = 100000000.0;
         if (prBlue==0.0) prBlue  = -1.0;
         if (prBlue1==0.0) prBlue1  = -1.0;
   }
   else
   {
      if(ObjectFind("TrendlineDn")!=-1)
      {
         prRed  = ObjectGetValueByShift("TrendlineDn",0);
         prRed1  = ObjectGetValueByShift("TrendlineDn",1);
      }
      else
      {
         prRed  = 100000000.0;
         prRed1  = 100000000.0;
      }
      if(ObjectFind("TrendlineUp")!=-1)
      {
         prBlue = ObjectGetValueByShift("TrendlineUp",0);
         prBlue1 = ObjectGetValueByShift("TrendlineUp",1);
      }
      else
      {
         prBlue = -1.0;
         prBlue1 = -1.0;
      }
   }
   if (useHL==1)
   {
      if (High[0] >= prRed + delta*MarketInfo(Symbol(),MODE_POINT) || 
          High[1] >= prRed1 + delta*MarketInfo(Symbol(),MODE_POINT)) 
      {
         lnret = getfilterma(1);
         if (lnret >= 1) timelastdn = timecurrdn;
         if(reversopen) lnret*=(-1);
         nullsigbar(lnret);
         return(lnret);
      }
      if (Low[0] <= prBlue-delta*MarketInfo(Symbol(),MODE_POINT) ||
          Low[1] <= prBlue1-delta*MarketInfo(Symbol(),MODE_POINT))
      {
         lnret = getfilterma(-1);
         if (lnret <= -1) timelastup = timecurrup;
         if(reversopen) lnret*=(-1);
         nullsigbar(lnret);
         return(lnret);
      }
   }
   if (useHL==2)
   {
      if (Ask >= prRed + delta*MarketInfo(Symbol(),MODE_POINT) || 
          High[1] >= prRed1 + delta*MarketInfo(Symbol(),MODE_POINT))
      {
         lnret = getfilterma(1);
         if (lnret >= 1) timelastdn = timecurrdn;
         if(reversopen) lnret*=(-1);
         nullsigbar(lnret);
         return(lnret);
      }
      if (Bid <= prBlue-delta*MarketInfo(Symbol(),MODE_POINT) ||
          Low[1] <= prBlue1-delta*MarketInfo(Symbol(),MODE_POINT))
      {
         lnret = getfilterma(-1);
         if (lnret <= -1) timelastup = timecurrup;
         if(reversopen) lnret*=(-1);
         nullsigbar(lnret);
         return(lnret);
      }
   }
   if (useHL==3)
   {
      if (Close[1] >= prRed1 + delta*MarketInfo(Symbol(),MODE_POINT)) 
      {
         lnret = getfilterma(1);
         if (glnobreak && lnret!=0)
         {
            if (Close[1]-gldeltaclose*MarketInfo(Symbol(),MODE_POINT)<=prRed1 + delta*MarketInfo(Symbol(),MODE_POINT) &&
                Open[0]>=prRed + delta*MarketInfo(Symbol(),MODE_POINT))
                lnret = 3;
         }
         if (lnret >= 1) timelastdn = timecurrdn;
         if(reversopen) lnret*=(-1);
         nullsigbar(lnret);
         return(lnret);
      }
      if (Close[1] <= prBlue1-delta*MarketInfo(Symbol(),MODE_POINT))
      {
         lnret = getfilterma(-1);
         if (glnobreak && lnret!=0)
         {
            if (Close[1]+gldeltaclose*MarketInfo(Symbol(),MODE_POINT)>=prBlue1 - delta*MarketInfo(Symbol(),MODE_POINT) &&
                Open[0]<=prBlue - delta*MarketInfo(Symbol(),MODE_POINT))
                lnret = -3;
         }
         if (lnret <= -1) timelastup = timecurrup;
         if(reversopen) lnret*=(-1);
         nullsigbar(lnret);
         return(lnret);
      }
   }
   nullsigbar(-100);
   return(lnret);
}
//+------------------------------------------------------------------+
int waitIfBusy() 
{   
   for (int Yx = 0; IsTradeContextBusy() && Yx < 50; Yx++) Sleep(125);   
   if (Yx >= 50) Print("Торговый поток занят больше ", DoubleToStr(25 * Yx / 1000, 2), " секунд");
   else if (Yx > 0) Print("Торговый поток был занят ", DoubleToStr(25 * Yx / 1000, 2), " секунд");   
   return (Yx);   
}
//+------------------------------------------------------------------+
/*void CloseAll(int type, int MAGIC)
  {
int cmd = 0;
  for (int i=OrdersTotal()+1;i>=0; i--)
    {
    if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true)
      {
      if (OrderSymbol()==Symbol() && OrderMagicNumber()==MAGIC)
      {//**
      RefreshRates();
      if(OrderType()==OP_BUY && OrderType()==type)
       {
        cmd = 0;
           for (int j = 0; cmd < 1 && j < MaxAttempts; j++)
            {
             waitIfBusy();
             cmd = OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid, Digits),slip, Blue);
             if(cmd<0) {Sleep(2000); RefreshRates();}
            }   
       }
      if(OrderType()==OP_SELL && OrderType()==type)
       {
        cmd = 0;
           for (j = 0; cmd < 1 && j < MaxAttempts; j++)
            {
             waitIfBusy();
             cmd = OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask, Digits),slip, Red);
             if(cmd<0) {Sleep(2000); RefreshRates();}
            }   
       }
      }//**
      }
    }
}*/
//+------------------------------------------------------------------+
void Buy(double Lot1, int SL1, int TP1, string com, int slip1, int MagicNumber, int MaxAttempts1, color c = CLR_NONE)
{
 int ticket=0, cmd = 0;
 double tp = 0, sl = 0;
         for (int j = 0; ticket < 1 && j < MaxAttempts1; j++)
         {
            waitIfBusy();
            ticket = OrderSend(Symbol(), OP_BUY, Lot1, NormalizeDouble(Ask, Digits), slip1, 0, 0, com, MagicNumber, 0, c);
            if(ticket<0) {Sleep(2000); RefreshRates();}
         }   
         if(ticket<0) 
         {
            Print("ОШИБКА: ",GetLastError()); 
         }
         if (ticket>0 && (TP1>0 || SL1>0))//
          {
           for (j = 0; cmd < 1 && j < MaxAttempts1; j++)
            {
             waitIfBusy();
             OrderSelect(ticket, SELECT_BY_TICKET);
             if(TP1>0) tp = OrderOpenPrice() + TP1*MarketInfo(Symbol(),MODE_POINT);
             if(SL1>0) sl = OrderOpenPrice() - SL1*MarketInfo(Symbol(),MODE_POINT);
             cmd = OrderModify(ticket, OrderOpenPrice(), sl, tp, 0, c);
             if(cmd<0) {Sleep(2000); RefreshRates();}
            }   
          }
}
//+------------------------------------------------------------------+
void Sell(double Lot1, int SL1, int TP1, string com, int slip1, int MagicNumber, int MaxAttempts1, color c = CLR_NONE)
{
 int ticket=0, cmd = 0;
 double tp = 0, sl = 0;
         for (int j = 0; ticket < 1 && j < MaxAttempts1; j++)
         {
            waitIfBusy();
            ticket = OrderSend(Symbol(), OP_SELL, Lot1, NormalizeDouble(Bid, Digits), slip1, 0, 0, com, MagicNumber, 0, c);
            if(ticket<0) {Sleep(2000); RefreshRates();}
         }   
         if(ticket<0) 
         {
            Print("ОШИБКА: ",GetLastError()); 
         }
         if (ticket>0 && (TP1>0 || SL1>0))//
          {
           for (j = 0; cmd < 1 && j < MaxAttempts1; j++)
            {
             waitIfBusy();
             OrderSelect(ticket, SELECT_BY_TICKET);
             if(TP1>0) tp = OrderOpenPrice() - TP1*MarketInfo(Symbol(),MODE_POINT);
             if(SL1>0) sl = OrderOpenPrice() + SL1*MarketInfo(Symbol(),MODE_POINT);
             cmd = OrderModify(ticket, OrderOpenPrice(), sl, tp, 0, c);
             if(cmd<0) {Sleep(2000); RefreshRates();}
            }   
          }
}
//+------------------------------------------------------------------+
void countOpenPosition(int MAGIC)
{
buy=0;sell=0;

for (int q=-1; q<OrdersTotal()+1; q++)
  {
  if (OrderSelect(q,SELECT_BY_POS,MODE_TRADES)==true)
    {
    if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MAGIC)continue;
      {          
      if(OrderType()==OP_BUY)      buy++;
      if(OrderType()==OP_SELL)     sell++;
      }
    }
  }
return;
} 
//+----------------------------------------------------------------------------+

void SimpleTrailing(string sy="", int op=-1, int mn=-1) {
  double po, pp, slb, sls;
  int    i, k=OrdersTotal();
  int iper;
  
  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)) {
        po=MarketInfo(OrderSymbol(), MODE_POINT);
        if (mn<0 || OrderMagicNumber()==mn) {
          if (OrderType()==OP_BUY) 
          {
            switch (typets)
            {
               case 1:
                  pp=Bid;
                  if (TStop.All > 0) slb = TStop.All; else slb = TStop.Buy;
                  if (!TSProfitOnly || pp-OrderOpenPrice()>slb*po) 
                  {
                    if (OrderStopLoss()<pp-(slb+TrailingStep-1)*po) 
                    {
                      ModifyOrder(-1, pp-slb*po, -1);
                    }
                  }
                  break;
               case 2:
                  if (iAtr_timeframe<=0) iper=Period(); else iper=iAtr_timeframe;
                  TrailingByATR(OrderTicket(),iper,iAtr1_period,iAtr1_shift,iAtr2_period,iAtr2_shift,dCoeff,iAtrstep,bTrlinloss);
                  break;
               case 3:
                  if (iTmfrm<=0) iper=Period(); else iper=iTmfrm;
                  TrailingByFractals(OrderTicket(),iper,iIndent,bTrlinloss1);
                  break;
               case 4:
                  if (giMATmFrme<=0) iper=Period(); else iper=giMATmFrme;
                  TrailingByMA(OrderTicket(),iper,giMAPeriod,giMAShift,giMAMethod,giApplPrice,giShift,giIndent,giMAstep,bTrlMAinloss);
                  break;                  
            }
          }
          if (OrderType()==OP_SELL) 
          {
            switch (typets)
            {
               case 1:
                  pp=Ask;
                  if (TStop.All > 0) sls = TStop.All; else sls = TStop.Sell;
                  if (!TSProfitOnly || OrderOpenPrice()-pp>sls*po) 
                  {
                    if (OrderStopLoss()>pp+(sls+TrailingStep-1)*po || OrderStopLoss()==0) 
                    {
                      ModifyOrder(-1, pp+sls*po, -1);
                    }
                  }
                  break;
               case 2:
                  if (iAtr_timeframe<=0) iper=Period(); else iper=iAtr_timeframe;
                  TrailingByATR(OrderTicket(),iper,iAtr1_period,iAtr1_shift,iAtr2_period,iAtr2_shift,dCoeff,iAtrstep,bTrlinloss);
                  break;
               case 3:
                  if (iTmfrm<=0) iper=Period(); else iper=iTmfrm;
                  TrailingByFractals(OrderTicket(),iper,iIndent,bTrlinloss1);
                  break;
               case 4:
                  if (giMATmFrme<=0) iper=Period(); else iper=giMATmFrme;
                  TrailingByMA(OrderTicket(),iper,giMAPeriod,giMAShift,giMAMethod,giApplPrice,giShift,giIndent,giMAstep,bTrlMAinloss);
                  break;     
            }
          }
        }
      }
    }
  }
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.11.2006                                                     |
//|  Описание : Модификация одного предварительно выбранного ордера.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    pp - цена установки ордера                                              |
//|    sl - ценовой уровень стопа                                              |
//|    tp - ценовой уровень тейка                                              |
//|    ex - дата истечения                                                     |
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0) {
  bool   fm;
  double op, pa, pb, os, ot;
  int    dg=Digits, er, it;

  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<=MaxAttempts; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(), pp, sl, tp, ex, CLR_NONE);
      if (fm) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        er=GetLastError();
        if (UseSound) PlaySound(SoundError);
        pa=Ask;
        pb=Bid;
        Print("Error(",er,") modifying order: ",ErrorDescription(er),", try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
              "  op="+GetNameOP(OrderType()),"  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
      }
    }
  }
}

string GetNameOP(int op) {
  switch (op) {
    case OP_BUY      : return("Buy");
    case OP_SELL     : return("Sell");
    case OP_BUYLIMIT : return("BuyLimit");
    case OP_SELLLIMIT: return("SellLimit");
    case OP_BUYSTOP  : return("BuyStop");
    case OP_SELLSTOP : return("SellStop");
    default          : return("Unknown Operation");
  }
}

void ClosePositions(string sy="", int op=-1, int mn=-1) {
  int i, k=OrdersTotal();

  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) ClosePosBySelect();
        }
      }
    }
  }
}

void ClosePosBySelect() {
  bool   fc;
  color  clClose;
  double ll, pa, pb, pp;
  int    dg=Digits, err, it;

  if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
    for (it=1; it<=MaxAttempts; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      pa=Ask;
      pb=Bid;
      if (OrderType()==OP_BUY) {
        pp=pb;
      } else {
        pp=pa;
      }
      ll=OrderLots();
      pp=NormalizeDouble(pp, dg);
      fc=OrderClose(OrderTicket(), ll, pp, slip, CLR_NONE);
      if (fc) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        err=GetLastError();
        if (UseSound) PlaySound(SoundError);
        if (err==146) while (IsTradeContextBusy()) Sleep(1000*11);
        Print("Error(",err,") Close ",GetNameOP(OrderType())," ",
              ErrorDescription(err),", try ",it);
        Print(OrderTicket(),"  Ask=",pa,"  Bid=",pb,"  pp=",pp);
        Print("sy=",OrderSymbol(),"  ll=",ll,"  sl=",OrderStopLoss(),
              "  tp=",OrderTakeProfit(),"  mn=",OrderMagicNumber());
        Sleep(1000*5);
      }
    }
  } else Print("Некорректная торговая операция. Close ",GetNameOP(OrderType()));
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 10.04.2008                                                     |
//|  Описание : Открывает позицию по рыночной цене.                            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    op - операция                                                           |
//|    ll - лот                                                                |
//|    sl - уровень стоп                                                       |
//|    tp - уровень тейк                                                       |
//|    mn - MagicNumber                                                        |
//+----------------------------------------------------------------------------+
//void OpenPosition(string sy, int op, double ll, double sl=0, double tp=0, int mn=0) {
//  color    clOpen;
//  datetime ot;
//  double   pp, pa, pb;
//  int      dg, err, it, ticket=0;
//  string   lsComm=WindowExpertName()+" "+GetNameTF(Period());
  
//  if (sy=="" || sy=="0") sy=Symbol();
//  if (op==OP_BUY) clOpen=clOpenBuy; else clOpen=clOpenSell;
//  for (it=1; it<=MaxAttempts; it++) {
//    if (!IsTesting() && IsStopped()) {
//      Print("OpenPosition(): Остановка работы функции");
//      break;
//    }
//    while (!IsTradeAllowed()) Sleep(1000);
//    dg=Digits;
//    pa=Ask;
//    pb=Bid;
//    if (op==OP_BUY) pp=pa; else pp=pb;
//    pp=NormalizeDouble(pp, dg);
//    sl=NormalizeDouble(sl, dg);
//    tp=NormalizeDouble(tp, dg);
//    ot=TimeCurrent();
//    if (MarketWatch)
//      ticket=OrderSend(sy, op, ll, pp, slip, 0, 0, lsComm, mn, 0, CLR_NONE);
//    else
//      ticket=OrderSend(sy, op, ll, pp, slip, sl, tp, lsComm, mn, 0, CLR_NONE);
//    if (ticket>0) {
//      if (UseSound) PlaySound(SoundSuccess); break;
//    } else {
//      err=GetLastError();
//      if (pa==0 && pb==0) Message("Проверьте в Обзоре рынка наличие символа "+sy);
//      // Вывод сообщения об ошибке
//      Print("Error(",err,") opening position: ",ErrorDescription(err)," try ",it);
//      Print("Ask=",pa," Bid=",pb," sy=",sy," ll=",ll," op=",GetNameOP(op),
//            " pp=",pp," sl=",sl," tp=",tp," mn=",mn);
//      // Блокировка работы советника
//      if (err==2 || err==64 || err==65 || err==133) {
//        gbDisabled=True; break;
//      }
//     // Длительная пауза
//      if (err==4 || err==131 || err==132) {
//        Sleep(1000); break;
//      }
//      if (err==128 || err==142 || err==143) {
//        Sleep(1000);
//        if (ExistPositions(sy, op, mn, ot)) {
//          if (UseSound) PlaySound(SoundSuccess); break;
//        }
//      }
//      if (err==140 || err==148 || err==4110 || err==4111) break;
//      if (err==141) Sleep(1000);
//      if (err==145) Sleep(1000);
//      if (err==146) while (IsTradeContextBusy()) Sleep(1000);
//      if (err!=135) Sleep(1000);
//    }
//    RefreshRates();
//  }
//  if (MarketWatch && ticket>0 && (sl>0 || tp>0)) {
//    if (OrderSelect(ticket, SELECT_BY_TICKET)) ModifyOrder(-1, sl, tp);
//  }
//}

void Message(string m) {
  Comment(m);
  if (StringLen(m)>0) Print(m);
}

//bool ExistPositions(string sy="", int op=-1, int mn=-1, datetime ot=0) {
//  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 (ot<=OrderOpenTime()) return(True);
//            }
//          }
//        }
//      }
//    }
//  }
//  return(False);
//}

void MovingInWL(string sy="", int op=-1, int mn=-1) 
{
  double po, pp;
  int    i, k=OrdersTotal();

  for (i=0; i<k; i++) 
  {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) 
    {
      if ((OrderSymbol()==sy || sy=="") && (OrderMagicNumber()==MAGIC || MAGIC==-1))
      {
         po=MarketInfo(OrderSymbol(), MODE_POINT);
         if (OrderType()==OP_BUY) 
         {
           if (OrderStopLoss()-OrderOpenPrice()<LevelWLoss*po) 
           {
             pp=Bid;
             if (pp-OrderOpenPrice()>LevelProfit*po) 
             {
               ModifyOrder(-1, OrderOpenPrice()+LevelWLoss*po, -1,CLR_NONE);
             }
           }
         }
         if (OrderType()==OP_SELL) 
         {
           if (OrderStopLoss()==0 || OrderOpenPrice()-OrderStopLoss()<LevelWLoss*po) 
           {
             pp=Ask;
             if (OrderOpenPrice()-pp>LevelProfit*po) 
             {
               ModifyOrder(-1, OrderOpenPrice()-LevelWLoss*po, -1,CLR_NONE);
             }
           }
         }
      }
    }
  }
}

double GetLot(int lottype_=1, int typesleep=-1, int lntop=-1)
{
   string lcsleep = "";
   string lcwork = "";
   double lotsize, rlotsize, los, lotsize1, rlotsize1;
   string opis1;

   switch (lottype_)
   {
      case 1:
         rlotsize = Lot;
         opis1 = "Fix lot ";
         break;
      case 2:
         double koef=1.0;
         double koef1=1.0;
         double rbalans1,rbalans2,rbalans;
         if (Digits<4) koef=100.0;
         if (StringFind(Symbol(), "XAU", 0)>=0) koef1 = 100.0;

         switch (MeansType)
         {
            case 1:
               rbalans=AccountBalance() * risk / 100;
               break;
            case 2:
               rbalans = AccountEquity() * risk / 100;
               break;
            case 3:
               rbalans1 = AccountBalance() * risk / 100;
               rbalans2 = AccountEquity() * risk / 100;
               rbalans  = MathMax(rbalans1,rbalans2);
               break;
            default:
               rbalans1 = AccountBalance() * risk / 100;
               rbalans2 = AccountEquity() * risk / 100;
               rbalans  = MathMax(rbalans1,rbalans2);
               break;
         }

         los = rpip * MarketInfo(Symbol(), MODE_POINT)*MarketInfo(Symbol(),MODE_LOTSIZE)/koef;
         rlotsize = MathCeil((NormalizeDouble(rbalans / los,2)*100))/100;
         rlotsize = rlotsize/koef1;
         opis1 = "Risk lot - ";
         break;
      case 3:
         rlotsize = GlobalVariableGet("ddsmmlot");
         opis1 = "DDSMM lot - ";
         break;
      default:
         rlotsize = Lot;
         opis1 = "Fix lot - ";
         break;
   }

   rlotsize1 = rlotsize;
   if ((lntop==OP_BUY && buy>0) || (lntop==OP_SELL && sell>0)) rlotsize=rlotsize*dopkoeflot;
//   if(glfiltr && ((lntop==OP_BUY && buy>0) || (lntop==OP_SELL && sell>0))) rlotsize=rlotsize*dopkoeflot;
   if(rlotsize < MarketInfo(Symbol(),MODE_MINLOT)) rlotsize = 0.0;
   if(rlotsize > MarketInfo(Symbol(),MODE_MAXLOT)) rlotsize = MarketInfo(Symbol(),MODE_MAXLOT);
   if(rlotsize1 < MarketInfo(Symbol(),MODE_MINLOT)) rlotsize1 = 0.0;
   if(rlotsize1 > MarketInfo(Symbol(),MODE_MAXLOT)) rlotsize1 = MarketInfo(Symbol(),MODE_MAXLOT);
      
   lotsize = normlot(rlotsize);
   lotsize1 = normlot(rlotsize1);
   
   if (typesleep==1)
   {
      if (tiuse)
      {
         if (StrToTime(tbeg) <= StrToTime(tend))
         {
            if ((TimeCurrent() < StrToTime(tbeg)) || (TimeCurrent() >= StrToTime(tend)))
            {
               lcsleep = " SLEEP";
            }  
         }
         else
         {
            if (((TimeCurrent() > StrToTime(tbeg)) && (TimeCurrent() >= StrToTime(tend))) || ((TimeCurrent() < StrToTime(tbeg)) && (TimeCurrent() <= StrToTime(tend))))
            {
               lcsleep = " SLEEP";
            }
         }
      }
   }
   
   lcwork = GetFrozenStr();
    
   opis1 = StringConcatenate(opis1, NormalizeDouble(lotsize1,2), lcsleep, lcwork, " MN - ",MAGIC);
   
   if (usewinlot)
   {
      if(ObjectFind("LabelMM1")>-1) ObjectSetText("LabelMM1", opis1, FontSize, FontType, FontColor);
   }
   
   return (lotsize);
}

double normlot(double ad) 
{
   double lotstep = MarketInfo(Symbol(), MODE_LOTSTEP);
   return (MathFloor(ad / lotstep + 0.5) * lotstep);
}

string GetFrozenStr()
{
   double aa=0.0, bb=0.0;   
   string lcwork = "";
   
   if (GlobalVariableCheck(f3noopenbuy))
      aa = GlobalVariableGet(f3noopenbuy);
   if (GlobalVariableCheck(f3noopensell))
      bb = GlobalVariableGet(f3noopensell);
   if(aa>0.0 && bb>0.0)
   {
      lcwork = " FROZEN";
   }
   else
   {
      if(aa>0.0)
      {
         lcwork = " ONLY SELL";
      }
      else
      {
         if(bb>0.0)
         {
            lcwork = " ONLY BUY";
         }
      }
   }
   return (lcwork);
}

bool GetFrozenBool(int typeop=-1)
{
   bool lcwork = true;
   double aa=0.0, bb=0.0;   
   
   if (GlobalVariableCheck(f3noopenbuy))
      aa = GlobalVariableGet(f3noopenbuy);
   if (GlobalVariableCheck(f3noopensell))
      bb = GlobalVariableGet(f3noopensell);
   if(aa>0.0 && bb>0.0)
   {
      lcwork = false;
   }
   else
   {
      if(aa>0.0 && typeop==OP_BUY)
      {
         lcwork = false;
      }
      else
      {
         if(bb>0.0 && typeop==OP_SELL)
         {
            lcwork = false;
         }
      }
   }
   return (lcwork);
}

//string GetNameTF(int TimeFrame=0) {
//  if (TimeFrame==0) TimeFrame=Period();
//  switch (TimeFrame) {
//    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("Daily");
//    case PERIOD_W1:  return("Weekly");
//    case PERIOD_MN1: return("Monthly");
//    default:         return("UnknownPeriod");
//  }
//}

void linednto1()
{
   datetime t1Up1,t1Up2,t1Dn1,t1Dn2;
   double zz1Up1,zz1Up2,zz1Dn1,zz1Dn2;

   if(ObjectFind("TrendlineDn")>-1)
   {
      t1Up1 = ObjectGet("TrendlineDn",OBJPROP_TIME2);
      zz1Up1 = ObjectGet("TrendlineDn",OBJPROP_PRICE2);
      t1Up2 = ObjectGet("TrendlineDn",OBJPROP_TIME1);
      zz1Up2 = ObjectGet("TrendlineDn",OBJPROP_PRICE1);
      ObjectDelete("TrendlineDn");
      if(ObjectFind("1TrendlineDn")==-1)
      {
         if(ObjectCreate("1TrendlineDn",OBJ_TREND,0,t1Up2,zz1Up2,t1Up1,zz1Up1))
         {
              ObjectSet("1TrendlineDn",OBJPROP_COLOR,linednc);                
              ObjectSet("1TrendlineDn",OBJPROP_WIDTH,linednw);
              ObjectSet("1TrendlineDn",OBJPROP_RAY,TRUE);
         }
       }
      else 
      {
         ObjectSet("1TrendlineDn",OBJPROP_TIME1,t1Up2);
         ObjectSet("1TrendlineDn",OBJPROP_PRICE1,zz1Up2);
         ObjectSet("1TrendlineDn",OBJPROP_TIME2,t1Up1);
         ObjectSet("1TrendlineDn",OBJPROP_PRICE2,zz1Up1);
      }
   }
   return;
}

void lineupto1()
{
   datetime t1Up1,t1Up2,t1Dn1,t1Dn2;
   double zz1Up1,zz1Up2,zz1Dn1,zz1Dn2;

   if(ObjectFind("TrendlineUp")>-1)
   {
      t1Dn1 = ObjectGet("TrendlineUp",OBJPROP_TIME2);
      zz1Dn1 = ObjectGet("TrendlineUp",OBJPROP_PRICE2);
      t1Dn2 = ObjectGet("TrendlineUp",OBJPROP_TIME1);
      zz1Dn2 = ObjectGet("TrendlineUp",OBJPROP_PRICE1);
      ObjectDelete("TrendlineUp");
      if(ObjectFind("1TrendlineUp")==-1)
      {
         if(ObjectCreate("1TrendlineUp",OBJ_TREND,0,t1Dn2,zz1Dn2,t1Dn1,zz1Dn1))
         {
              ObjectSet("1TrendlineUp",OBJPROP_COLOR,lineupc);                
              ObjectSet("1TrendlineUp",OBJPROP_WIDTH,lineupw);
              ObjectSet("1TrendlineUp",OBJPROP_RAY,TRUE);
         }
      }
      else 
      {
         ObjectSet("1TrendlineUp",OBJPROP_TIME1,t1Dn2);
         ObjectSet("1TrendlineUp",OBJPROP_PRICE1,zz1Dn2);
         ObjectSet("1TrendlineUp",OBJPROP_TIME2,t1Dn1);
         ObjectSet("1TrendlineUp",OBJPROP_PRICE2,zz1Dn1);
      }
   }      
   return;
}

void TrailingByATR(int ticket,int atr_timeframe,int atr1_period,int atr1_shift,int atr2_period,int atr2_shift,double coeff,double atrstep,bool trlinloss)
{
   // проверяем переданные значения   
   if ((ticket==0) || (atr1_period<1) || (atr2_period<1) || (coeff<=0) || (!OrderSelect(ticket,SELECT_BY_TICKET)) || 
   ((atr_timeframe!=1) && (atr_timeframe!=5) && (atr_timeframe!=15) && (atr_timeframe!=30) && (atr_timeframe!=60) && 
   (atr_timeframe!=240) && (atr_timeframe!=1440) && (atr_timeframe!=10080) && (atr_timeframe!=43200)) || (atr1_shift<0) || (atr2_shift<0))
   {
      Print("Трейлинг функцией TrailingByATR() невозможен из-за некорректности значений переданных ей аргументов.");
      return(0);
   }
   
   double curr_atr1; // текущее значение ATR - 1
   double curr_atr2; // текущее значение ATR - 2
   double best_atr; // большее из значений ATR
   double atrXcoeff; // результат умножения большего из ATR на коэффициент
   double newstop; // новый стоплосс
   double newstop1;
   
   // текущее значение ATR-1, ATR-2
   curr_atr1 = iATR(Symbol(),atr_timeframe,atr1_period,atr1_shift);
   curr_atr2 = iATR(Symbol(),atr_timeframe,atr2_period,atr2_shift);
   
   // большее из значений
   best_atr = MathMax(curr_atr1,curr_atr2);
   
   // после умножения на коэффициент
   atrXcoeff = best_atr * coeff;
              
   // если длинная позиция (OP_BUY)
   if (OrderType()==OP_BUY)
   {
      // откладываем от текущего курса (новый стоплосс)
      newstop = Bid - atrXcoeff;           
      newstop1 = newstop - atrstep*Point;
      newstop = NormalizeDouble(newstop,Digits);
      newstop1 = NormalizeDouble(newstop1,Digits);
      // если trlinloss==true (т.е. следует тралить в зоне лоссов), то
      if (trlinloss==true)      
      {
         // если стоплосс неопределен, то тралим в любом случае
         if ((OrderStopLoss()==0) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // иначе тралим только если новый стоп лучше старого
         else
         {
            if ((newstop1>OrderStopLoss()) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
               ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
      else
      {
         // если стоплосс неопределен, то тралим, если стоп лучше открытия
         if ((OrderStopLoss()==0) && (newstop>OrderOpenPrice()) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // если стоп не равен 0, то меняем его, если он лучше предыдущего и курса открытия
         else
         {
            if ((newstop1>OrderStopLoss()) && (newstop1>OrderOpenPrice()) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
   }
      
   // если короткая позиция (OP_SELL)
   if (OrderType()==OP_SELL)
   {
      // откладываем от текущего курса (новый стоплосс)
      newstop = Ask + atrXcoeff;
      newstop1 = newstop + atrstep*Point;
      newstop = NormalizeDouble(newstop,Digits);
      newstop1 = NormalizeDouble(newstop1,Digits);   

      // если trlinloss==true (т.е. следует тралить в зоне лоссов), то
      if (trlinloss==true)      
      {
         // если стоплосс неопределен, то тралим в любом случае
         if ((OrderStopLoss()==0) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // иначе тралим только если новый стоп лучше старого
         else
         {
            if ((newstop1<OrderStopLoss()) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
               ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
      else
      {
         // если стоплосс неопределен, то тралим, если стоп лучше открытия
         if ((OrderStopLoss()==0) && (newstop1<OrderOpenPrice()) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // если стоп не равен 0, то меняем его, если он лучше предыдущего и курса открытия
         else
         {
            if ((newstop1<OrderStopLoss()) && (newstop<OrderOpenPrice()) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
              ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
   }      
}

void TrailingByMA(int iTicket=0,int iMATmFrme=-1,int iMAPeriod=-1,int iMAShift=0,int iMAMethod=0,int iApplPrice=0,int iShift=1,int iIndent=0, int iMAstep=30, bool trlmainloss=false)
{
   // проверяем переданные значения
   if ((iTicket==0) || (!OrderSelect(iTicket,SELECT_BY_TICKET)) || (iMATmFrme==-1) ||
   (iMAPeriod<2) || (iMAMethod<0) || (iMAMethod>3) || (iApplPrice<0) || (iApplPrice>6) || (iShift<0) || (iIndent<0) || (iMAstep<0))
   {
      Print("Трейлинг функцией TrailingByMA() невозможен из-за некорректности значений переданных ей аргументов.");
      return(0);
   } 

   double   dMA; // значение скользящего среднего с переданными параметрами
   double newstop; // новый стоплосс
   double newstop1;
   
   // определим значение МА с переданными функции параметрами
   dMA = iMA(Symbol(),iMATmFrme,iMAPeriod,iMAShift,iMAMethod,iApplPrice,iShift);

   // если длинная позиция (OP_BUY)
   if (OrderType()==OP_BUY)
   {
      // откладываем от текущего курса (новый стоплосс)
      newstop = dMA-iIndent*Point;           
      newstop1 = newstop - iMAstep*Point;
      newstop = NormalizeDouble(newstop,Digits);
      newstop1 = NormalizeDouble(newstop1,Digits);
      // если trlinloss==true (т.е. следует тралить в зоне лоссов), то
      if (trlmainloss==true)      
      {
         // если стоплосс неопределен, то тралим в любом случае
         if ((OrderStopLoss()==0) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // иначе тралим только если новый стоп лучше старого
         else
         {
            if ((newstop1>OrderStopLoss()) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
               ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
      else
      {
         // если стоплосс неопределен, то тралим, если стоп лучше открытия
         if ((OrderStopLoss()==0) && (newstop>OrderOpenPrice()) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // если стоп не равен 0, то меняем его, если он лучше предыдущего и курса открытия
         else
         {
            if ((newstop1>OrderStopLoss()) && (newstop1>OrderOpenPrice()) && (newstop<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
   }
      
   // если короткая позиция (OP_SELL)
   if (OrderType()==OP_SELL)
   {
      // откладываем от текущего курса (новый стоплосс)
      newstop = dMA + iIndent*Point + MarketInfo(Symbol(),MODE_SPREAD)*Point;           
      newstop1 = newstop + iMAstep*Point;
      newstop = NormalizeDouble(newstop,Digits);
      newstop1 = NormalizeDouble(newstop1,Digits);   

      // если trlinloss==true (т.е. следует тралить в зоне лоссов), то
      if (trlmainloss==true)      
      {
         // если стоплосс неопределен, то тралим в любом случае
         if ((OrderStopLoss()==0) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // иначе тралим только если новый стоп лучше старого
         else
         {
            if ((newstop1<OrderStopLoss()) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
               ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
      else
      {
         // если стоплосс неопределен, то тралим, если стоп лучше открытия
         if ((OrderStopLoss()==0) && (newstop1<OrderOpenPrice()) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
         {
            ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
         // если стоп не равен 0, то меняем его, если он лучше предыдущего и курса открытия
         else
         {
            if ((newstop1<OrderStopLoss()) && (newstop<OrderOpenPrice()) && (newstop>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
              ModifyOrder(OrderOpenPrice(), newstop, OrderTakeProfit(), OrderExpiration());
         }
      }
   }      
}

void TrailingByFractals(int ticket,int tmfrm,int indent,bool trlinloss)
{
   int i, z, j; // counters
   int extr_n; // номер ближайшего экстремума frktl_bars-барного фрактала 
   double temp; // служебная переменная
   int after_x, be4_x; // свечей после и до пика соответственно
   int ok_be4, ok_after; // флаги соответствия условию (1 - неправильно, 0 - правильно)
   int sell_peak_n = 0, buy_peak_n = 0; // номера экстремумов ближайших фракталов на продажу (для поджатия дл.поз.) и покупку соответсвенно   
   // проверяем переданные значения
   if ((indent<0) || (ticket==0) || ((tmfrm!=1) && (tmfrm!=5) && (tmfrm!=15) && (tmfrm!=30) && (tmfrm!=60) && (tmfrm!=240) && (tmfrm!=1440) && (tmfrm!=10080) && (tmfrm!=43200)) || (!OrderSelect(ticket,SELECT_BY_TICKET)))
   {
      Print("Трейлинг функцией TrailingByFractals() невозможен из-за некорректности значений переданных ей аргументов.");
      return(0);
   } 
   if (iBars(Symbol(),tmfrm)<= 50) 
   {
      Print("Трейлинг функцией TrailingByFractals() невозможен из-за недостаточного количества данных на графике.");
      return(0);
   }
   int count = 50;
//   count = iBars(Symbol(),tmfrm) - 1;
   
   // если длинная позиция (OP_BUY), находим ближайший фрактал на продажу (т.е. экстремум "вниз")
   if (OrderType()==OP_BUY)
   {
      for (j = count-3; j >= 0; j--)
      {
         if ((iLow(Symbol(),tmfrm,j+2)<iLow(Symbol(),tmfrm,j+1)) && (iLow(Symbol(),tmfrm,j+2)<=iLow(Symbol(),tmfrm,j+3)))
         { 
            if (OrderOpenTime()<=(iTime(Symbol(),tmfrm,j+2)+tmfrm*60)) sell_peak_n = j+2;
         }
      }
      // находим последний фрактал на продажу
      // если тралить в убытке
      if (sell_peak_n >0)
      {
         if (trlinloss==true)
         {
            // если новый стоплосс лучше имеющегося (в т.ч. если стоплосс == 0, не выставлен)
            // а также если курс не слишком близко, ну и если стоплосс уже не был перемещен на рассматриваемый уровень         
            if ((iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point>OrderStopLoss()) && (iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            {
               ModifyOrder(OrderOpenPrice(), iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point,OrderTakeProfit(), OrderExpiration());
            }
         }
         // если тралить только в профите, то
         else
         {
            // если новый стоплосс лучше имеющегося И курса открытия, а также не слишком близко к текущему курсу
            if ((iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point>OrderStopLoss()) && (iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point>OrderOpenPrice()) && (iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            {
               ModifyOrder(OrderOpenPrice(), iLow(Symbol(),tmfrm,sell_peak_n)-indent*Point, OrderTakeProfit(), OrderExpiration());
            }
         }
      }
   }
      
   // если короткая позиция (OP_SELL), находим ближайший фрактал на покупку (т.е. экстремум "вверх")
   if (OrderType()==OP_SELL)
   {
      // находим последний фрактал на продажу
      for (j = count; j >= 0; j--)
      {
         if ((iHigh(Symbol(),tmfrm,j+2)>iHigh(Symbol(),tmfrm,j+1)) && (iHigh(Symbol(),tmfrm,j+2)>=iHigh(Symbol(),tmfrm,j+3))) 
         {
            if (OrderOpenTime()<=(iTime(Symbol(),tmfrm,j+2)+tmfrm*60)) buy_peak_n = j+2;
         }
      }
      if (buy_peak_n>0)
      {     
      // если тралить в убытке
         if (trlinloss==true)
         {
            if (((iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point<OrderStopLoss()) || (OrderStopLoss()==0)) && (iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            {
               ModifyOrder(OrderOpenPrice(), iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point, OrderTakeProfit(), OrderExpiration());
            }
         }      
         // если тралить только в профите, то
         else
         {
            // если новый стоплосс лучше имеющегося И курса открытия
            if ((((iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point<OrderStopLoss()) || (OrderStopLoss()==0))) && (iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point<OrderOpenPrice()) && (iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            {
               ModifyOrder(OrderOpenPrice(), iHigh(Symbol(),tmfrm,buy_peak_n)+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point, OrderTakeProfit(), OrderExpiration());
            }
         }
      }
   }      
}

void SimpleExit(string sy="", int mn=-1) 
{
   double po, pp;
   int i, k=OrdersTotal();
   int aa = 0, bb = 0, noma=0, nocci=0;
   int cper, mper;
   if (ma1tf==0) mper=Period();
   if (ccitf==0) cper=Period();

   if (usecurrma == false && prevtimema == iTime(Symbol(),mper,0)) noma = 1;
   if (usecurrma == false) prevtimema = iTime(Symbol(),mper,0);
   if (prevtimecci == iTime(Symbol(),cper,0)) nocci = 1;
   prevtimecci = iTime(Symbol(),cper,0);

   for (i=0; i<k; i++) 
   {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) 
      {
         if ((OrderSymbol()==sy || sy=="") && (OrderMagicNumber()==mn || mn==-1))
         {
            if (OrderType()==OP_BUY) 
            {
               if (useexitma && noma==0) aa = checkexitma(OP_BUY);
               if (useexitcci && nocci==0) bb = checkexitcci(OP_BUY);
               if (aa==1 || bb==1) ClosePosBySelect();
               aa=0;
               bb=0;
            }
            if (OrderType()==OP_SELL) 
            {
               if (useexitma && noma==0) aa = checkexitma(OP_SELL);
               if (useexitcci && nocci==0) bb = checkexitcci(OP_SELL);
               if (aa==1 || bb==1) ClosePosBySelect();
               aa=0;
               bb=0;
            }
         }
      }
   }
}

int checkexitma(int type_oper=-1)
{
   if (type_oper==-1) return(0);
  
   double ma11, ma21;
   int re = 0;
   int mper;
   if (ma1tf==0) mper=Period();

   if (usecurrma)
   {
      ma11 = iMA(Symbol(),mper,ma1per,ma1shif,ma1met,ma1price,0);
      ma21 = iMA(Symbol(),mper,ma2per,ma2shif,ma2met,ma2price,0);
   }
   else
   {
      ma11 = iMA(Symbol(),mper,ma1per,ma1shif,ma1met,ma1price,1);
      ma21 = iMA(Symbol(),mper,ma2per,ma2shif,ma2met,ma2price,1);
   }   

   if (type_oper==OP_BUY)
   {
      if ((ma11+madelta*MarketInfo(Symbol(),MODE_POINT))<ma21) re = 1;
   }
   if (type_oper==OP_SELL)
   {
      if ((ma11-madelta*MarketInfo(Symbol(),MODE_POINT))>ma21) re = 1;
   }
   return (re);
}

int checkexitcci(int type_oper=-1)
{
   if (type_oper==-1) return(0);
  
   double cci11;
   int re = 0;
   int cper;
   if (ccitf==0) cper=Period();

   cci11 = iCCI(Symbol(),cper,cciper,cciprice,1);

   if (type_oper==OP_BUY)
   {
      if (cci11<0.0) re = 1;
   }
   if (type_oper==OP_SELL)
   {
      if (cci11>0.0) re = 1;
   }
   return (re);
}

int getfilterma(int lnfilt=0)
{
   if (lnfilt==0) return(0);
   if (glfiltr==false && glusebv == false && gl4usef4 == false && gl5usef5 == false) return(lnfilt);
   if (gntypefiltr!=1 && gntypefiltr!=2 && glusebv == false && gl4usef4 == false && gl5usef5 == false) return(lnfilt);

   int lnpma,lnpma2,lnrma;
   double ldma, ldma2, lnvall;
   lnrma = lnfilt;
   if (gntypefiltr==1 && glfiltr==true)
   {
      if (gnmatf==0) lnpma=Period();
      else lnpma = gnmatf;
      ldma = iMA(Symbol(),lnpma,gnmaper,gnmashif,gnmamet,gnmaprice,1);
      switch(lnfilt)
      {
         case 1:
            if(Close[1]+gnmadelta*MarketInfo(Symbol(),MODE_POINT)<=ldma) lnrma = 2;//не открывать бай
            break;
         case -1:
            if(Close[1]-gnmadelta*MarketInfo(Symbol(),MODE_POINT)>=ldma) lnrma = -2;//не открывать селл
            break;
         default:
            lnrma = lnfilt;
      }
   }

   if (gntypefiltr==2 && glfiltr==true)
   {
      if (gnmatf==0) lnpma=Period();
      else lnpma = gnmatf;
      if (gnma2tf==0) lnpma2=Period();
      else lnpma2 = gnma2tf;

      ldma = iMA(Symbol(),lnpma,gnmaper,gnmashif,gnmamet,gnmaprice,1);
      ldma2 = iMA(Symbol(),lnpma2,gnma2per,gnma2shif,gnma2met,gnma2price,1);
      switch(lnfilt)
      {
         case 1:
            if(ldma2>ldma-gnmadelta*MarketInfo(Symbol(),MODE_POINT)) lnrma = 2;//не открывать бай
            break;
         case -1:
            if(ldma2<ldma+gnmadelta*MarketInfo(Symbol(),MODE_POINT)) lnrma = -2;//не открывать селл
            break;
         default:
            lnrma = lnfilt;
      }
   }

   if (glusebv == true)
   {
      ldma = iCustom(Symbol(),Period(),"BetterVolume 1.4",NumberOfBars,Note,MAPeriod,LookBack,0,1);
      ldma2 = iCustom(Symbol(),Period(),"BetterVolume 1.4",NumberOfBars,Note,MAPeriod,LookBack,4,1);
      switch(lnfilt)
      {
         case 1:
            if (lnrma == 2) break;
            if(ldma==0.0) lnrma = 0;//не открывать бай
            break;
         case -1:
            if (lnrma == -2) break;
            if(ldma2==0.0) lnrma = 0;//не открывать селл
            break;
         default:
            lnrma = lnfilt;
      }
   }

   if (gl4usef4 == true)
   {
      ldma = iCustom(Symbol(),Period(),"i_Alex_Activity_v02_light",gl4BARS_Period,0,1);
      switch(lnfilt)
      {
         case 1:
            if (lnrma == 2)
            {
               usebarf4prev = 0;
               usebarf4 = 0;
               usebarf4prevval = 0;
               break;
            }
            if (ldma <= gl4Levels) lnrma = 0;//не открывать бай
            else
            {
               usebarf4prev = 0;
               usebarf4 = 0;
               usebarf4prevval = 0;
               break;
            }

            if (usebarf4prev != Time[0])
            {
               if (usebarf4 > gl4nbarswait)
               {
                  linednto1();
                  if (usetest && IsTesting())
                  {
                     timelastdn = timecurrdn;
                  }
                  usebarf4prev = 0;
                  usebarf4 = 0;
                  usebarf4prevval = 0;
               }
               else
               {
                  if (usebarf4==0)
                  {
                     if (usetest && IsTesting())
                        usebarf4prevval = getvalline(gltypeind,0,0);
                     else
                        usebarf4prevval = ObjectGetValueByShift("TrendlineDn",0);
                  }
                  else
                  {
                     if (usetest && IsTesting())
                     {
                        lnvall = getvalline(gltypeind,0,usebarf4);
                     }
                     else
                     {
                        lnvall = ObjectGetValueByShift("TrendlineDn",usebarf4);
                     }
                     if (usebarf4prevval != lnvall)
                     {
                        usebarf4 = 0;
                        usebarf4prevval = lnvall;
                     }
                  }
                  usebarf4 = usebarf4 + 1;
                  usebarf4prev = Time[0];
               }
            }
            break;
         case -1:
            if (lnrma == -2)
            {
               usebarf4prev = 0;
               usebarf4 = 0;
               usebarf4prevval = 0;
               break;
            }
            if (ldma >= -gl4Levels) lnrma = 0;//не открывать селл
            else
            {
               usebarf4prev = 0;
               usebarf4 = 0;
               usebarf4prevval = 0;
               break;
            }

            if (usebarf4prev != Time[0])
            {
               if (usebarf4 > gl4nbarswait)
               {
                  lineupto1();
                  if (usetest && IsTesting())
                  {
                     timelastup = timecurrup;
                  }
                  usebarf4prev = 0;
                  usebarf4 = 0;
                  usebarf4prevval = 0;
               }
               else
               {
                  if (usebarf4==0)
                  {
                     if (usetest && IsTesting())
                        usebarf4prevval = getvalline(gltypeind,1,0);
                     else
                        usebarf4prevval = ObjectGetValueByShift("TrendlineUp",0);
                  }
                  else
                  {
                     if (usetest && IsTesting())
                     {
                        lnvall = getvalline(gltypeind,1,usebarf4);
                     }
                     else
                     {
                        lnvall = ObjectGetValueByShift("TrendlineUp",usebarf4);
                     }
                     if (usebarf4prevval != lnvall)
                     {
                        usebarf4 = 0;
                        usebarf4prevval = lnvall;
                     }
                  }
                  usebarf4 = usebarf4 + 1;
                  usebarf4prev = Time[0];
               }
            }
            break;
         default:
            lnrma = lnfilt;
            usebarf5prev = 0;
            usebarf5 = 0;
            usebarf5prevval = 0;
            break;
      }
   }

   if (gl5usef5 == true)
   {
      ldma = iCustom(Symbol(),Period(),"!EntropyMathMCD",gl5numbars,gl5SignalSMA,0,1);
      switch(lnfilt)
      {
         case 1:
            if (lnrma == 2)
            {
               usebarf5prev = 0;
               usebarf5 = 0;
               usebarf5prevval = 0;
               break;
            }
            if (ldma <= gl5Levels) lnrma = 0;//не открывать бай
            else
            {
               usebarf5prev = 0;
               usebarf5 = 0;
               usebarf5prevval = 0;
               break;
            }

            if (usebarf5prev != Time[0])
            {
               if (usebarf5 > gl5nbarswait)
               {
                  linednto1();
                  if (usetest && IsTesting())
                  {
                     timelastdn = timecurrdn;
                  }
                  usebarf5prev = 0;
                  usebarf5 = 0;
                  usebarf5prevval = 0;
               }
               else
               {
                  if (usebarf5==0)
                  {
                     if (usetest && IsTesting())
                        usebarf5prevval = getvalline(gltypeind,0,0);
                     else
                        usebarf5prevval = ObjectGetValueByShift("TrendlineDn",0);
                  }
                  else
                  {
                     if (usetest && IsTesting())
                     {
                        lnvall = getvalline(gltypeind,0,usebarf5);
                     }
                     else
                     {
                        lnvall = ObjectGetValueByShift("TrendlineDn",usebarf5);
                     }
                     if (usebarf5prevval != lnvall)
                     {
                        usebarf5 = 0;
                        usebarf5prevval = lnvall;
                     }
                  }
                  usebarf5 = usebarf5 + 1;
                  usebarf5prev = Time[0];
               }
            }
            break;
         case -1:
            if (lnrma == -2)
            {
               usebarf5prev = 0;
               usebarf5 = 0;
               usebarf5prevval = 0;
               break;
            }
            if (ldma >= -gl5Levels) lnrma = 0;//не открывать селл
            else
            {
               usebarf5prev = 0;
               usebarf5 = 0;
               usebarf5prevval = 0;
               break;
            }

            if (usebarf5prev != Time[0])
            {
               if (usebarf5 > gl5nbarswait)
               {
                  lineupto1();
                  if (usetest && IsTesting())
                  {
                     timelastup = timecurrup;
                  }
                  usebarf5prev = 0;
                  usebarf5 = 0;
                  usebarf5prevval = 0;
               }
               else
               {
                  if (usebarf5==0)
                  {
                     if (usetest && IsTesting())
                        usebarf5prevval = getvalline(gltypeind,1,0);
                     else
                        usebarf5prevval = ObjectGetValueByShift("TrendlineUp",0);
                  }
                  else
                  {
                     if (usetest && IsTesting())
                     {
                        lnvall = getvalline(gltypeind,1,usebarf5);
                     }
                     else
                     {
                        lnvall = ObjectGetValueByShift("TrendlineUp",usebarf5);
                     }
                     if (usebarf5prevval != lnvall)
                     {
                        usebarf5 = 0;
                        usebarf5prevval = lnvall;
                     }
                  }
                  usebarf5 = usebarf5 + 1;
                  usebarf5prev = Time[0];
               }
            }
            break;
         default:
            lnrma = lnfilt;
            usebarf5prev = 0;
            usebarf5 = 0;
            usebarf5prevval = 0;
            break;
      }
   }
   return(lnrma);
}

double getvalline(int typeind=0,int typeo=0,int lshif=0)
{
   double ldret=0.0;
   double zzDn1=0.0,zzDn2=0.0;
   int iDn1,iDn2;
   double zzTmp;
   int j=0;
   int lncount;
   double lnlow1=0.0;

   if (typeind==0) lncount=50; else lncount=1500;

   for(int i=1;i<=lncount;i++)
   {
      if (typeind==0)
         lnlow1 = iCustom(Symbol(),0,"fishingind_v2_03",false,false,"",false,false,"",glotstup1,1,Blue,1,Red,glkolshow1,false,240,1,Blue,1,1,Red,1,false,typeo,i);
      else
         lnlow1 = iCustom(Symbol(),0,"FishingZZ_v1_1",glExtDepth1,glExtDeviation,glExtBackstep,glotstup2,2,Blue,2,Red,glshowrline,typeo+1,i);

      zzTmp=0;//current
      if(lnlow1>0.0) zzTmp=lnlow1;

      if(zzTmp>0.0 && j==0 && zzTmp==lnlow1 && zzDn2==0.0)
      {
         zzDn2=zzTmp; 
         iDn2=i; 
         if (typeo == 0)
         {
            timecurrdn = iTime(Symbol(),0,iDn2);
            if (timecurrdn == timelastdn) break; else continue;
         }
         else
         {
            timecurrup = iTime(Symbol(),0,iDn2);
            if (timecurrup == timelastup) break; else continue;
         }
      }
      if(zzDn2!=0.0) j = 1;
      if(zzTmp>0.0 && zzTmp==lnlow1 && zzDn1==0.0)  {zzDn1=zzTmp; iDn1=i; continue;}
      if(zzDn1!=0.0 && zzDn2!=0.0) break;
   }
   bool showrline_ = false;
   if ((glshowrline && typeind==1)) showrline_ = true;
   else
   {
      if ((zzDn1<=zzDn2 && typeo==1) || (zzDn2<=zzDn1 && typeo==0)) showrline_ = true;
   }

   if(zzDn1!=0.0 && zzDn2!=0.0 && showrline_)
   {
      if (zzDn2 > zzDn1) //вверх
      {
         ldret = zzDn2 + (zzDn2 - zzDn1)/(iDn1 - iDn2)*(iDn2 - lshif);
      }
      else
      {
         ldret = zzDn2 - (zzDn1 - zzDn2)/(iDn1 - iDn2)*(iDn2 - lshif);
      }
   }

   return (ldret);
}

void nullsigbar(int val=-100)
{
   if (val != sigprev || val==2 || val==3 || val==-2 || val==-3 || val==-100)
   {
      if (gl4usef4 == true)
      {
         usebarf4prev = 0;
         usebarf4 = 0;
         usebarf4prevval = 0;
      }
      if (gl5usef5 == true)
      {
         usebarf5prev = 0;
         usebarf5 = 0;
         usebarf5prevval = 0;
      }
      sigprev = val;
   }
   return;
}