Navigation:Home > Content >

I_NT-.mq4

Time: 2015-04-13 | Download file:I_NT-.mq4

//+------------------------------------------------------------------+
//|                                                  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=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 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 && x20) CurrentUrov=NormalizeDouble(AccountEquity()/AccountMargin()*100,0);
           }
        }
     }
  }
//=========================================================================================================================================//
// Kordan . Функция получения ордера с макс и мин значением прибыли                                                                        //
//=========================================================================================================================================// 

void GetOrdMaxNinProfit()
  {
   int    Pos   =0;
   double result=0,profit=0;
   for(int cnt=0;cnt0 && profit>Lprofit)
                 {
                  Lprofit1 = Lprofit;
                  Lpos1    = Lpos;
                  Lprofit=profit; //макс значение
                  Lpos=Pos;
                 }
               if(profit<0 && profit 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(lotFreeMargin)
     {                                                         // Если лот дороже свободных средств,
      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=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 ",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=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);
   Indicati        

Recommend