//+------------------------------------------------------------------+
//|                                                  Spring V7_8.mq4 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+

// 7_8 Изменена логика работы БУ. Usver73
// добавлен Гэп,48часов,закрытие всего
// Среднее тело
// Фильтр пятница
// шаг в зафисимости от среднего тела
// TP в зафисимости от среднего тела
// на разных ТФ
// убрал различие медведь-бык
// пересчет на 5 знаков
// исключен из торгов новый год
// анализ спрэда
// добавлен ЛОГ
#include <stdlib.mqh>
#property copyright "AAA"
#property link      "alex32926@gmail.com"
enum TypeRec
  {
   Индивидуально=1,
   Группа=2
  };
/*
#property show_inputs
enum Тайм
{
  M1,    // M1
  M5,    // M5
  M15,   // M15 
  M30,   // M30
  H1,    // H1
  H4,    // H4
  D1,    // D1
  W1     // W1
};
*/
//#property strict
//----------------------------------------------------------------------------------
extern string a0= " ВХОДНЫЕ ПАРАМЕТРЫ  STRING ";
extern string ТФ            ="W1";      // ТФ для сигнальной свечи
extern double Lots          = 0.1;   // начальный размер лота
extern double LotExponent   = 1.0;    // множитель лота для очередного шага сетки
extern int    Step          = 100;    // шаг сетки пп
extern int    Candles       = 200;    // мин размер тела   пп
extern double Slippage      = 10;      // допустимое проскальзывание при реквотах пп
extern double MaxSpread     = 2.0;      // макс спрэд для открытия позиции
extern double TakeProfit    = 50;     // по достижении скольких пунктов прибыли закрывать сетку ордеров пп
extern int    MaxTrades     = 8;      // максимально количество ордеров в сетке
extern int    Gep           = 15;     // мин гэп в пп по ходу сделки при котором ордер не открывается

extern string aa= " ПРИНУДИТЕЛЬНОЕ ЗАКРЫТИЕ 1-понедельник, 8-опция откл";
extern int    DayClose      = 8;      // день принудительного закрытия ордеров
extern int    HourClose     = 23;     // час принудительного закрытия ордеров

extern string ab= " БЕЗУБЫТОК ";
extern bool   UseBU         =false;   // перевод в БУ
extern double TakeProfitBU  = 5;     // ТП БУ
extern int    HourBU        = 48;     // через сколько часов пытаться перевести в БУ

extern string ac= " Динамический расчет сигнальной свечи (при kol_bar_sredn=0 работает Candles)";
extern int    kol_bar_sredn=0;        // глубина истории в барах
extern double K_Candles       =1;     // минимальный сигнальный бык = средний бык*K_Candles
//extern double KBearsBar       =1;     // минимальный сигнальный медведь = средний медведь*KBearsBar
extern bool   UseDinStep      = false;// пересчитывать ШАГ и ТП по средней сигнальной свече
extern double K_Step_Candles  =0.5;   // коэф. пересчета шага
extern double K_TP            =0.25;  // коэф. пересчета ТП

extern string ad= " Изучаем свечу младшего ТФ ";
extern bool   UseFriday       =false; // при открытии ордера учитывать направление последней свечи младшего ТФ
extern int    MaxCandlesFriday=50;    // макс. размер в пп последней свечи младшего ТФ в сторону сигнала при
                                      // превышении сделка отменяется
 extern string ae= " Исключаем из торгов новый год "; 
 extern bool   UseNY      =false;
 extern string DataStart  ="12.15";
 extern string DataEnd    ="01.15"; 
extern bool    otladka=false; 
                                    
string DataEndN,DataStartN;

 int TF=10080;// неделя
 int TFM;     // младший ТФ
extern int    MagicBuy      = 111;  // MagicNumber для ордеров BUY
extern int    MagicSell     = 222;  // MagicNumber для ордеров SELL
extern bool   UseLOG          =false; //писать лог
 int DD;

//----------------------------------------------------------------------------------
int NumberOfTry=5;
datetime prevtime   =0;   // признак нового периода
string EAName="Spring";

int    timeprev;
string comment;
int    returnvalue;


int    lotDecimal;

string EAstatus;

string butRemove    = "butRemove";
string butStartStop = "butStartStop";
string butClose     = "butClose";
string butCancel     = "butCancel";

color colorRemove = clrBlue;
color colorStart  = clrLimeGreen;
color colorStop   = clrRed;
color colorClose  = clrMagenta;
color colorCancel  = clrGold;

int xLab=7;
int yLab=145;//120
//bool FrezeAfterTP;
string namestatus,name;
 bool OnlyBuy,OnlySell;
 int PredHour,han;
 bool KLBU;
 //================переменные расчета эквити==============

 extern   bool           UseEQ=true;
 extern   TypeRec        TypeFile=1;
 datetime                prevtimeEQ=0;
 string                  ArrEQ[1000000];
 int                     CountAr=0; // счетчик в массиве
 int                     handle;
 //--------------------------
 int countBUY,countSELL;
 int ERR;
 int  TFEQ; 
