MetaTrader 4 Build 186 - страница 6

 
Вопрос по новому билду:
Раньше, например в билд 183, после работы тестера в режиме оптимизации, результаты этой работы, весь получившийся файл, из папки Optimization Rezults можно было скопировать просто функцией Copy. Теперь эта функция копирует только одну строку из этого файла, и чтобы скопировать файл нужно выделит все строки. Это так задумано специально или получилось случайно? По моему удобнее было когда копировался весь файл, т.к. в копировании одной строки смысла не вижу.

вообще-то, в копировании не всего списка, а только выделенных позиций, смысл как раз есть.
уже добавили строку в контекстном меню Copy All. будет в следующем билде
кстати, если ни один элемент не выделен и вы просто нажали Ctrl-C, то скопируется весь список.
 

кстати, если ни один элемент не выделен и вы просто нажали Ctrl-C, то скопируется весь список.

Это работает только если при этом мышь навести на пустое пространство, что при длинном файле неудобно.
А за Copy All спасибо.
 
Функция также показывает, свободен поток в данный момент времени или нет.
не правда :)
Если бы показывала, не было бы 20-ти страничных обсуждений "как избавиться от ошибок". И у меня проверка была практически с самого начала - до фени.
Хотя как тогда объяснить то, что у mike-а работало без ошибок? Правда, у него всего 3 эксперта, у меня обычно штук 8 висело..


Давайте не будем путать правду с истиной :)

Вот правда:
"IsTradeAllowed()"

Slawa 25.07.05 12:09

функция IsTradeAllowed указывает на возможность торговать вообще. если в настройках эксперта снята галочка, разрешающая эксперту торговать, то результатом выполнеия функции будет false. если какой-то другой эксперт в данный момент торгует, то также будет возврат false.


Где находится истина, никто, похоже, не знает. :(
 
я помню, что говорил Слава.
Но от того, что он это говорил, ни правда, ни истина не изменились - а ошибки появлялись даже при соответствующей проверке =)
 
OrderClosePrice как раз возвращает нужную цену :) я долго не мог понять почему у меня не работает закрытие как в примере по ask и bid - постоянно говорит что invalid price и тогда я заменил на OrderClosePrice - и все заработало. Этот ClosePrice похоже та цена что показывается в метатрейдере в отрытых позициях, т.е. текущий бид или аск. Но точно не 0. А кажись я понял почему bid/ask не работал - я тестировал из скрипта и похоже bid и ask возможно были не установлены...

Это означает, что BId/Ask использовались закешированные и перед торговой операций они не были обновлены. А вот OrderSelect делался практически перед торговой операцией, что и давало в поле ClosePrice корректную обновленную цену. В результате и сделка проходила.

То есть, эксперт содержит как минимум одну фатальную ошибку - рыночное окружение корректно не обновляется вызовом RefreshRates().

Не забывайте, что все торговые операции занимают время (секунды и больше), операции Sleep() тоже занимают время, собственные записи/чтения файлов, расчетов и тд тоже занимают время. И если об этом забыть, то можно считать, что Bid и Ask верные, соответствуют рыночным условиям.
И удивляться, почему не проходит сделка по цене, которая была 1-2-3-4-5 секунд назад.
 
И если об этом забыть, то можно считать, что Bid и Ask верные, соответствуют рыночным условиям.
я использую MarketInfo, и проблем с реквотами нет. Когда спрашивал - правильноя ли я делаю, все промолчали ). Но сказали, что MarketInfo - это функция, и поэтому возвращает свежее значение. Я прав?
 
Это был вообще не эксперт а скрипт который никаких долгих операций не делал а тестировал одну мою функцию - закрыть ордер. Кроме того RefreshRates часто не работает в эксперте - возвращает false. Даже я бы сказал не часто а очень часто. Вот в этом коде RefreshRates не срабатывала постоянно:

