8_2_5

//-----------------------------------------------------------------------------+
#property copyright "Copyright © 2010, Trishkin Artyom A."
#property link      "support@goldsuccess.ru"
//-----------------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>
//==============================================================================
// --------------------------- Ïåðåìåííûå ñîâåòíèêà ---------------------------+
//==============================================================================
extern string P_Expert= "-- Experts Variables --";
extern bool   TradeBuy=true;                                   // Òîðãîâëÿ â Buy, true = ðàçðåøåíà, false = íå ðàçðåøåíà
extern bool   TradeSell=false;                                  // Òîðãîâëÿ â Sell, true = ðàçðåøåíà, false = íå ðàçðåøåíà
extern bool   UseEquClose=false;                                // Èñïîëüçîâàòü ëè ô-öèþ çàêðûòèÿ ïî ýêâèòè true = äà, false = íåò
extern bool   TrackLossEquity=false;                            // Èñïîëüçîâàòü ëè çàêðûòèå ïî ýêâèòè â ïðîñàäêå true = äà, false = íåò
//-------------------------------------
extern double StartLots=1;  // ïåðâîíà÷àëüíûé ëîò.
extern double MaxLots=100;  // äî ñòîëüêè ìîæíî óâåëè÷èâàòü ñòàðò-ëîò ñ êàæäûì íîâûì ðûíî÷íûì îðäåðîì.
extern double DeltaLots=3; // íà ñòîëüêî óâåëè÷èâàåòñÿ ñòàðò-ëîò.
//------------------------------------- 
extern int obSL=0; // Èñïîëüçîâàòü îáùèé ñòîï-ëîññ èëè íåò. 0-íå èñïîëüçîâàòü. Ëþáîå öåëîå ÷èñëî áîëüøå 0 - èñïîëüçîâàòü.
extern int    stoploss=100;                                     // Ñòîï-ëîññ
extern int    TakeProfit=100;                                   // Ðàçìåð TakeProfit â ïóíêòàõ
extern int    DistanceOpenPositions=100;                             // Äèñòàíöèÿ óñòàíîâêè îðäåðîâ â ïï
extern double PercentEquityForClose=0;                       // Ïðîöåíò ïðèðîñòà ýêâèòè äëÿ çàêðûòèÿ óáûòî÷íûõ ïîçèöèé
extern double PercentLossEquityForClose=0;                   // Ïðîöåíò ïàäåíèÿ ýêâèòè äëÿ çàêðûòèÿ óáûòî÷íûõ ïîçèöèé
extern int    NumberLossPoseForCloseEquUP=0;                   // Êîëè÷åñòâî çàêðûâàåìûõ óáûòî÷íûõ ïîçèöèé ïðè óâåëè÷åíèè ýêâèòè
extern int    NumberLossPoseForCloseEquDN=0;                   // Êîëè÷åñòâî çàêðûâàåìûõ óáûòî÷íûõ ïîçèöèé ïðè ïðîñàäêå ýêâèòè
//------- Ïàðàìåòðû èñïîëíåíèÿ òîðãîâûõ ïðèêàçîâ ------------------------------+
extern string P_Performanc= "-- Parameters for Trades --";
extern int    NumberOfTry = 5;                                 // Êîëè÷åñòâî òîðãîâûõ ïîïûòîê ïðè îøèáêàõ
extern int    Slippage    = 3;                                 // Âåëè÷èíà ïðîñêàëüçûâàíèÿ öåíû
extern bool   UseSound    = false;                              // Èñïîëüçîâàòü çâóêîâîé ñèãíàë
string        SoundSuccess= "ok.wav";                          // Çâóê óñïåõà
string        SoundError  = "timeout.wav";                     // Çâóê îøèáêè
string        SoundClose  = "Close_order.wav";                 // Çâóê çàêðûòèÿ
//==============================================================================
int      tf, dg, sp;
int      Magic, Level_old, Level_new, TradeDirection;
int      NumberUpLevels=1;                                     // Êîëè÷åñòâî óðîâíåé âûøå öåíû
int      NumberDnLevels=1;                                     // Êîëè÷åñòâî óðîâíåé íèæå öåíû
int      MassUpLen, MassDnLen;
string   Prefix, Exp_Name, NameGL_Equ, NameGL_Add, NameGL_Loss, PriceFirstSell;
string   end1, end2, type, sy;
color    clUP, clDN;
double   EquStart, EquAdd, EquClose, EquLoss, EquPercLoss;
double   CenterLevel, GL_CenterLevel, PointX;
//double   pGL1, pGL2;
double Lots;
double   pa, pb;
double   MassUpLev[5];
double   MassDnLev[5];
double   MassCtLev[1];
double   HighestLev;
double   LowestLev;
bool     CloseFact=true;
bool     FirstStart=true;
//bool     WriteAboutFStart=false;
//==============================================================================
//---------------------- Ïåðåìåííûå äëÿ ôóíêöèé--------------------------------+
//==============================================================================
bool   AllMessages, PrintEnable;
color  clOpenBuy    = MediumBlue;      // Öâåò çíà÷êà îòêðûòèÿ ïîêóïêè
color  clOpenSell   = OrangeRed;       // Öâåò çíà÷êà îòêðûòèÿ ïðîäàæè
color  clCloseBuy   = Blue;            // Öâåò çíà÷êà çàêðûòèÿ ïîêóïêè
color  clCloseSell  = IndianRed;       // Öâåò çíà÷êà çàêðûòèÿ ïðîäàæè
color  clModifyBuy  = DodgerBlue;      // Öâåò çíà÷êà ìîäèôèêàöèè ïîêóïêè
color  clModifySell = Tomato;          // Öâåò çíà÷êà ìîäèôèêàöèè ïðîäàæè
color  clDelete     = Yellow;          // Öâåò çíà÷êà óäàëåíèÿ îðäåðà
bool   MarketWatch  = True;            // Çàïðîñû ïîä èñïîëíåíèå "Market Watch".
bool   gbDisabled   = False;           // Ôëàã áëîêèðîâêè ñîâåòíèêà
int    modeSetOrders= 1;               // Ñïîñîá óñòàíîâêè îðäåðîâ:
                                       //  0 - ïî çàäàííîé öåíå
                                       //  1 - ñêîððåêòèðîâàòü öåíû
                                       //  2 - âõîä ïî òåêóùèì öåíàì
//----------------------------------------------------------------
//==============================================================================
int init()
{
   tf=Period();
   sy=Symbol();
   pa=MarketInfo(sy,MODE_ASK);
   pb=MarketInfo(sy,MODE_BID);
   dg=MarketInfo(sy,MODE_DIGITS);
   Level_old=MarketInfo(Symbol(),MODE_STOPLEVEL );             // Ìèíèì. äèñòàíèöèÿ óñòàíîâêè ñòîïîâ
   if(Digits==5 || Digits==3) PointX = Point * 10;             // Êîððåêòèðîâêà Point ïîä òð¸õ- ïÿòèçíàê
   if(Digits==4 || Digits==2) PointX = Point;
   Exp_Name=WindowExpertName();                                // Èìÿ ýêñïåðòà
   Prefix=Exp_Name+"_M"+Period();                              // Ïðåôèêñ äëÿ èì¸í îáúåêòîâ
   Magic=GetMagic(Exp_Name+Symbol(),Period());                 // Ìàãèê îðäåðîâ
   NameGL_Equ=Prefix+"_GL_Equ";
   NameGL_Add=Prefix+"_GL_Add";
   NameGL_Loss=Prefix+"_GL_Loss";
   PriceFirstSell=Prefix+"_GL_PFSell";
   if(!GlobalVariableCheck(NameGL_Equ)) {                      // Åñëè íåòó ãëîáàëüíîé ïåðåìåííîé òåðìèíàëà ñ èìåíåì NameGL_Equ
      EquStart=AccountEquity();                                // Ñòàðòîâûé ýêâèòè = ýêâèòè
      EquAdd=NormalizeDouble(EquStart/100*PercentEquityForClose,dg); // Ïðîöåíò îò ñðåäñòâ, íà êîòîðûé îíè äîëæíû óâåëè÷èòüñÿ äëÿ çàêðûòèÿ
      EquPercLoss=NormalizeDouble(EquStart/100*PercentLossEquityForClose,dg);// Ïðîöåíò ñðåäñòâ, ïðè ïàäåíèè íà êîòîðûé çàêðûòü óá. ïîçû
      GlobalVariableSet(NameGL_Equ,EquStart);                  // Ñîçäàäèì ãëîáàëüíóþ ïåðåìåííóþ òåðìèíàëà è ïðèñâîèì åé çíà÷åíèå ýêâèòè
      GlobalVariableSet(NameGL_Add,EquAdd);
      GlobalVariableSet(NameGL_Loss,EquLoss);
      }
   else {
      EquStart=GlobalVariableGet(NameGL_Equ);      // Åñëè ïåðåìåííàÿ òåðìèíàëà óæå åñòü, òî ñòàðòîâûé ýêâèòè = çíà÷åíèþ ýòîé ïåðåìåííîé
      EquAdd=GlobalVariableGet(NameGL_Add);
      EquPercLoss=GlobalVariableGet(NameGL_Loss);
      }
   double p1=GlobalVariableGet(NameGL_Equ);
   double p2=GlobalVariableGet(NameGL_Add);
   double p3=GlobalVariableGet(NameGL_Loss);
   EquClose=NormalizeDouble(p1+p2,dg);
   EquLoss= NormalizeDouble(p1-p3,dg);
   if (PercentEquityForClose<=0)          PercentEquityForClose=PointX;
   if (NumberLossPoseForCloseEquUP<=0)    NumberLossPoseForCloseEquUP=1;
   if (NumberLossPoseForCloseEquDN<=0)    NumberLossPoseForCloseEquDN=1;
   if (DistanceOpenPositions<=0 || 
       DistanceOpenPositions<=Level_old)  DistanceOpenPositions=Level_old+1;
   if (TakeProfit<=Level_old)             TakeProfit=Level_old+1;
//==============================================================================
// ------------- Çàïîëíåíèå ìàññèâîâ äàííûìè î öåíîâûõ óðîâíÿõ ----------------+
//==============================================================================
   ArrayResize(MassUpLev, NumberUpLevels);                     // Óâåëè÷èì ðàçìåðû ìàññèâîâ ...
   ArrayResize(MassDnLev, NumberDnLevels);                     // ... ïîä êîëè÷åñòâî óðîâíåé
   ArrayInitialize(MassCtLev, 0);                              // Èíèöèàëèçèðóåì ìàññèâ íóëÿìè
   ArrayInitialize(MassUpLev, 0);                              // Èíèöèàëèçèðóåì ìàññèâ íóëÿìè
   ArrayInitialize(MassDnLev, 0);                              // Èíèöèàëèçèðóåì ìàññèâ íóëÿìè
   CenterLevel=pa;
   MassCtLev[0]=CenterLevel;
// -----------------------------------------------------------------------------   
   return(0);
}
//==============================================================================
int deinit()                              // Ñïåö. ôóíêöèÿ deinit()
{
// -------- Áëîê óäàëåíèÿ âñåõ îáúåêòîâ, ïîñòðîåííûõ ñîâåòíèêîì íà ãðàôèêå --------
   string Name_Del[1]; 
   int Quant_Del=0;                    
   int Quant_Objects=ObjectsTotal();   
   int LenPref=StringLen(Prefix);
   ArrayResize(Name_Del,Quant_Objects);
   for(int k=0; k<Quant_Objects; k++) {
         string Obj_Name=ObjectName(k);   
         string Head=StringSubstr(Obj_Name,0,LenPref);
         if (Head==Prefix) {                              
               Quant_Del+=1;        
               Name_Del[Quant_Del-1]=Obj_Name;
            }
     }
   for(int i=0; i<Quant_Del; i++)    
      ObjectDelete(Name_Del[i]); 
// ----- Êîíåö áëîêà óäàëåíèÿ âñåõ îáúåêòîâ, ïîñòðîåííûõ ñîâåòíèêîì íà ãðàôèêå -----
   if (!IsTesting()) Comment("");                                 // Óäàëåíèå êîììåíòàðèåâ (íå ïðè îòëàäêå)
   else if (IsTesting())                                          // Åñëè â òåñòåðå, òî ...
      if(GlobalVariableCheck(NameGL_Equ)) {                       // ... åñëè åñòü ãëîáàëüíàÿ ïåðåìåííàÿ òåðìèíàëà ñ èìåíåì NameGL_Equ ...
         GlobalVariableDel(NameGL_Equ);                           // ... óäàëèì å¸
         GlobalVariableDel(NameGL_Add);
         GlobalVariableDel(NameGL_Loss);
         GlobalVariableDel(PriceFirstSell);
         }
   return;                                                        // Âûõîä èç deinit()
}
//==============================================================================
int start()
{
   tf=Period();
   sy=Symbol();
   pa=MarketInfo(sy,MODE_ASK);
   pb=MarketInfo(sy,MODE_BID);
   sp=MarketInfo(sy,MODE_SPREAD);
   Level_new=MarketInfo(sy,MODE_STOPLEVEL );                      // Ïîñëåäíåå ìèíèìàëüíîå çíà÷åíèå óðîâíÿ óñòàíîâêè ñòîïîâ
   if (Level_old!=Level_new) {                                    // Íîâîå íå ðàâíî ñòàðîìó, çíà÷èò èçìåíèëñÿ óðîâåíü
      Level_old=Level_new;                                        // Íîâîå "ñòàðîå çíà÷åíèå"
      }
   if (DistanceOpenPositions<=Level_new)  DistanceOpenPositions=Level_new+1;
   if (TakeProfit<=Level_new)             TakeProfit=Level_new+1;
//==============================================================================
// ------------------- Âûâîä äèñòàíöèé StopLevel íà ãðàôèê --------------------+
//==============================================================================
   color cl=FireBrick;
   string RectUP=Prefix+"_RectUp_StLevel";
   double pUP1=pa;
   double pUP2=NormalizeDouble(pa+Level_new*PointX,dg);
   SetRectangle(cl, RectUP, Time[3], pUP1, Time[0]+3*Period()*60, pUP2);
   string RectDN=Prefix+"_RectDn_StLevel";
   double pDN1=pb;
   double pDN2=NormalizeDouble(pb-Level_new*PointX,dg);
   SetRectangle(cl, RectDN, Time[3], pDN1, Time[0]+3*Period()*60, pDN2);
   informations();
//==============================================================================
// ---------------------- Îòêðûòèå ïåðâîé ïîçèöèè Sell ------------------------+
//==============================================================================
   if (FirstStart) {                                              // Åñëè ýòî ïåðâûé ñòàðò ñîâåòíèêà
      if(!GlobalVariableCheck(PriceFirstSell)) {                  // Åñëè íåò ãëîáàëüíîé ïåðåì. òåðìèíàëà PriceFirstSell (íå ïåðåçàãðóçêà)
         GlobalVariableSet(PriceFirstSell,0);                     // Ñòàâèì å¸ â 0
         double tp=NormalizeDouble(pb-TakeProfit*PointX,dg);
         string New_Comm="Ïåðâàÿ_ïîçèöèÿ_Sell";
         Print("Ïåðâûé ñòàðò: îòêðûâàåì Sell");
         OpenPosition(sy,OP_SELL,Lots,0,tp,Magic,New_Comm);
         if (ExistPositions(sy,OP_SELL,Magic))
            GlobalVariableSet(PriceFirstSell,OrderOpenPrice());  
         }
      }
//==============================================================================
// ----------------- Îòñëåæèâàíèå óðîâíåé îòíîñèòåëüíî öåíû -------------------+
//==============================================================================
   SetLevels();
   if (pa>NormalizeDouble(CenterLevel+DistanceOpenPositions*PointX,dg)) {
      CenterLevel=NormalizeDouble(CenterLevel+DistanceOpenPositions*PointX,dg);
      MassCtLev[0]=CenterLevel;
      SetLevels();
      }
   if (pb<NormalizeDouble(CenterLevel-DistanceOpenPositions*PointX,dg)) {
      CenterLevel=NormalizeDouble(CenterLevel-DistanceOpenPositions*PointX,dg);
      MassCtLev[0]=CenterLevel;
      SetLevels();
      }
      if (NormalizeDouble(pa-CenterLevel,dg)>0.5*PointX &&
          NormalizeDouble(CenterLevel-Low[1],dg)>=0.5*PointX)  OpenPosOnTradeMode(OP_BUY,  NormalizeDouble(CenterLevel,dg));
      if (NormalizeDouble(CenterLevel-pb,dg)>0.5*PointX &&
          NormalizeDouble(High[1]-CenterLevel,dg)>=0.5*PointX) OpenPosOnTradeMode(OP_SELL, NormalizeDouble(CenterLevel,dg));
//==============================================================================
// ------------ Îòñëåæèâàíèå ýêâèòè è çàêðûòèå óáûòî÷íûõ ïîçèöèé --------------+
//==============================================================================
   int    TotalLoss=0;
   int    NumPoseForClose=0;
   double loss=0;
   double p1=GlobalVariableGet(NameGL_Equ);
   double p2=GlobalVariableGet(NameGL_Add);
   double p3=GlobalVariableGet(NameGL_Loss);
   EquClose=NormalizeDouble(p1+p2,dg);
   EquLoss= NormalizeDouble(p1-p3,dg);
   if (UseEquClose) {
      if (AccountEquity()>=EquClose) {
         EquStart=AccountEquity();
         GlobalVariableSet(NameGL_Equ,EquStart);
         if (TotalLossPose()==0) {
            Print("Ñðåäñòâà äîñòèãëè çàäàííîãî çíà÷åíèÿ ",DoubleToStr(EquClose,2),", óáûòî÷íûõ ïîçèöèé íåò");
            CloseFact=false;
            return(0);
            }
         if (NumberLossPoseForCloseEquUP==1) {
            loss=ClosePosWithMaxLossInCurrency(sy, Magic);
            if (OrderType()==OP_BUY) type="Buy"; else type="Sell";
            Print("Ñðåäñòâà äîñòèãëè çàäàííîãî çíà÷åíèÿ ",DoubleToStr(EquClose,2),
                  ", çàêðûëè ïîçèöèþ ",type," ñ íàèáîëüøèì óáûòêîì (",DoubleToStr(loss,2),")");
            }
         else if (NumberLossPoseForCloseEquUP>1) {
            TotalLoss=TotalLossPose();
            if (TotalLoss<NumberLossPoseForCloseEquUP) NumPoseForClose=TotalLoss; else NumPoseForClose=NumberLossPoseForCloseEquUP;
            SetEndString(NumPoseForClose);
            Print("Ñðåäñòâà äîñòèãëè çàäàííîãî çíà÷åíèÿ ",DoubleToStr(EquClose,2),
                  ", çàêðûâàåì ",NumPoseForClose, " óáûòî÷í", end1, " ïîçèö", end2);
            CloseLoss(NumPoseForClose);
            }
         CloseFact=false;
         }
      else if (AccountEquity()<=EquLoss) {
         if (TrackLossEquity) {
//         if (!CloseFact) {
            if (TotalLossPose()==0) {
               Print("Ïðîñàäêà áîëüøå çàäàííîãî çíà÷åíèÿ ",DoubleToStr(EquLoss,2),", óáûòî÷íûõ ïîçèöèé íåò");
               CloseFact=false;
               return(0);
               }
            if (NumberLossPoseForCloseEquDN==1) {
               loss=ClosePosWithMaxLossInCurrency(sy, Magic);
               if (OrderType()==OP_BUY) type="Buy"; else type="Sell";
               Print("Ïðîñàäêà áîëüøå çàäàííîãî çíà÷åíèÿ ",DoubleToStr(EquLoss,2),
                     ", çàêðûëè ïîçèöèþ ",type," ñ íàèáîëüøèì óáûòêîì (",DoubleToStr(loss,2),")");
               }
            else if (NumberLossPoseForCloseEquDN>1) {
               TotalLoss=TotalLossPose();
               if (TotalLoss<NumberLossPoseForCloseEquDN) NumPoseForClose=TotalLoss; else NumPoseForClose=NumberLossPoseForCloseEquDN;
               SetEndString(NumPoseForClose);
               Print("Ïðîñàäêà áîëüøå çàäàííîãî çíà÷åíèÿ ",DoubleToStr(EquLoss,2),
                     ", çàêðûâàåì ",NumPoseForClose, " óáûòî÷í", end1, " ïîçèö", end2);
               CloseLoss(NumPoseForClose);
               }
            CloseFact=true;
            EquStart=AccountEquity();                                // Ñòàðòîâûé ýêâèòè = ýêâèòè
            EquPercLoss=NormalizeDouble(EquStart/100*PercentLossEquityForClose,dg);// Ïðîöåíò ñðåäñòâ, ïðè ïàäåíèè íà êîòîðûé çàêðûòü óá. ïîçû
            GlobalVariableSet(NameGL_Equ,EquStart);                  // Ñîçäàäèì ãëîáàëüíóþ ïåðåìåííóþ òåðìèíàëà è ïðèñâîèì åé çíà÷åíèå ýêâèòè
            GlobalVariableSet(NameGL_Loss,EquPercLoss);
            p1=GlobalVariableGet(NameGL_Equ);
            p2=GlobalVariableGet(NameGL_Add);
            p3=GlobalVariableGet(NameGL_Loss);
            EquClose=NormalizeDouble(p1+p2,dg);
            EquLoss= NormalizeDouble(p1-p3,dg);
            Print("Íîâûé ñòàðòîâûé ýêâèòè = ", EquStart, ", íîâûé ïðîöåíò ïðîñàäêè = ",EquPercLoss, ", óðîâåíü ñëåä. çàêðûòèÿ = ", EquLoss);
            }
         }
      }
   return(0);  // -------------------- Âûõîä èç start() -----------------------+
}

//==============================================================================
// --------------------------------- ÔÓÍÊÖÈÈ ----------------------------------+
//==============================================================================
//==============================================================================
// ---------------------------- Ôóíêöèè ñîâåòíèêà -----------------------------+
//==============================================================================
//==============================================================================
// ------------------ Îòêðûòèå ïîçèöèé ïðè ðàáîòå ïî ðûíêó --------------------+
//==============================================================================
void OpenPosOnTradeMode(int type, double price) {
   double tp=0, pp=0,SL=0;
   string New_Comm="";
   int total, cnt;
   Print("Öåíà ïåðåñåêëà óðîâåíü ",price,", ïðîâåðèì íåîáõîäèìîñòü îòêðûòèÿ ðûíî÷íîé ïîçèöèè");
   if (type==OP_BUY) 
   {
      tp=NormalizeDouble(pa+TakeProfit*PointX,dg);
      New_Comm="Ðàáîòà ïî ðûíêó_Buy";
      if (!PresentPosNearestLev(type, price)) 
      {
         Print("Âáëèçè óðîâíÿ ",DoubleToStr(price,dg)," íåò îòêðûòûõ ïîçèöèé, îòêðûâàåì Buy");
         total=OrdersTotal();
         for(cnt=total-1;cnt>=0;cnt--)
         {
            OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
            if(OrderSymbol()==Symbol() && OrderType()==OP_BUY)// && (OrderMagicNumber()==cmagic))
            {
               if(OrderProfit()<0)
               {
                   Lots=Lots+DeltaLots;
                   if (Lots>MaxLots) Lots=StartLots;
               }   
               else Lots=StartLots;
               break;
            }
         }   
         if (cnt<0) Lots=StartLots; //Íåò îòêðûòûõ áàé îðäåðîâ
if (Lots==StartLots)SL=Ask-stoploss*Point; //ÂÎÒ ÒÓÒ íàäî âû÷èñëèòü íîâûé óðîâåíü ñòîï-ëîññà.  òîì æå ôîðìàòå  ÷òî è êîòèðîâêè, à íå êîëè÷åñòâî ïèïñîâ.
         OpenPosition(sy,OP_BUY,Lots,SL,tp,Magic,New_Comm);
         if(obSL>0)
         {
         total=OrdersTotal();
         for(cnt=total-1;cnt>=0;cnt--)
         {
            OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
            if(OrderSymbol()==Symbol() && OrderType()==OP_BUY && OrderStopLoss()<SL && OrderLots()==StartLots)// && (OrderMagicNumber()==cmagic))
            {
                OrderModify(OrderTicket(),OrderOpenPrice(),SL,OrderTakeProfit(),0);
                Sleep(3000); //Æä¸ì 3 ñåêóíäû. Áóäåò íå õâàòàòü - ìîæíî ÷óòîê óâåëè÷èòü.
            }
         }   
         }
      }
   }
   return;
}
// ----------------------------------------------------------------------------+
// ----------------------------------------------------------------------------+
bool PresentPosNearestLev(int type, double price) {
   double delta=NormalizeDouble((DistanceOpenPositions/2)*PointX,dg);
   int i;   
   for (i=0; i<OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS)) {
         if (OrderMagicNumber()!=Magic)   continue;
         if (OrderSymbol()!=sy)           continue;
         if (OrderType()!=type)           continue;
         if (MathAbs(NormalizeDouble(OrderOpenPrice()-price,dg))<=delta) {
            if (OrderType()==OP_BUY) string ot="Buy"; else ot="Sell";
            Print("Âáëèçè óðîâíÿ ",DoubleToStr(price,dg)," óæå åñòü ðûíî÷íàÿ ïîçèöèÿ ",ot,", îòêðûòàÿ ïî öåíå ",DoubleToStr(OrderOpenPrice(),dg));
            return(true);
            }
         }
      }
   return(false);   
}
//+----------------------------------------------------------------------------+
void SetLevels() {
   int i;
   double step, lev;
   MassCtLev[0]=CenterLevel;
   string NameLevelCT=Prefix+"_CenterLevel";                   // Èìÿ öåíòðàëüíîé ëèíèè
   SetArrow(4, MediumSpringGreen, NameLevelCT, Time[0], CenterLevel, 0);
   
// -------------------- Âûâîä âåðõíèõ óðîâíåé íà ãðàôèê -----------------------+
   for (i=0; i<NumberUpLevels; i++) {
      step=((i+1)*DistanceOpenPositions)*PointX;                    // Øàã ïðèðàùåíèÿ öåíû
      lev=NormalizeDouble(MassCtLev[0]+step,dg);               // Öåíîâîå çíà÷åíèå i-ãî óðîâíÿ
      MassUpLev[i]=lev;                                        // Çàïîëíèì ìàññèâ
      clUP=DeepSkyBlue;                                        // Öâåò âåðõíèõ óðîâíåé
      string NameLevelUP=Prefix+"_UpLevel_"+DoubleToStr(i,0);  // Èìÿ ëèíèè
      SetArrow(4, clUP, NameLevelUP, Time[0], lev, 0);         // Íàðèñóåì i-óðîâåíü
      }
// -------------------- Âûâîä íèæíèõ óðîâíåé íà ãðàôèê ------------------------+
   for (i=0; i<NumberDnLevels; i++) {
      step=((i+1)*DistanceOpenPositions)*PointX;                    // Øàã ïðèðàùåíèÿ öåíû
      lev=NormalizeDouble(MassCtLev[0]-step,dg);               // Öåíîâîå çíà÷åíèå i-ãî óðîâíÿ
      MassDnLev[i]=lev;                                        // Çàïîëíèì ìàññèâ
      clDN=Gold;                                               // Öâåò íèæíèõ óðîâíåé
      string NameLevelDN=Prefix+"_DnLevel_"+DoubleToStr(i,0);  // Èìÿ ëèíèè
      SetArrow(4, clDN, NameLevelDN, Time[0], lev, 0);         // Åãî íèç
      }
   MassUpLen=ArrayRange(MassUpLev,0);
   MassDnLen=ArrayRange(MassDnLev,0);
   HighestLev=MassUpLev[MassUpLen-1];
   LowestLev =MassDnLev[MassDnLen-1];
   return;
}
//+----------------------------------------------------------------------------+
void CloseLoss(int numLoss) {
   for (int i=0; i<numLoss; i++) ClosePosWithMaxLossInCurrency(sy, Magic);
}
//+----------------------------------------------------------------------------+
void informations() {
   string Text, nmEqu, font;
   color  cl;
   int    angle, xDist, yDist, size;
//+----------------------------------------------------------------------------+
   Text="Áàëàíñ ñ÷¸òà: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_Balance";
   angle=2; xDist=10; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(AccountBalance(),2); // ×èñëîâîå çíà÷åíèå áàëàíñà
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_AccBalance";
   angle=2; xDist=150; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Ñâîáîäíûå ñðåäñòâà: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_Equity";
   angle=2; xDist=10; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(AccountEquity(),2); // ×èñëîâîå çíà÷åíèå ýêâèòè
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_AccEquity";
   angle=2; xDist=150; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Çàêðûòèå íà óðîâíå: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_CloseEquity";
   angle=2; xDist=10; yDist=30;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(EquClose,2); // ×èñëîâîå çíà÷åíèå ýêâèòè
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_ClsEquity";
   angle=2; xDist=150; yDist=30;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Êðèòè÷åñêèé óðîâåíü: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_CriticEquity";
   angle=2; xDist=10; yDist=10;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(EquLoss,2); // ×èñëîâîå çíà÷åíèå ýêâèòè
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_CriticEquity";
   angle=2; xDist=150; yDist=10;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
/*   
   Text="Ðåæèì ðàáîòû: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_Mode";
   angle=2; xDist=220; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   if (MarketTrade) Text="Ïîçèöèè"; else Text="Îðäåðà";
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_Mode";
   angle=2; xDist=320; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
*/   
//+----------------------------------------------------------------------------+
   Text="Óáûòî÷íûõ Buy: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_LossBuy";
   angle=2; xDist=220; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(NumLossPos(OP_BUY),0);
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_LossBuy";
   angle=2; xDist=320; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Óáûòî÷íûõ Sell: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_LossSell";
   angle=2; xDist=220; yDist=30;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(NumLossPos(OP_SELL),0);
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_LossSell";
   angle=2; xDist=320; yDist=30;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
}
//==============================================================================
// ----------------------------- Òîðãîâûå ôóíêöèè -----------------------------+
//==============================================================================
void OpenPosition(string sy, int op, double ll, double sl=0, double tp=0, int mn=0, string co="") {
  color    clOpen;
  datetime ot;
  double   pp, pa, pb;
  int      dg, err, it, ticket=0;

   if (op==OP_BUY) {
      if (!TradeBuy) {
         Print("Òîðãîâëÿ â Buy îòêëþ÷åíà â íàñòðîéêàõ ñîâåòíèêà");
         return;
         }
      }
   if (op==OP_SELL) {
      if (!TradeSell) {
         Print("Òîðãîâëÿ â Sell îòêëþ÷åíà â íàñòðîéêàõ ñîâåòíèêà");
         return;
         }
      }
  if (sy=="" || sy=="0") sy=Symbol();
  if (op==OP_BUY) clOpen=clOpenBuy; else clOpen=clOpenSell;
  if (co=="") co=WindowExpertName()+" "+GetNameTF(Period());
  for (it=1; it<=NumberOfTry; it++) {
    if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) {
      Print("OpenPosition(): Function stopped");
      break;
    }
    while (!IsTradeAllowed()) Sleep(5000); //Sleep_RND(5000);
    RefreshRates();
    dg=MarketInfo(sy, MODE_DIGITS);
    pa=MarketInfo(sy, MODE_ASK);
    pb=MarketInfo(sy, MODE_BID);
    if (op==OP_BUY) pp=pa; else pp=pb;
    pp=NormalizeDouble(pp, dg);
    ot=TimeCurrent();
    if (MarketWatch)
      ticket=OrderSend(sy, op, ll, pp, Slippage, 0, 0, co, mn, 0, clOpen);
    else
      ticket=OrderSend(sy, op, ll, pp, Slippage, sl, tp, co, mn, 0, clOpen);
    if (ticket>0) {
      if (UseSound) PlaySound(SoundSuccess); break;
    } else {
      err=GetLastError();
      if (UseSound) PlaySound(SoundError);
      if (pa==0 && pb==0) Message("Check in the MarketWatch presence of the symbol "+sy);
      // Âûâîä ñîîáùåíèÿ îá îøèáêå
      Print("Error(",err,") opening position: ",ErrorDescription(err),", try ",it);
      Print("Ask=",pa," Bid=",pb," sy=",sy," ll=",ll," op=",GetNameOP(op),
            " pp=",pp," sl=",sl," tp=",tp," mn=",mn);
      // Áëîêèðîâêà ðàáîòû ñîâåòíèêà
      if (err==2  ||                // Îáùàÿ îøèáêà
          err==64 ||                // Ñ÷åò çàáëîêèðîâàí
          err==65 ||                // Íåïðàâèëüíûé íîìåð ñ÷åòà
          err==133)                 // Òîðãîâëÿ çàïðåùåíà
          {
        gbDisabled=True; break;     // Îòêëþ÷åíèå ñîâåòíèêà
      }
      // Äëèòåëüíàÿ ïàóçà
      if (err==4   ||               // Òîðãîâûé ñåðâåð çàíÿò
          err==131 ||               // Íåïðàâèëüíûé îáúåì
          err==132)                 // Ðûíîê çàêðûò
          {
        Sleep(1000*300); break; // Sleep_RND(1000*300);
      }
      if (err==128 ||               // Èñòåê ñðîê îæèäàíèÿ ñîâåðøåíèÿ ñäåëêè
          err==142 ||               // Îðäåð ïîñòàâëåí â î÷åðåäü
          err==143)                 // Îðäåð ïðèíÿò äèëåðîì ê èñïîëíåíèþ
          {
        Sleep(1000*66.666); // Sleep_RND(1000*66.666);
        if (ExistPositions(sy, op, mn, ot)) {
          if (UseSound) PlaySound(SoundSuccess); break;
        }
      }
      if (err==140  ||              // Ðàçðåøåíà òîëüêî ïîêóïêà
          err==148  ||              // Êîëè÷åñòâî îòêðûòûõ è îòëîæåííûõ îðäåðîâ äîñòèãëî ïðåäåëà, óñòàíîâëåííîãî áðîêåðîì
          err==4110 ||              // Äëèííûå ïîçèöèè íå ðàçðåøåíû. Íåîáõîäèìî ïðîâåðèòü ñâîéñòâà ýêñïåðòà
          err==4111)                // Êîðîòêèå ïîçèöèè íå ðàçðåøåíû. Íåîáõîäèìî ïðîâåðèòü ñâîéñòâà ýêñïåðòà
          break;
      if (err==141) /*Sleep(1000*100);*/ Sleep_RND(1000*100); // Ñëèøêîì ìíîãî çàïðîñîâ
      if (err==145) /*Sleep(1000*17);*/  Sleep_RND(1000*17);  // Ìîäèôèêàöèÿ çàïðåùåíà, òàê êàê îðäåð ñëèøêîì áëèçîê ê ðûíêó
      if (err==146) while (IsTradeContextBusy()) /*Sleep(1000*11);*/ Sleep_RND(1000*11);  // Ïîäñèñòåìà òîðãîâëè çàíÿòà
      if (err!=135) /*Sleep(1000*7.7);*/ Sleep_RND(1000*7.7);                             // Öåíà èçìåíèëàñü
    }
  }
  if (MarketWatch && ticket>0 && (sl>0 || tp>0)) {
    if (OrderSelect(ticket, SELECT_BY_TICKET)) ModifyOrder(-1, sl, tp);
  }
}
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0,color cl=CLR_NONE) {
  bool   fm;
              cl=IIFc(OrderType()==OP_BUY
              || OrderType()==OP_BUYLIMIT
              || OrderType()==OP_BUYSTOP, clModifyBuy, clModifySell);
  double op, pa, pb, os, ot;
  int    dg=MarketInfo(OrderSymbol(), MODE_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, ex, cl);
      if (fm) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        er=GetLastError();
        if (UseSound) PlaySound(SoundError);
        pa=MarketInfo(OrderSymbol(), MODE_ASK);
        pb=MarketInfo(OrderSymbol(), MODE_BID);
        Print("Error(",er,") modifying order: ",ErrorDescription(er),", try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
              "  op="+GetNameOP(OrderType()),"  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
      }
    }
  }
}
//+----------------------------------------------------------------------------+
double ClosePosWithMaxLossInCurrency(string sy="", int mn=-1) {
   double pr=0;
   int    i, k=OrdersTotal(), np=-1;

   for (i=k-1; i>=0; i--) {
      if (OrderSelect(i, SELECT_BY_POS)) {
         if (OrderSymbol()!=sy)        continue;
         if (OrderType()>1)            continue;
         if (OrderMagicNumber()!=mn)   continue;
         if (OrderProfit()+OrderSwap()+OrderCommission()<pr) {
            pr=OrderProfit()+OrderSwap()+OrderCommission();
            np=i;
            }
         }
      }
   if (np>=0) {
      if (OrderSelect(np, SELECT_BY_POS)) {
         ClosePosBySelect();
         }
      }
   return(pr);
}
//+----------------------------------------------------------------------------+
void ClosePosBySelect() {
  bool   fc;
  color  clClose;
  double ll, pa, pb, pp;
  int    err, it;

  if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
    for (it=1; it<=NumberOfTry; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      pa=MarketInfo(OrderSymbol(), MODE_ASK);
      pb=MarketInfo(OrderSymbol(), MODE_BID);
      if (OrderType()==OP_BUY) {
        pp=pb; clClose=clCloseBuy;
      } else {
        pp=pa; clClose=clCloseSell;
      }
      ll=OrderLots();
      fc=OrderClose(OrderTicket(), ll, NormalizeDouble(pp,dg), Slippage, clClose);
      if (fc) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        err=GetLastError();
        if (err==146) while (IsTradeContextBusy()) Sleep(1000*11);
        Print("Error(",err,") Close ",GetNameOP(OrderType())," ",
              ErrorDescription(err),", try ",it);
        Print(OrderTicket(),"  Ask=",pa,"  Bid=",pb,"  pp=",pp);
        Print("sy=",OrderSymbol(),"  ll=",ll,"  sl=",OrderStopLoss(),
              "  tp=",OrderTakeProfit(),"  mn=",OrderMagicNumber());
        Sleep(1000*5);
      }
    }
  } else Print("Íåêîððåêòíàÿ òîðãîâàÿ îïåðàöèÿ. Close ",GetNameOP(OrderType()));
}
//==============================================================================
// ------------------------- Âñïîìîãàòåëüíûå ôóíêöèè --------------------------+
//==============================================================================
void Sleep_RND(int _Pausa) {
   MathSrand(TimeLocal());
   MathRand();
   Sleep(MathRound(_Pausa*MathRand()/32767+_Pausa/5));
   return;
}
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
//+----------------------------------------------------------------------------+
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 Message(string m) {
   static string prevMessage="";
   Comment(m);
   if (StringLen(m)>0 && PrintEnable) {
      if (AllMessages || prevMessage!=m) {
         prevMessage=m;
         Print(m);
         }
      }
}
//+----------------------------------------------------------------------------+
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 GetMagic(string symbolstring, int multiplier) {
   int res=0;
   int len=StringLen(symbolstring);
   for(int i=0; i<len; i++)
       res+=StringGetChar(symbolstring,i);      
   return(res*multiplier);
}
//+----------------------------------------------------------------------------+
void SetEndString(int num) {         
   int x = num%10;      // ïîñëåäíÿÿ öèôðà
   switch (x) {
      case 1:  end1="óþ"; end2="èþ"; break;
      case 2:  end1="ûå"; end2="èè"; break;
      case 3:  end1="ûå"; end2="èè"; break;
      case 4:  end1="ûå"; end2="èè"; break;
      default: end1="ûõ"; end2="èé"; break;
      }
   return;
}
//==============================================================================
// ------------------------ Ôóíêöèè äëÿ ïîèñêà äàííûõ--------------------------+
//==============================================================================
int NumLossPos(int type) {
   int    numloss=0;
   for (int i=0; i<OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS)) {
         if (OrderType()!=type)           continue;
         if (OrderSymbol()!=sy)           continue;
         if (OrderMagicNumber()!=Magic)   continue;
         if (OrderProfit()+OrderSwap()+OrderCommission()<0) numloss++;
         }
      }
   return(numloss);
}
//+----------------------------------------------------------------------------+
int TotalLossPose() {
   int    numloss=0;
   for (int i=0; i<OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS)) {
         if (OrderType()>1)               continue;
         if (OrderSymbol()!=sy)           continue;
         if (OrderMagicNumber()!=Magic)   continue;
         if (OrderProfit()+OrderSwap()+OrderCommission()<0) numloss++;
         }
      }
   return(numloss);
}
//+----------------------------------------------------------------------------+
bool ExistPositions(string sy="", int op=-1, int mn=-1, datetime ot=0) 
{
   int i, k=OrdersTotal();
   if (sy=="0") sy=Symbol();
   for (i=0; i<k; i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderSymbol()!=sy)        continue;
         if (OrderType()!=op)          continue;
         if (OrderMagicNumber()!=mn)   continue;
         if (ot<=OrderOpenTime()) return(True);
         }
      }
  return(False);
}
//==============================================================================
// --------------------------- Ãðàôè÷åñêèå ôóíêöèè ----------------------------+
//==============================================================================
void SetArrow(int cd, color cl, string nm="", datetime t1=0, double p1=0, int sz=0) {
   if (nm=="") nm=DoubleToStr(Time[0], 0);
   if (t1<=0) t1=Time[0];
   if (p1<=0) p1=Bid;
   if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_ARROW, 0, 0, 0);
   ObjectSet(nm, OBJPROP_TIME1    , t1);
   ObjectSet(nm, OBJPROP_PRICE1   , p1);
   ObjectSet(nm, OBJPROP_ARROWCODE, cd);
   ObjectSet(nm, OBJPROP_COLOR    , cl);
   ObjectSet(nm, OBJPROP_WIDTH    , sz);
}
//+----------------------------------------------------------------------------+
void SetRectangle(color cl, string nm="", datetime t1=0, double p1=0, datetime t2=0, double p2=0, int sz=0) {
   if (nm=="") nm=DoubleToStr(Time[0], 0);
   if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_RECTANGLE, 0, 0, 0, 0, 0);
   ObjectSet(nm, OBJPROP_TIME1    , t1);
   ObjectSet(nm, OBJPROP_PRICE1   , p1);
   ObjectSet(nm, OBJPROP_TIME2    , t2);
   ObjectSet(nm, OBJPROP_PRICE2   , p2);
   ObjectSet(nm, OBJPROP_COLOR    , cl);
   ObjectSet(nm, OBJPROP_WIDTH    , sz);
}
//+----------------------------------------------------------------------------+
void SetText(string Text, color cl, string nm, int angle, int x, int y, string font, int sz=0) {
   if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_LABEL, 0, 0, 0);
   ObjectSet(nm, OBJPROP_CORNER   , angle);
   ObjectSet(nm, OBJPROP_XDISTANCE, x);
   ObjectSet(nm, OBJPROP_YDISTANCE, y);
   ObjectSet(nm, OBJPROP_WIDTH    , sz);
   ObjectSetText(nm, Text, sz, font, cl);
   }
//+----------------------------------------------------------------------------+