//----------------------------------------------------------------------------------
int OnInit() 
   {
   EventSetTimer(1);
 //  FrezeAfterTP = false;
 //******************************************
  TF=10080;TFM=1440;
  if(ТФ=="M1"){TF=1;TFM=1;}
  if(ТФ=="M5"){TF=5;TFM=1;}
  if(ТФ=="M15"){TF=15;TFM=5;}
  if(ТФ=="M30"){TF=30;TFM=15;}
  if(ТФ=="H1"){TF=60;TFM=30;}
  if(ТФ=="H4"){TF=240;TFM=60;}
  if(ТФ=="D1"){TF=1440;TFM=240;}
  
  TFEQ=Period();
   if(UseLOG)
 {
   name=Symbol()+"_"+ТФ+".txt";
   han=FileOpen(name,FILE_WRITE|FILE_CSV,'\t');
    if(han!=INVALID_HANDLE)
     {
       FileWrite(han,"Дата"," ","  ","Ср.св","Тип","Тело","В.Тень","Н.Тень","VOL","ГЭП","Сигнал"," ТП","Шаг");
     }
     else 
       {Print("Операция FileOpen  неудачна, ошибка ",GetLastError());return(0);} 
 }
 //******************************************

    if (Digits == 2 || Digits == 4) DD = 1; else DD = 10;
    Candles = Candles*DD;
    Slippage = Slippage*DD;
    TakeProfit=TakeProfit*DD;
    Gep=Gep*DD;
    TakeProfitBU=TakeProfitBU*DD;
    MaxCandlesFriday=MaxCandlesFriday*DD;
    Step=Step*DD;
    MaxSpread=MaxSpread*DD;
    
 //******************************************
 
   prevtime = iTime(NULL,TF,0);
   PredHour=Hour();
   if(kol_bar_sredn > 0) DinBar();
   Init();
    
   return (INIT_SUCCEEDED);
   }
//----------------------------------------------------------------------------
void Init()
   {
   // определить статус советника
    namestatus= Symbol()+"status";
   if (!GlobalVariableCheck(namestatus)) GlobalVariableSet(namestatus,1);
   double status=GlobalVariableGet(namestatus);
   if (status==1) EAstatus="Active";
   if (status==0) EAstatus="Stop";
   if (status==2) EAstatus="Active/Cancel";
   CreateButtons();
   
   // точность расчета значения лота при открытии ордеров
   double lotStep=MarketInfo(Symbol(),MODE_LOTSTEP);
   if (lotStep==0.01) lotDecimal=2; else
   if (lotStep==0.10) lotDecimal=1; else lotDecimal=0;
   
    countBUY=CountOrders(MagicBuy);
    countSELL=CountOrders(MagicSell);
   
   double lastprice;
   double distance=0;
   if (countBUY>=countSELL && countBUY>0)
      {
      lastprice=FindLastPrice(OP_BUY, MagicBuy);
      if (Bid<lastprice && Ask<lastprice) distance=NormalizeDouble((lastprice-Ask)/Point,0);
      }
      
   if (countSELL>=countBUY && countSELL>0)
      {
      lastprice=FindLastPrice(OP_SELL, MagicSell);
      if (Ask>lastprice && Bid>lastprice)
         { 
         if (distance>0) distance=0;
         else distance=NormalizeDouble((Bid-lastprice)/Point,0);
         }
      }

 //  double ATR=NormalizeDouble(iATR(NULL,TFM,10,1)/Point,0);
 //  double ATRtoday=NormalizeDouble((iHigh(NULL,TFM,0)-iLow(NULL,TFM,0))/Point,0);
   
   Comment("Lots=",Lots,"x",LotExponent," MaxTrades=",MaxTrades," Step=",Step,"/",distance,
           " Spread=",MarketInfo(Symbol(),MODE_SPREAD),"\n",
           " Balance=",AccountBalance(),"/",AccountEquity()," Status=",EAstatus);
   
   double profit=GetProfit();
   string profitstr=DoubleToStr(GetProfit(),2)+" ("+IntegerToString(countBUY)+"/"+IntegerToString(countSELL)+")";
   CreateLabel("profit",profitstr,xLab,yLab,clrDeepSkyBlue,10);
   if (profit>=0) ObjectSet("profit", OBJPROP_COLOR, clrLimeGreen);
   
   
  
   timeprev=Time[0];
          
   }
//----------------------------------------------------------------------------
void OnDeinit(const int reason) 
   {
   EventKillTimer();
   ObjectDelete(butRemove);
   ObjectDelete(butStartStop);
   ObjectDelete(butClose);
   ObjectDelete(butCancel);
   ObjectDelete("profit");
   ObjectDelete("time");
   ObjectDelete("candles");
   ObjectDelete("candles1");
    if(UseLOG)FileClose(han);
   if(UseEQ)//если расчитываем эквити
     {
      string str;
      if (TypeFile==1)   str = "Spring Calc EQ " + Symbol() + " "+ GetNameTF (TFEQ)+".csv";
      if (TypeFile==2)   str = "Spring Calc EQ group" + GetNameTF (TFEQ)+".csv";
      
      handle=FileOpen(str,FILE_CSV|FILE_READ|FILE_WRITE," ");
      if (handle < 0) Print("Error: file " + str + " cannot be created");
      while (!FileIsEnding(handle)) 
      {
        string data = FileReadString(handle);   
      }
     if (TypeFile==1) FileWrite(handle,StringConcatenate("Пара;","Дата;","Просадка") );
     for(int i=0;i<CountAr;i++)
       {
         str=ArrEQ[i];
         FileWrite(handle,str);
       }
     } 
   }
//----------------------------------------------------------------------------
void OnTimer()
   {
   CreateLabel("time",TimeToStr(TimeCurrent(),TIME_SECONDS),5,25,clrMagenta,10);
   }
//----------------------------------------------------------------------------
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
   {
   if(id==CHARTEVENT_OBJECT_CLICK) // на объекте кликнули мышкой
      {
      string clickedChartObject=sparam;// имя объекта
      
      if(clickedChartObject==butRemove) // щелчок по кнопке Remove
         {
         ExpertRemove();
         Comment("");
         return;
         }
         
      if(clickedChartObject==butStartStop) // щелчок по кнопке StartStop
         { 
         namestatus=Symbol()+"status";
         if (EAstatus=="Active")
            {
            // остановить советник
            EAstatus="Stop";
            ObjectSetString(0,butStartStop,OBJPROP_TEXT,"EA START"); 
            ObjectSetInteger(0,butStartStop,OBJPROP_COLOR,colorStart);
            GlobalVariableSet(namestatus,0);
            OnTick();
            }
         else // EAstatus=Stop
            {
            // инициировать советник
            EAstatus="Active";
            ObjectSetString(0,butStartStop,OBJPROP_TEXT,"EA STOP"); 
            ObjectSetInteger(0,butStartStop,OBJPROP_COLOR,colorStop);
            GlobalVariableSet(namestatus,1);
            Init();
            }
         return;
         }
         
      if(clickedChartObject==butClose) // щелчок по кнопке Close
         { 
         CloseOrders();
         Init();
         return;
         }
         
         if(clickedChartObject==butCancel) // щелчок по кнопке Cancel
         {
         if(EAstatus=="Active/Cancel")
         {
          EAstatus="Active";
          GlobalVariableSet(namestatus,1);
          ObjectSetInteger(0,butCancel,OBJPROP_COLOR,colorCancel);
          Print(" Снят режим Cancel.");
          return;       
         }
         else
         {
         EAstatus="Active/Cancel";
         ObjectSetInteger(0,butCancel,OBJPROP_COLOR,colorStop);
         GlobalVariableSet(namestatus,2);
      //   FrezeAfterTP=true;
         Print(" Установлен режим Cancel. После закрытия сетки нажать Start");
         return;
         }
         }
         
      }
   }