//---------------------------------------------------------------------
// wait for trade context
//---------------------------------------------------------------------
bool WaitForTradeContext()
  {
    int i;
  
    // wait for trade to be allowed if trade context is busy for 30 seconds
    i = 0;
    while ((i < 300) && !(IsTradeAllowed())) 
      {
        Sleep(100);
        i++;
      }
     
    if (i == 300) 
      {
        OrderError = "Trade is not allowed";
        return(false);
      }
     
    // refresh rates  
    if (i > 10) 
      if (!RefreshRates()) 
        {
          OrderError = ErrorDescription(GetLastError());
          return(false);
        }
        
    return(true);  
  }



срабатывают 3 эксперта, один ставит ордер сразу - 2 других ждут 3 - 5 секунд и попадают на RefreshRates которая их спокойно посылает.

 
Подскажите, может кто знает, в этом билде можно подтвердить открытие ордера без участия мыши (с клавиатуры)? Пробовал по-всякому - не получается.
Отклонение от принципов Windows получается
 
Подскажите, может кто знает, в этом билде можно подтвердить открытие ордера без участия мыши (с клавиатуры)? Пробовал по-всякому - не получается.
Отклонение от принципов Windows получается

Уже сам и разобрался - пробелом это делается, а я на Enter жал :)
 
в чем может быть дело, индикатор выглядит по разному после инициализации и 1 просчета





//+------------------------------------------------------------------+
//|                                                    rvmGSv_mt.mq4 |
//|                      Copyright © 2005, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 DeepSkyBlue
#property indicator_color2 DeepSkyBlue
#property indicator_color3 DeepSkyBlue
#property indicator_color4 DeepSkyBlue
//---- buffers
double Buf1[];
double Buf2[];
double Buf3[];
double Buf4[];
double aH[];
double aL[];
//----
int lb,lbars,fpoint,spoint,lrtb,idFile;
double fpprice,spprice;
bool draw_up,draw_dn,useB1,useB2,fH,fL,lH,lL;

//+----------------------------------------------------------------------------------------------------------------------+
//| Custom indicator initialization function                                                                             |
//+----------------------------------------------------------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(6);
   SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,2);
   SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,2);
   SetIndexStyle(2,DRAW_HISTOGRAM,STYLE_SOLID,2);
   SetIndexStyle(3,DRAW_HISTOGRAM,STYLE_SOLID,2);
   SetIndexStyle(4,DRAW_NONE);
   SetIndexStyle(5,DRAW_NONE);
   SetIndexBuffer(0,Buf1);
   SetIndexBuffer(1,Buf2);
   SetIndexBuffer(2,Buf3);
   SetIndexBuffer(3,Buf4);
   SetIndexBuffer(4,aH);
   SetIndexBuffer(5,aL);
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   SetIndexEmptyValue(2,0.0);
   SetIndexEmptyValue(3,0.0);
   SetIndexEmptyValue(4,0.0);
   SetIndexEmptyValue(5,0.0);
   SetIndexEmptyValue(6,0.0);
   SetIndexLabel(0,"Малая тенденция л.1");
   SetIndexLabel(1,"Малая тенденция л.2");
   SetIndexLabel(2,"Малая тенденция гист.h");
   SetIndexLabel(3,"Малая тенденция гист.l");
   SetIndexLabel(4,"High активного бара");
   SetIndexLabel(5,"Low активного бара");
//----
   useB1=1;
   useB2=0;
//----
   return(0);
  }
//+----------------------------------------------------------------------------------------------------------------------+

