//+------------------------------------------------------------------+
//|                                                  Integra_v2.7.25 |
//|                                                                  |
//+------------------------------------------------------------------+
#property strict

extern string Exp_Name = "I_NT";
input string t0 = "ТП в валюте депозита";
input int    Default_Profit = 5;
// Тейк профит в валюте депозита (гарантированная сумма профита)

input string t1 = "Установки расстояний";
input int    Tral_Start = 2;
// Расстояние начала трала от линии Profit в пунктах (классический ТП в пунктах)
input int    Tral_Size = 5;
// Величина трала после Tral_Start в пунктах
input int    PipStep = 47;
// Шаг открытия колен в пунктах

input string t2 = "Установки объемов и MМ";
input int    Bonus_NS = 0;
// Средства, не учавствующие в торговле (в валюте депозита)
input double Risk = 1;
// Первая сделка размером в % от свободных средств, если Risk=0 то первая сделка открывается размером DefaultLot
input double DefaultLot = 0.1;
// Начальный лот, работает если Risk=0
input double LotExponent = 1.3;
// Коэффициент увеличения лота
input int    LockPercentInfo = 40;
// Процент локового ордера от суммарного объема основной серии (пока только инфо)

input string t3 = "Переход на фикслот";
input int    FixLotPercent = 30;
// Процент просадки для автоперехода на фиксированный лот
input bool   FixLot = FALSE;
// Если TRUE, то фиксированный лот, если FALSE - динамический

input string t4 = "Установки перекрытия";
input int    LeadingOrder = 4;
// C какого колена работает перекрытие
input int    ProfitPersent = 30;
// Процент перекрытия(10...50)
input int    SecondProfitPersent = 50;
// Процент перекрытия когда подключается предпоследний ордер

input string t5 = "Ограничения";
input int    MaxTrades = 5;
// Максимальное количество одновременно открытых колен
input double MaxLot = 1.1;
// Ограничение на максимальный лот, если MaxLot=0, то макс возможный лот ДЦ
input string t7 = "Разрешить торговлю";
input bool   ManualTrade = FALSE;
// При ManualTrade = TRUE первый ордер серии открывается вручную, далее серия сопровождается советником автоматически
input bool   NewCycle_ON = TRUE;
// При запрете - цикл дорабатывается до конца, новый цикл не начинается
input bool   TradeBuy = TRUE;
// FALSE\TRUE - Запретить\Разрешить длинные позиции  
input bool   TradeSell = TRUE;
// FALSE\TRUE - Запретить\Разрешить короткие позиции 

input string t8 = "Установки CCI";
input int    CCI_TimeFrame = 0;
// ТФ      CCI  (0-текущий ТФ графика, 1=М1,2=М5,3=М15,4=М30,5=Н1,6=Н4,7=D1,8=W1,9=MN1)   
input int    Level = 100;
// Уровень CCI     
input int    Period_CCI = 14;
// Период  CCI 
input int    Sens = 0;
// Порог шумоподавления в пунктах. Если Sens=0, то вкл штатный CCI.
int    PriceTip = 5;
// Тип цены
// 0 - PRICE_CLOSE    - цена закрытия 
// 1 - PRICE_OPEN     - цена открытия
// 2 - PRICE_HIGH     - макс.цена
// 3 - PRICE_LOW      - мин.цена
// 4 - PRICE_MEDIAN   - средняя цена,(high+low)/2
// 5 - PRICE_TYPICAL  - типичная цена,(high+low+close)/3
// 6 - PRICE_WEIGHTED - взвешенная цена закрытия,(high+low+close+close)/4

input string t9 = "Фильтры уровней по МА";
input int    TipMAFilter = 2;
// Тип фильтра. Если 0-Выкл, если 1-фильтр shvondera, если 2-фильтр Kordana
input int    TimeFrame_MA = 5;
// ТФ баров (0-текущий ТФ графика, 1=М1,2=М5,3=М15,4=М30,5=Н1,6=Н4,7=D1,8=W1,9=MN1)  
input int    Period_МА = 1000;
// Период скользящей средней
input int    Distance_МА = 350;
// Если Тип1 - Дистанция в пунктах на сколько цена должна отойти от МА для открытия ордера. Работа в сторону МА.
// Если Тип2 - Уровень запрета открытия ордеров выше/ниже от скользящей средней в пунктах. Отсечка на краях диапазона.

input string t11 = "Изменение цвета и размера индикации";
input color  ColorInd = clrSilver;
// Цвет основной индикации
input color  ColorTP = clrSilver;
// Цвет линии Profit
input color  ColTPTrail = clrDarkOrange;
// Цвет линии Profit после срабатывания трала
input color  ColorZL = clrDeepSkyBlue;
// Цвет линии безубытка
input int    xDist1 = 300;
// Расстояние по горизонтали блока трала и нехватки средств
input int    xDist2 = 800;
// Расстояние по горизонтали блока суммарных профитов и объемов
input int    FontSize = 10;
// Размер шрифта индикации

input string t12 = "Дополнительные параметры";
input bool   Info = TRUE;
// Вкл индикации, звукового сопровождения открытия колен и подробного протоколирования
input int    MagicNumber=777;
// Уникальный номер советника (при MagicNumber=0 сов подхватывает ручные ордера)
input string MagicNumList = "777 0 123";
// Список, через пробел, магиков которые советник будет считать своими (не более 10)
// Первое число до пробела - Магик номер советника (при MagicNumber=0 сов подхватывает ручные ордера)
input int    PauseTrade = 6;
// Время ожидания между торговыми командами в сек 


//INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA 

int      mper[10]={0,1,5,15,30,60,240,1440,10080,43200},magic[10]={1,1,1,1,1,1,1,1,1,1};
int      dig,Lpos,Lpos1,Cpos,PrcCL1,cmagic,totalord, Total_Buy, Total_Sell, pipstep,tral_start,tral_size,lockpercent,leadingorder,cci_timeframe,
buybtn,sellbtn,closebtn,lottxt,lotbtnp,lotbtnm,closesellbtn,closebuybtn,hwnd,btn1,sum,sens,distance_ma,Magic_Number,cu=1;
color    col,ZLcolor,TPcolor;
double   TPPrice,ZeroLine,Cprofit,Lprofit,Lprofit1,PrcCL,CurrentDrawdown,CurrentUrov,Profit,SumProfit,SumLotBuy,SumLotSell,
Lot,LotR,Sum_lot,Sumlot,minLot,maxLot,delta,delta2,TV,DrawDownRate,FreeMargin,Balance,Sredstva,One_Lot,Step,
spr,freez,stlev,defaultprofit,defaultlot,
ProfitBuy,ProfitSell,LastLotBuy,LastLotSell,LastPriceBuy,LastPriceSell;
string   Order_Comment, prevar;
bool     CloseTrigger,NoTrade,CloseAll,CloseFM,fixlot,InitFail,tralinfo;
//INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA  

void OnInit()
  {
   DeleteObject();  // Сброс триггера и очистка экрана
   
   if(iBars(Symbol(),mper[CCI_TimeFrame]  ) < Period_CCI  ) {Print("! Недостачно баров в истории для CCI !"              ); InitFail = True;}
   if(iBars(Symbol(),mper[CCI_TimeFrame+1]) < Period_CCI  ) {Print("! Недостачно баров в истории для свечного анализа !" ); InitFail = True;}
   if(iBars(Symbol(),mper[TimeFrame_MA])< Period_МА && TipMAFilter!=0) {Print("! Недостачно баров в истории для МА !"    ); InitFail = True;}
   defaultprofit  =  (double)Default_Profit;
   tral_start     =  Tral_Start;
   tral_size      =  Tral_Size;
   pipstep        =  PipStep;
   defaultlot     =  DefaultLot;
   lockpercent    =  LockPercentInfo;
   leadingorder   =  LeadingOrder;
//   Первоначальная строка close_all      =  Close_All;  заблокирована, 
//   чтобы избежать случайного удаления всех ордеров.
   cci_timeframe  =  CCI_TimeFrame;
   sens           =  Sens;
   distance_ma    =  Distance_МА;
   Magic_Number   =  MagicNumber;
   TV      = MarketInfo(Symbol(),MODE_TICKVALUE   );
   minLot  = MarketInfo(Symbol(),MODE_MINLOT      );
   maxLot  = MarketInfo(Symbol(),MODE_MAXLOT      );
   One_Lot = MarketInfo(Symbol(),MODE_MARGINREQUIRED);  // Размер свободных средств, необходимых для открытия 1 лота на покупку
   Step    = MarketInfo(Symbol(),MODE_LOTSTEP);         // Шаг изменения размера лота
   if(!IsTesting() && !InitFail)
      {
      if(IsExpertEnabled()) Print("Советник установлен и будет запущен следующим тиком");
      else Print("Внимание! Отжата кнопка Cоветники на панели");
      }
   if(InitFail) {Print("! Ошибка иницилизации советника !"); return;}
        if(Step>= 1   ) dig=0;
   else if(Step>= 0.1 ) dig=1;
   else if(Step>= 0.01) dig=2;

//***************** Автоматический переход на пятизнак **************************************** 

   double _digits=MarketInfo(Symbol(),MODE_DIGITS);
   if(_digits==5 || _digits==3)
     {
      cu             = 10;
      tral_start    *= 10;
      tral_size     *= 10;
      pipstep       *= 10;
      distance_ma   *= 10;
      sens          *= 10;
     }

//***************  Защита от неправильного выставления параметров  ****************************

   if(defaultprofit<=0 )  defaultprofit = 0.01;
   if(lockpercent  <=0 )  lockpercent=1;
   if(defaultlot   <=0 )  defaultlot=0.01;
   if(leadingorder <=2 )  leadingorder=2;

//********************************************************************************************* 

   cmagic=0; string st; int k=StringLen(MagicNumList);
   for(int a=0; a<k; a++)
     {
      if(StringSubstr(MagicNumList,a,1)!=" ")
        {
         st=st+StringSubstr(MagicNumList,a,1);
         if(a<k-1) continue;
        }
      if(st!="") {magic[cmagic]=StrToInteger(st); cmagic++; st="";}
     } 
  } 

void OnDeinit(const int res)
  {
   DeleteObject();  // Сброс триггера и очистка экрана
  }

void OnTick()
  {
   CurrentCondition();
   FreeMargin = NormalizeDouble(AccountFreeMargin()- Bonus_NS, 2);
   Balance    = NormalizeDouble(AccountBalance   ()- Bonus_NS, 2);
   Sredstva   = NormalizeDouble(AccountEquity    ()       , 2);
   spr        = MarketInfo(Symbol(),MODE_SPREAD     );
   freez      = MarketInfo(Symbol(),MODE_FREEZELEVEL);
   stlev      = MarketInfo(Symbol(),MODE_STOPLEVEL  );
   Lot        = GetLot();
   if(Sumlot==0) Sumlot=0.00000001; // Защита от нулевого значения 
   if(FreeMargin<0 || Balance<0)                        return;
   if(leadingorder>=2) CheckOverlapping();
   if(Sum_lot >0) sum= 1;           // Суммарный лот серии Buy больше, чем Sell
   if(Sum_lot <0) sum=-1;           // Суммарный лот серии Sell больше, чем Buy
   if(Sum_lot==0) sum= 0;           // Суммарный лот серии Sell равен Buy
   if(Bid==0.0 || Ask==0.0) {Print(StringConcatenate("Неправильные цены. Ask: ",Ask," Bid: ",Bid)); return;}

//***************  Защита от неправильного выставления стопуровней  ***************************

   int levels     =(int)spr+(int)freez+(int)stlev;
   if(pipstep    <=levels) pipstep   =levels;
   if(tral_start <=levels) tral_start=levels;

//===========================================  Управление закрытием ордеров  ==========================================

   if(totalord==0) {CloseAll=false;}
   if(CloseAll || CloseFM)
     {
      CloseOrders(); Indication("ICloseAll",2,10,150,"Закрытие ордеров",FontSize,"Times New Roman",ColorInd);
      DeleteObject(); // Сброс триггера и очистка экрана
      CloseFM=false;
      if(Info) Print("Закрыть ВСЁ");
      return;
     }

//===============================   Переход на фиксированный лот   ====================================================

   if(CurrentDrawdown<=FixLotPercent) fixlot=false; else fixlot=true;
   if(FixLot) fixlot=true;

//=========================================  Расчет динамического профита  ============================================

   if(Risk!=0) Profit=NormalizeDouble(Lot*defaultprofit/minLot,2); else Profit=defaultprofit;

//==========================================  Трейлинг профита  =======================================================

   if(!CloseTrigger && SumProfit>(Profit+tral_start*TV*Sumlot))
     {
      CloseTrigger=1; TPcolor=ColTPTrail; ZLcolor=ColorZL;
     }
   if(!CloseTrigger && totalord>0)
     {
      TPcolor=ColorTP; ZLcolor=ColorZL;
      delta=(Profit-SumProfit)/TV/Sumlot; // Число пунктов до профита
      delta2=SumProfit/TV/Sumlot;         // Число пунктов до безубытка 
      switch(sum)
        {
         case  1 : {TPPrice=NormalizeDouble(Bid+(delta+tral_start)*Point,Digits); ZeroLine=NormalizeDouble(Bid-delta2*Point,Digits);} break;
         case -1 : {TPPrice=NormalizeDouble(Ask-(delta+tral_start)*Point,Digits); ZeroLine=NormalizeDouble(Ask+delta2*Point,Digits);} break;
        }
     }
   if(!totalord==0)
     {
      if(!IsTesting() || IsVisualMode() || !IsOptimization())
        {
         DrawLine("ILineTP",TPPrice,TPcolor,2); DrawLine("ILineZL",ZeroLine,ZLcolor,0);
         DrawText("ItxtTP","Уровень ТП",TPPrice,TPcolor); DrawText("ItxtБУ","Уровень БУ",ZeroLine,ZLcolor);
        }
      else {ObjectDelete("ILineTP"); ObjectDelete("ILineZL"); ObjectDelete("ItxtTP"); ObjectDelete("ItxtБУ");}
     }

//==========================  Триггер трала  ======================================
   if(CloseTrigger==1 && Sum_lot!=0)
     {
      switch(sum)
        {
         //==========================  Buy  ======================================      
         case  1 : if(Bid<=NormalizeDouble(TPPrice,Digits)) {if(Info) Print("Команда трала на закрытие Buy SL");  CloseAll=true;}
         else   if(TPPrice<(Bid-tral_size*Point)) TPPrice=NormalizeDouble(Bid-tral_size*Point,Digits);  break;
         //==========================  Sell  ======================================             
         case -1 : if(Ask>=NormalizeDouble(TPPrice,Digits)) {if(Info) Print("Команда трала на закрытие Sell SL"); CloseAll=true;}
         else   if(TPPrice>(Ask+tral_size*Point)) TPPrice=NormalizeDouble(Ask+tral_size*Point,Digits);  break;
        }
     }

//********************************************************************************************* 
   if(!IsTesting() || IsVisualMode() || !IsOptimization())
     {
      if(Info)
        {
         MainIndication();
         if(sens==0) PriceCCI(Level);
        }
     }

//============================================================  Начало серии  ===================================================
   if(!ManualTrade && NewCycle_ON && !NoTrade)
     {
      //=========================================================  Открытие первого Buy  ==============================================

      double StartLot;
      int ticketbuy=0,ticketsell=0;
      if(TradeBuy && Total_Buy==0)
        {
         if(ticketbuy==0)
           {
            if(!(TipMAFilter==1) || GetMASignalS()==1)
              {
               if(!(TipMAFilter==2) || !(GetMASignalK()==1))
                 {
                  if(Signal_CCI()==1)
                    {
                     DeleteObject(); RefreshRates();
                     if(Total_Sell!=1) StartLot=NormalizeDouble(Lot,dig); else StartLot=NormalizeDouble(LastLotSell,dig);
                     if(Info) Print("Команда на открытие первого BUY");
                     Order_Comment = StringConcatenate(Exp_Name, "_Buy_", Total_Buy + 1, "_", Magic_Number);
                     ticketbuy = SendOrder(OP_BUY, StartLot, 0, 0, Magic_Number, Order_Comment);
                     if(!IsTesting() || IsVisualMode() || !IsOptimization())
                       {
                        if(Info) PlaySound("alert.wav");
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.; 
                       }
                    }
                 }
              }
           }
        }

      //=========================================================  Открытие первого Sell  =============================================

      if(TradeSell && Total_Sell==0)
        {
         if(ticketsell==0)
           {
            if(!(TipMAFilter==1) || GetMASignalS()==2)
              {
               if(!(TipMAFilter==2) || !(GetMASignalK()==2))
                 {
                  if(Signal_CCI()==2)
                    {
                     DeleteObject(); RefreshRates();
                     if(Total_Sell!=1) StartLot=NormalizeDouble(Lot,dig); else StartLot=NormalizeDouble(LastLotSell,dig);
                     if(Info) Print("Команда на открытие первого SELL");
                     Order_Comment = StringConcatenate(Exp_Name, "_Sell_", Total_Sell + 1, "_", Magic_Number);
                     ticketsell = SendOrder(OP_SELL, StartLot, 0, 0, Magic_Number, Order_Comment);
                     if(!IsTesting() || IsVisualMode() || !IsOptimization())
                       {
                        if(Info) PlaySound("alert.wav");
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.; 
                       }
                    }
                 }
              }
           }
        }
     }

//=====================================================  Сопровождение серии  ===================================================

   if(!NoTrade)
     {
      double NewLot,afmc;
      ObjectDelete("InewLot");

      //==========================  Buy  ======================================

      if(TradeBuy && Total_Buy > 0 && Total_Buy <= MaxTrades)
        {
         if(Ask<(LastPriceBuy-pipstep*Point))
           {
            RefreshRates();
            NewLot=NewLot(1);
            afmc=NormalizeDouble(AccountFreeMarginCheck(Symbol(),OP_BUY,NewLot)-Bonus_NS,0);
            if(Info) Indication("InewLot",3,10,115,StringConcatenate("Ожидаем ордер: Buy ",DoubleToStr(NewLot,dig)," / ","Оcтанется : $",DoubleToStr(afmc,0)),FontSize,"Times New Roman",ColorInd);

            if(afmc<=0) return; else
            if(!(TipMAFilter==1) || GetMASignalS()==1)
              {
               if(!(TipMAFilter==2) || !(GetMASignalK()==1))
                 {
                  if(Signal_CCI()==1)
                    {
                     if(Info) Print("Команда индикаторов на открытие колена - BUY");
                     Order_Comment = StringConcatenate(Exp_Name, "_Buy_", Total_Buy + 1, "_", Magic_Number);
                     SendOrder(OP_BUY, NewLot, 0, 0, Magic_Number, Order_Comment);
                     if(!IsTesting() || IsVisualMode() || !IsOptimization())
                       {
                        if(Info) PlaySound("alert.wav");
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.;      
                       }
                    }
                 }
              }
           }
        }

      //==========================  Sell  =====================================

      if(TradeSell && Total_Sell > 0 && Total_Sell <= MaxTrades)
        {
         if(Bid>(LastPriceSell+pipstep*Point))
           {
            RefreshRates();
            NewLot=NewLot(2);
            afmc=NormalizeDouble(AccountFreeMarginCheck(Symbol(),OP_BUY,NewLot)-Bonus_NS,0);
            if(Info) Indication("InewLot",3,10,115,StringConcatenate("Ожидаем ордер: Sell ",DoubleToStr(NewLot,dig)," / ","Оcтанется : $",DoubleToStr(afmc,0)),FontSize,"Times New Roman",ColorInd);

            if(afmc<=0) return; else
            if(!(TipMAFilter==1) || GetMASignalS()==2)
              {
               if(!(TipMAFilter==2) || !(GetMASignalK()==2))
                 {
                  if(Signal_CCI()==2)
                    {
                     if(Info) Print("Команда индикаторов на открытие колена - SELL");
                     Order_Comment = StringConcatenate(Exp_Name, "_Sell_", Total_Sell + 1, "_", Magic_Number);
                     SendOrder(OP_SELL, NewLot, 0, 0, Magic_Number, Order_Comment);
                     if(!IsTesting() || IsVisualMode() || !IsOptimization())
                       {
                        if(Info) PlaySound("alert.wav");
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.;       
                       }
                    }
                 }
              }
           }
        }
     }
  }

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++           ФУНКЦИИ            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//=========================================================================================================================================//
// Qimer . Функция контроля наличия своего магика                                                                                          //
//=========================================================================================================================================//