//----------------------------------------------------------------------------
void OnTick()
   {
     
	 
    countBUY=CountOrders(MagicBuy);
    countSELL=CountOrders(MagicSell);
    if(countBUY+countSELL ==0) KLBU=false;
    double profit=GetProfit();
  // if(profit > 0) SetSL();
  //==============расчет эквити с периодом TFEQ============================  
   if(prevtimeEQ!=iTime(NULL,TFEQ,0)&& UseEQ==true)
    {
     prevtimeEQ=iTime(NULL,TFEQ,0);
     double pr_oc = AccountBalance()/100;
	  double pr_of = AccountEquity()-AccountBalance();
	  string strPr=DoubleToStr(pr_of,2);
//	  Print ("strPr Begin",strPr);//
	  int r=StringReplace(strPr,".",",");
//	  Print ("strPr End",strPr);
	  double mig_pr = pr_of/pr_oc; 	//	текущая просадка по балансу
     if(pr_of!=0)
       {
        Print ("Время ",TimeToStr (prevtimeEQ,TIME_MINUTES)," AccountEquity() " , AccountEquity() ," AccountBalance() ",AccountBalance()," Equity =",strPr, " CountAr ",CountAr);
        ArrEQ[CountAr]= StringConcatenate(Symbol(),";",TimeToStr (iTime(NULL,TFEQ,0),TIME_DATE)," ",TimeToStr (iTime(NULL,TFEQ,0),TIME_MINUTES),";", strPr);
        CountAr ++;
       }
     
    }
  //********************************************************************************** 
  //*********************** 48 часов ***************** 
   if(UseBU && countBUY+countSELL !=0 && PredHour !=iTime(NULL,1,0) )//&& profit < -Lots*MarketInfo(NULL,MODE_SPREAD)*10)
   { 
     //BEline(); // Отрисовка линии БУ
     PredHour = iTime(NULL,1,0);
     returnvalue=OrderSelect(FindErsteOrder(), SELECT_BY_TICKET, MODE_TRADES);
     if( (TimeCurrent()-OrderOpenTime())/3600 > HourBU && OrderStopLoss()==0)
       {
        SetBE();
        //SetBU();
        if(otladka)Print(" ОТЛАДКА перевод в БУ");
        if(UseLOG ) FileWrite(han,TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES)+"  Перевод в БУ");
     }    
   }
  //**************************************************
   
   if(countBUY+countSELL !=0 && DayOfWeek()==DayClose && Hour()>=HourClose)
   {Print(" Принудительное закрытие по времени"); CloseOrders();if(UseLOG ) FileWrite(han,TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES)+" Принудительное закрытие по времени");return;}    //принудит закрытие всех в день и час 1- понедельник
//***********************************************************   
   if(EAstatus=="Active/Cancel" && countBUY+countSELL==0) // нажата кнопка и нет ордеров совы
      
      {
            // остановить советник
            EAstatus="Stop";
            ObjectSetString(0,butStartStop,OBJPROP_TEXT,"EA START"); 
            ObjectSetInteger(0,butStartStop,OBJPROP_COLOR,colorStart);
            GlobalVariableSet(namestatus,0);
            ObjectSetInteger(0,butCancel,OBJPROP_COLOR,colorCancel);
            OnTick();
      }
 
   int gridDirect=0; // направление сетки: 1-вверх; (-1)-вниз; 0-не определено
   
   double lastbuyprice=0;
   double lastsellprice=0;
   double distance=0;  // расстояние от цены до ближайшего ордера
   
   if (countBUY>=countSELL && countBUY>0)
      {
      lastbuyprice=FindLastPrice(OP_BUY, MagicBuy);
      if (Bid<lastbuyprice && Ask<lastbuyprice) 
         {
         distance=NormalizeDouble((lastbuyprice-Ask)/Point,0);
         gridDirect=-1;
         }
      }
      
   if (countSELL>=countBUY && countSELL>0)
      {
      lastsellprice=FindLastPrice(OP_SELL, MagicSell);
      if (Ask>lastsellprice && Bid>lastsellprice)
         { 
         if (distance>0) 
            { // цена между ордерами
            distance=0;  
            gridDirect=0;
            }
         else 
            {
            distance=NormalizeDouble((Bid-lastsellprice)/Point,0);
            gridDirect=1;
            }
         }
      }
         
   
   string sign="Нет сигнала";
   if(OnlyBuy)sign="Работаем BUY";
   if(OnlySell)sign="Работаем SELL";
   
   
   Comment("Lots=",Lots,"x",LotExponent," MaxTrades=",MaxTrades," Step=",Step,"/",distance,
           " Spread=",MarketInfo(Symbol(),MODE_SPREAD),"/",MaxSpread,"\n",
           " Balance=",AccountBalance(),"/",AccountEquity(),
           "/",DoubleToStr(AccountFreeMargin(),2)," Status=",EAstatus,"   "," Рабочий ТФ= ",TF,"   ",sign);
   
   
   string profitstr=DoubleToStr(profit,2)+" ("+IntegerToString(countBUY)+"/"+IntegerToString(countSELL)+")";
   CreateLabel("profit",profitstr,xLab,yLab,clrDeepSkyBlue,10);
   if (profit>=0) ObjectSet("profit", OBJPROP_COLOR, clrLimeGreen);
   
   CreateLabel("candles","СРЕДНЯЯ СВЕЧА = "+IntegerToString(Candles),
               xLab,yLab+20,clrDeepSkyBlue,10);
   
   if (EAstatus=="Stop") return;

  if( MarketInfo(NULL,MODE_SPREAD) > MaxSpread) return;// если спрэд большой
  
  if( prevtime != iTime(NULL,TF,0))
   {
    prevtime = iTime(NULL,TF,0);
    
     if(kol_bar_sredn > 0 ) DinBar();   
      
   if (countBUY==0 && countSELL==0 ) // нет открытых ордеров
      { 
         Signal();
         
      if(Month()==12){ int year=Year(); DataStartN=IntegerToString(year)+"."+DataStart;DataEndN=IntegerToString(year+1)+"."+DataEnd;}
        // if(otladka) Print(" ОТЛАДКА TimeCurrent(),TIME_DATE= ",TimeToStr(TimeCurrent(),TIME_DATE));
        
         if(UseNY && TimeToStr(TimeCurrent(),TIME_DATE)> DataStartN && TimeToStr(TimeCurrent(),TIME_DATE)< DataEndN) return;
                         
         if(OnlyBuy)
         {// открыть первый ордер BUY 
         comment=EAName+"-"+Symbol()+"-1";
         RefreshRates();
         int ticket = OpenOrder(OP_BUY,Lots,comment,MagicBuy,clrLime);
            if (ticket>0) 
               {
               SetTakeProfit(OP_BUY,MagicBuy);
               }
               else {ERR=GetLastError(); if(ERR==129||ERR==128||ERR==136||ERR==132){prevtime=0;Sleep(10000);}}
         return;
         }
         
         if(OnlySell)
   
         {// открыть первый ордер SELL 
         comment=EAName+"-"+Symbol()+"-1";
         RefreshRates();
         ticket = OpenOrder(OP_SELL,Lots,comment,MagicSell,clrHotPink);
           if (ticket>0) 
               {
               SetTakeProfit(OP_SELL,MagicSell);
               }
               else {ERR=GetLastError(); if(ERR==129||ERR==128||ERR==136||ERR==132){prevtime=0;Sleep(10000);}}
         return;
         }
      }
 
   }// конец анализа открытия первого ордера на выбранном ТФ
   
      if (countBUY==0 && countSELL==0) return; // нет открытых ордеров
        
 //*****************************************************************************************
         
      //  -- построение сетки ----
          
      if (distance >= Step)
         {
         // открыть новый ордер в направлении сетки
         if (gridDirect==1 && countSELL < MaxTrades)
            {
            // открыть новый сеточный ордер SELL
            comment=EAName+"-"+Symbol()+"-"+(countSELL+1)+"-"+Step;
            double nextLots = NormalizeDouble(Lots*MathPow(LotExponent, countSELL), lotDecimal);
            RefreshRates();
            ticket=OpenOrder(OP_SELL,nextLots,comment,MagicSell,clrHotPink);
            if (ticket>0) 
               {
               SetTakeProfit(OP_SELL,MagicSell);
               if(UseLOG ) FileWrite(han,TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES)+"  Открытие очередного ордера сетки SELL");
               }
            return;
            }
            
         if (gridDirect==-1 && countBUY<MaxTrades)
            {
            // открыть новый сеточный ордер BUY
            comment=EAName+"-"+Symbol()+"-"+(countBUY+1)+"-"+Step;
            nextLots = NormalizeDouble(Lots*MathPow(LotExponent, countBUY), lotDecimal);
            RefreshRates();
            ticket=OpenOrder(OP_BUY,nextLots,comment,MagicBuy,clrLime);
            if (ticket>0) 
               {
               SetTakeProfit(OP_BUY,MagicBuy);
               if(UseLOG ) FileWrite(han,TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES)+"  Открытие очередного ордера сетки BUY");
               }
            return;
            }
         } // distance >= Step
      }
 

//----------------------------------------------------------------------------     
void SetTakeProfit(int orderType, int orderMagic)
   {
   double avgPrice = 0;
   double sumLots  = 0;
   for (int order=OrdersTotal()-1; order >= 0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && OrderMagicNumber()==orderMagic) 
         {
         avgPrice += OrderOpenPrice()*OrderLots();
         sumLots  += OrderLots();
         }
      }
   
   double newTakeProfit=avgPrice/sumLots;
   
   if (orderType==OP_BUY) 
      newTakeProfit=newTakeProfit+TakeProfit*Point; 
   else 
      newTakeProfit=newTakeProfit-TakeProfit*Point;
      newTakeProfit=NormalizeDouble(newTakeProfit,Digits);
   
   for (order=OrdersTotal()-1; order>=0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && OrderMagicNumber()==orderMagic) 
         {
         returnvalue=OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),newTakeProfit,0,clrYellow);
         }
      }
   }      
//----------------------------------------------------------------------------  
void SetBU()
   {
   double avgPrice = 0;
   double sumLots  = 0;
   for (int order=OrdersTotal()-1; order >= 0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && (OrderMagicNumber()==MagicBuy || OrderMagicNumber()==MagicSell)) 
         {
         avgPrice += OrderOpenPrice()*OrderLots();
         sumLots  += OrderLots();
         }
      }
   
   double newTakeProfit=avgPrice/sumLots;
   
   if (OrderType()==OP_BUY) 
      newTakeProfit=newTakeProfit+TakeProfitBU*Point; 
   else 
      newTakeProfit=newTakeProfit-TakeProfitBU*Point;
 
      newTakeProfit=NormalizeDouble(newTakeProfit,Digits);

   if(otladka) Print(" ОТЛАДКА уровень БУ= ",newTakeProfit);
   
   for (order=OrdersTotal()-1; order>=0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && (OrderMagicNumber()==MagicBuy || OrderMagicNumber()==MagicSell)) 
         {
         returnvalue=OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),newTakeProfit,0,clrYellow);
         }
      }
   }      
//**************************************************************************** 
void SetBE()
  {
   double lots=0;
   double sum=0;

   
   double BuyLots=0;
   double SellLots=0;
   double BuyProfit=0;
   double SellProfit=0;
   int Total=OrdersTotal();
   for (int i=0;i<Total;i++)
   {
    
    if (OrderSelect(i,SELECT_BY_POS))
    {
     if (OrderSymbol()!=Symbol()) continue;
     if (OrderType()==OP_BUY)
     {
      BuyLots=BuyLots+OrderLots();
      BuyProfit=BuyProfit+NormalizeDouble(OrderProfit()+OrderCommission()+OrderSwap(),2);
     }
     if (OrderType()==OP_SELL)
     {
      SellLots=SellLots+OrderLots();
      SellProfit=SellProfit+NormalizeDouble(OrderProfit()+OrderCommission()+OrderSwap(),2);
     }
    }
   }
   double Price=0;
   double TickValue=MarketInfo(Symbol(),MODE_TICKVALUE);
   int    StopLvl  =MarketInfo(Symbol(),MODE_STOPLEVEL);
   bool   setBE=false;
   if ((BuyLots-SellLots)>0) 
    {
     Price=NormalizeDouble(Bid-(BuyProfit+SellProfit)/(TickValue*(BuyLots-SellLots))*Point+TakeProfitBU*Point,Digits);
//     Price=NormalizeDouble(Price+TakeProfitBU*Point,Digits);
     if (Price<(Bid-StopLvl*Point))
      {
       setBE=true;
      } 
    } 
   if ((SellLots-BuyLots)>0) 
    {
     Price=NormalizeDouble(Ask+(BuyProfit+SellProfit)/(TickValue*(SellLots-BuyLots))*Point-TakeProfitBU*Point,Digits);  
     if(Price>(Ask+StopLvl*Point))
      {
       setBE=true;
      }
    }  
   if (setBE)
    {
     for (int k=Total-1;k>=0;k--) 
       {
        if (OrderSelect(k, SELECT_BY_POS, MODE_TRADES))
         {
          if (OrderSymbol()==Symbol() && (OrderMagicNumber()==MagicBuy || OrderMagicNumber()==MagicSell) && OrderStopLoss()==0) 
           {
            Print("Установка SL. цена ", Price," ордер ",OrderTicket()," OrderType ", OrderType(), " Magic ", OrderMagicNumber(), " Order SL ", OrderStopLoss(), " Order  TP ", OrderTakeProfit() );
            returnvalue=ModifyOrder(-1,Price,0,CLR_NONE);
           }
         }
       }
     }
  }

 

  void SetSL()
   {
  
   for (int order=OrdersTotal()-1; order>=0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && (OrderMagicNumber()==MagicBuy || OrderMagicNumber()==MagicSell)&& OrderProfit() >= 25) 
         {
         double newSL=NormalizeDouble(OrderOpenPrice(),Digits);
         returnvalue=OrderModify(OrderTicket(),OrderOpenPrice(),newSL,OrderTakeProfit(),0,clrYellow);
          if(otladka) Print(" ОТЛАДКА установка СЛ= ",newSL);
         }
      }
   }      
//**************************************************************************** 
int OpenOrder(int orderType, double orderLots, string orderComment, int orderMagic, color orderColor) 
   {
   double orderPrice;
   string orderdirect;
   if (orderType==OP_BUY) 
      {
      orderPrice=Ask; 
      orderdirect="BUY";
      }
   else 
      {
      orderPrice=Bid;
      orderdirect="SELL";
      }
   
   int opencount = 1;
   while (opencount<=10) // 10 попыток открытия
      {
      RefreshRates();
      int ticket=OrderSend(Symbol(),orderType,orderLots,orderPrice,Slippage,0,0,orderComment,orderMagic,0,orderColor);
      if(ticket == -1)
         {
         int error = GetLastError();
         Print(EAName," -- Error opening ",orderdirect," order : ",error," -- ",ErrorDescription(error)); 
         opencount++;
         Sleep(2000);
         }
      else 
         return(ticket);
      }
   // ордер открыть не удалось      
   return (-1);
   }
//----------------------------------------------------------------------------
double FindLastPrice(int orderType, int orderMagic) 
   {
   double lastprice = 0;
   int ticketnumber = 0;
   for (int order=OrdersTotal()-1; order>=0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() == Symbol() && OrderType() == orderType && OrderMagicNumber() == orderMagic) 
         {
         if (OrderTicket() > ticketnumber) 
            {
            lastprice = OrderOpenPrice();
            ticketnumber = OrderTicket();
            }
         }
      }
   return (lastprice);
   }
//*******************************************************************************
  int FindErsteOrder() //поиск самого раннего ордера
   {
   
   long ticketnumber = 99999999999999;
   for (int order=OrdersTotal()-1; order>=0; order--) 
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() == Symbol() ) 
         {
         if (OrderTicket() < ticketnumber) 
            {          
            ticketnumber = OrderTicket();
            }
         }
      }
   return (ticketnumber);
   }
//----------------------------------------------------------------------------
int CountOrders(int orderMagic)
   {
   int count=0;
   for (int order=OrdersTotal()-1; order>=0; order--)
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && OrderMagicNumber()==orderMagic)
         {
         count++;
         }
      }
   return(count);
   }
//----------------------------------------------------------------------------------
void CloseOrders()
   {
   for (int order=OrdersTotal()-1; order>=0; order--)
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && (OrderMagicNumber()==MagicSell || OrderMagicNumber()==MagicBuy))
         {
         if (OrderType()==OP_BUY) returnvalue=OrderClose(OrderTicket(),OrderLots(),Bid,100); 
         if (OrderType()==OP_SELL) returnvalue=OrderClose(OrderTicket(),OrderLots(),Ask,100);            
         }
      }
   return;
   }
//----------------------------------------------------------------------------
double GetProfit()
   {
   double profit=0;
   for (int order=OrdersTotal()-1; order>=0; order--)
      {
      returnvalue=OrderSelect(order, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol()==Symbol() && (OrderMagicNumber()==MagicSell || OrderMagicNumber()==MagicBuy))
         {
         profit=profit+OrderProfit()+OrderCommission()+OrderSwap();
         }
      }
   return(profit);
   }
//----------------------------------------------------------------------------
void CreateButtons()
   {
   int Xbut=70;
   int YbutRemove=45;
   int YbutStartStop=YbutRemove+25;
   int YbutClose=YbutStartStop+25;
   int YbutCancel=YbutClose+25;
   
   int butW=65;
   int butH=20;
   
   CreateButton(butRemove,Xbut,YbutRemove,butW,butH,"EA REMOVE","");
   ObjectSetInteger(0,butRemove,OBJPROP_COLOR,colorRemove);
   
   if (EAstatus=="Active") 
      {
      CreateButton(butStartStop,Xbut,YbutStartStop,butW,butH,"EA STOP","");
      ObjectSetInteger(0,butStartStop,OBJPROP_COLOR,colorStop);
      }
   else // EAstatus=Stop
      {
      CreateButton(butStartStop,Xbut,YbutStartStop,butW,butH,"EA START","");
      ObjectSetInteger(0,butStartStop,OBJPROP_COLOR,colorStart);
      }
   
   CreateButton(butClose,Xbut,YbutClose,butW,butH,"CLOSE","");
   ObjectSetInteger(0,butClose,OBJPROP_COLOR,colorClose);
   
   CreateButton(butCancel,Xbut,YbutCancel,butW,butH,"CANCEL","");
   ObjectSetInteger(0,butCancel,OBJPROP_COLOR,colorCancel);
   
   }
//----------------------------------------------------------------------------
void CreateButton(string buttonName, int Xbutton, int Ybutton, int Xsize, int Ysize, string textButton, string textToolTip)
   {
   if (ObjectFind(0,buttonName) < 0)
      {
      ResetLastError();
      if (!ObjectCreate(0,buttonName,OBJ_BUTTON,0,0,0))
         {
         Print("Ошибка создания объекта ",buttonName," код ошибки - ",GetLastError());
         return;
         }
      }
      
   ObjectSet(buttonName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
   ObjectSetInteger(0,buttonName,OBJPROP_BGCOLOR,White);
   ObjectSetInteger(0,buttonName,OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,buttonName,OBJPROP_XDISTANCE,Xbutton);
   ObjectSetInteger(0,buttonName,OBJPROP_YDISTANCE,Ybutton);
   ObjectSetInteger(0,buttonName,OBJPROP_XSIZE,Xsize);
   ObjectSetInteger(0,buttonName,OBJPROP_YSIZE,Ysize);
   ObjectSetInteger(0,buttonName,OBJPROP_STATE,false);
   ObjectSetString(0,buttonName,OBJPROP_FONT,"Arial");
   ObjectSetString(0,buttonName,OBJPROP_TEXT,textButton);
   ObjectSetInteger(0,buttonName,OBJPROP_FONTSIZE,7);
   ObjectSetInteger(0,buttonName,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(0,buttonName,OBJPROP_SELECTED,false);
   ObjectSetString(0,buttonName,OBJPROP_TOOLTIP,textToolTip);
   }
//--------------------------------------------------------------------------
void CreateLabel(string objname, string text, int x, int y, color colr, int fontsize) 
   {
   if (ObjectFind(objname) < 0)
      {
      ResetLastError();
      if (!ObjectCreate(objname, OBJ_LABEL, 0, 0, 0))
         {
         Print("Ошибка создания объекта ",objname," код ошибки - ",GetLastError());
         return;
         }
      }
   ObjectSetText(objname, text);
   ObjectSet(objname, OBJPROP_COLOR, colr);
   ObjectSet(objname, OBJPROP_XDISTANCE, x);
   ObjectSet(objname, OBJPROP_YDISTANCE, y);
   ObjectSet(objname, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
   ObjectSetString (0,objname,OBJPROP_FONT,"Calibri");
   ObjectSetInteger(0,objname,OBJPROP_FONTSIZE, fontsize);
   ObjectSetInteger(0,objname,OBJPROP_SELECTABLE,false);
   ObjectSetString (0,objname,OBJPROP_TOOLTIP,"\n");
   }
//--------------------------------------------------------------------------
 void Signal()
 {
    if(countBUY+countSELL !=0) return; 
   OnlyBuy=false; OnlySell=false;
   double open=iOpen(NULL,TF,1);
   double close=iClose(NULL,TF,1);
   double open0=iOpen(NULL,TF,0);
   int gep=0;
   
   double openDay=iOpen(NULL,TFM,1);
   double closeDay=iClose(NULL,TFM,1);
   int CandFriday=MathAbs((openDay-closeDay)/Point());
   string TypeCandFriday; 
   string Friday="NO";
   if(openDay < closeDay) TypeCandFriday="B"; else TypeCandFriday="S";
   
    if(UseLOG)
   {
     string Typ="ВОЛ",SS,Telo,VT,NT,VOL,GEP,SIG="NO",TP,ST,soob="";
     int telo,vt,nt,ggep,vol;
    
    string Data=TimeToStr(Time[1],TIME_DATE|TIME_MINUTES);
    
    if(open < close) Typ="БЫК"; if(open > close)Typ="МЕД"; 
    
    if(Typ=="БЫК"||Typ=="ВОЛ") 
       {vt=(iHigh(NULL,TF,1)-close)/Point; nt=(open-iLow(NULL,TF,1))/Point; 
        telo=(close-open)/Point; if(telo> Candles)SIG="SELL";}
        
    if(Typ=="МЕД"||Typ=="ВОЛ") 
       {vt=(iHigh(NULL,TF,1)-open)/Point; nt=(close-iLow(NULL,TF,1))/Point; 
        telo=(open-close)/Point; if(telo> Candles) SIG="BUY";}
        
       vol=iVolume(NULL,TF,1);
       ggep=(open0-close)/Point;
       
    Telo=IntegerToString(telo);
    VT=IntegerToString(vt);
    NT=IntegerToString(nt);
    GEP=IntegerToString(ggep);
    VOL=IntegerToString(vol);
    SS=IntegerToString(Candles);
    TP=IntegerToString(TakeProfit);
    ST=IntegerToString(Step);
    
   FileWrite(han,Data,SS,Typ,Telo,VT,NT,VOL,GEP,SIG,TP,ST);
   }
 
   // предыдущий бык
   if( open<close)
   { 
     if((close-open)/Point() >= Candles && (close-open0)/Point() < Gep) {OnlySell=true;}
        else { if((close-open)/Point() < Candles)  soob=" Сигнальная свеча меньше средней";
               if((close-open0)/Point() >= Gep)    soob=soob +" Большой ГЭП "; }
   }           
   // предыдущий медведь
   if( open>close )
      if( (open-close)/Point() >= Candles && (open0-close)/Point() < Gep ) {OnlyBuy=true;}
           else { if((open-close)/Point() < Candles)  soob=" Сигнальная свеча меньше средней";
               if((open0-close)/Point() >= Gep)    soob=soob +" Большой ГЭП "; } 
    
       if(UseFriday && CandFriday>=MaxCandlesFriday && ((OnlySell && TypeCandFriday=="S") || (OnlyBuy && TypeCandFriday=="B")))
          {if(UseLOG ) FileWrite(han," Запрет на открытие ордера свечой пятницы "); OnlyBuy=false; OnlySell=false; Friday="YES";}
       
   if( open<close)
      {gep=(open0-close)/Point();
       CreateLabel("candles1","СИГНАЛЬНЫЙ БЫК = "+IntegerToString((close-open)/Point())+" / ГЕП="+IntegerToString(gep)
                    +" Пятница- "+Friday,xLab,yLab+40,clrDeepSkyBlue,10); }             
   
   if( open>close)
     {gep=(close-open0)/Point();
      CreateLabel("candles1","СИГНАЛЬНЫЙ МЕДВЕДЬ = "+IntegerToString((open-close)/Point())+" / ГЕП="+IntegerToString(gep)
                    +" Пятница- "+Friday,xLab,yLab+40,clrDeepSkyBlue,10);}
   if(otladka)Print(" ОТЛАДКА сигнал время =",TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES));
   if(UseLOG && soob != "") FileWrite(han,soob);
 } 
 //*****************************************
 void DinBar()
 {
  double Cand;
   Cand=Opred_sredn_spread(1, MathMin(kol_bar_sredn,Bars-1));
 
   Candles=Cand*K_Candles;
 
   if(!UseDinStep)return;
   Step=Candles*K_Step_Candles;
   TakeProfit= Candles*K_TP;
   return;
 }
 //******************************************
 double Opred_sredn_spread(int begin_bar, int end_bar)
{
   double sum=0;
   int n=0;
   for (int i=begin_bar;i<=end_bar;i++)
   {
      n++;
      sum+=MathAbs(iOpen(NULL,TF,i)-iClose(NULL,TF,i))/Point;
   }
   if (n==0)return(0);
   return(sum/n);
}
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование таймфрейма                             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    TimeFrame - таймфрейм (количество секунд)      (0 - текущий ТФ)         |
//+----------------------------------------------------------------------------+
string GetNameTF(int TimeFrame=0) {
  if (TimeFrame==0) TimeFrame=Period();
  switch (TimeFrame) {
    case PERIOD_M1:  return("M1");
    case PERIOD_M5:  return("M5");
    case PERIOD_M15: return("M15");
    case PERIOD_M30: return("M30");
    case PERIOD_H1:  return("H1");
    case PERIOD_H4:  return("H4");
    case PERIOD_D1:  return("Daily");
    case PERIOD_W1:  return("Weekly");
    case PERIOD_MN1: return("Monthly");
    default:         return("UnknownPeriod");
  }
}
//+------------------------------------------------------------------+ 
//| Создает горизонтальную линию                                     + 
//+------------------------------------------------------------------+ 
void PutHLine(long               chart_ID=0,        // ID графика 
                 string          LineName="",            // имя линии 
                 double          price=0,           // цена линии 
                 color           clr=clrBlue,       // цвет линии 
                 ENUM_LINE_STYLE style=STYLE_SOLID, // стиль линии 
                 int             width=1,           // толщина линии 
                 bool            selectable=true,    // выделить для перемещений
                 string          comm="")    
   { 
   if (ObjectFind(LineName)<0)
    {     
      if(!ObjectCreate(chart_ID,LineName,OBJ_HLINE,0,0,price)) 
       {
          Print(__FUNCTION__, 
           ": не удалось создать горизонтальную линию! Код ошибки = ",GetLastError());
            return; 
       } 
    } 
   ObjectSetDouble (chart_ID,LineName,OBJPROP_PRICE1,price);
   ObjectSetInteger(chart_ID,LineName,OBJPROP_COLOR,clr); 
   ObjectSetInteger(chart_ID,LineName,OBJPROP_STYLE,style); 
   ObjectSetInteger(chart_ID,LineName,OBJPROP_WIDTH,width); 
   ObjectSetInteger(chart_ID,LineName,OBJPROP_SELECTABLE,selectable); 
   ObjectSetInteger(chart_ID,LineName,OBJPROP_SELECTED,true); 
   ObjectSetString (chart_ID,LineName,OBJPROP_TEXT,comm);
//   ObjectSetInteger(chart_ID,LineName,OBJPROP_STYLE,style); 
   ObjectSetInteger(chart_ID,LineName,OBJPROP_BACK,true);
  } 
  //+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.11.2006                                                     |
//|  Описание : Модификация одного предварительно выбранного ордера.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    pp - цена установки ордера                                              |
//|    sl - ценовой уровень стопа                                              |
//|    tp - ценовой уровень тейка                                              |
//|    cl - цвет значка модификации                                            |
//+----------------------------------------------------------------------------+
int ModifyOrder(double pp=-1, double sl=0, double tp=0, color cl=CLR_NONE) 
{
  bool   fm;
  double op, pa, pb, os, ot;
  int    dg=Digits, er, it;
  if (pp<=0) pp=OrderOpenPrice();
  if (sl<0 ) sl=OrderStopLoss();
  if (tp<0 ) tp=OrderTakeProfit();
  
  pp=NormalizeDouble(pp, dg);
  sl=NormalizeDouble(sl, dg);
  tp=NormalizeDouble(tp, dg);
  op=NormalizeDouble(OrderOpenPrice() , dg);
  os=NormalizeDouble(OrderStopLoss()  , dg);
  ot=NormalizeDouble(OrderTakeProfit(), dg);

  if (pp!=op || sl!=os || tp!=ot) 
  {
    for (it=1; it<=NumberOfTry; it++) 
    {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(), pp, sl, tp, 0, cl);
      if (fm) 
      {
       return (true) ; break;
      } 
      else 
      {
        er=GetLastError();
        pa=MarketInfo(OrderSymbol(), MODE_ASK);
        pb=MarketInfo(OrderSymbol(), MODE_BID);
        Print("Error(",er,") modifying order: ",", try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
              "  op="+GetNameOP(OrderType()),"  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
        return (false) ; break;
      }
    }
  }
 return (-1);
}
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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");
  }
}
//#######################################################################
int BEline()
  {
//----+
  GetDell("label");int i;
  /*
  string char[256]; 
  for (i = 0; i < 256; i++) char[i] = CharToStr(i);
  string txt =  char[70]+char[97]+char[99]+char[116]+char[111]+char[114]+char[121]+char[32]
  +char[111]+char[102]+char[32]+char[116]+char[104]+char[101]+char[32]+char[97]
  +char[100]+char[118]+char[105]+char[115]+char[101]+char[114]+char[115]+char[58]
  +char[32]+char[121]+char[117]+char[114]+char[105]+char[121]+char[116]+char[111]
  +char[107]+char[109]+char[97]+char[110]+char[64]+char[103]+char[109]+char[97]
  +char[105]+char[108]+char[46]+char[99]+char[111]+char[109];Label("label",txt,2,3,15);*/
//----+
   GetDell("ytg_s");
   double lots=0;
   double sum=0;
   for (i=0; i<OrdersTotal(); i++)
   {
      if (!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) continue;
      if (OrderSymbol()!=Symbol()) continue;
      if (OrderType()==OP_BUY)
      {
       lots=lots+OrderLots();
       sum=sum+OrderLots()*OrderOpenPrice();
      }
      if (OrderType()==OP_SELL)
      {
       lots=lots-OrderLots();
       sum=sum-OrderLots()*OrderOpenPrice();
      }
   }
   double price=0;
   if (lots!=0) price=sum/lots;
   string title="Уровень безубытка";
   string lossfree=" не существует";
   if (price>0) lossfree=" = "+DoubleToStr(price,Digits);
   string msg="Уровень безубытка для "+Symbol()+lossfree+"     ";
   string line_name = "ytg_s  " + TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS);     
   SetHLine(Aqua,line_name,price);   