//+----------------------------------------------------------------------------------------------------------------------+
//| Custom indicator iteration function                                                                                  |
//+----------------------------------------------------------------------------------------------------------------------+
int start()
  {
   int counted_bars=IndicatorCounted();
   int cb,ai,i,limit,index;
   double a;
//---- 
   if( counted_bars>=0 )
   {
      index=Bars-1;
      if( counted_bars!=0 )
      {
         if( index-counted_bars-1<=0 )
         {
            limit=0;
         }
         else
         {
            limit=index-counted_bars;
         }
      }
      else
      {
         aH[Bars-1]=High[Bars-1];
         aL[Bars-1]=Low[Bars-1];
         limit=index-1;
      }
   }
   else
   {
      Alert("Сбой расчета индикатора rvmGSv_mt");
   }
   for( cb=limit; cb>=0; cb-- )
   {
      ai=index-cb;
      //если новый бар
      if( lb!=ai )
      {
         lb=ai;
         //обнуляем
         fH=0;
         fL=0;
         lH=0;
         lL=0;
         //если бар не внутренний
         if( High[cb+1]>aH[cb+1] || Low[cb+1]<aL[cb+1] )
         {
            aH[cb]=High[cb+1];
            aL[cb]=Low[cb+1];
         }
         else //иначе если он не внутренний
         {
            aH[cb]=aH[cb+1];
            aL[cb]=aL[cb+1];
         }
      }
      //если бар внутренний
      if( High[cb]<=aH[cb] && Low[cb]>=aL[cb] )
      {
         continue;
      }
      if( High[cb]>aH[cb] && Low[cb]<aL[cb] )
      {
         Buf3[cb]=High[cb];
         Buf4[cb]=Low[cb];
      }
//-------------------------------------------------------------------------------------------------------------
      //если просчитывается реал-тайм
      if( counted_bars>0 && cb==0 )
      {
         //если есть оба экстримума
         if( High[cb]>aH[cb] && Low[cb]<aL[cb] )
         {
            Buf3[cb]=High[cb];
            Buf4[cb]=Low[cb];
         }
         //определяем очередность появления экстримума
         //если еще не было экстримума (т.е. первый экстримум)
         if( fH!=1 && fL!=1 )
         {
            if( High[cb]>aH[cb] )
            {
               fH=1;
               lH=1;
            }
            else
            {
               if( Low[cb]<aL[cb] )
               {
                  fL=1;
                  lL=1;
               }
            }
         }
         else
         {
            if( Close[cb]==High[cb] && High[cb]>aH[cb] )
            {
               lH=1;
               lL=0;
            }
            else
            {
               if( Close[cb]==Low[cb] && Low[cb]<aL[cb] )
               {
                  lL=1;
                  lH=0;
               }
            }
         }
         //*********************************************************************************************
         //если первым появился максимум
         if( fH!=0 )
         {
            //если индикатор еще не отрисовывался
            if( Buf1[cb]==0 && Buf2[cb]==0 )
            {
               //если индикатор рисуется вверх
               if( draw_up!=0 )
               {
                  spoint=ai;
                  //если на первой точке одновременные экстримумы
                  if( Buf3[index-fpoint]>0 )
                  {
                     //если для отрисовки используется 1 линия
                     if( useB2!=1 )
                     {
                        //если на первой точке значение индикатора не равно минимуму
                        if( Buf1[index-fpoint]!=Low[index-fpoint] )
                        {
                           fpprice=Low[index-fpoint];
                           Buf1[index-fpoint]=0;
                           useB1=0;
                           useB2=1;
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                     else
                     {
                        if( Buf2[index-fpoint]!=Low[index-fpoint] )
                        {
                           fpprice=Low[index-fpoint];
                           Buf2[index-fpoint]=0;
                           useB2=0;
                           useB1=1;
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;                           
                        }
                     }
                     spprice=High[cb];
                     //вычисляем угол
                     a=(spprice-fpprice)/(spoint-fpoint);
                     //если для отрисовки индикатора используется 1 линия
                     if( useB2!=1 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                     else
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                  }
                  else //иначе если на первой точке одновременные экстримумы
                  {
                     //на первой точке только один экстримум = минимуму
                     spprice=High[cb];
                     //вычисляем угол
                     a=(spprice-fpprice)/(spoint-fpoint);
                     //если для отрисовки индикатора используется 1 линия
                     if( useB2!=1 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                     else
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                  }
               }
               else //иначе если индикатор рисуется вверх
               {
                  //индикатор рисуется вниз
                  fpoint=spoint;
                  fpprice=spprice;
                  spoint=ai;
                  spprice=High[cb];
                  //вычисляем угол
                  a=(spprice-fpprice)/(spoint-fpoint);
                  draw_dn=0;
                  draw_up=1;
                  //если для отрисовки индикатора используется 1 линия
                  if( useB2!=1 )
                  {
                     Buf1[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
                  else
                  {
                     Buf2[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
               }
            }
            else //иначе если индикатор еще не отрисовывался
            {
               //индикатор уже отрисовывался на текущем баре
               //если он не внешний
               if( !Buf3[cb]>0 )
               {
                  spprice=High[cb];
                  //вычисляем угол
                  a=(spprice-fpprice)/(spoint-fpoint);
                  //если для отрисовки индикатора используется 1 линия
                  if( useB2!=1 )
                  {
                     Buf1[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
                  else
                  {
                     Buf2[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
               }
//*********    
               else //иначе если он не внешний
               {
                  //если одна из вершин еще не рисовалась
                  if( Buf1[cb]==0 || Buf2[cb]==0 )
                  {
                     //если последний минимум
                     if( lL!=0 )
                     {
                        draw_up=0;
                        draw_dn=1;
                        fpoint=spoint;
                        fpprice=spprice;
                        spprice=Low[cb];
                        //если для отрисовки индикатора по Low используется 1 линия
                        if( Buf2[cb]>0 )
                        {
                           Buf1[cb]=spprice;
                           useB2=0;
                           useB1=1;
                        }
                        else
                        {
                           Buf2[cb]=spprice;
                           useB1=0;
                           useB2=1;
                        }
                     }
                  }
                  else //иначе если одна из вершин еще не рисовалась
                  {
                     //обе вершины уже рисовались
                     //если последний минимум
                     if( lL!=0 )
                     {
                        draw_up=0;
                        draw_dn=1;
                        fpoint=spoint;
                        fpprice=spprice;
                        spprice=Low[cb];
                        //если для отрисовки индикатора по Low используется 1 линия
                        if( Buf2[cb]>Buf1[cb] )
                        {
                           Buf1[cb]=spprice;
                           useB2=0;
                           useB1=1;
                        }
                        else
                        {
                           Buf2[cb]=spprice;
                           useB1=0;
                           useB2=1;
                        }
                     }
                     else
                     {
                        draw_dn=0;
                        draw_up=1;
                        fpoint=spoint;
                        fpprice=spprice;
                        spprice=High[cb];
                        //если для отрисовки индикатора по High используется 1 линия
                        if( Buf1[cb]>Buf2[cb] )
                        {
                           Buf1[cb]=spprice;
                           Buf2[cb]=0;
                           useB1=1;
                           useB2=0;
                        }
                        else
                        {
                           Buf2[cb]=spprice;
                           Buf1[cb]=0;
                           useB2=1;
                           useB1=0;
                        }
                     }
                  }
               }
//*********    
            }
         }
         else //иначе если первым появился максимум
         {
            //первым появился минимум
            //если индикатор еще не отрисовывался
            if( Buf1[cb]==0 && Buf2[cb]==0 )
            {
               //если индикатор рисуется вниз
               if( draw_dn!=0 )
               {
                  spoint=ai;
                  //если на первой точке одновременные экстримумы
                  if( Buf3[index-fpoint]>0 )
                  {
                     //если для отрисовки используется 1 линия
                     if( useB2!=1 )
                     {
                        //если на первой точке значение индикатора не равно максимуму
                        if( Buf1[index-fpoint]!=High[index-fpoint] )
                        {
                           fpprice=High[index-fpoint];
                           Buf1[index-fpoint]=0;
                           useB1=0;
                           useB2=1;
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                     else
                     {
                        if( Buf2[index-fpoint]!=High[index-fpoint] )
                        {
                           fpprice=High[index-fpoint];
                           Buf2[index-fpoint]=0;
                           useB2=0;
                           useB1=1;
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                     spprice=Low[cb];
                     //вычисляем угол
                     a=(fpprice-spprice)/(spoint-fpoint);
                     //если для отрисовки индикатора используется 1 линия
                     if( useB2!=1 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                     else
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                  }
                  else //иначе если на первой точке одновременные экстримумы
                  {
                     //на первой точке только один экстримум = максимум
                     spprice=Low[cb];
                     //вычисляем угол
                     a=(fpprice-spprice)/(spoint-fpoint);
                     //если для отрисовки индикатора используется 1 линия
                     if( useB2!=1 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                     else
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                  }
               }
               else //иначе если индикатор рисуется вниз
               {
                  //индикатор рисуется вверх
                  fpoint=spoint;
                  fpprice=spprice;
                  spoint=ai;
                  spprice=Low[cb];
                  //вычисляем угол
                  a=(fpprice-spprice)/(spoint-fpoint);
                  draw_up=0;
                  draw_dn=1;
                  //если для отрисовки индикатора используется 1 линия
                  if( useB2!=1 )
                  {
                     Buf1[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
                  else
                  {
                     Buf2[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
               }
            }
            else //иначе если индикатор еще не отрисовывался
            {
               //индикатор уже отрисовывался на текущем баре
               //если он не внешний
               if( !Buf3[cb]>0 )
               {
                  spprice=Low[cb];
                  //вычисляем угол
                  a=(fpprice-spprice)/(spoint-fpoint);
                  //если для отрисовки индикатора используется 1 линия
                  if( useB2!=1 )
                  {
                     Buf1[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
                  else
                  {
                     Buf2[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
               }
//*********    
               else //иначе если он не внешний
               {
                  //если вторая точка еще не рисовалась
                  if( Buf1[cb]==0 || Buf2[cb]==0 )
                  {
                     //если последний максимум
                     if( lH!=0 )
                     {
                        draw_up=1;
                        draw_dn=0;
                        fpoint=spoint;
                        fpprice=spprice;
                        spprice=High[cb];
                        //если для отрисовки индикатора по High используется 1 линия
                        if( Buf2[cb]>0 )
                        {
                           Buf1[cb]=spprice;
                           useB2=0;
                           useB1=1;
                        }
                        else
                        {
                           Buf2[cb]=spprice;
                           useB1=0;
                           useB2=1;
                        }
                     }
                  }
                  else
                  {
                     //если последний максимум
                     if( lH!=0 )
                     {
                        draw_up=1;
                        draw_dn=0;
                        fpoint=spoint;
                        fpprice=spprice;
                        spprice=High[cb];
                        //если для отрисовки индикатора по High используется 1 линия
                        if( Buf1[cb]>Buf2[cb] )
                        {
                           Buf1[cb]=spprice;
                           useB2=0;
                           useB1=1;
                        }
                        else
                        {
                           Buf2[cb]=spprice;
                           useB1=0;
                           useB2=1;
                        }
                     }
                     else
                     {
                        draw_dn=1;
                        draw_up=0;
                        fpoint=spoint;
                        fpprice=spprice;
                        spprice=Low[cb];
                        //если для отрисовки индикатора по High используется 1 линия
                        if( Buf1[cb]>Buf2[cb] )
                        {
                           Buf1[cb]=spprice;
                           Buf2[cb]=0;
                           useB1=1;
                           useB2=0;
                        }
                        else
                        {
                           Buf2[cb]=spprice;
                           Buf1[cb]=0;
                           useB2=1;
                           useB1=0;
                        }
                     }
                  }
               }
//*********    
            }
         }
      }
      else //иначе если просчитывается реал-тайм (т.е. история)
      {
//-------------------------------------------------------------------------------------------------------------
         //если свеча внешняя
         if( High[cb]>aH[cb] && Low[cb]<aL[cb] )
         {
            //необходимо выяснить последовательность возникновения экстримумов
            //если открытие было уже экстримумом
            if( Open[cb]>aH[cb] )
            {
               fH=1;
            }
            else
            {
               if( Open[cb]>aH[cb] )
               {
                  fL=1;
               }
               else
               {
                  if( MathAbs(Close[cb]-aH[cb])>MathAbs(Close[cb]-aL[cb]) )
                  {
                     fH=1;
                  }
                  else
                  {
                     if( MathAbs(Close[cb]-High[cb])>MathAbs(Close[cb]-Low[cb]) )
                     {
                        if( Open[cb]>Close[cb] )
                        {
                           fH=1;
                        }
                        else
                        {
                           fL=1;
                        }
                     }
                     else
                     {
                        fL=1;
                     }
                  }
               }
            }
            //если индикатор рисуется вверх
            if( draw_up!=0 )
            {
               //если сначала не минимум
               if( fL!=1 )
               {
                  spoint=ai;
                  //если на первой точке одновременные экстримумы
                  if( Buf3[index-fpoint]>0 )
                  {
                     //если для отрисовки используется 1 линия
                     if( useB2!=1 )
                     {
                        //если на первой точке значение индикатора не равно минимуму
                        if( Buf1[index-fpoint]!=Low[index-fpoint] )
                        {
                           //Buf1[index-fpoint]=Low[index-fpoint];
                           Buf1[index-fpoint]=0;
                           useB1=0;
                           useB2=1;
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                     else
                     {
                        if( Buf2[index-fpoint]!=Low[index-fpoint] )
                        {
                           //Buf2[index-fpoint]=Low[index-fpoint];
                           Buf2[index-fpoint]=0;
                           useB2=0;
                           useB1=1;
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                  }
                  spprice=High[cb];
                  //вычисляем угол
                  a=(spprice-fpprice)/(spoint-fpoint);
                  //если для отрисовки индикатора используется 1 линия
                  if( useB2!=1 )
                  {
                     Buf1[cb]=spprice;
                     Buf2[cb]=Low[cb];
                     useB1=0;
                     useB2=1;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
                  else
                  {
                     Buf2[cb]=spprice;
                     Buf1[cb]=Low[cb];
                     useB1=1;
                     useB2=0;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
                  fpoint=spoint;
                  fpprice=spprice;
                  spprice=Low[cb];
                  draw_up=0;
                  draw_dn=1;
               }
               else
               {
                  fpoint=spoint;
                  fpprice=spprice;
                  spprice=Low[cb];
                  spoint=ai;
                  //вычисляем угол
                  a=(fpprice-spprice)/(spoint-fpoint);
                  //если для отрисовки индикатора используется 1 линия
                  if( useB2!=1 )
                  {
                     Buf1[cb]=spprice;
                     Buf2[cb]=High[cb];
                     useB1=0;
                     useB2=1;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
                  else
                  {
                     Buf2[cb]=spprice;
                     Buf1[cb]=High[cb];
                     useB1=1;
                     useB2=0;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
                  fpoint=spoint;
                  fpprice=spprice;
                  spprice=High[cb];
                  draw_up=1;
                  draw_dn=0;
               }
            }
            else //иначе если индикатор рисуется вверх
            {
               //если индикатор рисуется вниз
               if( draw_dn!=0 )
               {
                  //если сначала не максимум
                  if( fH!=1 )
                  {
                     spoint=ai;
                     //если на первой точке одновременные экстримумы
                     if( Buf3[index-fpoint]>0 )
                     {
                        //если для отрисовки используется 1 линия
                        if( useB2!=1 )
                        {
                           //если на первой точке значение индикатора не равно максимуму
                           if( Buf1[index-fpoint]!=High[index-fpoint] )
                           {
                              //Buf1[index-fpoint]=High[index-fpoint];
                              Buf1[index-fpoint]=0;
                              useB1=0;
                              useB2=1;
                              Buf3[index-fpoint]=0;
                              Buf4[index-fpoint]=0;
                           }
                        }
                        else //иначе если для отрисовки используется 1 линия
                        {
                           if( Buf2[index-fpoint]!=High[index-fpoint] )
                           {
                              //Buf2[index-fpoint]=High[index-fpoint];
                              Buf2[index-fpoint]=0;
                              useB2=0;
                              useB1=1;
                              Buf3[index-fpoint]=0;
                              Buf4[index-fpoint]=0;
                           }
                        }
                     }
                     spprice=Low[cb];
                     //вычисляем угол
                     a=(fpprice-spprice)/(spoint-fpoint);
                     //если для отрисовки индикатора используется 1 линия
                     if( useB2!=1 )
                     {
                        Buf1[cb]=spprice;
                        Buf2[cb]=High[cb];
                        useB1=0;
                        useB2=1;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                     else
                     {
                        Buf2[cb]=spprice;
                        Buf1[cb]=High[cb];
                        useB1=1;
                        useB2=0;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                     fpoint=spoint;
                     fpprice=spprice;
                     spprice=High[cb];
                     draw_up=1;
                     draw_dn=0;
                  }
                  else //иначе если сначала не максимум
                  {
                     fpoint=spoint;
                     fpprice=spprice;
                     spprice=High[cb];
                     spoint=ai;
                     //вычисляем угол
                     a=(spprice-fpprice)/(spoint-fpoint);
                     //если для отрисовки индикатора используется 1 линия
                     if( useB2!=1 )
                     {
                        Buf1[cb]=spprice;
                        Buf2[cb]=Low[cb];
                        useB1=0;
                        useB2=1;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                     else
                     {
                        Buf2[cb]=spprice;
                        Buf1[cb]=Low[cb];
                        useB1=1;
                        useB2=0;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                     fpoint=spoint;
                     fpprice=spprice;
                     spprice=Low[cb];
                     draw_up=0;
                     draw_dn=1;
                  }
               }
               else //иначе если индикатор рисуется вниз
               {
                  spoint=ai;
                  //индикатор пока не рисовался
                  //если первым был максимум
                  if( fH!=0 )
                  {
                     fpprice=Low[index];
                     Buf1[index]=fpprice;
                     spprice=High[cb];
                     Buf1[cb]=spprice;
                     //вычисляем угол
                     a=(spprice-fpprice)/(spoint-fpoint);
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice+(index-fpoint-i)*a;
                     }
                     fpoint=spoint;
                     fpprice=spprice;
                     useB1=0;
                     useB2=1;
                     Buf2[cb]=Low[cb];
                     draw_dn=1;
                  }
                  else
                  {
                     fpprice=High[index];
                     Buf1[index]=fpprice;
                     spprice=Low[cb];
                     Buf1[cb]=spprice;
                     //вычисляем угол
                     a=(fpprice-spprice)/(spoint-fpoint);
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice-(index-fpoint-i)*a;
                     }
                     fpoint=spoint;
                     fpprice=spprice;
                     useB1=0;
                     useB2=1;
                     Buf2[cb]=High[cb];
                     draw_up=1;
                  }
               }
            }
         }
         else //иначе если свеча внешняя
         {
            //если индикатор рисуется вверх
            if( draw_up!=0 )
            {
               //если рост продолжается
               if( High[cb]>aH[cb] )
               {
                  //если первая свеча двойной экстримум
                  if( Buf3[index-fpoint]>0 )
                  {
                     //если для отрисовки используется первая линия индикатора
                     if( useB1!=0 )
                     {
                        //если на первой точке перелома значение индикатора не равно минимуму
                        if( Buf1[index-fpoint]!=Low[index-fpoint] )
                        {
                           //Buf1[index-fpoint]=Low[index-fpoint];
                           Buf1[index-fpoint]=0;
                           useB1=0;
                           useB2=1;
                           //затираем гистограмму
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                     else
                     {
                        //если на первой точке перелома значение индикатора не равно минимуму
                        if( Buf2[index-fpoint]!=Low[index-fpoint] )
                        {
                           //Buf2[index-fpoint]=Low[index-fpoint];
                           Buf2[index-fpoint]=0;
                           useB2=0;
                           useB1=1;
                           //затираем гистограмму
                           Buf3[index-fpoint]=0;
                           Buf4[index-fpoint]=0;
                        }
                     }
                  }
                  spoint=ai;
                  spprice=High[cb];
                  //вычисляем угол
                  a=(spprice-fpprice)/(spoint-fpoint);
                  //если для отрисовки используется первая линия индикатора
                  if( useB1!=0 )
                  {
                     Buf1[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
                  else //иначе если используется первая линия индикатора
                  {
                     Buf2[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice+(index-fpoint-i)*a;
                     }
                  }
               }
               else //иначе если рост продолжается
               {
                  //если произошел перелом и теперь тенденция вниз
                  fpoint=spoint;
                  fpprice=spprice;
                  spoint=ai;
                  spprice=Low[cb];
                  draw_up=0;
                  draw_dn=1;
                  //вычисляем угол
                  a=(fpprice-spprice)/(spoint-fpoint);
                  //если для отрисовки используется первая линия индикатора
                  if( useB1!=0 )
                  {
                     Buf1[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf1[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
                  else //иначе если используется первая линия индикатора
                  {
                     Buf2[cb]=spprice;
                     for( i=index-spoint;i<index-fpoint;i++ )
                     {
                        Buf2[i]=fpprice-(index-fpoint-i)*a;
                     }
                  }
               }
            }
            else //иначе если индикатор рисуется вверх
            {
               //если индикатор рисуется вниз
               if( draw_dn!=0 )
               {
                  //если спад продолжается
                  if( Low[cb]<aL[cb] )
                  {
                     //если первая свеча двойной экстримум
                     if( Buf3[index-fpoint]>0 )
                     {
                        //если для отрисовки используется первая линия индикатора
                        if( useB1!=0 )
                        {
                           //если на первой точке перелома значение индикатора не равно максимуму
                           if( Buf1[index-fpoint]!=High[index-fpoint] )
                           {
                              //Buf1[index-fpoint]=High[index-fpoint];
                              Buf1[index-fpoint]=0;
                              useB1=0;
                              useB2=1;
                              //затираем гистограмму
                              Buf3[index-fpoint]=0;
                              Buf4[index-fpoint]=0;
                           }
                        }
                        else
                        {
                           //если на первой точке перелома значение индикатора не равно максимуму
                           if( Buf2[index-fpoint]!=High[index-fpoint] )
                           {
                              //Buf2[index-fpoint]=High[index-fpoint];
                              Buf2[index-fpoint]=0;
                              useB2=0;
                              useB1=1;
                              //затираем гистограмму
                              Buf3[index-fpoint]=0;
                              Buf4[index-fpoint]=0;
                           }
                        }
                     }
                     spoint=ai;
                     spprice=Low[cb];
                     //вычисляем угол
                     a=(fpprice-spprice)/(spoint-fpoint);
                     //если для отрисовки используется первая линия индикатора
                     if( useB1!=0 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                     else //иначе если используется первая линия индикатора
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                  }
                  else //иначе если спад продолжается
                  {
                     //если произошел перелом и теперь тенденция вверх
                     fpoint=spoint;
                     fpprice=spprice;
                     spoint=ai;
                     spprice=High[cb];
                     draw_up=1;
                     draw_dn=0;
                     //вычисляем угол
                     a=(spprice-fpprice)/(spoint-fpoint);
                     //если для отрисовки используется первая линия индикатора
                     if( useB1!=0 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                     else //иначе если используется первая линия индикатора
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                  }
               }
               else //иначе если индикатор рисуется вниз
               {
                  //если индикатор еще не рисовался
                  //если появился только максимум
                  if( Low[cb]>=aL[cb] )
                  {
                     fpprice=Low[index];
                     spoint=ai;
                     spprice=High[cb];
                     draw_up=1;
                     //вычисляем угол
                     a=(spprice-fpprice)/(spoint-fpoint);
                     //если для отрисовки используется первая линия индикатора
                     if( useB1!=0 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                     else //иначе если используется первая линия индикатора
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice+(index-fpoint-i)*a;
                        }
                     }
                  }
                  else //иначе если появился только максимум
                  {
                     //если появился только минимум
                     fpprice=High[index];
                     spoint=ai;
                     spprice=Low[cb];
                     draw_dn=1;
                     //вычисляем угол
                     a=(fpprice-spprice)/(spoint-fpoint);
                     //если для отрисовки используется первая линия индикатора
                     if( useB1!=0 )
                     {
                        Buf1[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf1[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                     else //иначе если используется первая линия индикатора
                     {
                        Buf2[cb]=spprice;
                        for( i=index-spoint;i<index-fpoint;i++ )
                        {
                           Buf2[i]=fpprice-(index-fpoint-i)*a;
                        }
                     }
                  }
               }
            }
         }
      }
//-------------------------------------------------------------------------------------------------------------
   }
//----
   return(0);
  }
//+----------------------------------------------------------------------------------------------------------------------+

//+----------------------------------------------------------------------------------------------------------------------+
//| Custor indicator deinitialization function                                                                           |
//+----------------------------------------------------------------------------------------------------------------------+
int deinit()
  {
//---- 
//----
   return(0);
  }
//+----------------------------------------------------------------------------------------------------------------------+
Причина обращения: