id_lite_info_ma

//+------------------------------------------------------------------+
//|                                              ID Lite Info MA.mq4 |
//|                                                2015, Dina Paches |
//|                           https://login.mql5.com/ru/users/dipach |
//+------------------------------------------------------------------+
#property copyright "2015, Dina Paches"
#property link      "https://login.mql5.com/ru/users/dipach"
#property version   "1.86"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
//+------------------------------------------------------------------+
/*êîëè÷åñòâî çíà÷åíèé ÌÀ è äåëüò, ïîêàçûâàåìûõ íà ÷àðòå â
 ÿ÷åéêàõ ïî îñè Õ (>=2 or <=30):*/
#define ARRAY_SIZE_X     (9)  
#define ARRAY_SIZE_Y     (6) //êîëè÷åñòâî ñòðîê  â òàáëèöå ïî îñè Y
#define DISTANCE_XY      (1)//äèñòàíöèÿ ìåæäó ÿ÷åéêàìè òàáëèöû
#define COUNT_BUFFERS    (2)//êîëè÷åñòâî áóôåðîâ (äëÿ Moving Averages)
#define LINE_NUMBER      "Line: ",__LINE__,", "
//+------------------------------------------------------------------+
//| Âûáîð êîëè÷åñòâà äåñÿòè÷íûõ çíàêîâ äëÿ çíà÷åíèé ÌÀ:              |
//+------------------------------------------------------------------+
enum varDigits
  {
   auto=-1,//current chart
   dig0=0,//0
   dig1=1,//1
   dig2=2,//2
   dig3=3,//3
   dig4=4,//4
   dig5=5,//5
   dig6=6,//6
   dig7=7,//7
   dig8=8,//8
  };
//+------------------------------------------------------------------+ 
/*ïîêàçûâàòü ðàñ÷¸òíûå îòðåçêè ëèíèé ÌÀ íà ÷àðòå:*/
input bool showLine=true;//Show lines MA

/*îòñòóï â ïóíêòàõ äëÿ ïåðâîé ÌÀ:*/
input int indent1=0;//Shift in points from MA1 (-/+ Down or Up)

/*îòñòóï â ïóíêòàõ äëÿ âòîðîé ÌÀ:*/
input int indent2=0;//Shift in points from MA2 (-/+ Down or Up)

/*êîëè÷åñòâî äåñÿòè÷íûõ çíàêîâ äëÿ îòîáðàæàåìûõ â òàáëèöå çíà÷åíèé:*/
input varDigits digCh=auto;//Decimal digits

/*íîìåð íà÷àëüíîãî áàðà äëÿ ÌÀ:*/
input int shift=1;//Shift (bar for first value): 

sinput string stripe1="+++++++++++++++++++++";//+++++++++++++++++++++
/*ïåðèîä ïåðâîé ÌÀ:*/
input int ma_period1=1;//Period Moving Averages (1)>= 1 or <= 3000:

/*âûáîð ìåòîäà óñðåäíåíèÿ äëÿ ïåðâîé ÌÀ:*/
input ENUM_MA_METHOD ma_method1=MODE_SMA;//MA method (1):

/*âûáîð òèïà öåíû äëÿ ïåðâîé ÌÀ:*/
input ENUM_APPLIED_PRICE applied_price1=PRICE_HIGH;//Apply to (1):

sinput string stripe2="+++++++++++++++++++++";//+++++++++++++++++++++
/*ïåðèîä âòîðîé ÌÀ:*/
input int ma_period2=1;//Period Moving Averages (2)>= 1 or <= 3000:

/*âûáîð ìåòîäà óñðåäíåíèÿ äëÿ âòîðîé ÌÀ:*/
input ENUM_MA_METHOD ma_method2=MODE_SMA;//MA method (2): 

/*âûáîð òèïà öåíû äëÿ âòîðîé ÌÀ:*/
input ENUM_APPLIED_PRICE applied_price2=PRICE_LOW;//Apply to (2):

sinput string stripe3="+++++++++++++++++++++";//+++++++++++++++++++++
/*äèñòàíöèÿ òàáëèöû îò ïðàâîãî êðàÿ ãðàôèêà:*/
input int xDistance=3;//X coordinate

/*äèñòàíöèÿ òàáëèöû îò âåðõíåãî êðàÿ ãðàôèêà:*/
input int yDistance=3;//Y coordinate

/*öâåò îñíîâíîãî ôîíà è öâåò ôîíà ÿ÷ååê òàáëèöû,
 åñëè çíà÷åíèå ÌÀ ðàâíî ïðåäûäóùåìó:*/
input color backClrMain=C'224,224,224';// background color (table and Equal)

/*öâåò ôîíà ÿ÷åéêè òàáëèöû, åñëè çíà÷åíèå ÌÀ âûøå ïðåäûäóùåãî:*/
input color backClrUp=clrCornflowerBlue;//background color (Up)

/*öâåò ôîíà ÿ÷åéêè òàáëèöû, åñëè çíà÷åíèå ÌÀ íèæå ïðåäûäóùåãî:*/
input color backClrDown=C'255,85,85';//background color (Down)

/*öâåò øðèôòà äëÿ çíà÷åíèé ÌÀ:*/
input color textClrMA=C'48,48,48';//text color for MA

/*öâåò øðèôòà äëÿ çíà÷åíèé äåëüòû,
åñëè çíà÷åíèå ÌÀ ðàâíî ïðåäûäóùåìó:*/
input color textClrDelta=clrDimGray;// color text for delta

/*øèðèíà ÿ÷ååê òàáëèöû ïî îñè Õ:*/
input int widthObj=60;//width

/*âûñîòà ÿ÷ååê äëÿ çíà÷åíèé ÌÀ â òàáëèöå ïî îñè Y:*/
input int heightObj=18;//height

/*ðàçìåð øðèôòà äëÿ çíà÷åíèé ÌÀ:*/
input int fontSize=9;//font size

/*îáúåêòû èíäèêàòîðà íà çàäíåì ïëàíå ÷àðòà*/
input bool backObj=true;//in the background
//+------------------------------------------------------------------+
double priceM1buffer[],priceM2buffer[],indentK1,indentK2,pointK;
int dig,minBars,shiftK,switchButtonClick,chartWidthK,switchMA1,switchMA2,
coordinateY0,coordinateY1,coordinateX0,coordinateX1;
color backClrObjOddY[COUNT_BUFFERS+1][ARRAY_SIZE_X],
textClrObjEvenY[COUNT_BUFFERS][ARRAY_SIZE_X];
string prefixObj,symb,
nameObj[ARRAY_SIZE_Y][ARRAY_SIZE_X],
textObjOddY[COUNT_BUFFERS+1][ARRAY_SIZE_X],
textObjEvenY[COUNT_BUFFERS][ARRAY_SIZE_X],
nameObjBut0,nameObjBut1;
bool changeClr0[ARRAY_SIZE_X],changeClr1[ARRAY_SIZE_X];
ENUM_TIMEFRAMES timeframe1;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   symb=Symbol();
   prefixObj=StringConcatenate("vMA(",IntegerToString(COUNT_BUFFERS),
                               "):",symb,"_",xDistance,yDistance);
   IndicatorSetString(INDICATOR_SHORTNAME,prefixObj);
//+------------------------------------------------------------------+
   if(!SetOnInitAny())return(INIT_FAILED);
//+------------------------------------------------------------------+
   SetOnInitTable();
//+------------------------------------------------------------------+
/*óñòàíîâêà çíà÷åíèé áóôåðîâ èíäèêàòîðà:*/
   SetIndexBuffer(0,priceM1buffer,INDICATOR_DATA);
   SetIndexBuffer(1,priceM2buffer,INDICATOR_DATA);

   if(showLine==true)//åñëè ïîêàçûâàòü íà ÷àðòå ëèíèÿìè ðàñ÷¸òíûå ó÷àñòêè ÌÀ
     {
      for(int i=0;i<COUNT_BUFFERS;i++)
        {SetIndexStyle(i,DRAW_LINE,STYLE_SOLID,1,backClrMain);}
     }
   else//åñëè íå ïîêàçûâàòü íà ÷àðòå ëèíèÿìè ðàñ÷¸òíûå ó÷àñòêè ÌÀ
     {
      for(int i=0;i<COUNT_BUFFERS;i++)
        {SetIndexStyle(i,DRAW_NONE);}
     }
/*íàçâàíèÿ áóôåðîâ èíäèêàòîðà, îòîáðàæàåìûå â "Îêíå Äàííûõ":*/
   string textLabel1=StringConcatenate(COUNT_BUFFERS-1,
                                       " MA(",
                                       IntegerToString(ma_period1),"):");
   string textLabel2=StringConcatenate(COUNT_BUFFERS,
                                       " MA(",
                                       IntegerToString(ma_period2),"):");
   SetIndexLabel(0,textLabel1);
   SetIndexLabel(1,textLabel2);
   IndicatorSetInteger(INDICATOR_DIGITS,dig);

   for(int i=0;i<COUNT_BUFFERS;i++){SetIndexEmptyValue(i,0.0);}
//+------------------------------------------------------------------+
   return(INIT_SUCCEEDED);
  }//int OnInit()
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
/*ýòà ôóíêöèÿ, ñ äîáàâëåííîé â íå¸ âîçìîæíîñòüþ óäàëÿòü îáúåêòû ïî
 ïðåôèêñó, ñ 840-ãî áèëäà ÌÒ4:*/
   ObjectsDeleteAll(0,prefixObj,0,EMPTY);
//---
   ChartRedraw();
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   if(prev_calculated<0) return(0);
   if(rates_total-1<minBars) return(0);
//+------------------------------------------------------------------+
/*îïðåäåëåíèå íàïðàâëåíèÿ èíäåêñàöèè â òàéìñåðèÿõ:*/
   bool asSeriesFirst=ArrayGetAsSeries(time);
/*è åñëè îíî ñëåâà íàïðàâî, òî óñòàíîâêà ñïðàâà íàëåâî*/
   if(!asSeriesFirst)
     {ArraySetAsSeries(time,true);}
//+------------------------------------------------------------------+
   static datetime timeNewBar=0;
   static color clrK1=0;//äëÿ ñìåíû öâåòà ëèíèè ïåðâîé ÌÀ
   static color clrK2=0;//äëÿ ñìåíû öâåòà ëèíèè âòîðîé ÌÀ
   int limit=0;
//+------------------------------------------------------------------+
   if(prev_calculated==0)
     {
      for(int i=0;i<COUNT_BUFFERS;i++){SetIndexEmptyValue(i,0.0);}

      limit=ARRAY_SIZE_X+shiftK+1;
      timeNewBar=0;
     }
   else {limit=rates_total-prev_calculated+shiftK;}
//+------------------------------------------------------------------+
   if(timeNewBar!=time[0])
     {
      timeNewBar=time[0];
/*+------------------------------------------------------------------+
îïðåäåëåíèå íàïðàâëåíèÿ èíäåêñàöèè â äèíàìè÷åñêèõ ìàññèâàõ (â áóôåðàõ
èíäèêàòîðà):*/
      bool asSeriesBuffer1=ArrayGetAsSeries(priceM1buffer);
      bool asSeriesBuffer2=ArrayGetAsSeries(priceM2buffer);
/*è åñëè îíî ñëåâà íàïðàâî, òî óñòàíîâêà ñïðàâà íàëåâî*/
      if(!asSeriesBuffer1)
        {ArraySetAsSeries(priceM1buffer,true);}
      if(!asSeriesBuffer2)
        {ArraySetAsSeries(priceM2buffer,true);}
/*+------------------------------------------------------------------*/
      for(int i=0;i<COUNT_BUFFERS;i++)
        {SetIndexDrawBegin(i,rates_total-(ARRAY_SIZE_X+shiftK+1));}
      //+------------------------------------------------------------------+
      if(!IsStopped())
        {
         switch(switchMA1)
           {
/*åñëè ìåòîä óñðåäíåíèÿ = MODE_SMA + period Moving Averages = 1 +                                     
applied_price = PRICE_CLOSE/PRICE_OPEN/PRICE_HIGH/PRICE_LOW:*/
            case 0:PriceSwitchForBuffer(priceM1buffer,applied_price1,
                                        indentK1,limit);break;
               /*èíà÷å, ïîëó÷åíèå çíà÷åíèé Moving Averages ÷åðåç iMA:*/
            case 1:PriceIMAforBuffer0(priceM1buffer,ma_period1,ma_method1,
                                      applied_price1,indentK1,limit);break;
               default:break;
           }
         //+------------------------------------------------------------------+
         switch(switchMA2)
           {
/*åñëè ìåòîä óñðåäíåíèÿ = MODE_SMA + period Moving Averages = 1 +                                      
applied_price = PRICE_CLOSE/PRICE_OPEN/PRICE_HIGH/PRICE_LOW:*/
            case 0: PriceSwitchForBuffer(priceM2buffer,applied_price2,
                                         indentK2,limit);break;
               /*èíà÷å, ïîëó÷åíèå çíà÷åíèé Moving Averages ÷åðåç iMA:*/
            case 1:PriceIMAforBuffer0(priceM2buffer,ma_period2,ma_method2,
                                      applied_price2,indentK2,limit);break;
               default:break;
           }
/*+------------------------------------------------------------------+
ðàñ÷¸ò è îòîáðàæåíèå çíà÷åíèé è ðàñöâåòîê äëÿ èíäèêàòîðà:*/
         int newValues=MathMin(limit-shiftK,ARRAY_SIZE_X);
         if(newValues>0)
           {
            ChangeValuesTable0(1,priceM1buffer,0,newValues,changeClr0,clrK1);
            ChangeValuesTable0(3,priceM2buffer,1,newValues,changeClr1,clrK2);
            ChangeValuesTable1(5,priceM1buffer,priceM2buffer,2,newValues);
           }
/*+------------------------------------------------------------------+*/
        }
     }//  if(timeNewBar!=time[0])
//+------------------------------------------------------------------+
   return(rates_total);
  }//int OnCalculate
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//+------------------------------------------------------------------+
//| Ñîáûòèå ùåë÷êà ìûøè íà ãðàôè÷åñêîì îáúåêòå                       |
//+------------------------------------------------------------------+ 
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
/*+------------------------------------------------------------------+ 
åñëè êëèê ìûøè ïðîèçâåä¸í â ïðåäåëàõ êîîðäèíàò èìåþùåéñÿ ñåé÷àñ íà 
÷àðòå êíîïêè èíäèêàòîðà:*/
      if(lparam>=coordinateX0 && lparam<=coordinateX1 &&
         dparam>=coordinateY0 && dparam<=coordinateY1)
        {
         string clickedChartObject=sparam;
/*è åñëè ýòî êëèê ïî êíîïêå â âèäå ïîëîñû ïîä çàãîëîâêîì òàáëèöû:*/
         if(StringCompare(clickedChartObject,nameObjBut0,true)==0)
           {
            bool stateBut=ObjectGetInteger(0,clickedChartObject,OBJPROP_STATE);
/*è åñëè ïðè ýòîì êëèêå êíîïêà íàæàòà:*/
            if(stateBut==true)
              {
/*òî óäàëåíèå òàáëèöû äëÿ òîãî, ÷òîáû â òî âðåìÿ, ïîêà îíà "ñâ¸ðíóòà", íå áûëî
ñëó÷àéíûõ óäàëåíèé ñ ÷àðòà å¸ êàêèõ-ëèáî îáúåêòîâ (ïðîãðàììíî èëè 
âðó÷íóþ ÷åðåç "Ñïèñîê îáúåêòîâ"):*/
               ObjectsDeleteAll(0,prefixObj,0,EMPTY);
/*çíà÷åíèå ôëàãà, ÷òî åñëè â äàëüíåéøåì øèðèíà ÷àðòà áóäåò èçìåíÿòüñÿ, òî ïåðåñ÷¸ò
ãðàíèöû êëèêîâ ïî êíîïêå "ñâ¸ðíóòîé" òàáëèöû:*/
               switchButtonClick=3;
/*ñîçäàíèå íà ÷àðòå êíîïêè "ñâ¸ðíóòîé" òàáëèöû:*/
               SetButtonMin(switchButtonClick,nameObjBut1,xDistance+heightObj,
                            yDistance,heightObj,heightObj);

               ChartRedraw();
               return;
              }//if(stateBut==true)
           }//if(StringCompare(clickedChartObject,nameObjBut0,true)==0)
/*+------------------------------------------------------------------+                  
èíà÷å, åñëè ýòî êëèê ïî êíîïêå "ñâ¸ðíóòîé" òàáëèöû:*/
         else if(StringCompare(clickedChartObject,nameObjBut1,true)==0)
           {
            bool stateBut=ObjectGetInteger(0,clickedChartObject,OBJPROP_STATE);
            if(stateBut==true)
              {
               ObjDelete(0,nameObjBut1);//óäàëåíèå êíîïêè "ñâ¸ðíóòîé" òàáëèöû
               TableCreate();//îòîáðàæåíèå òàáëèöû íà ÷àðòå

               ChartRedraw();
               return;
              }
           }//if(StringCompare(clickedChartObject,nameObjBut1,true)==0)
         else return;
        }//lparam/dparam
      else return;
     }//  if(id==CHARTEVENT_OBJECT_CLICK)
//+------------------------------------------------------------------+
//| Èçìåíåíèå ðàçìåðîâ ãðàôèêà èëè èçìåíåíèå ñâîéñòâ ãðàôèêà ÷åðåç   |
//| äèàëîã ñâîéñòâ                                                   |
//+------------------------------------------------------------------+ 
   else if(id==CHARTEVENT_CHART_CHANGE)
     {
      int ch=ChartWidthInPixels();
/*åñëè èçìåíèëàñü øèðèíà ãðàôèêà, òî ïåðåñ÷¸ò êîîðäèíàò êíîïîê
 ìèíèìèçàöèè:*/
      if(chartWidthK!=ch)
        {
         chartWidthK=ch;
         switch(switchButtonClick)
           {
            case 1:GetClickCoordinateObj(nameObjBut0); break;
            case 3:GetClickCoordinateObj(nameObjBut1);break;
            default: break;
           }
         return;
        }
      else return;
     }
   return;
  }
//+------------------------------------------------------------------+
//| Óñòàíîâêà è îãðàíè÷åíèÿ ðàçëè÷íûõ ïàðàìåòðîâ â OnInit:           |
//+------------------------------------------------------------------+
bool SetOnInitAny()
  {
/*+------------------------------------------------------------------+
åñëè ÷èñëî ñòðîê ïî îñè X < èëè > îãðàíè÷åíèÿ:*/
   if(ARRAY_SIZE_X<2 || ARRAY_SIZE_X>30)
     {
      Print(LINE_NUMBER,"Error code: ARRAY_SIZE_X.");
      return(false);
     }
/*+------------------------------------------------------------------+
Ýòîò èíäèêàòîð íå áóäåò óäàëÿòü ñâîè îáúåêòû íà ÷àðòå, åñëè áèëä 
òîðãîâîãî òåðìèíàëà ìåíüøå 840, ïîñêîëüêó â í¸ì åñòü ôóíêöèÿ, 
ñòàâøàÿ äîñòóïíîé ñ 840-ãî áèëäà. Ïîýòîìó ïðè çàïóñêå ïðîãðàììû - 
ïðîâåðêà íà íîìåð áèëäà òîðãîâîãî òåðìèíàëà:*/
   if(TerminalInfoInteger(TERMINAL_BUILD)<840)
     {
      Alert("Indicator removed. The client terminal build number < 840.");
      return(false);
     }
//+------------------------------------------------------------------+
/*ïðîâåðêè íà êîððåêòíîñòü ïåðèîäîâ äëÿ ÌÀ:*/
   if(!CheckInput(ma_period1,"Period Moving Averages (1)"))return(false);
   if(!CheckInput(ma_period2,"Period Moving Averages (2)"))return(false);
/*+------------------------------------------------------------------+
åñëè çàäàí íà÷àëüíûé áàð <1, òî íà÷àëüíûé áàð = 1:*/
   shiftK=(shift<1)?1:shiftK=shift;
//+------------------------------------------------------------------+
   timeframe1=PERIOD_CURRENT;
/*äâå ñòðîêè íèæå ïðèìåíèìû òîëüêî äëÿ çíà÷åíèé ÌÀ ñ òåêóùåãî òàéìôðåéìà
è ñèìâîëà:*/
   int minP1=ma_period1+ARRAY_SIZE_X+shiftK+5;
   int minP2=ma_period2+ARRAY_SIZE_X+shiftK+5;

/*ìèíèìàëüíîå êîëè÷åñòâî áàðîâ íà ÷àðòå, ïðè êîòîðîì èíäèêàòîð áóäåò
ðàáîòàòü:*/
   minBars=MathMax(minP1,minP2);
//+------------------------------------------------------------------+
/*óñòàíîâêà ïåðåêëþ÷àòåëÿì çíà÷åíèé ïðèìåíÿòü èëè íå ïðèìåíÿòü 
ôóíêöèþ iMA ïðè ðàáîòå èíäèêàòîðà:*/
   switchMA1=-1;switchMA2=-1;
   SetOnInitSwitchMA(switchMA1,ma_period1,ma_method1,applied_price1);
   SetOnInitSwitchMA(switchMA2,ma_period2,ma_method2,applied_price2);
//+------------------------------------------------------------------+
   dig=(digCh==auto)?Digits():digCh;//êîëè÷åñòâî äåñÿòè÷íûõ çíàêîâ
/*+------------------------------------------------------------------+
äëÿ ïðåîáðàçîâàíèÿ äåëüòû èç äåñÿòè÷íûõ çíàêîâ â âèä öåëîãî ÷èñëà:*/
   pointK=MathPow(10,dig);
/*+------------------------------------------------------------------+
åñëè íå çàäàí îòñòóï îò ÌÀ èëè îí áîëüøå/ìåíüøå îãðàíè÷åíèÿ, òî 
îòñòóï ðàâåí 0:*/
   SetInputIndent(indent1,indentK1);
   SetInputIndent(indent2,indentK2);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ óñòàíîâêè çíà÷åíèé ïåðåêëþ÷àòåëÿ, äëÿ îïðåäåëåíèÿ         |
//|ïðèìåíÿòü èëè íå ïðèìåíÿòü ôóíêöèþ iMA â îñíîâíîì êîäå:           |
//+------------------------------------------------------------------+
int SetOnInitSwitchMA(int &switch_MA,
                      const int ma_period,
                      const ENUM_MA_METHOD ma_method,
                      const ENUM_APPLIED_PRICE applied_price)
  {
   if(ma_period==1 && ma_method==MODE_SMA && (applied_price==PRICE_CLOSE || 
      applied_price==PRICE_OPEN ||applied_price==PRICE_HIGH ||
      applied_price==PRICE_LOW))
     {
/*åñëè â ñâîéñòâàõ âûáðàíà ÌÀ, êàê ïðîñòàÿ ñêîëüçÿùàÿ ñðåäíÿÿ ñ ïåðèîäîì 1
òî ñ÷èòàòü ïî îòìåòêàì áàðîâ, íå ïðèìåíÿÿ iMA:*/
      switch_MA=0;
     }
   else {switch_MA=1;}//èíà÷å, ïðèìåíÿòü iMA
//---
   return(switch_MA);
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ äëÿ ôîðìèðîâàíèÿ çíà÷åíèé òàáëèöû â OnInit:              |
//+------------------------------------------------------------------+
void SetOnInitTable()
  {
//+------------------------------------------------------------------+
   switchButtonClick=-1;chartWidthK=-1;
/*+------------------------------------------------------------------+
öâåò ôîíà ÿ÷ååê òàáëèöû ñî çíà÷åíèÿìè ÌÀ è äåëüò ìåæäó ñàìèìè ÌÀ ïðè
èíèöèàëèçàöèè èíäèêàòîðà*/
   for(int y=0;y<COUNT_BUFFERS+1;y++)
             for(int x=0;x<ARRAY_SIZE_X;x++){backClrObjOddY[y][x]=backClrMain;}
/*+------------------------------------------------------------------+
èìåíà äëÿ îáúåêòîâ òàáëèöû:*/
   NameObjTwoDArray(ARRAY_SIZE_Y,nameObj,"Edit");
   nameObjBut0=StringConcatenate(prefixObj,"B0");
   nameObjBut1=StringConcatenate(prefixObj,"B1");
//+------------------------------------------------------------------+
   TableCreate();//óñòàíîâêà òàáëèöû íà ÷àðò
//+------------------------------------------------------------------+
   return;
  }
//+------------------------------------------------------------------+
//| Ñîçäàíèå êíîïîê ìèíèìèçàöèè, â çàâèñèìîñòè îò óñëîâèé            |
//+------------------------------------------------------------------+
void SetButtonMin(int flag,string name,int x,int y,int width,int height)
  {
   switch(flag)
     {
      case 1:   if(ObjectFind(0,name)<0)
         ButtonCreate(0,name,0,x,y,width,height,
                      CORNER_RIGHT_UPPER,"","\n",
                      "Arial",0,
                      backClrMain,backClrMain,clrNONE,false);
      break;

      case 3:
         if(ObjectFind(0,name)<0)
         ButtonCreate(0,name,0,x,y,width,height,
                      CORNER_RIGHT_UPPER,CharToString(229),"ID Lite Info MA",
                      "Wingdings",fontSize+1,
                      clrBlack,backClrMain,clrNONE,false);
         break;
      default:break;
     }
/*+------------------------------------------------------------------+
ðàñ÷¸ò êîîðäèíàò êíîïêè "ìèíèçàöèè" èëè "ðàçâîðà÷èâàíèÿ" òàáëèöû,
ïðè êëèêå ìûøîé íà êîòîðûå, èíäèêàòîð áóäåò ïðîâîäèòü àíàëèç è ðàñ÷¸òû 
ïî "ìèíèìèçàöèè" èëè "ðàçâîðà÷èâàíèþ" òàáëèöû:*/
   ChartWidthInPixels();
   GetClickCoordinateObj(name);
//---
   return;
  }
//+------------------------------------------------------------------+
//| Óäàëåíèå îáúåêòà ñ îïðåäåë¸ííûì èìåíåì                           |
//+------------------------------------------------------------------+
bool ObjDelete(long chart_ID,string name)
  {
   if(ObjectFind(chart_ID,name)>-1){ObjectDelete(chart_ID,name);}
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ óñòàíîâêè òàáëèöû èíäèêàòîðà:                             |
//|                                                                  |
//|                                                                  |
//+------------------------------------------------------------------+
void TableCreate()
  {
   string toolTipM1=NULL,toolTipM2=NULL,toolTip="Number of bar";

   int xDis=widthObj+DISTANCE_XY,
/*âûñîòà ÿ÷ååê äëÿ çàãîëîâêà òàáëèöû è çíà÷åíèé äåëüò ïîìåíüøå,
÷åì äëÿ îòìåòîê ÌÀ:*/
   heightObjMin=(heightObj/3)*2,
/*øðèôò äëÿ çàãîëîâêà òàáëèöû è çíà÷åíèé äåëüò ìåæäó ñîñåäíèìè
ïîñëåäîâàòåëüíûìè çíà÷åíèÿìè êàæäîé èç ÌÀ, ïîìåíüøå, ÷åì äëÿ
çíà÷åíèé ÌÀ è äåëüò ìåæäó ñàìèìè ÌÀ:*/
   font=fontSize-1;
//+------------------------------------------------------------------+
//|Çàãîëîâîê òàáëèöû:                                                |
//+------------------------------------------------------------------+
   for(int x=0;x<ARRAY_SIZE_X;x++)
     {
      if(ObjectFind(0,nameObj[0][x])<0)
        {
         EditCreate(0,nameObj[0][x],0,xDistance+xDis*(x+DISTANCE_XY),
                    yDistance,widthObj,heightObjMin,IntegerToString(shiftK+x),
                    toolTip,"Arial",font,ALIGN_CENTER,true,CORNER_RIGHT_UPPER,
                    textClrDelta,backClrMain,clrSnow,backObj);
        }
     }
//+------------------------------------------------------------------+
//| Êíîïêà ìèíèìèçàöèè òàáëèöû                                       |
//+------------------------------------------------------------------+
   int xDisBut=(xDis*ARRAY_SIZE_X),
   yDis=yDistance+heightObjMin+DISTANCE_XY,
   widthBut=(widthObj)*(ARRAY_SIZE_X),
   heightBut=(heightObj/3)-1;
/*çíà÷åíèå ôëàãà, ÷òî åñëè â äàëüíåéøåì øèðèíà ÷àðòà áóäåò èçìåíÿòüñÿ,
òî ïåðåñ÷¸ò ãðàíèöû êëèêîâ ïî êíîïêå "ìèíèìèçàöèè" òàáëèöû:*/
   switchButtonClick=1;
/*ñîçäàíèå êíîïêè "ìèíèìèçàöèè" òàáëèöû:"*/
   SetButtonMin(switchButtonClick,nameObjBut0,xDisBut,yDis,widthBut,heightBut);
//+------------------------------------------------------------------+
//| ß÷åéêè òàáëèöû äëÿ çíà÷åíèé ÌÀ è äåëüò ìåæäó ñàìèìè ÌÀ:          |
//+------------------------------------------------------------------+
   int k=COUNT_BUFFERS-1,
   y=COUNT_BUFFERS-1,
   heightObjK=heightObj,
   yDisK=0;
   yDis=coordinateY1+DISTANCE_XY;

/*òåêñò âñïëûâàþùèõ ïîäñêàçîê äëÿ ÌÀ:*/
   toolTipM1=SetToolTipMA(toolTipM1,1,timeframe1,ma_period1,ma_method1,
                          applied_price1);
   toolTipM2=SetToolTipMA(toolTipM2,2,timeframe1,ma_period2,ma_method2,
                          applied_price2);

   do//while(y<ARRAY_SIZE_Y && !IsStopped())
     {
      yDisK=yDis+((heightObjK+heightObjMin)*(y-k))+((DISTANCE_XY*COUNT_BUFFERS)*(y-k));
      switch(y)
        {
         case 1:toolTip=toolTipM1;break;
         case 3:toolTip=toolTipM2;break;
         case 5:toolTip="MA1 - MA2";heightObjK=heightObjMin;break;
        }

      for(int x=0;x<ARRAY_SIZE_X;x++)
        {
         if(ObjectFind(0,nameObj[y][x])<0)
           {
            EditCreate(0,nameObj[y][x],0,xDistance+xDis*(x+DISTANCE_XY),
                       yDisK,widthObj,heightObjK,textObjOddY[y-k][x],toolTip,
                       "Arial",fontSize,ALIGN_RIGHT,true,CORNER_RIGHT_UPPER,
                       textClrMA,backClrObjOddY[y-k][x],clrSnow,backObj);
           }
        }
      y=y+COUNT_BUFFERS;
      k=k+1;
     }
   while(y<ARRAY_SIZE_Y && !IsStopped());
//+------------------------------------------------------------------+
//|ß÷åéêè òàáëèöû äëÿ çíà÷åíèé äåëüò ìåæäó ñîñåäíèìè                 |
//|ïîñëåäîâàòåëüíûìè çíà÷åíèÿìè ÌÀ:                                  |
//+------------------------------------------------------------------+
   k=COUNT_BUFFERS;
   y=COUNT_BUFFERS;
   yDis=yDis+(heightObj+DISTANCE_XY);
   int widthObjD=(widthObj/3)*2;

   do//while(y<ARRAY_SIZE_Y && !IsStopped())
     {
      toolTip=(y==COUNT_BUFFERS)?toolTip=toolTipM1:toolTipM2;
      yDisK=yDis+((heightObj+heightObjMin)*(y-k))+((DISTANCE_XY*COUNT_BUFFERS)*(y-k));
      for(int x=0;x<ARRAY_SIZE_X;x++)
        {
         if(ObjectFind(0,nameObj[y][x])<0)
           {
            EditCreate(0,nameObj[y][x],0,xDistance+xDis*(x+DISTANCE_XY),
                       yDisK,widthObjD,heightObjMin,textObjEvenY[y-k][x],toolTip,
                       "Arial",font,ALIGN_CENTER,true,CORNER_RIGHT_UPPER,
                       textClrObjEvenY[y-k][x],backClrMain,clrSnow,backObj);
           }
        }
      y=y+COUNT_BUFFERS;
      k=k+1;
     }
   while(y<ARRAY_SIZE_Y && !IsStopped());
//---
   return;
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïîëó÷àåò çíà÷åíèå øèðèíû ãðàôèêà â ïèêñåëÿõ.             |
//| Ñêîïèðîâàíà èç:                                                  |
//| Ñïðàâî÷íèê MQL4  / Ñòàíäàðòíûå êîíñòàíòû, ïåðå÷èñëåíèÿ è         |
//| ñòðóêòóðû  / Êîíñòàíòû ãðàôèêîâ / Ïðèìåðû ðàáîòû ñ ãðàôèêîì      |
//| Ìî¸ äîïîëíåíèå: äîáàâëåíà ñòðîêà LINE_NUMBER                     |
//+------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- ïîäãîòîâèì ïåðåìåííóþ äëÿ ïîëó÷åíèÿ çíà÷åíèÿ ñâîéñòâà
   long result=-1;
//--- ñáðîñèì çíà÷åíèå îøèáêè
   ResetLastError();
//--- ïîëó÷èì çíà÷åíèå ñâîéñòâà
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- âûâåäåì ñîîáùåíèå îá îøèáêå â æóðíàë "Ýêñïåðòû"
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
     }
//--- âåðíåì çíà÷åíèå ñâîéñòâà ãðàôèêà
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ îïðåäåëÿåò îáëàñòü îáúåêòà äëÿ êëèêà                     |
//| (CHARTEVENT_OBJECT_CLICK).                                       |
//| äëÿ îáúåêòîâ: OBJ_LABEL (read-only), OBJ_BUTTON, OBJ_BITMAP,     |
//| OBJ_BITMAP_LABEL, OBJ_EDIT, OBJ_RECTANGLE_LABEL.                 |
//+------------------------------------------------------------------+                
//| (ïðè OBJPROP_CORNER: ENUM_BASE_CORNER = CORNER_RIGHT_UPPER)      |
//+------------------------------------------------------------------+
void GetClickCoordinateObj(string name)
  {
   int x1=(int)ObjectGetInteger(0,name,OBJPROP_XDISTANCE);
   int w1=(int)ObjectGetInteger(0,name,OBJPROP_XSIZE);

   coordinateX0=chartWidthK-x1;//>lparam (ãðàíèöà ïî îñè X ñëåâà)
   coordinateX1=coordinateX0+w1;//<lparam (ãðàíèöà ïî îñè X ñïðàâà)

   int h1=(int)ObjectGetInteger(0,name,OBJPROP_YSIZE);
/*dparam (ãðàíèöà ïî îñè Y ñâåðõó):*/
   coordinateY0=(int)ObjectGetInteger(0,name,OBJPROP_YDISTANCE);//> dparam
/*dparam (ãðàíèöà ïî îñè Y ñíèçó):*/
   coordinateY1=coordinateY0+h1;//< dparam
//---
   return;
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ-ïåðåêëþ÷àòåëü, åñëè ìåòîä óñðåäíåíèÿ = MODE_SMA +         |
//|Period Moving Averages = 1 +                                      |
//|applied_price = PRICE_CLOSE/PRICE_OPEN/PRICE_HIGH/PRICE_LOW:      |
//+------------------------------------------------------------------+
void PriceSwitchForBuffer(double &buffer[],
                          ENUM_APPLIED_PRICE applied_price,
                          double indent,int limit)
  {
   switch(applied_price)
     {
      case PRICE_CLOSE:CopyCloseBuffer(buffer,indent,limit);
      break;
      case PRICE_OPEN:CopyOpenBuffer(buffer,indent,limit);
      break;
      case PRICE_HIGH:CopyHighBuffer(buffer,indent,limit);
      break;
      case PRICE_LOW:CopyLowBuffer(buffer,indent,limit);
      break;
      default:break;
     }
//---
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CopyCloseBuffer(double &buffer[],double indent,int limit)
  {
   double dt[];
   ArrayResize(dt,limit,limit+1);
   ArraySetAsSeries(dt,true);

   int copied=CopyClose(symb,timeframe1,0,limit,dt);
   if(copied<limit)
     {
      Print(LINE_NUMBER,"Failed to copy close values. Error code = ",GetLastError());
      return(-1);
     }
   else
     {
      for(int i=limit-1;i>=shiftK;i--)
        {
         buffer[i]=NormalizeDouble(dt[i]+indent,dig);
        }
     }
//---
   return(copied);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CopyOpenBuffer(double &buffer[],double indent,int limit)
  {
   double dt[];
   ArrayResize(dt,limit,limit+1);
   ArraySetAsSeries(dt,true);

   int copied=CopyOpen(symb,timeframe1,0,limit,dt);
   if(copied<limit)
     {
      Print(LINE_NUMBER,"Failed to copy open values. Error code = ",GetLastError());
      return(-1);
     }
   else
     {
      for(int i=limit-1;i>=shiftK;i--)
        {
         buffer[i]=NormalizeDouble(dt[i]+indent,dig);
        }
     }
//---
   return(copied);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CopyHighBuffer(double &buffer[],double indent,int limit)
  {
   double dt[];
   ArrayResize(dt,limit,limit+1);
   ArraySetAsSeries(dt,true);

   int copied=CopyHigh(symb,timeframe1,0,limit,dt);
   if(copied<limit)
     {
      Print(LINE_NUMBER,"Failed to copy high values. Error code = ",GetLastError());
      return(-1);
     }
   else
     {
      for(int i=limit-1;i>=shiftK;i--)
        {
         buffer[i]=NormalizeDouble(dt[i]+indent,dig);
        }
     }
//---
   return(copied);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CopyLowBuffer(double &buffer[],double indent,int limit)
  {
   double dt[];
   ArrayResize(dt,limit,limit+1);
   ArraySetAsSeries(dt,true);

   int copied=CopyLow(symb,timeframe1,0,limit,dt);
   if(copied<limit)
     {
      Print(LINE_NUMBER,"Failed to copy low values. Error code = ",GetLastError());
      return(-1);
     }
   else
     {
      for(int i=limit-1;i>=shiftK;i--)
        {
         buffer[i]=NormalizeDouble(dt[i]+indent,dig);
        }
     }
//---
   return(copied);
  }
//+------------------------------------------------------------------+
//|Ïîëó÷åíèå çíà÷åíèé Moving Averages ÷åðåç iMA:                     |
//+------------------------------------------------------------------+
void PriceIMAforBuffer0(double &buffer[],int ma_period,
                        ENUM_MA_METHOD ma_method,
                        ENUM_APPLIED_PRICE applied_price,
                        double indent,int limit)
  {
   for(int i=limit-1;i>=shiftK;i--)
     {
      buffer[i]=NormalizeDouble(iMA(NULL,timeframe1,
                                ma_period,0,ma_method,
                                applied_price,i)+indent,
                                dig);
     }
//---
   return;
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ äëÿ èçìåíåíèé òåêñòà è ðàñöâåòîê â ÿ÷åéêàõ òàáëèöû.      |
//| Äëÿ íîâûõ äàííûõ ïðîèçâîäèò ïîëíûé ðàñ÷¸ò, äëÿ ïðåæíèõ -         |
//| ïåðåìåùåíèå â òàáëèöå ðàíåå ðàñ÷èòàííûõ çíà÷åíèé.                | 
//+------------------------------------------------------------------+
void ChangeValuesTable0(const int y_name,//èíäåêñ ìàññèâà èì¸í îáúåêòîâ ïî îñè Y 
                        const double &buffers[],//áóôåð ñ öåíàìè
                        int index,// èíäåêñ áóôåðà &buffers[]
                        int newValues,//ñêîëüêî íîâûõ áàðîâ äëÿ ðàñ÷¸òà
                        bool &changeClr[],
                        color &clr,//ïåðåìåííàÿ äëÿ öâåòà 
                        //îòðèñîâêè áóôåðà íà ÷àðòå
                        long chart_ID=0)
  {
   int copyOld=0;
   double deltaK[ARRAY_SIZE_X];
/*+------------------------------------------------------------------+
åñëè êîëè÷åñòâî íîâûõ áàðîâ ìåíüøå ðàíåå óæå ïîñ÷èòàííûõ çíà÷åíèé äëÿ
òàáëèöû, òî ïîìåñòèòü íå òðåáóþùèå ïåðåðàñ÷¸òà äàííûå â êîíåö 
ìàññèâîâ, íå ïðîâîäÿ ïî ýòèì äàííûì ïåðåðàñ÷¸òîâ çíà÷åíèé è ðàñöâåòîê:*/
   copyOld=ARRAY_SIZE_X-newValues;

   if(copyOld>0)//åñëè áûë íå ïîëíûé ïåðåñ÷¸ò çíà÷åíèé
     {
      for(int i=ARRAY_SIZE_X-1;i>=newValues; i--)
        {
         if(StringCompare(textObjOddY[index][i],textObjOddY[index][i-1],true)!=0)
            textObjOddY[index][i]=textObjOddY[index][i-1];
        }
      for(int i=ARRAY_SIZE_X-1;i>=newValues; i--)
        {
         if(backClrObjOddY[index][i]!=backClrObjOddY[index][i-1])
           {
            backClrObjOddY[index][i]=backClrObjOddY[index][i-1];
            textClrObjEvenY[index][i]=textClrObjEvenY[index][i-1];
            changeClr[i]=true;
           }
         else {if(changeClr[i])changeClr[i]=false;}
        }
      for(int i=ARRAY_SIZE_X-1;i>=newValues; i--)
        {
         if(StringCompare(textObjEvenY[index][i],textObjEvenY[index][i-1],true)!=0)
            textObjEvenY[index][i]=textObjEvenY[index][i-1];
        }
     }
/*+------------------------------------------------------------------+
      ïîäãîòîâèòåëüíûå ðàñ÷¸òû ïî åù¸ íåïîñ÷èòàííûì áàðàì:*/
   for(int i=newValues-1;i>=0; i--)//òåêñò ñ íîâûìè çíà÷åíèÿìè öåí
     {
      textObjOddY[index][i]=DoubleToString(buffers[i+shiftK],dig);
     }
//+------------------------------------------------------------------+
   for(int i=newValues-1;i>=0;i--)//òåêñò ñ íîâûìè çíà÷åíèÿìè äåëüòû
     {
      deltaK[i]=NormalizeDouble((buffers[i+shiftK]-buffers[i+shiftK+1])*pointK,0);
      textObjEvenY[index][i]=DoubleToString(deltaK[i],0);
     }
//+------------------------------------------------------------------+
/*öâåòà â òàáëèöå äëÿ íîâûõ äàííûõ:*/
   ChangeColor(index,newValues,deltaK,backClrObjOddY,textClrObjEvenY,
               changeClr,0);
/*+------------------------------------------------------------------+
Òåïåðü, êîãäà äàííûå äëÿ èçìåíåíèé â òàáëèöå íà ÷àðòå ïîäãîòîâëåíû, 
ñìåíà, ïðè íåîáõîäèìîñòè,òåêñòà è ðàñöâåòîê â ñòðîêàõ òàáëèöû ñî
çíà÷åíèÿìè ÌÀ íà ÷àðòå:*/
   if(switchButtonClick==1)//åñëè òàáëèöà ïî òåîðèè ñåé÷àñ íà ÷àðòå
     {
      for(int i=ARRAY_SIZE_X-1;i>=0;i--)
        {
/*è åñëè åñòü ýòîò îáúåêò òàáëèöû íà ÷àðòå:*/
         if(ObjectFind(0,nameObj[y_name][i])>-1)
           {
/*òî ïðîâîäèòü âèçóàëüíûå èçìåíåíèÿ â òàáëèöå, åñëè ïðåæíèé òåêñò íå ðàâåí
íîâîìó:*/
            string text=ObjectGetString(chart_ID,nameObj[y_name][i],OBJPROP_TEXT);
            if(StringCompare(text,textObjOddY[index][i],true)!=0)
              {
               ObjSetString(0,nameObj[y_name][i],OBJPROP_TEXT,textObjOddY[index][i]);
              }
/*çàîäíî, åñëè ïðåæíåå çíà÷åíèå öâåòà ôîíà ýòîãî îáúåêòà â òàáëèöå íå ðàâíî íîâîìó,
 òî ïåðåêðàñêà ôîíà â íîâûé öâåò:*/
            if(changeClr[i]==true)
              {
               ObjSetIntegerColor(0,nameObj[y_name][i],OBJPROP_BGCOLOR,backClrObjOddY[index][i]);
               changeClr[i]=false;
              }
           }
        }
/*+---------------------------------------------------------------------------+
Ñìåíà, ïðè íåîáõîäèìîñòè, òåêñòà è ðàñöâåòîê â ñòðîêàõ òàáëèöû ñî çíà÷åíèÿìè
äåëüòû:*/
      for(int i=ARRAY_SIZE_X-1;i>=0;i--)
        {
/*åñëè åñòü ýòîò îáúåêò òàáëèöû íà ÷àðòå:*/
         if(ObjectFind(0,nameObj[y_name+1][i])>-1)
           {
/*òî ïðîâîäèòü âèçóàëüíûå èçìåíåíèÿ â òàáëèöå íà ÷àðòå, åñëè ïðåæíèé òåêñò
íå ðàâåí íîâîìó:*/
            string text=ObjectGetString(chart_ID,nameObj[y_name+1][i],OBJPROP_TEXT);
            if(StringCompare(text,textObjEvenY[index][i],true)!=0)
              {
               ObjSetString(0,nameObj[y_name+1][i],OBJPROP_TEXT,textObjEvenY[index][i]);
              }
/*çàîäíî, åñëè çíà÷åíèå öâåòà òåêñòà îáúåêòà íà ÷àðòå íå ðàâíî íîâîìó,
òî ïåðåêðàñêà òåêñòà â íîâûé öâåò:*/
            if(changeClr[i]==true)
              {
               ObjSetIntegerColor(0,nameObj[y_name+1][i],OBJPROP_COLOR,textClrObjEvenY[index][i]);
              }
           }
        }
     }// if(switchButtonClick==1)
/*+------------------------------------------------------------------+
ñìåíà öâåòà ëèíèè èíäèêàòîðà, â çàâèñèìîñòè îò äåëüòû ìåæäó 
ïîñëåäîâàòåëüíûìè çíà÷åíèÿìè ÌÀ (íà îñíîâå öâåòà ìåæäó ïåðâûì çàäàííûì
â ñâîéñòâàõ áàðîì è åìó ïðåäøåñòâóþùèì):*/
   if(showLine)//åñëè â ñâîéñòâàõ âûáðàíî ïîêàçûâàòü ëèíèþ íà ÷àðòå
     {
      if(clr!=textClrObjEvenY[index][0])
        {
         clr=textClrObjEvenY[index][0];
         SetIndexStyle(index,DRAW_LINE,EMPTY,EMPTY,clr);
        }
     }
//+------------------------------------------------------------------+
   return;
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ äëÿ ðàñ÷¸òà è èçìåíåíèé òåêñòà â ÿ÷åéêàõ òàáëèöû äëÿ     |
//| äåëüò ìåæäó ñàìèìè ÌÀ (ïðè ïîñòóïëåíèè íîâûõ áàðîâ,ïðè           |
//| íåîáõîäèìîñòè).                                                  |
//| Äëÿ íîâûõ äàííûõ ïðîèçâîäèò ïîëíûé ðàñ÷¸ò, äëÿ ïðåæíèõ -         |
//| ïåðåìåùåíèå â òàáëèöå ðàíåå ðàñ÷èòàííûõ çíà÷åíèé.                | 
//+------------------------------------------------------------------+
void ChangeValuesTable1(const int y_name,//èíäåêñ ïî îñè Y ìàññèâà èì¸í îáúåêòîâ
                        const double &buffers0[],//áóôåð ñ öåíàìè ïåðâîé ÌÀ
                        const double &buffers1[],//áóôåð ñ öåíàìè âòîðîé ÌÀ
                        int y_text,// èíäåêñ èçìåíÿåìîé ñòðîêè ïî îñè Y 
                        int newValues,//ñêîëüêî íîâûõ áàðîâ äëÿ ðàñ÷¸òà
                        long chart_ID=0)
  {
   int copyOld=0;
/*+------------------------------------------------------------------+
åñëè êîëè÷åñòâî íîâûõ áàðîâ ìåíüøå ðàíåå óæå ïîñ÷èòàííûõ çíà÷åíèé äëÿ
òàáëèöû, òî ïîìåñòèòü íå òðåáóþùèå ïåðåðàñ÷¸òà äàííûå â êîíåö 
ìàññèâîâ, íå ïðîâîäÿ ïî ýòèì äàííûì ïåðåðàñ÷¸òîâ:*/
   copyOld=ARRAY_SIZE_X-newValues;
   if(copyOld>0)//åñëè áûë íå ïîëíûé ïåðåñ÷¸ò çíà÷åíèé
     {
      for(int i=ARRAY_SIZE_X-1;i>=newValues; i--)
        {
         if(StringCompare(textObjOddY[y_text][i],textObjOddY[y_text][i-1],true)!=0)
            textObjOddY[y_text][i]=textObjOddY[y_text][i-1];
        }
     }
/*+------------------------------------------------------------------+
      ïîäãîòîâèòåëüíûå ðàñ÷¸òû ïî åù¸ íåïîñ÷èòàííûì áàðàì:*/
   for(int i=newValues-1;i>=0; i--)//òåêñò ñ íîâûìè çíà÷åíèÿìè öåí
     {
      double valueDelta=MathAbs((buffers0[i+shiftK]-buffers1[i+shiftK])*pointK);
      textObjOddY[y_text][i]=DoubleToString(valueDelta,0);
     }

/*+------------------------------------------------------------------+
Òåïåðü, êîãäà äàííûå äëÿ èçìåíåíèé â òàáëèöå ïîäãîòîâëåíû, ñìåíà, ïðè 
íåîáõîäèìîñòè,òåêñòà â ñòðîêàõ òàáëèöû ñî çíà÷åíèÿìè äåëüò ìåæäó ñàìèìè ÌÀ:*/
   if(switchButtonClick==1)//åñëè òàáëèöà ïî òåîðèè ñåé÷àñ íà ÷àðòå
     {
      for(int i=ARRAY_SIZE_X-1;i>=0;i--)
        {
/*è åñëè ýòîò îáúåêò òàáëèöû åñòü íà ÷àðòå:*/
         if(ObjectFind(0,nameObj[y_name][i])>-1)
           {
/*òî ïðîâîäèòü èçìåíåíèÿ ñ òåêñòîì ýòîãî îáúåêòà, åñëè åãî ïðåæíèé òåêñò
íà ÷àðòå íå ðàâåí íîâîìó:*/
            string text=ObjectGetString(chart_ID,nameObj[y_name][i],OBJPROP_TEXT);
            if(StringCompare(text,textObjOddY[y_text][i],true)!=0)
              {
               ObjSetString(0,nameObj[y_name][i],OBJPROP_TEXT,textObjOddY[y_text][i]);
              }
           }
        }
     }
//+------------------------------------------------------------------+
   return;
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïðîâåðêè ïåðèîäà âî âõîäíûõ ïàðàìåòðàõ íà ñîîòâåòñòâèå   |
//| îãðàíè÷åíèÿì â èíäèêàòîðå (3000 - ýòî ïàðàìåòð îãðàíè÷åíèÿ       |
//| ìàêñèìàëüíîãî çíà÷åíèÿ ïåðèîäà ÌÀ è îí çàäàí ïðîèçâîëüíî):       |
//+------------------------------------------------------------------+
bool CheckInput(int period,string text)
  {
   string t=NULL;
   if(period<1 || period>3000)
     {
      t=StringConcatenate("Indicator removed. ",text,": < 1 or > 3000.");
      Alert(t);
      return(false);
     }
   return(true);
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ ïðåîáðàçóåò è çàäà¸ò îòñòóï èç ÷èñëà int â âèä ÷èñëà      | 
//|double:                                                           |
//+------------------------------------------------------------------+
double SetInputIndent(const int indent,//îòñòóï â ïóíêòàõ, çàäàííûé âî âíåøíèõ ïàðàìåòðàõ
                      double &indentK)//íàèìåíîâàíèå ïåðåìåííîé, ïðèìåíÿåìîé â êîäå äëÿ îòñòóïîâ

  {
   int p=(int)(100*pointK);//ìàêñèìàëüíîå çíà÷åíèå îòñòóïà â ïóíêòàõ  
   int ind0=(int)MathAbs(indent);
/*+------------------------------------------------------------------+
åñëè íå çàäàí îòñòóï ââåðõ èëè âíèç îò ÌÀ èëè îí áîëüøå/ìåíüøå îãðàíè÷åíèÿ,
òî îòñòóï ðàâåí 0:*/
   indentK=(ind0==0 || ind0>=p)?0.0:indent*Point();
//+------------------------------------------------------------------+
   return(indentK);
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ çàäà¸ò èìåíà îáúåêòàì äâóìåðíîãî ìàññèâà                 |
//+------------------------------------------------------------------+
void NameObjTwoDArray(int countY,//ñêîëüêî ñòðîê ïî îñè Y
                      string &array[][ARRAY_SIZE_X],//ìàññèâ äëÿ èì¸í îáúåêòîâ
                      string dt="_")//ìèíè-ïðåôèêñ)
  {
   string text=NULL;
   for(int y=0;y<countY;y++)
      for(int x=0;x<ARRAY_SIZE_X;x++)
        {
         text=StringConcatenate(prefixObj,dt,IntegerToString(y),
                                IntegerToString(x));
         array[y][x]=text;
        }
//---
   return;
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ ñîçäàåò êíîïêó.                                           |
//|Ñîñòàâëåíà íà îñíîâå âçÿòîé èç:                                   |
//|Ñïðàâî÷íèê MQL5  / Ñòàíäàðòíûå êîíñòàíòû, ïåðå÷èñëåíèÿ è          |
//|ñòðóêòóðû  / Êîíñòàíòû îáúåêòîâ  / Òèïû îáúåêòîâ / OBJ_BUTTON     |
//+------------------------------------------------------------------+
bool ButtonCreate(const long              chart_ID=0,               // ID ãðàôèêà
                  const string            name="Button",            // èìÿ êíîïêè
                  const int               sub_window=0,             // íîìåð ïîäîêíà
                  const int               x=0,                      // êîîðäèíàòà ïî îñè X
                  const int               y=0,                      // êîîðäèíàòà ïî îñè Y
                  const int               width=50,                 // øèðèíà êíîïêè
                  const int               height=18,                // âûñîòà êíîïêè
                  const ENUM_BASE_CORNER  corner=CORNER_LEFT_UPPER, // óãîë ãðàôèêà äëÿ ïðèâÿçêè
                  const string            text="Button",            // òåêñò
                  const string            toolTip="\n",             // òåêñò âñïëûâàþùåé ïîäñêàçêè
                  const string            font="Arial",             // øðèôò
                  const int               font_size=10,             // ðàçìåð øðèôòà
                  const color             clr=clrBlack,             // öâåò òåêñòà
                  const color             back_clr=C'236,233,216',  // öâåò ôîíà
                  const color             border_clr=clrNONE,       // öâåò ãðàíèöû
                  const bool              state=false,              // íàæàòà/îòæàòà
                  const bool              back=false,               // íà çàäíåì ïëàíå
                  const bool              selection=false,          // âûäåëèòü äëÿ ïåðåìåùåíèé
                  const bool              hidden=true,              // ñêðûò â ñïèñêå îáúåêòîâ
                  const long              z_order=0,                // ïðèîðèòåò íà íàæàòèå ìûøüþ
                  const int               timeframes=OBJ_ALL_PERIODS)//îòîáðàæåíèå îáúåêòà íà ðàçëè÷íûõ ïåðèîäàõ
  {
//--- ñáðîñèì çíà÷åíèå îøèáêè
   ResetLastError();
//--- ñîçäàäèì êíîïêó
   if(!ObjectCreate(chart_ID,name,OBJ_BUTTON,sub_window,0,0))
     {
      Print(LINE_NUMBER,__FUNCTION__,
            ": failed to create the button! Error code = ",GetLastError());
      return(false);
     }
   ObjSetIntegerInt(chart_ID,name,OBJPROP_XDISTANCE,x);//Çàäà¸ò äèñòàíöèþ â ïèêñåëÿõ ïî îñè X îò óãëà ïðèâÿçêè 
   ObjSetIntegerInt(chart_ID,name,OBJPROP_YDISTANCE,y);//Çàäà¸ò äèñòàíöèþ â ïèêñåëÿõ ïî îñè Y îò óãëà ïðèâÿçêè 
   ObjSetIntegerInt(chart_ID,name,OBJPROP_XSIZE,width);//Çàäà¸ò øèðèíó îáúåêòà ïî îñè X â ïèêñåëÿõ.
   ObjSetIntegerInt(chart_ID,name,OBJPROP_YSIZE,height);//Çàäà¸ò øèðèíó îáúåêòà ïî îñè Y â ïèêñåëÿõ.
   ObjSetIntegerCorner(chart_ID,name,corner);//Çàäà¸ò óãîë ãðàôèêà äëÿ ïðèâÿçêè ãðàôè÷åñêîãî îáúåêòà 
   ObjSetString(chart_ID,name,OBJPROP_TOOLTIP,toolTip);//Çàäàåò òåêñò âñïëûâàþùåé ïîäñêàçêè
   ObjSetString(chart_ID,name,OBJPROP_TEXT,text);//Çàäàåò îïèñàíèå îáúåêòà (òåêñò, ñîäåðæàùèéñÿ â îáúåêòå) 
   ObjSetString(chart_ID,name,OBJPROP_FONT,font);//Çàäà¸ò øðèôò
   ObjSetIntegerInt(chart_ID,name,OBJPROP_FONTSIZE,font_size);//Çàäà¸ò ðàçìåð øðèôòà
   ObjSetIntegerColor(chart_ID,name,OBJPROP_COLOR,clr);//Çàäàåò öâåò òåêñòà èëè îáúåêòà(åñëè ëèíèÿ è ò.ä.)
   ObjSetIntegerColor(chart_ID,name,OBJPROP_BGCOLOR,back_clr);//Çàäàåò ôîí äëÿ OBJ_EDIT, OBJ_BUTTON, OBJ_RECTANGLE_LABEL 
   ObjSetIntegerColor(chart_ID,name,OBJPROP_BORDER_COLOR,border_clr);//Çàäàåò öâåò ðàìêè äëÿ îáúåêòà OBJ_EDIT è OBJ_BUTTON
   ObjSetIntegerBool(chart_ID,name,OBJPROP_BACK,back);//Çàäàåò îáúåêò íà çàäíåì ïëàíå(true) èëè íà ïåðåäíåì (false)
   ObjSetIntegerBool(chart_ID,name,OBJPROP_STATE,state);//OBJPROP_STATE Çàäà¸ò ñîñòîÿíèå êíîïêè (íàæàòà = true/îòæàòà = false 
   ObjSetIntegerBool(chart_ID,name,OBJPROP_SELECTABLE,selection);
   ObjSetIntegerBool(chart_ID,name,OBJPROP_SELECTED,selection);//Çàäàåò âûäåëåííîñòü îáúåêòà(true) èëè íå âûäåëåííîñòü(false)
   ObjSetIntegerBool(chart_ID,name,OBJPROP_HIDDEN,hidden);//Çàäàåò ñêðûòèå (true) èëè îòîáðàæåíèå (false) èìåíè ãðàôè÷åñêîãî îáúåêòà â ñïèñêå îáúåêòîâ
   ObjSetIntegerLong(chart_ID,name,OBJPROP_ZORDER,z_order);//Çàäà¸ò ïðèîðèòåò íà íàæàòèå ìûøüþ
   ObjSetIntegerInt(chart_ID,name,OBJPROP_TIMEFRAMES,timeframes);//Çàäàåò îòîáðàæåíèå îáúåêòà íà ðàçëè÷íûõ ïåðèîäàõ.
//--- óñïåøíîå âûïîëíåíèå
   return(true);
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ ñîçäàåò îáúåêò "Ïîëå ââîäà".                              |
//|Ñîñòàâëåíà íà îñíîâå âçÿòîé èç:                                   |
//|Ñïðàâî÷íèê MQL5 / Ñòàíäàðòíûå êîíñòàíòû, ïåðå÷èñëåíèÿ è           |
//|ñòðóêòóðû / Êîíñòàíòû îáúåêòîâ / Òèïû îáúåêòîâ / OBJ_EDIT         |  
//+------------------------------------------------------------------+
bool EditCreate(const long             chart_ID=0,               // ID ãðàôèêà
                const string           name="Edit",              // èìÿ îáúåêòà
                const int              sub_window=0,             // íîìåð ïîäîêíà
                const int              x=0,                      // êîîðäèíàòà ïî îñè X
                const int              y=0,                      // êîîðäèíàòà ïî îñè Y
                const int              width=50,                 // øèðèíà
                const int              height=20,                // âûñîòà
                const string           text="Text",              // òåêñò
                const string           toolTip="\n",             // òåêñò âñïëûâàþùåé ïîäñêàçêè
                const string           font="Arial",             // øðèôò
                const int              font_size=9,              // ðàçìåð øðèôòà
                const ENUM_ALIGN_MODE  align=ALIGN_CENTER,       // ñïîñîá âûðàâíèâàíèÿ
                const bool             read_only=false,          // âîçìîæíîñòü ðåäàêòèðîâàòü
                const ENUM_BASE_CORNER corner=CORNER_LEFT_UPPER, // óãîë ãðàôèêà äëÿ ïðèâÿçêè
                const color            clr=clrBlack,             // öâåò òåêñòà
                const color            back_clr=clrWhite,        // öâåò ôîíà
                const color            border_clr=clrNONE,       // öâåò ãðàíèöû
                const bool             back=false,               // íà çàäíåì ïëàíå
                const bool             selection=false,          // âûäåëèòü äëÿ ïåðåìåùåíèé
                const bool             hidden=true,              // ñêðûò â ñïèñêå îáúåêòîâ
                const long             z_order=0,                // ïðèîðèòåò íà íàæàòèå ìûøüþ
                const int             timeframes=OBJ_ALL_PERIODS)//îòîáðàæåíèå îáúåêòà íà ðàçëè÷íûõ ïåðèîäàõ
  {
//--- ñáðîñèì çíà÷åíèå îøèáêè
   ResetLastError();
//--- ñîçäàäèì ïîëå ââîäà
   if(!ObjectCreate(chart_ID,name,OBJ_EDIT,sub_window,0,0))
     {
      Print(LINE_NUMBER,__FUNCTION__,
            ": failed to create \"Edit\" object! Error code = ",GetLastError());
      return(false);
     }
   ObjSetIntegerInt(chart_ID,name,OBJPROP_XDISTANCE,x);//Çàäà¸ò äèñòàíöèþ â ïèêñåëÿõ ïî îñè X îò óãëà ïðèâÿçêè
   ObjSetIntegerInt(chart_ID,name,OBJPROP_YDISTANCE,y);//Çàäà¸ò äèñòàíöèþ â ïèêñåëÿõ ïî îñè Y îò óãëà ïðèâÿçêè 
   ObjSetIntegerInt(chart_ID,name,OBJPROP_XSIZE,width);//Çàäà¸ò øèðèíó îáúåêòà ïî îñè X â ïèêñåëÿõ.
   ObjSetIntegerInt(chart_ID,name,OBJPROP_YSIZE,height);//Çàäà¸ò øèðèíó îáúåêòà ïî îñè Y â ïèêñåëÿõ.
   ObjSetString(chart_ID,name,OBJPROP_TOOLTIP,toolTip);//Çàäàåò òåêñò âñïëûâàþùåé ïîäñêàçêè 
   ObjSetString(chart_ID,name,OBJPROP_TEXT,text);//Çàäàåò îïèñàíèå îáúåêòà (òåêñò, ñîäåðæàùèéñÿ â îáúåêòå)
   ObjSetString(chart_ID,name,OBJPROP_FONT,font);//Çàäà¸ò øðèôò
   ObjSetIntegerInt(chart_ID,name,OBJPROP_FONTSIZE,font_size);//Çàäà¸ò ðàçìåð øðèôòà
   ObjSetIntegerAlign(chart_ID,name,align);//Çàäà¸ò ãîðèçîíòàëüíîå âûðàâíèâàíèå òåêñòà â îáúåêòå "Ïîëå ââîäà" (OBJ_EDIT)
   ObjSetIntegerBool(chart_ID,name,OBJPROP_READONLY,read_only);//Çàäàåò âîçìîæíîñòü íå(true)/ðåäàêòèðîâàòü(false) òåêñò â ïîëå ââîäà
   ObjSetIntegerCorner(chart_ID,name,corner);//Çàäà¸ò óãîë ãðàôèêà äëÿ ïðèâÿçêè ãðàôè÷åñêîãî îáúåêòà 
   ObjSetIntegerColor(chart_ID,name,OBJPROP_COLOR,clr);//Çàäàåò öâåò òåêñòà èëè îáúåêòà(åñëè ëèíèÿ è ò.ä.)
   ObjSetIntegerColor(chart_ID,name,OBJPROP_BGCOLOR,back_clr);//Çàäàåò ôîí äëÿ OBJ_EDIT, OBJ_BUTTON, OBJ_RECTANGLE_LABEL 
   ObjSetIntegerColor(chart_ID,name,OBJPROP_BORDER_COLOR,border_clr);//Çàäàåò öâåò ðàìêè äëÿ îáúåêòà OBJ_EDIT è OBJ_BUTTON
   ObjSetIntegerBool(chart_ID,name,OBJPROP_BACK,back);//Çàäàåò îáúåêò íà çàäíåì ïëàíå(true) èëè íà ïåðåäíåì (false)
   ObjSetIntegerBool(chart_ID,name,OBJPROP_SELECTABLE,selection);
   ObjSetIntegerBool(chart_ID,name,OBJPROP_SELECTED,selection);//Çàäàåò âûäåëåííîñòü îáúåêòà(true) èëè íå âûäåëåííîñòü(false)
   ObjSetIntegerBool(chart_ID,name,OBJPROP_HIDDEN,hidden);//Çàäàåò ñêðûòèå (true) èëè îòîáðàæåíèå (false) èìåíè ãðàôè÷åñêîãî îáúåêòà â ñïèñêå îáúåêòîâ
   ObjSetIntegerLong(chart_ID,name,OBJPROP_ZORDER,z_order);//Çàäà¸ò ïðèîðèòåò íà íàæàòèå ìûøüþ
   ObjSetIntegerInt(chart_ID,name,OBJPROP_TIMEFRAMES,timeframes);//Çàäàåò îòîáðàæåíèå îáúåêòà íà ðàçëè÷íûõ ïåðèîäàõ
//--- óñïåøíîå âûïîëíåíèå
   return(true);
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ çàäà¸ò òåêñò âñïëûâàþùåé ïîäñêàçêè ñ óñòàíîâî÷íûìè        | 
//|ïàðàìåòðàìè ÌÀ                                                    |
//+------------------------------------------------------------------+
string SetToolTipMA(string &name,int n,ENUM_TIMEFRAMES timeframe,
                    int ma_period,ENUM_MA_METHOD ma_method,
                    ENUM_APPLIED_PRICE applied_price)
  {
   name=StringConcatenate("MA ",n,": ",EnumToString(timeframe),
                          ",\r\nma_period: ",ma_period,",\r\n",EnumToString(ma_method),
                          ",\r\n",EnumToString(applied_price),",\r\nshift: ",shiftK);
//---
   return(name);
  }
//+------------------------------------------------------------------+
//|Ôóíêöèÿ çàäà¸ò öâåò â ñòðîêå ìàññèâà, â çàâèñèìîñòè îò óñëîâèÿ    |
//|(íà îñíîâå ñðàâíåíèÿ çíà÷åíèÿ äåëüòû ñ íóë¸ì):                    |  
//+------------------------------------------------------------------+
void ChangeColor(int y,//ñòðîêà ìàññèâà ïî îñè Y
                 int newValues,//ñðåäè ñêîëüêè îáúåêòîâ ïî îñè X îïðåäåëÿòü íîâûå çíà÷åíèÿ
                 double &price[ARRAY_SIZE_X],//ìàññèâ ñ íîâûìè çíà÷åíèÿìè äåëüò 
                 color &back_clr[][ARRAY_SIZE_X],//öâåò ôîíà 
                 color &clr[][ARRAY_SIZE_X],//öâåò òåêñòà
                 bool &changeClr[],
                 const int digits)
  {
   color color1=0,color2=0;

   for(int x=newValues-1;x>=0;x--)//öâåòà â òàáëèöå äëÿ íîâûõ äàííûõ
     {
      if(NormalizeDouble(price[x],digits)>0)
        {color1=color2=backClrUp;} //åñëè price[1]>price[2]
      else if(NormalizeDouble(price[x],digits)<0)
        {color1=color2=backClrDown;} //åñëè price[1]<price[2]
      else if(NormalizeDouble(price[x],digits)==0)
        {color1=backClrMain;color2=textClrDelta;} //price[1]=price[2]      
      //---
      if(back_clr[y][x]!=color1)
        {
         back_clr[y][x]=color1;
         clr[y][x]=color2;
         changeClr[x]=true;
        }
      else{changeClr[x]=false;}
     }
//---
   return;
  }//void ChangeColor
//+------------------------------------------------------------------+
//|ObjectSetString (Óñòàíîâêà çíà÷åíèÿ ñâîéñòâà, íå èìåþùåãî ìîäèôèêàòîðà)
//+------------------------------------------------------------------+
//|ENUM_OBJECT_PROPERTY_STRING:
//+------------------------------------------------------------------+
//|OBJPROP_NAME - Èìÿ îáúåêòà - string;
//+------------------------------------------------------------------+
//|OBJPROP_TEXT - Îïèñàíèå îáúåêòà (òåêñò, ñîäåðæàùèéñÿ â îáúåêòå)- string;
//+------------------------------------------------------------------+
//|OBJPROP_TOOLTIP - Òåêñò âñïëûâàþùåé ïîäñêàçêè. Åñëè ñâîéñòâî íå çàäàíî,
//|òî ïîêàçûâàåòñÿ ïîäñêàçêà, àâòîìàòè÷åñêè ñôîðìèðîâàííàÿ òåðìèíàëîì.
//|Ìîæíî  îòêëþ÷èòü ïîêàç ïîäñêàçêè, óñòàíîâèâ äëÿ íåå çíà÷åíèå "\n" (ïåðåâîä ñòðîêè)- string;
//+------------------------------------------------------------------+
//|OBJPROP_LEVELTEXT - Îïèñàíèå óðîâíÿ - string    ìîäèôèêàòîð=íîìåð óðîâíÿ;
//+------------------------------------------------------------------+
//|OBJPROP_FONT - Øðèôò - string;
//+------------------------------------------------------------------+
//|OBJPROP_BMPFILE - Èìÿ BMP-ôàéëà äëÿ îáúåêòà "Ãðàôè÷åñêàÿ ìåòêà". Ñì. òàêæå Ðåñóðñû - string
//|ìîäèôèêàòîð: 0-ñîñòîÿíèå ON, 1-ñîñòîÿíèå OFF;
//+------------------------------------------------------------------+
//|OBJPROP_SYMBOL Ñèìâîë äëÿ îáúåêòà "Ãðàôèê" - string.
//+------------------------------------------------------------------+
bool ObjSetString(long chart_ID,string name,ENUM_OBJECT_PROPERTY_STRING pr,string font)
  {
   ResetLastError();
//---
   if(!ObjectSetString(chart_ID,name,pr,font))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|ObjectSetIntegerColor (Óñòàíîâêà çíà÷åíèÿ ñâîéñòâà, íå èìåþùåãî ìîäèôèêàòîðà)
//|ENUM_OBJECT_PROPERTY_INTEGER:
//+------------------------------------------------------------------+
//|OBJPROP_COLOR - Öâåò (â çàâèñèìîñòè îò òèïà îáúåêòà ýòî öâåò ëèíèè,
//|òåêñòà  è ò.ä.) - color;
//+------------------------------------------------------------------+
//|OBJPROP_LEVELCOLOR - Öâåò ëèíèè-óðîâíÿ - color ìîäèôèêàòîð=íîìåð óðîâíÿ;
//+------------------------------------------------------------------+
//|OBJPROP_BGCOLOR - Öâåò ôîíà äëÿ OBJ_EDIT, OBJ_BUTTON, OBJ_RECTANGLE_LABEL - color;
//+------------------------------------------------------------------+
//|OBJPROP_BORDER_COLOR - Öâåò ðàìêè äëÿ îáúåêòà OBJ_EDIT è OBJ_BUTTON - color;
//+------------------------------------------------------------------+
bool ObjSetIntegerColor(long chart_ID,string name,ENUM_OBJECT_PROPERTY_INTEGER pr,color dt)
  {
   ResetLastError();
//---
   if(!ObjectSetInteger(chart_ID,name,pr,dt))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|ObjectSetIntegerInt (Óñòàíîâêà çíà÷åíèÿ ñâîéñòâà, íå èìåþùåãî ìîäèôèêàòîðà)
//|ENUM_OBJECT_PROPERTY_INTEGER:
//+------------------------------------------------------------------+
//|OBJPROP_WIDTH - Òîëùèíà ëèíèè - int;
//+------------------------------------------------------------------+
//|OBJPROP_LEVELS - Êîëè÷åñòâî óðîâíåé - int;
//+------------------------------------------------------------------+
//|OBJPROP_LEVELWIDTH - Òîëùèíà ëèíèè-óðîâíÿ - int ìîäèôèêàòîð=íîìåð óðîâíÿ;
//+------------------------------------------------------------------+
//|OBJPROP_FONTSIZE - Ðàçìåð øðèôòà - int;
//+------------------------------------------------------------------+
//|OBJPROP_TIMEFRAMES - Âèäèìîñòü îáúåêòà íà òàéìôðåéìàõ - íàáîð ôëàãîâ flags;int
//+------------------------------------------------------------------+
//|OBJPROP_XDISTANCE - Äèñòàíöèÿ â ïèêñåëÿõ ïî îñè X îò óãëà 
//|ïðèâÿçêè (ñì. ïðèìå÷àíèå) - int;
//+------------------------------------------------------------------+
//|OBJPROP_YDISTANCE - Äèñòàíöèÿ â ïèêñåëÿõ ïî îñè Y îò óãëà
//|ïðèâÿçêè (ñì. ïðèìå÷àíèå) - int;
//+------------------------------------------------------------------+
//|OBJPROP_XSIZE - Øèðèíà îáúåêòà ïî îñè X â ïèêñåëÿõ. Çàäàåòñÿ äëÿ
//|îáúåêòîâ OBJ_LABEL (read only), OBJ_BUTTON, OBJ_CHART, OBJ_BITMAP,
//|OBJ_BITMAP_LABEL, OBJ_EDIT, OBJ_RECTANGLE_LABEL. - int;
//+------------------------------------------------------------------+
//|OBJPROP_YSIZE - Âûñîòà îáúåêòà ïî îñè Y â ïèêñåëÿõ. Çàäàåòñÿ äëÿ 
//|îáúåêòîâ OBJ_LABEL (read only), OBJ_BUTTON, OBJ_CHART, OBJ_BITMAP,
//|OBJ_BITMAP_LABEL, OBJ_EDIT, OBJ_RECTANGLE_LABEL. - int;
//+------------------------------------------------------------------+
//|OBJPROP_XOFFSET - X-êîîðäèíàòà ëåâîãî âåðõíåãî óãëà ïðÿìîóãîëüíîé îáëàñòè
//|âèäèìîñòè  â ãðàôè÷åñêèõ îáúåêòàõ "Ãðàôè÷åñêàÿ ìåòêà" è
//|"Ðèñóíîê" (OBJ_BITMAP_LABEL è OBJ_BITMAP). Çíà÷åíèå çàäàåòñÿ â ïèêñåëÿõ
//|îòíîñèòåëüíîãî âåðõíåãî ëåâîãî óãëà èñõîäíîãî èçîáðàæåíèÿ. - int;
//+------------------------------------------------------------------+
//|OBJPROP_YOFFSET - Y-êîîðäèíàòà ëåâîãî âåðõíåãî óãëà ïðÿìîóãîëüíîé îáëàñòè
//|âèäèìîñòè  â ãðàôè÷åñêèõ îáúåêòàõ "Ãðàôè÷åñêàÿ ìåòêà" è
//|"Ðèñóíîê" (OBJ_BITMAP_LABEL è OBJ_BITMAP). Çíà÷åíèå çàäàåòñÿ â ïèêñåëÿõ
//|îòíîñèòåëüíîãî âåðõíåãî ëåâîãî óãëà èñõîäíîãî èçîáðàæåíèÿ. - int;
//+------------------------------------------------------------------+
//|OBJPROP_CHART_SCALE - Ìàñøòàá äëÿ îáúåêòà "Ãðàôèê" - int   çíà÷åíèå â äèàïàçîíå 0–5
//+------------------------------------------------------------------+
bool ObjSetIntegerInt(long chart_ID,string name,ENUM_OBJECT_PROPERTY_INTEGER pr,int dt)
  {
   ResetLastError();
//---
   if(!ObjectSetInteger(chart_ID,name,pr,dt))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|Çàäà¸ò óãîë ãðàôèêà äëÿ ïðèâÿçêè ãðàôè÷åñêîãî îáúåêòà
//+------------------------------------------------------------------+
//|OBJPROP_CORNER - Óãîë ãðàôèêà äëÿ ïðèâÿçêè ãðàôè÷åñêîãî îáúåêòà - ENUM_BASE_CORNER;
//+------------------------------------------------------------------+
bool ObjSetIntegerCorner(long chart_ID,string name,ENUM_BASE_CORNER corner)
  {
   ResetLastError();
//---
   if(!ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|ObjectSetIntegerBool (Óñòàíîâêà çíà÷åíèÿ ñâîéñòâà, íå èìåþùåãî ìîäèôèêàòîðà)
//|ENUM_OBJECT_PROPERTY_INTEGER:
//+------------------------------------------------------------------+
//|OBJPROP_BACK - Îáúåêò íà çàäíåì ïëàíå - bool;
//+------------------------------------------------------------------+
//|OBJPROP_FILL Çàëèâêà îáúåêòà öâåòîì (äëÿ OBJ_RECTANGLE, OBJ_TRIANGLE,
//|OBJ_ELLIPSE, OBJ_CHANNEL, OBJ_STDDEVCHANNEL, OBJ_REGRESSION) - bool;
//+------------------------------------------------------------------+
//|OBJPROP_HIDDEN - Çàïðåò íà ïîêàç èìåíè ãðàôè÷åñêîãî îáúåêòà â ñïèñêå
//|îáúåêòîâ èç ìåíþ òåðìèíàëà "Ãðàôèêè" - "Îáúåêòû" - "Ñïèñîê îáúåêòîâ".
//|Çíà÷åíèå true ïîçâîëÿåò ñêðûòü íåíóæíûé äëÿ ïîëüçîâàòåëÿ îáúåêò èç ñïèñêà. 
//|Ïî óìîë÷àíèþ true óñòàíàâëèâàåòñÿ äëÿ îáúåêòîâ, êîòîðûå îòîáðàæàþò ñîáûòèÿ
//|êàëåíäàðÿ, èñòîðèþ òîðãîâëè, à òàêæå äëÿ ñîçäàííûõ èç MQL5-ïðîãðàììû.
//|Äëÿ òîãî ÷òîáû óâèäåòü òàêèå ãðàôè÷åñêèå îáúåêòû è ïîëó÷èòü äîñòóï ê èõ
//|ñâîéñòâàì, íóæíî íàæàòü êíîïêó "Âñå" â îêíå "Ñïèñîê îáúåêòîâ". - bool
//+------------------------------------------------------------------+
//|OBJPROP_SELECTED - Âûäåëåííîñòü îáúåêòà - bool;
//+------------------------------------------------------------------+
//|OBJPROP_READONLY - Âîçìîæíîñòü ðåäàêòèðîâàíèÿ òåêñòà â îáúåêòå Edit - bool;
//+------------------------------------------------------------------+
//|OBJPROP_SELECTABLE - Äîñòóïíîñòü îáúåêòà - bool;
//+------------------------------------------------------------------+
//|OBJPROP_RAY_LEFT - Ëó÷ ïðîäîëæàåòñÿ âëåâî - bool;
//+------------------------------------------------------------------+
//|OBJPROP_RAY_RIGHT - Ëó÷ ïðîäîëæàåòñÿ âïðàâî - bool;
//+------------------------------------------------------------------+
//|OBJPROP_RAY - Âåðòèêàëüíàÿ ëèíèÿ ïðîäîëæàåòñÿ íà âñå îêíà ãðàôèêà - bool;
//+------------------------------------------------------------------+
//|OBJPROP_ELLIPSE - Îòîáðàæåíèå ïîëíîãî ýëëèïñà äëÿ îáúåêòà 
//|"Äóãè Ôèáîíà÷÷è" (OBJ_FIBOARC) - bool;
//+------------------------------------------------------------------+
//|OBJPROP_DRAWLINES - Îòîáðàæåíèå ëèíèé äëÿ âîëíîâîé ðàçìåòêè Ýëëèîòà - bool;
//+------------------------------------------------------------------+
//|OBJPROP_STATE - Ñîñòîÿíèå êíîïêè (Íàæàòà/Îòæàòà) - bool;
//+------------------------------------------------------------------+
//|OBJPROP_DATE_SCALE - Ïðèçíàê îòîáðàæåíèÿ øêàëû âðåìåíè äëÿ îáúåêòà "Ãðàôèê" - bool;
//+------------------------------------------------------------------+
//|OBJPROP_PRICE_SCALE - Ïðèçíàê îòîáðàæåíèÿ öåíîâîé øêàëû äëÿ îáúåêòà "Ãðàôèê" - bool;
//+------------------------------------------------------------------+
bool ObjSetIntegerBool(long chart_ID,string name,ENUM_OBJECT_PROPERTY_INTEGER pr,bool dt)
  {
   ResetLastError();
//---
   if(!ObjectSetInteger(chart_ID,name,pr,dt))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|ObjectSetIntegerLong (Óñòàíîâêà çíà÷åíèÿ ñâîéñòâà, íå èìåþùåãî ìîäèôèêàòîðà)
//|ENUM_OBJECT_PROPERTY_INTEGER:
//+------------------------------------------------------------------+
//|OBJPROP_ZORDER - Ïðèîðèòåò ãðàôè÷åñêîãî îáúåêòà íà ïîëó÷åíèå ñîáûòèÿ
//|íàæàòèÿ ìûøêè íà ãðàôèêå (CHARTEVENT_CLICK). Ïî óìîë÷àíèþ ïðè ñîçäàíèè
//|çíà÷åíèå âûñòàâëÿåòñÿ ðàâíûì íóëþ, íî ïðè íåîáõîäèìîñòè ìîæíî ïîâûñèòü
//|ïðèîðèòåò. Ïðè íàëîæåíèè îáúåêòîâ äðóã íà äðóãà ñîáûòèå CHARTEVENT_CLICK
//|ïîëó÷èò òîëüêî îäèí îáúåêò, ÷åé ïðèîðèòåò âûøå îñòàëüíûõ. - long;
//+------------------------------------------------------------------+
//|OBJPROP_CHART_ID - Èäåíòèôèêàòîð îáúåêòà "Ãðàôèê" (OBJ_CHART). Ïîçâîëÿåò 
//|ðàáîòàòü ñî ñâîéñòâàìè ýòîãî îáúåêòà êàê ñ îáû÷íûì ãðàôèêîì ñ ïîìîùüþ
//|ôóíêöèé èç ðàçäåëà Îïåðàöèè ñ ãðàôèêàìè, íî åñòü íåêîòîðûå èñêëþ÷åíèÿ. - long  r/o;
//+------------------------------------------------------------------+
bool ObjSetIntegerLong(long chart_ID,string name,ENUM_OBJECT_PROPERTY_INTEGER pr,long dt)
  {
   ResetLastError();
//---
   if(!ObjectSetInteger(chart_ID,name,pr,dt))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|Çàäà¸ò ãîðèçîíòàëüíîå âûðàâíèâàíèå òåêñòà â îáúåêòå "Ïîëå ââîäà"  
//|(OBJ_EDIT)
//+------------------------------------------------------------------+
//|OBJPROP_ALIGN - Ãîðèçîíòàëüíîå âûðàâíèâàíèå òåêñòà â îáúåêòå 
//|"Ïîëå ââîäà" (OBJ_EDIT) = ENUM_ALIGN_MODE;
//+------------------------------------------------------------------+
bool ObjSetIntegerAlign(long chart_ID,string name,ENUM_ALIGN_MODE align)
  {
   ResetLastError();
//---
   if(!ObjectSetInteger(chart_ID,name,OBJPROP_ALIGN,align))
     {
      Print(LINE_NUMBER,__FUNCTION__,", Error Code = ",GetLastError());
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+