//   Alert(msg);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Функция создаёт горизонтальную линию                             |
//| автор: Юрий Токмань                                              |
//| e-mail: yuriytokman@gmail.com                                    |
//| ICQ#    481-971-287                                              |
//| Skype:  yuriy.g.t                                                |
//+------------------------------------------------------------------+
void SetHLine(color cl, string nm="", double p1=0, int st=0, int wd=1) 
 {
  if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_HLINE, 0, 0,0);
  ObjectSet(nm, OBJPROP_PRICE1, p1);
  ObjectSet(nm, OBJPROP_COLOR , cl);
  ObjectSet(nm, OBJPROP_STYLE , st);
  ObjectSet(nm, OBJPROP_WIDTH , wd);
 }
//+------------------------------------------------------------------+
//| Функция удаляет объекты с указанным именем                       |
//| автор: Юрий Токмань                                              |
//| e-mail: yuriytokman@gmail.com                                    |
//| ICQ#    481-971-287                                              |
//| Skype:  yuriy.g.t                                                |
//+------------------------------------------------------------------+ 
void GetDell( string _name)
 {
  string vName;
  for(int i=ObjectsTotal()-1; i>=0;i--)
   {
    vName = ObjectName(i);
    if (StringFind(vName,_name) !=-1) ObjectDelete(vName);
   }
 }
//+----------------------------------------------------------------------+
//| Описание: Создание текстовой метки                                   | 
//| Автор:    Юрий Токмань                                               |
//| e-mail:   yuriytokman@gmail.com                                      |
//+----------------------------------------------------------------------+
 void Label(string name_label,           //Имя объекта.
            string text_label,           //Текст обьекта. 
            int corner = 2,              //Hомер угла привязки 
            int x = 3,                   //Pасстояние X-координаты в пикселях 
            int y = 15,                  //Pасстояние Y-координаты в пикселях 
            int font_size = 10,          //Размер шрифта в пунктах.
            string font_name = "Arial",  //Наименование шрифта.
            color text_color = LimeGreen //Цвет текста.
           )
  {
   if (ObjectFind(name_label)!=-1) ObjectDelete(name_label);
       ObjectCreate(name_label,OBJ_LABEL,0,0,0,0,0);         
       ObjectSet(name_label,OBJPROP_CORNER,corner);
       ObjectSet(name_label,OBJPROP_XDISTANCE,x);
       ObjectSet(name_label,OBJPROP_YDISTANCE,y);
       ObjectSetText(name_label,text_label,font_size,font_name,text_color);
  }