bool MagicCheck()
  {
   for(int i=0; i<cmagic; i++)
     {
      if(OrderMagicNumber()==magic[i]) return(true);
     }
   return(false);
  }
//=========================================================================================================================================//
// shvonder . Фильтр уровней по МА S                                                                                                       //
//=========================================================================================================================================//  

int GetMASignalS()
  {
   int Signal=0;
   if(TipMAFilter==1)
     {
      double iMA_Signal=iMA(Symbol(),TimeFrame_MA,Period_МА,0,MODE_SMMA,PRICE_CLOSE,1);
      double Ma_Bid_Diff=MathAbs(iMA_Signal-Bid)/Point;
      if(Ma_Bid_Diff > distance_ma && Bid > iMA_Signal) Signal =  2; //Sell
      if(Ma_Bid_Diff > distance_ma && Bid < iMA_Signal) Signal =  1; //Buy   
      double LevelNoBuy =iMA_Signal-distance_ma*Point;
      double LevelNoSell=iMA_Signal+distance_ma*Point;
      if(!IsTesting() || IsVisualMode() || !IsOptimization())
        {
         DrawLine("ILevelNoBuy  ",LevelNoBuy,clrRoyalBlue,3);
         DrawLine("ILevelNoSell ",LevelNoSell,clrCrimson,3);
         DrawText("ItxtLevelBuy ","Filter shvonder - запрет Buy",LevelNoBuy,clrRoyalBlue);
         DrawText("ItxtLevelSell","Filter shvonder - запрет Sell",LevelNoSell,clrCrimson);
        }
     }
   return(Signal);
  }
//=========================================================================================================================================//
// Kordan . Фильтр уровней по МА K                                                                                                         //
//=========================================================================================================================================//  

int    GetMASignalK()
  {
   int    Signal=0;
   if(TipMAFilter==2)
     {
      double iMA_Signal=iMA(Symbol(),TimeFrame_MA,Period_МА,0,MODE_SMMA,PRICE_CLOSE,1);
      double Ma_Bid_Diff=MathAbs(iMA_Signal-Bid)/Point;
      double LevelNoBuy =iMA_Signal+distance_ma*Point;
      double LevelNoSell=iMA_Signal-distance_ma*Point;
      if(Ma_Bid_Diff>distance_ma)
        {
         if(Bid > iMA_Signal) Signal = 1; //Запрет Buy
         if(Bid < iMA_Signal) Signal = 2; //Запрет Sell  
        }
      if(!IsTesting() || IsVisualMode() || !IsOptimization())
        {
         DrawLine("ILevelNoBuy  ",LevelNoBuy,clrRoyalBlue,3);
         DrawLine("ILevelNoSell ",LevelNoSell,clrCrimson,3);
         DrawText("ItxtLevelBuy ","Filter Kordan - запрет Buy",LevelNoBuy,clrRoyalBlue);
         DrawText("ItxtLevelSell","Filter Kordan - запрет Sell",LevelNoSell,clrCrimson);
        }
     }
   return(Signal);
  }
//=========================================================================================================================================//
// Kordan . Сигнал СCI                                                                                                                     //
//=========================================================================================================================================// 

int Signal_CCI()
  {
   int Signal=0;
   double x0,x1,x2,x3,x4;
   x0 = iClose(Symbol(),mper[cci_timeframe+1], 0);
   x1 = iClose(Symbol(),mper[cci_timeframe+1], 2);
   if(sens==0)
     {
      x2 = iCCI(NULL,mper[cci_timeframe],Period_CCI,0,0);
      x3 = iCCI(NULL,mper[cci_timeframe],Period_CCI,0,1);
      x4 = iCCI(NULL,mper[cci_timeframe],Period_CCI,0,3);
     }
   else
     {
      x2 = iCustom(NULL,mper[cci_timeframe],"iCCI.NR", Period_CCI,PriceTip,sens, 0,0);
      x3 = iCustom(NULL,mper[cci_timeframe],"iCCI.NR", Period_CCI,PriceTip,sens, 0,1);
      x4 = iCustom(NULL,mper[cci_timeframe],"iCCI.NR", Period_CCI,PriceTip,sens, 0,3);
     }
   if(x2>-Level && x3<-Level && x2>x4 && x1>x0) Signal = 1;    //Buy 
   if(x2< Level && x3> Level && x2<x4 && x1<x0) Signal = 2;    //Sell
   return(Signal);
  }
//=========================================================================================================================================//
// Kordan . Функция получения информации по открытым ордерам                                                                               //
//=========================================================================================================================================// 

void CurrentCondition()
  {
   totalord=0;Total_Buy = 0;Total_Sell = 0;SumProfit=0;CurrentDrawdown=0;ProfitBuy=0;ProfitSell=0;SumLotBuy=0;SumLotSell=0;LastPriceBuy=0;LastPriceSell=0;
   for(int cnt=0;cnt<OrdersTotal();cnt++)
     {
      if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
           {
            if(OrderType()==OP_SELL || OrderType()==OP_BUY)
              {
               switch(OrderType())
                 {
                  case OP_BUY :
                     Total_Buy++;
                     SumLotBuy    += OrderLots();
                     LastLotBuy    = OrderLots();
                     LastPriceBuy  = NormalizeDouble(OrderOpenPrice() , Digits);
                     ProfitBuy    += NormalizeDouble(OrderProfit()+OrderSwap()+OrderCommission(), 2);
                     break;
                  case OP_SELL:
                     Total_Sell++;
                     SumLotSell   += OrderLots();
                     LastLotSell   = OrderLots();
                     LastPriceSell = NormalizeDouble(OrderOpenPrice() , Digits);
                     ProfitSell   += NormalizeDouble(OrderProfit()+OrderSwap()+OrderCommission(), 2);
                     break;
                  default: return;
                 }
              }
            totalord        = Total_Buy + Total_Sell;
            SumProfit      += OrderProfit()+OrderSwap()+OrderCommission();
            CurrentDrawdown = NormalizeDouble(MathMax((AccountBalance()+AccountCredit()-AccountEquity())/(AccountBalance()+AccountCredit())*100,0),2);
            Sum_lot         = NormalizeDouble(SumLotBuy-SumLotSell ,dig);  // Суммарный лот (плюс или минус)        
            Sumlot          = NormalizeDouble(MathAbs(Sum_lot     ),dig);  // Aбсолютное значение суммарного лота (значение по модулю, всегда плюс)        
            if(AccountMargin()>0) CurrentUrov=NormalizeDouble(AccountEquity()/AccountMargin()*100,0);
           }
        }
     }
  }
//=========================================================================================================================================//
// Kordan . Функция получения ордера с макс и мин значением прибыли                                                                        //
//=========================================================================================================================================// 

void GetOrdMaxNinProfit()
  {
   int    Pos   =0;
   double result=0,profit=0;
   for(int cnt=0;cnt<OrdersTotal();cnt++)
     {
      if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
           {
            if(OrderType()==OP_SELL || OrderType()==OP_BUY)
              {
               profit   = OrderProfit();
               Pos      = OrderTicket();
               if(profit>0 && profit>Lprofit)
                 {
                  Lprofit1 = Lprofit;
                  Lpos1    = Lpos;
                  Lprofit=profit; //макс значение
                  Lpos=Pos;
                 }
               if(profit<0 && profit<Cprofit)
                 {
                  Cprofit=profit; //мин  значение
                  Cpos=Pos;
                 }
              }
           }
        }
     }
  }
//=========================================================================================================================================//
// Kordan . Функция расчета лота для открытия колен                                                                                        //
//=========================================================================================================================================//

double NewLot(int OrdType)
  {
   double newlot=0,cp;
   switch(OrdType)
     {
      case 1 :
         if(!fixlot) cp=MathAbs((LastPriceBuy-Ask)/Point/pipstep);  else cp=1;
         newlot=NormalizeDouble(LastLotBuy*LotExponent*cp,dig);         break;
      case 2 :
         if(!fixlot) cp=MathAbs((Bid-LastPriceSell)/Point/pipstep); else cp=1;
         newlot=NormalizeDouble(LastLotSell*LotExponent*cp,dig);        break;
     }
   if(MaxLot==0) newlot=newlot; else
   if(newlot > MaxLot) newlot = NormalizeDouble(MaxLot,dig);
   if(newlot < minLot) newlot = minLot;
   return(newlot);
  }
//=========================================================================================================================================//
// Kordan . Функция расчета начального лота                                                                                                //
//=========================================================================================================================================//

double GetLot()
  {
   double lot=0;
   if(Risk!=0)                                                 // Если кол-во лотов заданно в % от свободных средств,                                                          
   lot=MathAbs(FreeMargin*Risk/3200/One_Lot/Step)*Step; else   // то считаем стоимость лота
   lot=MathMax(defaultlot,minLot);                             // иначе выставляется заданное значение DefaultLot не меньше мин. размерa лота
   if(lot<minLot) lot=minLot;                                  // Не меньше минимального  размерa лотa
   if(MaxLot==0) lot=lot; else
   lot=MathMin(MaxLot,lot);                                    // Не больше максимально установленного размерa лотa                                                                  
   if(lot*One_Lot>FreeMargin)
     {                                                         // Если лот дороже свободных средств,
      if(!IsTesting() || IsVisualMode() || !IsOptimization())
        {                                                      // то выводим сообщение в режиме Тест,
         Indication("INoMoney",2,xDist1,40,"Недостаточно средств!!!",FontSize+5,"Courier",clrRed);  // Нулевая маржа              
        }
      else
        {
         Indication("INoMoney",2,xDist1,40,"Недостаточно средств!!! Торговля остановлена!!!",FontSize+5,"Courier",clrRed);
         NoTrade=TRUE;                                         // останавливаем торговлю
        }
      return(0);                                               // и выходим из функции start()
     }
   else  ObjectDelete("INoMoney");
   return(lot);
  }

//=========================================================================================================================================//
// ir0407 . Функция открытия ордеров                                                                                                       //
//=========================================================================================================================================//   

int SendOrder(int Type,double lots,int TP,int SL,int magics,string Cmnt)
  {
   double Price,Take,Slippage,Stop;
   int Ticket=0,Color,Err=0;
   bool Delay= False;
//if(Info) Print("Функция открытия ордеров");
   while(!IsStopped())
     {
      if(!IsTesting())
        { //Если мы не в режиме тестирования
         if(!IsExpertEnabled()){Print("Эксперту запрещено торговать! Кнопка \"Советники\" отжата."); return(-1);}
         if(!IsConnected()) Print("Связь с сервером отсутствует!");  //else if(Info>=1) Print("Связь с сервером установлена");
         if(IsTradeContextBusy())
           {
            Print("Торговый поток занят!");
            Print(StringConcatenate("Ожидаем ",PauseTrade," cek"));
            Sleep(PauseTrade*1000);
            Delay=True;
            continue;
           }
         if(Delay)
           {
            if(Info) Print("Обновляем котировки");
            RefreshRates();
            Delay=False;
           }
         else if(Info) Print("Котировки актуальны");
        }
      switch(Type)
        {
         case OP_BUY:
            //               if (Info) Print("Инициализируем параметры для BUY-ордера");
            Price= NormalizeDouble(Ask,Digits);
            Take = IIFd(TP == 0, 0, NormalizeDouble( Ask + TP * Point, Digits));
            Stop = IIFd(SL == 0, 0, NormalizeDouble( Ask - SL * Point, Digits));
            Color= clrBlue;
            break;
         case OP_SELL:
            //               if (Info) Print("Инициализируем параметры для SELL-ордера");
            Price= NormalizeDouble(Bid,Digits);
            Take = IIFd(TP == 0, 0, NormalizeDouble( Bid - TP * Point, Digits));
            Stop = IIFd(SL == 0, 0, NormalizeDouble( Bid + SL * Point, Digits));
            Color= clrRed;
            break;
         default:
            Print("!Тип ордера не соответствует требованиям!");
            return(-1);
        }
      string NameOP=GetNameOP(Type);
      Slippage=2*MarketInfo(Symbol(),MODE_SPREAD);
      if(Slippage==0) Slippage=1*cu;
      if(Info) Print(StringConcatenate("Ордер: ",NameOP," / "," Цена=",DoubleToString(Price,Digits)," / ","Lot=",DoubleToString(lots,dig)," / ","Slip=",Slippage," pip"," / ",Cmnt));

      if(IsTradeAllowed())
        {
         if(Info) Print(">>>>>Торговля разрешена, отправляем ордер >>>>>");
         Ticket=OrderSend(Symbol(),Type,lots,Price,(int)Slippage,Stop,Take,Cmnt,magics,0,Color);

         if(Ticket<0)
           {
            Err=GetLastError();
            if(Err == 4   || /* SERVER_BUSY       */
               Err == 129 || /* ERR_INVALID_PRICE */
               Err == 130 || /* INVALID_STOPS     */
               Err == 135 || /* PRICE_CHANGED     */
               Err == 137 || /* BROKER_BUSY       */
               Err == 138 || /* REQUOTE           */
               Err == 146 || /* TRADE_CONTEXT_BUSY*/
               Err == 136 )  /* OFF_QUOTES        */
              {
               if(!IsTesting())
                 {
                  Print(StringConcatenate("Ошибка(OrderSend - ",Err,"): ",ErrorDescription(Err),")"));
                  Print(StringConcatenate("Ожидаем ",PauseTrade," cek"));
                  Sleep(PauseTrade*1000);
                  Delay=True;
                  continue;
                 }
              }
            else
              {
               Print(StringConcatenate("Критическая ошибка(OrderSend - ",Err,"): ",ErrorDescription(Err),")"));
               break;
              }
           }
         break;
        }
      else
        {
         if(Info) Print("Эксперту запрещено торговать! Снята галка в свойствах эксперта.");
         break;
        }
     }
   if(Ticket>0)
      if(Info) Print(StringConcatenate("Ордер отправлен успешно. Тикет = ",Ticket));
   else
     {
      if(Info) Print(StringConcatenate("Ошибка! Ордер не отправлен. (Код ошибки = ",Err,": ",ErrorDescription(Err),")"));
     }
   return(Ticket);
  }

//=========================================================================================================================================//
// KimIV . Функция "если-то" для double                                                                                                    //
//=========================================================================================================================================//

double IIFd(bool condition,double ifTrue,double ifFalse)
  {if(condition) return(ifTrue); else return(ifFalse);}
//=========================================================================================================================================//
// ir0407 . Функция закрытия ордеров                                                                                                       //
//=========================================================================================================================================//  

void CloseOrders()
  {
   bool Delay=False;
   double  ClosePrice=0, Slippage=0;
   color   CloseColor=0;
   int Err;
   if(!IsTesting())
     { //Если мы не в режиме тестирования
      if(!IsExpertEnabled()) {Print("Эксперту запрещено торговать!"); return;}
      if(!IsConnected()) Print("Связь с сервером отсутствует!");  //else if(Info>=1) Print("Связь с сервером установлена");
     }

   for(int trade=OrdersTotal()-1; trade>=0; trade--)
     {
      if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
           {
            if(Info) Print("Закрываем ордер #",OrderTicket());
            while(!IsStopped())
              {
               if(!OrderSelect(OrderTicket(),SELECT_BY_TICKET)) break;
               if(IsTradeContextBusy())
                 {
                  Print("Торговый поток занят!");
                  Print(StringConcatenate("Ожидаем ",PauseTrade," cek"));
                  Sleep(PauseTrade*1000);
                  Delay=True;
                  continue;
                 }

               if(!IsTesting())
                 {
                  if(Info) Print("Торговый поток свободен");
                 }
               if(Delay)
                 {
                  if(Info) Print("Обновляем котировки");
                  RefreshRates();
                  Delay=False;
                 }
               switch(OrderType())
                 {
                  case OP_BUY : ClosePrice = NormalizeDouble(Bid, Digits); CloseColor = clrBlue; break;
                  case OP_SELL: ClosePrice = NormalizeDouble(Ask, Digits); CloseColor = clrRed;  break;
                 }
               Slippage=2*MarketInfo(Symbol(),MODE_SPREAD);
               if(Slippage==0) Slippage=1*cu;
               if(Info) Print(StringConcatenate("Цена закрытия=",DoubleToString(ClosePrice,Digits)," / ","Slip = ",Slippage," pip"));
               if(!IsTradeAllowed())
                 {
                  Print("Эксперту запрещено торговать, снята галка в свойствах эксперта!");
                  return;
                 }
               else
               if(!OrderClose(OrderTicket(),OrderLots(),ClosePrice,(int)Slippage,CloseColor))
                 {
                  Err=GetLastError();
                  if(Err == 4   || /* SERVER_BUSY       */
                     Err == 129 || /* ERR_INVALID_PRICE */
                     Err == 130 || /* INVALID_STOPS     */
                     Err == 135 || /* PRICE_CHANGED     */
                     Err == 137 || /* BROKER_BUSY       */
                     Err == 138 || /* REQUOTE           */
                     Err == 146 || /* TRADE_CONTEXT_BUSY*/
                     Err==136)     /* OFF_QUOTES        */
                    {

                     Print(StringConcatenate("Ошибка(OrderClose - ",Err,"): ",ErrorDescription(Err),")"));
                     Print(StringConcatenate("Ожидаем ",PauseTrade," cek"));
                     Sleep(PauseTrade*1000);
                     Delay=True;
                     continue;
                    }
                  else
                    {
                     Print(StringConcatenate("Критическая ошибка(OrderClose - ",Err,"): ",ErrorDescription(Err),")"));
                     break;
                    }
                 }
               else break;
              }
            Sleep(100);        // конец while(!IsStopped())	
           }
        }
     }
   if(Info) Print("Конец функции закрытия ордеров.");
   return;
  }
//=========================================================================================================================================//
// shvonder . Перекрытие ордеров                                                                                                           //
//=========================================================================================================================================//

void CheckOverlapping()
  {
   Lpos=0; Cpos=0; Lprofit=0; Cprofit=0;
   GetOrdMaxNinProfit();
   if(Total_Buy >= leadingorder || Total_Sell >= leadingorder)
     {
      if(Lprofit>0 && Lprofit1<=0 && Cprofit<0)
        {
         if(Lprofit+Cprofit>0 && (Lprofit+Cprofit)*100/Lprofit>ProfitPersent)
           {
            Lpos1=0;
            CloseSelectOrder();
           }
        }
      else

      if(Lprofit > 0 && Lprofit1 > 0 && (Total_Buy > leadingorder || Total_Sell > leadingorder) && Cprofit < 0)
        {
         if(Lprofit+Lprofit1+Cprofit>0 && (Lprofit+Lprofit1+Cprofit)*100/(Lprofit+Lprofit1)>SecondProfitPersent)
            CloseSelectOrder();
        }
     }
  }
//=========================================================================================================================================//
// shvonder . Функция закрытия перекрытых ордеров                                                                                          //
//=========================================================================================================================================//

void CloseSelectOrder()
  {
   if(Info) Print("Функция перекрытия ордеров.");
   int error  = 0;
   int error1 = 0;
   int error2 = 0;
   double Slippage=2*MarketInfo(Symbol(),MODE_SPREAD);
   if(Slippage==0) Slippage=1*cu;
   int i;
//                       ---------------------- последний  -----------------------                            

   while(error1==0)
     {
      RefreshRates();
      i=OrderSelect(Lpos,SELECT_BY_TICKET,MODE_TRADES);
      if(i!=1){Print("Ошибка! Невозможно выбрать ордер с наибольшим профитом. Выполнение перекрытия отменено."); return;}
      if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
        {
         switch(OrderType())
           {
            case OP_BUY : error1 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), (int)Slippage, clrBlue); break;
            case OP_SELL: error1 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), (int)Slippage, clrRed ); break;
           }
         if(error1==1) { if(Info) Print("Лидирующий ордер закрыт успешно"); Sleep(500); }
         else Print("Ошибка закрытия лидирующего ордера, повторяем операцию.");
        }
     }

//                       ---------------------- пред последний  -----------------------   

   if(Lpos1!=0)
     {
      while(error2==0)
        {
         RefreshRates();
         i=OrderSelect(Lpos1,SELECT_BY_TICKET,MODE_TRADES);
         if(i!=1){Print("Ошибка! Невозможно выбрать пред ордер с наибольшим профитом. Выполнение перекрытия отменено."); return;}
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
           {
            switch(OrderType())
              {
               case OP_BUY : error2 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), (int)Slippage, clrBlue); break;
               case OP_SELL: error2 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), (int)Slippage, clrRed ); break;
              }
            if(error2==1) { if(Info) Print("Пред Лидирующий ордер закрыт успешно"); Sleep(500); }
            else Print("Ошибка закрытия Пред лидирующего ордера, повторяем операцию.");
           }
        }
     }

//                      ----------- выбранный (обычно с наименьшим профитом ) -----------

   while(error==0)
     {
      RefreshRates();
      i=OrderSelect(Cpos,SELECT_BY_TICKET,MODE_TRADES);
      if(i!=1){Print("Ошибка! Невозможно выбрать ордер с наименьшим профитом. Выполнение перекрытия отменено."); return;}
      if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
        {
         switch(OrderType())
           {
            case OP_BUY : error = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), (int)Slippage, clrBlue); break;
            case OP_SELL: error = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), (int)Slippage, clrRed ); break;
           }
         if(error==1){ if(Info) Print("Перекрываемый ордер закрыт успешно."); Sleep(500); }
         else Print("Ошибка закрытия перекрываемого ордера, повторяем операцию.");
        }
     }
   if(Info) Print("Конец функции перекрытия ордеров.");
   return;
  }
//=========================================================================================================================================//
// Kordan . Функция удаления объектов                                                                                                      //
//=========================================================================================================================================//

int DeleteObject()
  {
   CloseTrigger=0; TPPrice=0; ZeroLine=0;
   int    ObjTotal=ObjectsTotal();
   string ObName;
   for(int i=0; i<ObjTotal; i++)
     {
      ObName=ObjectName(i);
      if(StringSubstr(ObName,0,1)=="I"
         || StringSubstr(ObName,0,1)=="i")
        {
         ObjectDelete(ObName);
         Comment("");
         i=i-1;
        }
     }
   return(0);
  }
//=========================================================================================================================================//
// Qimer . Отрисовка линий                                                                                                                 //
//=========================================================================================================================================//

void DrawLine(string name,double price,color cols,int width)
  {
   if(ObjectFind(name)<0)
      ObjectCreate(name,OBJ_HLINE,0,0,price);
   else
      ObjectMove(name,0,Time[1],price);
   ObjectSet(name,OBJPROP_COLOR,cols);
   ObjectSet(name,OBJPROP_WIDTH,width);
  }
//=========================================================================================================================================//
// Qimer . Отрисовка текста                                                                                                                //
//=========================================================================================================================================//

void DrawText(string name,string txt,double y,color cols)
  {
   if(ObjectFind(name)<0) ObjectCreate(name,OBJ_TEXT,0,Time[WindowFirstVisibleBar()-WindowFirstVisibleBar()/5],y);
   else ObjectMove(name,0,Time[WindowFirstVisibleBar()-WindowFirstVisibleBar()/4],y);
   ObjectSetText(name,txt,10,"Times New Roman",cols);
  }
//=========================================================================================================================================//
// Kordan . Индикация                                                                                                                      //
//=========================================================================================================================================//   

void Indication(string name,int corner,int Xdist,int Ydist,string txt,int fontsize,string font,color cols)
  {
   if(ObjectFind(name)<0)
      ObjectCreate(name,OBJ_LABEL,0,0,0);
   ObjectSet(name,OBJPROP_CORNER,corner);
   ObjectSet(name,OBJPROP_XDISTANCE,Xdist);
   ObjectSet(name,OBJPROP_YDISTANCE,Ydist);
   ObjectSetText(name,txt,fontsize,font,cols);
  }
//=========================================================================================================================================//
// Функция отрисовки и расчета CCI                                                                                                         //
//=========================================================================================================================================//

double PriceCCI(double Levels,int CurrentCandle=0)
  {
   double MovBuffer=0;
   double Price=0,SummPrice=0,Abs=0,SummAbs=0,CCI=0;
   double K=0.015;
   int j,i;
   for(i=Period_CCI-1; i>=0; i--)
     {
      j=i+CurrentCandle;
      Price=(High[j]+Low[j]+Close[j])/3;
      MovBuffer=iMA(NULL,0,Period_CCI,0,MODE_SMA,PRICE_TYPICAL,CurrentCandle);
      Abs=MathAbs(Price-MovBuffer);
      if(i>0)
        {
         SummPrice+=Price;
         SummAbs+=Abs;
        }
     }
   if(Info==true)
     {
      CCI=(Price-MovBuffer)/((SummAbs+Abs)*K/Period_CCI);
      Indication("ICCI",2,10,45,StringConcatenate("CCI (",DoubleToStr(Level,0),",",Period_CCI,",",cci_timeframe,") = ",DoubleToStr(CCI,0)),FontSize,"Times New Roman",ColorInd);
     }

   double H = High[CurrentCandle];
   double L =  Low[CurrentCandle];
   i=Period_CCI;
   if(CCI>=0)
     {
      CCI=Levels;
      Price=-(H*i-L*i*i-H*i*i+L*i-CCI*H*K-CCI*L*K+3*SummPrice*i-
              CCI*3*K*SummPrice+CCI*H*K*i+CCI*L*K*i+CCI*3*K*SummAbs*i)/(i-i*i-CCI*K+CCI*K*i);
     }
   else
     {
      CCI=-Levels;
      Price=-(H*i-L*i*i-H*i*i+L*i+CCI*H*K+CCI*L*K+3*SummPrice*i+
              CCI*3*K*SummPrice-CCI*H*K*i-CCI*L*K*i+CCI*3*K*SummAbs*i)/(i-i*i+CCI*K-CCI*K*i);
     }
   if(ObjectFind("ILineCCI")!=-1) ObjectDelete("ILineCCI"    );
   if(ObjectFind("ItxtCCI" )!=-1) ObjectDelete("ItxtCCI"     );
   if(Price>H)
     {
      ObjectCreate("ILineCCI",OBJ_HLINE,0,0,Price);
      ObjectSet("ILineCCI",OBJPROP_COLOR,clrSteelBlue);
      DrawText("ItxtCCI",StringConcatenate("CCI < ",DoubleToStr(CCI,0)),Price,clrSteelBlue);
     }
   else ObjectCreate("ILineCCI",OBJ_HLINE,0,0,Price);
   if(Price<L)
     {
      ObjectCreate("ILineCCI",OBJ_HLINE,0,0,Price);
      ObjectSet("ILineCCI",OBJPROP_COLOR,clrTeal);
      DrawText("ItxtCCI",StringConcatenate("CCI > ",DoubleToStr(CCI,0)),Price,clrTeal);
     }
   else ObjectCreate("ILineCCI",OBJ_HLINE,0,0,Price);
   return(Price);
  }
//=========================================================================================================================================//
// Kordan . Функция главной индикации                                                                                                      //
//=========================================================================================================================================//

void MainIndication()
  {
   int TotalBuyOrd  = 1;
   int TotalSellOrd = 1;
   int i;
   string ObName;
//========================================  Oтрисовкa профита и лотов ордеров =============================================================

   int ObjTotal=ObjectsTotal();
   for(i=0; i<ObjTotal; i++)
     {
      ObName=ObjectName(i);
      if(StringSubstr(ObName,0,1)=="i")
        {
         ObjectDelete(ObName);
         i=i-1;
        }
     }
   for(i=OrdersTotal();i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
           {
            if(OrderType()==OP_BUY)
              {
               ObjectCreate(StringConcatenate("iB",TotalBuyOrd),OBJ_TEXT,0,Time[40],OrderOpenPrice());
               ObjectSetText(StringConcatenate("iB",TotalBuyOrd),StringConcatenate("Lot: ",DoubleToStr(OrderLots(),2)," Prof: ",DoubleToStr(OrderProfit()+OrderCommission()+OrderSwap(),2)),8,"Verdana",clrDeepSkyBlue);
               TotalBuyOrd=TotalBuyOrd+1;
              }
           }
        }
     }
   for(i=OrdersTotal();i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic_Number || MagicCheck()))
           {
            if(OrderType()==OP_SELL)
              {
               ObjectCreate(StringConcatenate("iS",TotalSellOrd),OBJ_TEXT,0,Time[40],OrderOpenPrice());
               ObjectSetText(StringConcatenate("iS",TotalSellOrd),StringConcatenate("Lot: ",DoubleToStr(OrderLots(),2)," Prof: ",DoubleToStr(OrderProfit()+OrderCommission()+OrderSwap(),2)),8,"Verdana",clrDarkOrange);
               TotalSellOrd=TotalSellOrd+1;
              }
           }
        }
     }

//=========================================================================================================================================

   if(ObjectFind("DrawDown")>=0)
     {
      datetime time_coordinate=(int)ObjectGet("DrawDown",OBJPROP_TIME1);
      int shiftD=iBarShift(Symbol(),0,time_coordinate);
      double price_coordinate=iHigh(Symbol(),0,shiftD)+(WindowPriceMax()-WindowPriceMin())/20;
      bool changed=ObjectSet("DrawDown",OBJPROP_PRICE1,price_coordinate);
     }
   if(DrawDownRate<(AccountBalance()+AccountCredit()-AccountEquity()+AccountCredit())/AccountBalance()+AccountCredit())
     {
      ObjectDelete("DrawDown");
      DrawDownRate=(AccountBalance()+AccountCredit()-AccountEquity()+AccountCredit())/AccountBalance()+AccountCredit();
      prevar=StringConcatenate(DoubleToStr(DrawDownRate*100,2)," %");
      ObjectCreate("DrawDown",OBJ_ARROW,0,Time[0],High[0]+(WindowPriceMax()-WindowPriceMin())/20);
      ObjectSet("DrawDown",OBJPROP_ARROWCODE,117);
      ObjectSet("DrawDown",OBJPROP_COLOR,clrDarkOrange);
      ObjectSet("DrawDown",OBJPROP_TIMEFRAMES,0);
      ObjectSetText("DrawDown",prevar);
     }
   if(Sredstva >= Balance/6*5) col = ColorInd;
   if(Sredstva >= Balance/6*4 && Sredstva < Balance/6*5) col = clrDeepSkyBlue;
   if(Sredstva >= Balance/6*3 && Sredstva < Balance/6*4) col = clrGold;
   if(Sredstva >= Balance/6*2 && Sredstva < Balance/6*3) col = clrOrangeRed;
   if(Sredstva >= Balance/6   && Sredstva < Balance/6*2) col = clrCrimson;
   if(Sredstva <  Balance/6                            ) col = clrRed;

//-------------------------

   string spips,Prof,Bezub,lock;
   double pips;
   pips=NormalizeDouble((AccountEquity()-AccountStopoutLevel()*AccountEquity()/ 100.0)/Sumlot/TV,0);
   lock=DoubleToStr(NormalizeDouble(Sumlot/100*lockpercent,dig),dig);
   if(Sum_lot!=0)
     {
      Prof  = StringConcatenate("До профита "  ,DoubleToStr(delta+tral_start, 0)," пунктов");  // Число пунктов до профита
      Bezub = StringConcatenate("До безубытка ",DoubleToStr(delta2, 0)          ," пунктов");  // Число пунктов до безубытка       
      if(Sum_lot<0)
        {
         spips = StringConcatenate("До слива ",pips," пунктов вверх");
         lock  = StringConcatenate("Ордер для лока: Buy ",lock);
        }
      else
        {
         spips = StringConcatenate("До слива ",pips," пунктов вниз");
         lock  = StringConcatenate("Ордер для лока: Sell ",lock);
        }
     }
   else
     {
      if(SumLotBuy==0 && SumLotSell==0)
        {
         spips="Нет ордеров"; Prof=""; Bezub="";
        }
      else
        {
         spips ="Ждем первое колено";
         Prof  ="Трал отдыхает";
         Bezub ="Выставлен замок";
        }
      lock=StringConcatenate("Процент локового ордера = ",lockpercent);
     }

//==========================  Левый нижний угол и центр ===============================
   string txt;
   if(fixlot) txt="Фиксированный лот"; else txt="Динамический лот";
   if(!NewCycle_ON)  Indication("INewCycleON",2,10,150,"Запрет начала нового цикла",FontSize,"Times New Roman",ColorInd);
   if(!TradeBuy)     Indication("ITradeBuy",2,10,135,"Ручной запрет Buy",FontSize,"Times New Roman",ColorInd);
   if(!TradeSell)    Indication("ITradeSell",2,10,120,"Ручной запрет Sell",FontSize,"Times New Roman",ColorInd);
   switch(TipMAFilter)
     {
      case 1:
        {
         if(GetMASignalS()== 2 || GetMASignalS()==0) Indication ("ILevelBuy" ,2,10,105,"Запрет Buy" ,FontSize,"Times New Roman",ColorInd ); else ObjectDelete("ILevelBuy" );
         if(GetMASignalS()== 1 || GetMASignalS()==0) Indication ("ILevelSell",2,10,90 ,"Запрет Sell",FontSize,"Times New Roman",ColorInd ); else ObjectDelete("ILevelSell");
        }
      break;
      case 2:
        {
         if(GetMASignalK()== 1) Indication ("ILevelBuy" ,2,10,105,"Запрет Buy" ,FontSize,"Times New Roman",ColorInd ); else ObjectDelete("ILevelBuy" );
         if(GetMASignalK()== 2) Indication ("ILevelSell",2,10,90 ,"Запрет Sell",FontSize,"Times New Roman",ColorInd ); else ObjectDelete("ILevelSell");
        }
      break;
     }
   string tral;
   if(!CloseTrigger) tral=""; else tral="Поздравляю! Пошел трал профита!";
   Indication("ITrail",2,xDist1,30,tral,FontSize+5,"Courier",clrLime);
   Indication("IFixLot",2,10,60,txt,FontSize,"Times New Roman",ColorInd);

//==========================  Правый нижний угол  ===================================== 

   Indication("Ispips",3,10,55,spips,FontSize,"Times New Roman",col);
   Indication("Ilock",3,10,10,lock,FontSize,"Times New Roman",ColorInd);
   Indication("IProf",3,10,40,Prof,FontSize,"Times New Roman",col);
   Indication("IBezub",3,10,25,Bezub,FontSize,"Times New Roman",col);
   double MaxDrDown = MathMax(DrawDownRate,0)*100;
   Indication("IMaxDrDown",3,10,145,StringConcatenate("Макс. Просадка: ",DoubleToStr(MaxDrDown,2)," %"),FontSize,"Times New Roman",ColorInd);
//   Indication("IMaxDrDown",3,10,145,StringConcatenate("Макс. Просадка: ",DoubleToStr(MathMax(DrawDownRate,0)*100,2)," %"),FontSize,"Times New Roman",ColorInd);
   Indication("IBalance ",3,10,100,StringConcatenate("Баланс   ",DoubleToStr(Balance,2)),FontSize,"Times New Roman",ColorInd);
   Indication("IEquity  ",3,10,85,StringConcatenate("Свободно ",DoubleToStr(FreeMargin,2)),FontSize,"Times New Roman",col);
   Indication("IDrawDown",3,10,70,StringConcatenate("Просадка ",DoubleToStr(CurrentDrawdown,2),"%"),FontSize,"Times New Roman",col);

   if(Sum_lot!=0) Indication("ICurUrov",3,10,130,StringConcatenate("Уровень: ",DoubleToStr(CurrentUrov,0),"%"),FontSize,"Times New Roman",ColorInd); else ObjectDelete("ICurUrov");
   color ColProf,ColBuy,ColSell;
   if(SumProfit <0) ColProf= clrLightCoral; else ColProf= clrLime;
   if(ProfitBuy <0) ColBuy = clrLightPink;  else ColBuy = clrLightGreen;
   if(ProfitSell<0) ColSell= clrLightPink;  else ColSell= clrLightGreen;

   double LotsTake=FreeMargin/MarketInfo(Symbol(),MODE_MARGINREQUIRED);  //количество лотов которое можно купить  
//   Indication("IPrice",1,10,20,StringConcatenate("",DoubleToStr(MarketInfo(Symbol(),MODE_BID),Digits)),40,"Times New Roman",clrDodgerBlue);
   Indication("ILotTake",2,xDist2,130,StringConcatenate("Можно купить: ",DoubleToStr(LotsTake,dig)," лот"),FontSize,"Times New Roman",ColorInd);
   Indication("ILot",2,xDist2,115,StringConcatenate("Начальный лот: ",DoubleToStr(Lot,dig)),FontSize,"Times New Roman",ColorInd);
   Indication("IProfit",2,xDist2,100,StringConcatenate("Тейк профит в валюте депо: ",DoubleToStr(Profit,2)),FontSize,"Times New Roman",ColorInd);
   Indication("ISumLotBuy",2,xDist2,85,StringConcatenate("Суммарный объем Buy ордеров: ",DoubleToStr(SumLotBuy,dig)),FontSize,"Times New Roman",ColorInd);
   Indication("ISumLotSell",2,xDist2,70,StringConcatenate("Суммарный объем Sell ордеров: ",DoubleToStr(SumLotSell,dig)),FontSize,"Times New Roman",ColorInd);
   Indication("ISumlot",2,xDist2,55,StringConcatenate("Разность объемов ордеров: ",DoubleToStr(Sumlot,dig)),FontSize,"Times New Roman",ColorInd);
   Indication("IProfitBuy",2,xDist2,40,StringConcatenate("Суммарный профит Buy: ",DoubleToStr(ProfitBuy,2)),FontSize,"Times New Roman",ColBuy);
   Indication("IProfitSell",2,xDist2,25,StringConcatenate("Суммарный профит Sell: ",DoubleToStr(ProfitSell,2)),FontSize,"Times New Roman",ColSell);
   Indication("ISumProfit",2,xDist2,10,StringConcatenate("Суммарный профит: ",DoubleToStr(SumProfit,2)),FontSize,"Times New Roman",ColProf);

//-------------------------                                        
   string Integra;
   if(Total_Buy > MaxTrades || Total_Sell > MaxTrades) Integra = "Ограничение числа колен";
   Indication("IIntegra",2,10,25,Integra,FontSize,"Times New Roman",ColorInd);
  }
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование дня недели                             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    ndw - номер дня недели                                                  |
//+----------------------------------------------------------------------------+
string NameDayOfWeek(int ndw)
  {
   if(ndw==0) return("Воскресенье");
   if(ndw==1) return("Понедельник");
   if(ndw==2) return("Вторник"    );
   if(ndw==3) return("Среда"      );
   if(ndw==4) return("Четверг"    );
   if(ndw==5) return("Пятница"    );
   if(ndw==6) return("Суббота"    );
              return("День не определён");
  }
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование торговой операции                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    op - идентификатор торговой операции                                    |
//+----------------------------------------------------------------------------+
string GetNameOP(int op)
  {
   switch(op)
     {
      case OP_BUY      : return("BUY"       );
      case OP_SELL     : return("SELL"      );
      case OP_BUYLIMIT : return("BUY LIMIT" );
      case OP_SELLLIMIT: return("SELL LIMIT");
      case OP_BUYSTOP  : return("BUY STOP"  );
      case OP_SELLSTOP : return("SELL STOP" );
      default          : return("Unknown Operation");
     }
  }
//=========================================================================================================================================//
//                                                                                                                                         //
//=========================================================================================================================================//

void CloseThisSymbolAll(int _MN,int _ot=-1)
  {
   int _err = 0;
   double slip=MarketInfo(Symbol(), MODE_SPREAD)*2;
   if(slip==0) slip=1*cu;
   for(int trade=OrdersTotal()-1; trade>=0; trade--)
     {
      if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==_MN || MagicCheck()) && (OrderType()==_ot || _ot==-1))
           {
            RefreshRates();
            switch(OrderType())
              {
               case OP_BUY : _err = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), (int)slip, clrBlue); break;
               case OP_SELL: _err = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), (int)slip, clrRed ); break;
              }
            if(_err==1)
              {
               if(Info) Print("Oрдер закрыт вручную успешно");
               Sleep(500);
                 } else {
               Print("Ошибка закрытия ордера, повторяем операцию. ");
              }
           }
        }
     }
  }
//+--------------------------------------------------------------------------------------------------------------+
//| ErrorDescription. Возвращает описание ошибки по её номеру.
//+--------------------------------------------------------------------------------------------------------------+

string ErrorDescription(int error)
  {
   string ErrorNumber;
   switch(error)
     {
      case 0:
      case 1:     ErrorNumber = "Нет ошибки, но результат неизвестен";                        break;
      case 2:     ErrorNumber = "Общая ошибка";                                               break;
      case 3:     ErrorNumber = "Неправильные параметры";                                     break;
      case 4:     ErrorNumber = "Торговый сервер занят";                                      break;
      case 5:     ErrorNumber = "Старая версия клиентского терминала";                        break;
      case 6:     ErrorNumber = "Нет связи с торговым сервером";                              break;
      case 7:     ErrorNumber = "Недостаточно прав";                                          break;
      case 8:     ErrorNumber = "Слишком частые запросы";                                     break;
      case 9:     ErrorNumber = "Недопустимая операция нарушающая функционирование сервера";  break;
      case 64:    ErrorNumber = "Счет заблокирован";                                          break;
      case 65:    ErrorNumber = "Неправильный номер счета";                                   break;
      case 128:   ErrorNumber = "Истек срок ожидания совершения сделки";                      break;
      case 129:   ErrorNumber = "Неправильная цена";                                          break;
      case 130:   ErrorNumber = "Неправильные стопы";                                         break;
      case 131:   ErrorNumber = "Неправильный объем";                                         break;
      case 132:   ErrorNumber = "Рынок закрыт";                                               break;
      case 133:   ErrorNumber = "Торговля запрещена";                                         break;
      case 134:   ErrorNumber = "Недостаточно денег для совершения операции";                 break;
      case 135:   ErrorNumber = "Цена изменилась";                                            break;
      case 136:   ErrorNumber = "Нет цен";                                                    break;
      case 137:   ErrorNumber = "Брокер занят";                                               break;
      case 138:   ErrorNumber = "Новые цены - Реквот";                                        break;
      case 139:   ErrorNumber = "Ордер заблокирован и уже обрабатывается";                    break;
      case 140:   ErrorNumber = "Разрешена только покупка";                                   break;
      case 141:   ErrorNumber = "Слишком много запросов";                                     break;
      case 145:   ErrorNumber = "Модификация запрещена, так как ордер слишком близок к рынку";break;
      case 146:   ErrorNumber = "Подсистема торговли занята";                                 break;
      case 147:   ErrorNumber = "Использование даты истечения ордера запрещено брокером";     break;
      case 148:   ErrorNumber = "Количество открытых и отложенных ордеров достигло предела "; break;
      case 4000:  ErrorNumber = "Нет ошибки";                                                 break;
      case 4001:  ErrorNumber = "Неправильный указатель функции";                             break;
      case 4002:  ErrorNumber = "Индекс массива - вне диапазона";                             break;
      case 4003:  ErrorNumber = "Нет памяти для стека функций";                               break;
      case 4004:  ErrorNumber = "Переполнение стека после рекурсивного вызова";               break;
      case 4005:  ErrorNumber = "На стеке нет памяти для передачи параметров";                break;
      case 4006:  ErrorNumber = "Нет памяти для строкового параметра";                        break;
      case 4007:  ErrorNumber = "Нет памяти для временной строки";                            break;
      case 4008:  ErrorNumber = "Неинициализированная строка";                                break;
      case 4009:  ErrorNumber = "Неинициализированная строка в массиве";                      break;
      case 4010:  ErrorNumber = "Нет памяти для строкового массива";                          break;
      case 4011:  ErrorNumber = "Слишком длинная строка";                                     break;
      case 4012:  ErrorNumber = "Остаток от деления на ноль";                                 break;
      case 4013:  ErrorNumber = "Деление на ноль";                                            break;
      case 4014:  ErrorNumber = "Неизвестная команда";                                        break;
      case 4015:  ErrorNumber = "Неправильный переход";                                       break;
      case 4016:  ErrorNumber = "Неинициализированный массив";                                break;
      case 4017:  ErrorNumber = "Вызовы DLL не разрешены";                                    break;
      case 4018:  ErrorNumber = "Невозможно загрузить библиотеку";                            break;
      case 4019:  ErrorNumber = "Невозможно вызвать функцию";                                 break;
      case 4020:  ErrorNumber = "Вызовы внешних библиотечных функций не разрешены";           break;
      case 4021:  ErrorNumber = "Недостаточно памяти для строки, возвращаемой из функции";    break;
      case 4022:  ErrorNumber = "Система занята";                                             break;
      case 4050:  ErrorNumber = "Неправильное количество параметров функции";                 break;
      case 4051:  ErrorNumber = "Недопустимое значение параметра функции";                    break;
      case 4052:  ErrorNumber = "Внутренняя ошибка строковой функции";                        break;
      case 4053:  ErrorNumber = "Ошибка массива";                                             break;
      case 4054:  ErrorNumber = "Неправильное использование массива-таймсерии";               break;
      case 4055:  ErrorNumber = "Ошибка пользовательского индикатора";                        break;
      case 4056:  ErrorNumber = "Массивы несовместимы";                                       break;
      case 4057:  ErrorNumber = "Ошибка обработки глобальныех переменных";                    break;
      case 4058:  ErrorNumber = "Глобальная переменная не обнаружена";                        break;
      case 4059:  ErrorNumber = "Функция не разрешена в тестовом режиме";                     break;
      case 4060:  ErrorNumber = "Функция не подтверждена";                                    break;
      case 4061:  ErrorNumber = "Ошибка отправки почты";                                      break;
      case 4062:  ErrorNumber = "Ожидается параметр типа string";                             break;
      case 4063:  ErrorNumber = "Ожидается параметр типа integer";                            break;
      case 4064:  ErrorNumber = "Ожидается параметр типа double";                             break;
      case 4065:  ErrorNumber = "В качестве параметра ожидается массив";                      break;
      case 4066:  ErrorNumber = "Запрошенные исторические данные в состоянии обновления";     break;
      case 4067:  ErrorNumber = "Ошибка при выполнении торговой операции";                    break;
      case 4099:  ErrorNumber = "Конец файла";                                                break;
      case 4100:  ErrorNumber = "Ошибка при работе с файлом";                                 break;
      case 4101:  ErrorNumber = "Неправильное имя файла";                                     break;
      case 4102:  ErrorNumber = "Слишком много открытых файлов";                              break;
      case 4103:  ErrorNumber = "Невозможно открыть файл";                                    break;
      case 4104:  ErrorNumber = "Несовместимый режим доступа к файлу";                        break;
      case 4105:  ErrorNumber = "Ни один ордер не выбран";                                    break;
      case 4106:  ErrorNumber = "Неизвестный символ";                                         break;
      case 4107:  ErrorNumber = "Неправильный параметр цены для торговой функции";            break;
      case 4108:  ErrorNumber = "Неверный номер тикета";                                      break;
      case 4109:  ErrorNumber = "Торговля не разрешена";                                      break;
      case 4110:  ErrorNumber = "Длинные позиции не разрешены";                               break;
      case 4111:  ErrorNumber = "Короткие позиции не разрешены";                              break;
      case 4200:  ErrorNumber = "Объект уже существует";                                      break;
      case 4201:  ErrorNumber = "Запрошено неизвестное свойство объекта";                     break;
      case 4202:  ErrorNumber = "Объект не существует";                                       break;
      case 4203:  ErrorNumber = "Неизвестный тип объекта";                                    break;
      case 4204:  ErrorNumber = "Нет имени объекта";                                          break;
      case 4205:  ErrorNumber = "Ошибка координат объекта";                                   break;
      case 4206:  ErrorNumber = "Не найдено указанное подокно";                               break;
      case 4207:  ErrorNumber = "Ошибка при работе с объектом";                               break;
      default:    ErrorNumber = "Неизвестная ошибка";
     }
   return (ErrorNumber);
  }