//+------------------------------------------------------------------+
//|                                                         Rest.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                              GlobalVariables.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 //+------------------------------------------------------------------+
//ВСЕ ОЧЕНЬ ПРОСТО: ОТКРЫТИЕ ПЕРВОЙ ПОЗИЦИИ ПРОИЗВОДИТСЯ НА НУЛЕВОМ БАРЕ ПРИ ПРОБОЕ ТЕКУЩЕГО ФРАКТАЛА ВЫШЕ ЗУБОВ АЛЛИГАТОРА.
//                  ДОПОЛНИТЕЛЬНЫЕ ПОЗИЦИИ В НАПРАВЛЕНИЕ ПЕРВОЙ ПОЗИЦИИ ОТКРЫВАЮТСЯ НА НУЛЕВОМ БАРЕ ПРИ ПРОБОЕ ТЕКУЩЕГО ФРАКТАЛА 
//                  ВЫШЕ ЗУБОВ АЛЛИГАТОРА, НО ЛИШЬ ПРИ УСЛОВИИ, ЕСЛИ ВСЕ ТРИ ЛИНИИ АЛЛИГАТОРА ВЫСТРОИЛИСЬ В ТРЕНД НА НУЛЕВОМ БАРЕ.
//                  ЗАКРЫТИЕ ВСЕХ ПОЗИЦИЙ ПРИОИЗВОДИТСЯ ПРИ ВОЗНИКНОВЕНИЕ НУЛЕВОГО БАРА ПРИ УСЛОВИЕ, КОГДА ЗАКРЫТИЕ ПЕРВОГО БАРА 
//                  ПРОИЗОШЛО ЗА ПРЕДЕЛАМИ ГУБ/ЗУБОВ/ЧЕЛЮСТИ (ЗАДАЕТСЯ ВНЕШНИМ ПАРАМЕТРОМ) АЛЛИГАТОРА.
// Delta, TakeProfit, StopLoss и Stop_0 заданы для 4-х разрядных котировок, если котировки 5-ти разрядные, то программа сама это обнаруживает
// и умножает заданные величины на 10.
//+------------------------------------------------------------------+
extern bool TradeAllowed = true;  // разрешение на торговлю, если TradeAllowed = false, но есть открытые позиции,
                                  // то они будут закрыта обычным манером - при возникновения сигнала на закрытие,
                                  // однако, новые позиции открываться не будет.
                                  // Поэтому задав TradeAllowed = false, можно идти отдыхать, надеясь что все будет хорошо.
extern double ProfitTarget     = 10.0;    // целевая прибыль в валюте депозита, при достижение общей прибылью ProfitTotal этого значения все позиции закрываются
extern int    MagicNumber = 20110218;    // при нудевом значение советник принимает за свои все ордера открытые на инструменте, на котором он запущен
extern double LotInitial  = 0.01;  // эти лотом мы будем торговать
// TakeProfit,StopLoss, Stop_0 и Delta заданы для 4-х разрядных котировок, если котировки 5-ти разрядные, то программа сама это обнаруживает
// и умножает заданные величины на 10.
extern int    TakeProfit  = 0;  // 4-х разрядная котировка
extern int    StopLoss    = 0;  // 4-х разрядная котировка
extern int    Stop_0      = 0;  // 4-х разрядная котировка, при достижение любым из ордеров такого профита  в пунктах его стоп-лосс переносится в безубыток.
                                // Если Stoplevel не позволяет этого сделать, выдается сообщение и звуковой сигнал тревоги.
                                // Если Stop_0 = 0, то никаких действий по переносу StopLoss-уровня в безубыток не производим.
extern double Stop_0_Zero    = 1.0; // когда общая прибыль превысит это значение, стоп-лосы всех ордеров переносятся на линию безубытка ZeroTargetPrice
                                     // Если   Stop_0_Zero = 0, никаких действий не производим 
extern double ZeroTarget     = 0.0;  // значение общей прибыли на уровне безубытка  ZeroTargetPrice                                                                
extern int    Delta       = 1;    // 4-х разрядная котировка, когда цена Bid превысила/опустилась ниже значения верхнего/нижнего фрактала
                                  // на это значение в пунктах, фрактал считается пробитым
extern int    Distance = 50;      // 4-х разрядная котировка, пункты - не спешить усиливаться....                              
                                  
// Критерий закрытия всех позиций - выбираться должен только один из этих критериев, в противном случае советник откажется работать
extern bool   CloseAllonLIPS  = false;
extern bool   CloseAllonTEETH = false;
extern bool   CloseAllonJAW   = true;
// Еще один критерий закрытия всех позиций. Этот критерий имеет приоритет над критериями, указанными выше.
extern double CloseAllonProfitValue = 1000000.0; // при  превышение профитом указанной величины в валюте депозита, все позиции закрываются
// Возможно вам захочется принудительно закрыть все позиции независимо от достижения других критериев
extern bool   CloseForced  = false; // принудительное закрытие всех позиций
extern bool   OpenBuyOnly  = false; // будут открываться только позиции вверх
extern bool   OpenSellOnly = false; // будут открываться только позиции вниз

int           Stoplevel;          // здесь будет храниться текущий Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVE)   

double      ProfitTotal;
double      ZeroTargetPrice;
double      ProfitTargetPrice;
double      TicValue;

static bool     BUY_Sign  = false;
static bool     BUY_Stop  = false;
static bool     SELL_Sign = false;
static bool     SELL_Stop = false;

static datetime LastBar = 0;
int             bar2, bar1, bar0;
//---
double   FractalUpperValue = 0;
datetime FractalUpperTime  = 0;
bool     FractalUpperHit   = false;
double   FractalLowerValue = 0;
datetime FractalLowerTime  = 0;
bool     FractalLowerHit   = false;

//---
int jaw_period    = 13;	          //Период усреднения синей линии (челюсти аллигатора).
int jaw_shift 	   = 8;            //Смещение синей линии относительно графика цены.
int teeth_period  = 8; 	          //Период усреднения красной линии (зубов аллигатора).
int teeth_shift   = 5;	          //Смещение красной линии относительно графика цены.
int lips_period   = 5;	          //Период усреднения зеленой линии (губ аллигатора).
int lips_shift    = 3;	          //Смещение зеленой линии относительно графика цены.
int ma_method 	   = MODE_SMMA;    //Метод усреднения. Может быть любым из значений методов скользящего среднего (Moving Average).
int applied_price = PRICE_MEDIAN; //Используемая цена. Может быть любой из ценовых констант.
//mode 	  -   	Источник данных, идентификатор одной из линий индикатора. Mожет быть любой из следующих величин:
//MODE_GATORJAW - синяя линия (линия челюсти аллигатора),
//MODE_GATORTEETH - красная линия (линия зубов аллигатора),
//MODE_GATORLIPS - зеленая линия (линия губ аллигатора).
double Jaw_0;
double Jaw_1;
double Jaw_2;

double Teeth_0;
double Teeth_1;
double Teeth_2;

double Lips_0;
double Lips_1;
double Lips_2;

bool   TrendUp0;      // TrendUp0   = true if (Lips_0 > Teeth_0 && Teeth_0 > Jaw_0)
bool   TrendDown0;    // TrendDown0 = true if (Lips_0 < Teeth_0 && Teeth_0 < Jaw_0)

bool   TrendUp1;      // TrendUp1   = true if (Lips_1 > Teeth_1 && Teeth_1 > Jaw_1)
bool   TrendDown1;    // TrendDown1 = true if (Lips_1 < Teeth_1 && Teeth_1 < Jaw_1)

bool   TrendUp2;      // TrendUp2   = true if (Lips_2 > Teeth_2 && Teeth_2 > Jaw_2)
bool   TrendDown2;    // TrendDown2 = true if (Lips_2 < Teeth_2 && Teeth_2 < Jaw_2)

double CloseLevel;   // зависит от внешних параметров CloseAllonLIPS, CloseAllonTEETH, CloseAllonJAW

int _ExpertOrdersTotal;    //общее количество ордеров, принадлежащих эксперту
int _ExpertOrdersBuy;     
int _ExpertOrdersSell;     
int _ExpertOrdersBuyStop;    
int _ExpertOrdersSellStop;     
int _ExpertOrdersBuyLimit;    
int _ExpertOrdersSellLimit;     

// массивы, в которых будут хранитсья характеристики ордеров при входе по текущему тику:
int      _OrderTicket[], _OrderType[];
double   _OrderLots[], _OrderOpenPrice[], _OrderStopLoss[], _OrderTakeProfit[];
double   _OrderProfit[], _OrderSwap[], _OrderCommission[];
datetime _OrderOpenTime[], _OrderExpiration[];
string   _OrderComment[];
int      _OrderMagicNumber[];

color   Order_Clr;
#define ORDER_BUY_CLR  Blue 
#define ORDER_SELL_CLR Red

string OrderOpenSetOkMes           = "  - Открыт/установлен успешно"; 
string OrderOpenSetErrorMes        = "  - Ошибка открытия/установки"; 
string OrderOpenStoplevel_ErrorMes = "  - Ошибка открытия: StopLoss/TakeProfit меньше текущего Stoplevel=";
string OrderOpenLotValue_ErrorMes  = "  - Ошибка открытия: не хватает денег для открытия позиции";

string OrderModifyOkMes            = "  - Модифицирован успешно";   
string OrderModifyErrorMes         = "  - Ошибка при модификации"; 
string OrderModifyStop_0_ErrorMes  = "  - Ошибка при модификации: Stop_0 меньше текущего Stoplevel="; 
string OrderModifyZeroPrice_ErrorMes  = "  - Ошибка при модификации: разница между текущей ценой и ZeroPrice меньше текущего Stoplevel="; 

string OrderDeleteOkMes        = "  - Удален успешно"; 
string OrderDeleteErrorMes     = "  - Ошибка при удалении"; 

string OrderCloseOkMes        = "  - Закрыт успешно"; 
string OrderCloseErrorMes     = "  - Ошибка при закрытии"; 

string CloseParmErrorMes="Неверно заданы параметры закрытия позиций CloseAllonLIPS,CloseAllonTEETH,CloseAllonJAW,должен бать задан только один критерий"; 
string CloseForcedParmErrorMes="Неверно задан параметр принудительного закрытия всех позиций CloseForced, на старте этот параметр д.б. равен false";
string OnlyTradeParmErrorMes="Неверно заданы параметры односторонней торговли OpenBuyOnly, OpenSellOnly, только один из них д.б. true";
string Stop_0Stop_0_ZeroParmErrorMes="Неверно заданы параметры  Stop_0, Stop_0_Zero, только один из может быть отличным от нуля";
string ParmsErrorsMes="Ошибки в задание значений внешних параметров, советник не работает !";
string ParmsOKReadyMes="Внешние параметры заданы верно,Советник работает и готов открывать позиции - TradeAllowed = true";
string ParmsOKNotReadyMes="Внешние параметры заданы верно,Советник работает, но открытие новых позиций  запрещено  - TradeAllowed = false";

int TradeDirection;
int LastError;
int i;
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                             SetSignalesMarti.mq4 |
//|                                         Copyright © 2010, "more" |
//|                                      "mailto:tradertobe@gmail.co |
//+------------------------------------------------------------------+
//************************************************************          
void SetSignalesMarti(bool& BUY_Sign, bool& BUY_Stop, bool& SELL_Sign, bool& SELL_Stop, int& LastBar, int& bar2, int& bar1,int& bar0 )  
  {      
   datetime IBARS = iTime(NULL,0,0); 
//---  
   if (LastBar != IBARS)  // проверка на начало нового бара
   {
    LastBar  = IBARS;     // новый бар
    SetFractalsValue();
    GetJTLCloseLevelTrend();
   }  // if (LastBar != IBARS) - конец обработки появления нового бара
   else  
   {   // просто тик на нулевом баре
//---   
    SetFractalsValue();
    GetJTLCloseLevelTrend();
//--- 
    double BuyLevel  = FractalUpperValue + Delta*Point;
    double SellLevel = FractalLowerValue - Delta*Point;
    if (!FractalUpperHit)
    {
// Сигнал на открытие первой позиции в торговом цикле вверх  
      if (_ExpertOrdersBuy == 0 && _ExpertOrdersSell == 0 && (Bid > BuyLevel) && (BuyLevel > Teeth_0))
      {
       BUY_Sign  = true; 
       FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);  
       return;
      } 
// Сигнал на открытие доливочных поозиций в торговом цикле вверх  
      int distance = (_OrderOpenPrice[_ExpertOrdersTotal-1] - Ask)/Point;
      if (_ExpertOrdersBuy >= 1 && _ExpertOrdersSell == 0 && (Bid > BuyLevel) && (BuyLevel > Teeth_0) && TrendUp0 && distance >= Distance)
      {
       BUY_Sign  = true; 
       FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);  
       return;
      } 
    } // if (!FractalUpperHit)
//---  
    if (!FractalLowerHit)
    {
// Сигнал на открытие первой позиции в торговом цикле вниз  
      if (_ExpertOrdersSell == 0 && _ExpertOrdersBuy == 0 && (Bid < SellLevel) && (SellLevel < Teeth_0))
      {
       SELL_Sign  = true; 
       FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);  
       return;
      } 
// Сигнал на открытие доливочных позиций в торговом цикле вниз
      distance = (Bid - _OrderOpenPrice[_ExpertOrdersTotal-1])/Point;
      if (_ExpertOrdersSell >= 1 && _ExpertOrdersBuy == 0 && (Bid < SellLevel) && (SellLevel < Teeth_0) && TrendDown0 && distance >= Distance)
      {
       SELL_Sign  = true; 
       FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);  
       return;
      } 
    } // if (!FractalLowerHit) 
//---
    
// Может так случиться, что общая прибыль превысит значение, заданное во внешней переменной -
// extern double ProfitTarget     = 3000.0 - целевая прибыль в валюте депозита, когда  общая прибылью ProfitTotal превысит это значения
// все позиции закрываются.
// Если ProfitTarget = 0, этот механизм закрытия торгового цикла не используется
    ProfitTotal = 0;
    for (i = 0; i < _ExpertOrdersTotal; i++)
    {
     ProfitTotal  += _OrderProfit[i];
    }
    Comment("Прибыль в валюте депозита = ",NormalizeDouble(ProfitTotal,0));
    if (ProfitTarget != 0 && ProfitTotal > ProfitTarget)
    {
     if (_OrderType[0] == OP_BUY)  BUY_Stop = true;
     if (_OrderType[0] == OP_SELL) SELL_Stop  = true;
    }
//---
// Если задано значение параметра советника extern bool   CloseForced  = true(принудительное закрытие всех позиций),
// то все позиции будут закрыты одна за другой. После закрытия всех позиций советник возобновляет работу в обычном режиме,
// однако, чтобы избежать случайностей инициируйте советник значением CloseForced = false
    if (CloseForced && _ExpertOrdersTotal !=0)
    {
     if (_OrderType[0] == OP_BUY)  BUY_Stop = true;
     if (_OrderType[0] == OP_SELL) SELL_Stop  = true;
     CloseForced = false;
     Comment("Принудительное закрытие всех позиций согласно значения CloseForced=true"+"\n"+
            "После закрытия всех позиций обязательно инициируйте советник со зачением CloseForced=false");
    }
//---
   } // else - конец обработки тика
   return;  
  } // end of void SetSignales ()       
//************************************************************          
//+------------------------------------------------------------------+
//|                                                  OrdersOpen.mq4  |
//|                                      Copyright © 2010, "more"    |
//|                                     "mailto:tradertobe@gmail.com |
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------------------------------------------+
//| функция открывает ордера                                                                                      |
//+---------------------------------------------------------------------------------------------------------------+
bool OrdersOpen(bool& BUY_Sign, bool& SELL_Sign)   // return(true) -функция выполнила все что могла и управление следует передать терминалу
{                                      // return(false)-в вызове функции не было необходимости, управление следует передать далее по телу функции start()
    if (!BUY_Sign && !SELL_Sign) return(false);
//----
    if (TradeAllowed)  
     {
       Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVEL);
       if ((StopLoss != 0 && StopLoss < Stoplevel) || (TakeProfit != 0 && TakeProfit < Stoplevel))
       {
        PlaySound("alert.wav");
        Print(OrderOpenStoplevel_ErrorMes+Stoplevel);
        return(false);
       } // if ((StopLoss != 0 && StopLoss < Stoplevel) || (TakeProfit != 0 && TakeProfit < Stoplevel))
       i = 0; // ради удобства
       double LotValue = 0;     
       _OrderType       [i] = iif(TradeDirection < 0,OP_SELL,OP_BUY);
       if (!GetLotValue(Symbol(),_OrderType[i],LotValue)) 
       {
        PlaySound("alert.wav");
        Print(OrderOpenLotValue_ErrorMes);
        return(false);
       }
       RefreshRates();
       TradeDirection = iif(BUY_Sign,+1,-1);
      _OrderType       [i] = iif(TradeDirection < 0,OP_SELL,OP_BUY);
      _OrderLots       [i] = LotValue;
      _OrderOpenPrice  [i] = iif(_OrderType[i]==OP_BUY,Ask,Bid);

      _OrderStopLoss  [i] = iif(_OrderType[i]==OP_BUY,_OrderOpenPrice[i] - StopLoss * Point,_OrderOpenPrice[i] + StopLoss * Point);
      _OrderStopLoss  [i] = iif( _OrderStopLoss[i]==_OrderOpenPrice[i],0,_OrderStopLoss[i]);

      _OrderTakeProfit[i] = iif(_OrderType[i]==OP_BUY,_OrderOpenPrice[i] + TakeProfit*Point,_OrderOpenPrice[i] - TakeProfit*Point);
      _OrderTakeProfit[i] = iif(_OrderTakeProfit[i] == _OrderOpenPrice[i],0,_OrderTakeProfit[i]);

      _OrderMagicNumber[i] = MagicNumber;
      _OrderComment    [i] = " "; 
      Order_Clr            = iif(TradeDirection > 0,ORDER_BUY_CLR,ORDER_SELL_CLR);  
      bool temp = false;
      if (_OrderSend())
      {
       BUY_Sign  = iif(TradeDirection == +1,false,BUY_Sign ); 
       SELL_Sign = iif(TradeDirection == -1,false,SELL_Sign); 
       temp = true;
      }
      return(temp);
     } // if (TradeAllowed)
 //----
    return(false); // вызов функции не был необходим, управление следует передать далее по телу функции start()
} // bool OrdersOpen(bool& BUY_Sign, bool& SELL_Sign)
//+---------------------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| функция посылает на ТОРГОВЫЙ СЕРВЕР команды на немедленное       |
//| открытие ордера или на установку лимитного ордера                |
//+------------------------------------------------------------------+
bool _OrderSend()
  {
   if (IsTradeContextBusy()) { PlaySound("alert.wav"); return(false);} // торговый поток занят, подождем следующего тика
   _OrderTicket[i]=  
        OrderSend(Symbol(),_OrderType       [i]
                          ,_OrderLots       [i]
                          ,_OrderOpenPrice  [i] ,3
                          ,_OrderStopLoss   [i]
                          ,_OrderTakeProfit [i]
                          ,_OrderComment    [i]
                          ,_OrderMagicNumber[i],0,Order_Clr);
   if (_OrderTicket[i] < 0)
    {
     LastError = GetLastError();
     Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+OrderOpenSetErrorMes+" : "+ LastError+" - "+ErrorDescription(LastError));
     PlaySound("alert.wav");
     return(false);
    }
   Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderOpenSetOkMes);
   PlaySound("ok.wav");
   return(true);
}    // end of bool _OrderSend()  
//+---------------------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                  OrdersClose.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------------------------------------------------+
//| функция производит закрытие всех открытых ордеров BUY или | всех открытых ордеров SELL
//+----------------------------------------------------------------------------------------------------------------------+
bool OrdersClose(bool& BUY_Stop, bool& SELL_Stop )   // return(true) -функция выполнила все что могла и управление следует передать терминалу
{                  // return(false)-в вызове функции не было необходимости, управление следует передать далее по телу функции start()
    if (!BUY_Stop && !SELL_Stop)             return(false);
    if (BUY_Stop  && _ExpertOrdersBuy  == 0) {BUY_Stop  = false; return(false);}
    if (SELL_Stop && _ExpertOrdersSell == 0) {SELL_Stop = false; return(false);}
    
    i = 0;
    RefreshRates();
    TradeDirection = iif(BUY_Stop,+1,-1);
    _OrderOpenPrice  [i] = iif(TradeDirection == +1,Bid,Ask);
    Order_Clr            = iif(TradeDirection > 0,ORDER_BUY_CLR,ORDER_SELL_CLR);  
    if (_OrderClose())  return(true);
    return(false);   
}  // end of if ( (BUY_Stop && _ExpertOrdersBuy  != 0) ||  (SELL_Stop && _ExpertOrdersSell != 0))
 //+--------------------------------------------------------------------+
//| функция посылает на ТОРГОВЫЙ СЕРВЕР команду на немедленное         |
//| закрытие открытогоо ордера                                          |
//+--------------------------------------------------------------------+
bool _OrderClose()
  {
   if (IsTradeContextBusy()) { PlaySound("alert.wav"); return(false);} // торговый поток занят, подождем следующего тика
   if (OrderClose(_OrderTicket   [i]
                 ,_OrderLots     [i]
                 ,_OrderOpenPrice[i],3
                 ,Order_Clr))
    {
     Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderCloseOkMes);
     PlaySound("ok.wav");
     return(true);
    }
     LastError = GetLastError();  
     Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderCloseErrorMes+" : "+ LastError+" - "+ErrorDescription(LastError));
     PlaySound("alert.wav");
     return(false);
  }  // end of bool _OrderClose()
//************************************************************************************************************************************
//+------------------------------------------------------------------+
//|                                                 OrdersModify.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------------------+
//| функция производит модификацию ордеров исходя из результатов анализа текущей ситуации |
//+---------------------------------------------------------------------------------------+
bool OrdersModify()    // return(true) -функция выполнила все что могла и управление следует передать терминалу
{                      // return(false)-в вызове функции не было необходимости, управление следует передать далее по телу функции start()
    if (_ExpertOrdersTotal == 0) return(false);
//--    
    RefreshRates();
    ProfitTotal = 0;
    for (i = 0; i < _ExpertOrdersTotal; i++)
    {
     ProfitTotal  += _OrderProfit[i];
    }
    Comment("Прибыль в валюте депозита = ",NormalizeDouble(ProfitTotal,0));
//--
// Если  Stop_0 != 0, установим стоп-лосы всех открытых позиций в безубыток
    if (Stop_0 != 0) 
    {
     for (i = 0; i < _ExpertOrdersTotal; i++)
     {    
      TradeDirection = iif(_OrderType[i] == OP_BUY,+1,-1);
      double CurrentPrice = iif(TradeDirection == +1,Bid,Ask);
      int ProfitPips = iif(TradeDirection == +1,(CurrentPrice - _OrderOpenPrice[i])/Point,(_OrderOpenPrice[i] - CurrentPrice)/Point);
      if (ProfitPips < Stop_0)     continue;
      Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVEL);
      if (Stop_0 <= Stoplevel)
      {
       PlaySound("alert.wav");
       Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyStop_0_ErrorMes+Stoplevel);
       continue;
      }
      if (_OrderStopLoss  [i] == _OrderOpenPrice [i]) continue;
      _OrderStopLoss  [i] = _OrderOpenPrice [i]; 
      bool temp = _OrderModify();
      break;
     } // for (i = 0; i < _ExpertOrdersTotal; i++)
     return(temp); 
    } // if (Stop_0 != 0) 
// Когда общая прибыль ProfitTotal превысмт значение extern double Stop_0_Zero , стоп-лосы всех ордеров переносятся на линию безубытка ZeroTargetPrice
    if (ProfitTotal > Stop_0_Zero && Stop_0_Zero != 0) 
    {
     for (i = 0; i < _ExpertOrdersTotal; i++)
     {    
      if (_OrderStopLoss  [i] == ZeroTargetPrice) continue;
      TradeDirection = iif(_OrderType[i] == OP_BUY,+1,-1);
      CurrentPrice = iif(TradeDirection == +1,Bid,Ask);
      int ZeroPips = iif(TradeDirection == +1,(CurrentPrice - ZeroTargetPrice)/Point,(ZeroTargetPrice - CurrentPrice)/Point);
      Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVEL);
      if (ZeroPips <= Stoplevel)
      {
       PlaySound("alert.wav");
       Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyZeroPrice_ErrorMes+Stoplevel);
       continue;
      }
      _OrderStopLoss  [i] = ZeroTargetPrice; 
      temp = _OrderModify();
      break;
     } // for (i = 0; i < _ExpertOrdersTotal; i++)
     return(temp); 
    } // if (ProfitTotal > Stop_0_Zero)
} // end of bool OrdersModify()
//+--------------------------------------------------------------------+
//| функция посылает на ТОРГОВЫЙ СЕРВЕР команду на немедленную         |
//| модификацию открытого или лимитного ордера                         |
//+--------------------------------------------------------------------+
bool _OrderModify()
  {
   if (IsTradeContextBusy()) { PlaySound("alert.wav"); return(false);} // торговый поток занят, подождем следующего тика
   if (OrderModify(_OrderTicket    [i]
                  ,_OrderOpenPrice [i]
                  ,_OrderStopLoss  [i]
                  ,_OrderTakeProfit[i]
                  ,0
                  ,CLR_NONE))
    {
     Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyOkMes);
     PlaySound("ok.wav");
     return(true);
    }
     LastError = GetLastError(); if (LastError == ERR_NO_RESULT) return(true);
     Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyErrorMes+" : "+ LastError+" - "+ErrorDescription(LastError));
     PlaySound("alert.wav");
     return(false);
  }  // end of bool _OrderModify() 
//+---------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                             SetFractalsValue.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
void  SetFractalsValue() 
  {
   datetime FractalUpperTimeOld = FractalUpperTime;
   datetime FractalLowerTimeOld = FractalLowerTime;
   
   FractalUpperValue = 0;
   FractalLowerValue = 0;
//---   
   int i = 0;
   while (FractalUpperValue == 0)
   {
    FractalUpperValue = iFractals(NULL, 0, MODE_UPPER, i);
    i++;
   }
   int FractalUpperBar = i - 1;
//---   
   i = 0;
   while (FractalLowerValue == 0)
   {
    FractalLowerValue = iFractals(NULL, 0, MODE_LOWER, i);
    i++;
   }
   int FractalLowerBar = i - 1;
//---   
   if (ObjectFind("FractalUpper")<0) 
    {
     ObjectCreate("FractalUpper",OBJ_TREND,0,Time[FractalUpperBar+1],FractalUpperValue,Time[FractalUpperBar-1],FractalUpperValue);
     ObjectSet("FractalUpper",OBJPROP_STYLE,STYLE_SOLID);
     if (Bid > FractalUpperValue){FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);}

     else                        {FractalUpperHit = false; ObjectSet("FractalUpper",OBJPROP_COLOR,Blue); }
    }
    FractalUpperTime = Time[FractalUpperBar];
    if (FractalUpperTime != FractalUpperTimeOld)
    {
     if (Bid > FractalUpperValue){FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);}

     else                        {FractalUpperHit = false; ObjectSet("FractalUpper",OBJPROP_COLOR,Blue); }
     
     ObjectMove("FractalUpper",0,Time[FractalUpperBar+1],FractalUpperValue);  
     ObjectMove("FractalUpper",1,Time[FractalUpperBar-1],FractalUpperValue);
    }
//---
//---   
   if (ObjectFind("FractalLower")<0) 
    {
     ObjectCreate("FractalLower",OBJ_TREND,0,Time[FractalLowerBar+1],FractalLowerValue,Time[FractalLowerBar-1],FractalLowerValue);
     ObjectSet("FractalLower",OBJPROP_STYLE,STYLE_SOLID);
     if (Bid < FractalLowerValue) {FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);}
     else                         {FractalLowerHit = false; ObjectSet("FractalLower",OBJPROP_COLOR,Red);  }
    }
    FractalLowerTime = Time[FractalLowerBar];
    if (FractalLowerTime != FractalLowerTimeOld)
    {
     if (Bid < FractalLowerValue) {FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);}
     else                         {FractalLowerHit = false; ObjectSet("FractalLower",OBJPROP_COLOR,Red);  }
     
     ObjectMove("FractalLower",0,Time[FractalLowerBar+1],FractalLowerValue);
     ObjectMove("FractalLower",1,Time[FractalLowerBar-1],FractalLowerValue);
    }
//---   
  } //  void  SetFractalsValue() 
//+------------------------------------------------------------------+
//|                                        GetJTLCloseLevelTrend.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 void GetJTLCloseLevelTrend()
{
    Jaw_0  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORJAW  ,0);
    Teeth_0  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORTEETH,0);
    Lips_0  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORLIPS ,0);
   
    Jaw_1  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORJAW  ,1);
    Teeth_1  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORTEETH,1);
    Lips_1  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORLIPS ,1);
   
    Jaw_2  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORJAW  ,2);
    Teeth_2  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORTEETH,2);
    Lips_2  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORLIPS ,2);
   
    
    if (Lips_0 > Teeth_0 && Teeth_0 > Jaw_0) TrendUp0   = true; else TrendUp0   = false;
    if (Lips_0 < Teeth_0 && Teeth_0 < Jaw_0) TrendDown0 = true; else TrendDown0 = false;
    
    if (Lips_1 > Teeth_1 && Teeth_1 > Jaw_1) TrendUp1   = true; else TrendUp1   = false;
    if (Lips_1 < Teeth_1 && Teeth_1 < Jaw_1) TrendDown1 = true; else TrendDown1 = false;
    
    if (Lips_2 > Teeth_2 && Teeth_2 > Jaw_2) TrendUp2   = true; else TrendUp2   = false;
    if (Lips_2 < Teeth_2 && Teeth_2 < Jaw_2) TrendDown2 = true; else TrendDown2 = false;
    
/*    
    if (CloseAllonLIPS  && (TrendUp0 || TrendDown0))  {CloseLevel = Lips_1;  return;}
    if (CloseAllonTEETH && (TrendUp0 || TrendDown0))  {CloseLevel = Teeth_1; return;}
    if (CloseAllonJAW   && (TrendUp0 || TrendDown0))  {CloseLevel = Jaw_1;   return;}
*/    
    if (CloseAllonLIPS)  {CloseLevel = Lips_1;  return;}
    if (CloseAllonTEETH) {CloseLevel = Teeth_1; return;}
    if (CloseAllonJAW  ) {CloseLevel = Jaw_1;   return;}
    return;
    
}  // void GetJawTeethLips()
//+------------------------------------------------------------------+
//|                                           GetZeroTargetLines.mq4 |
//|                                      Copyright © 2010, "more"    |
//|                                     "mailto:tradertobe@gmail.com |
//+------------------------------------------------------------------+
int GetZeroTargetLines()
  {
   if (_ExpertOrdersTotal == 0)
   {
    ObjectDelete("ZeroTargetPrice");
    ObjectDelete("ProfitTargetPrice");
    return;
   }
   double sum=0;
   double sum1=0;
   double ZeroTargetPriceOld;
   double ProfitTargetPriceOld;
   ZeroTargetPriceOld = ZeroTargetPrice;
   ProfitTargetPriceOld = ProfitTargetPrice;
   for (i=0; i < _ExpertOrdersTotal; i++)
   {
      if (_OrderType[i] == OP_BUY)
      {
       sum  = sum   + _OrderLots[i]  * _OrderOpenPrice[i] * TicValue;
       sum1 = sum1  + _OrderLots[i]  * TicValue ; 
      }
      if (_OrderType[i] == OP_SELL)
      {
       sum =  sum -  _OrderLots[i] * _OrderOpenPrice[i] * TicValue;
       sum1 = sum1 - _OrderLots[i] * TicValue ; 
      }
   } // for (i=0; i < _ExpertOrdersTotal; i++)
   if (sum1 == 0) return;
//---   
   ZeroTargetPrice = (ZeroTarget * Point +  sum)/sum1;
   ZeroTargetPrice = NormalizeDouble(ZeroTargetPrice,Digits); 
   if (ObjectFind("ZeroTargetPrice")<0)   
    {
     ObjectCreate("ZeroTargetPrice",OBJ_HLINE,0,D'2007.05.01 00:00:00',ZeroTargetPrice);
     ObjectSet   ("ZeroTargetPrice",OBJPROP_COLOR,White);
     ObjectSet   ("ZeroTargetPrice",OBJPROP_STYLE,STYLE_SOLID);
    }
   if (ZeroTargetPrice != ZeroTargetPriceOld)
   {
    PlaySound("Ku_ku.wav"); 
    ObjectMove("ZeroTargetPrice",0,D'2007.05.01 00:00:00', ZeroTargetPrice);
   }
//---   
   if (ProfitTarget == 0) return;
   ProfitTargetPrice = (ProfitTarget * Point +  sum)/sum1;
   ProfitTargetPrice = NormalizeDouble(ProfitTargetPrice,Digits); 
   if (ObjectFind("ProfitTargetPrice")<0)   
    {
     ObjectCreate("ProfitTargetPrice",OBJ_HLINE,0,D'2007.05.01 00:00:00',ProfitTargetPrice);
     ObjectSet   ("ProfitTargetPrice",OBJPROP_COLOR,Gold);
     ObjectSet   ("ProfitTargetPrice",OBJPROP_STYLE,STYLE_SOLID);
    }
   if (ProfitTargetPrice != ProfitTargetPriceOld)
   {
    PlaySound("Ku_ku.wav"); 
    ObjectMove("ProfitTargetPrice",0,D'2007.05.01 00:00:00', ProfitTargetPrice);
   }
//---   
   return(0);
} // GetZeroTargetLines
//+------------------------------------------------------------------+
//|                                                  GetLotValue.mq4 |
//|                                         Copyright © 2010, "more" |
//|                                      "mailto:tradertobe@gmail.co |
//+------------------------------------------------------------------+
bool GetLotValue(string symbol, int Cmd, double& Lot)
 {
   if (_ExpertOrdersTotal < 3) 
   {
    Lot = LotInitial;
   }
   else
   {
    for (int i = 0; i < _ExpertOrdersTotal; i++) {Lot += _OrderLots[i];}
   }
//---+
   int  Margin_Check;
   //---
   double MINLOT = MarketInfo(symbol, MODE_MINLOT);
   if (MINLOT == 0)
              return(false);
   //---          
   if (Lot < MINLOT)
    {
     Lot = 0.0;
     return(false);
    }
   //---           
   double LOTSTEP = MarketInfo(symbol, MODE_LOTSTEP);
   if (LOTSTEP == 0)
              return(false);
   //---           
   Lot = LOTSTEP * MathFloor(Lot / LOTSTEP); 
   //---
/*   
   while(Lot >= MINLOT && Margin_Check <= 0)
     {
       Margin_Check =
         AccountFreeMarginCheck(symbol, Cmd, Lot);
       //---              
       if (Margin_Check < 0)
                     Lot -= LOTSTEP; 
       //---              
       if (Lot < MINLOT)
        {
         Lot = 0.0;
         return(false);
        }
     }
*/            
  return(true);
//---+
 }  // bool GetLotValue(string symbol, int Cmd, double& Lot)
//********************************************************************************************************************
//+------------------------------------------------------------------+
//|                                                AllOrdersInit.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 //| функция производит  формирование массивов, каждый из которых представляет одно                      |
//| поле ордера, принадлежащего эксперту. таким образом, множество элементов массивов с                 |
//| одним значение индекса представляет ордер. массивы отсортированы в порядке возрастания тикета       |
//| размерность массивов =  _ExpertOrdersTotal + 1                                                      |
//| последние элементы массивов будут использоваться нами для формирования данных при открытии/установки|
//| нового ордера                                                                                       |
 //+----------------------------------------------------------------------------------------------------+
//"mailto:komposterius@mail.ru" - Андрей Хатимлянский - автор этой функции
//http://www.mql4.com/ru/users/komposter Андрей Хатимлянский
void AllOrdersInit( int magic )
{
	int _GetLastError = 0, _OrdersTotal = OrdersTotal();
    _ExpertOrdersTotal     = 0;    //общее количество ордеров, принадлежащих эксперту
    _ExpertOrdersBuy       = 0;    // 
    _ExpertOrdersSell      = 0;    // 
    _ExpertOrdersBuyStop   = 0;    // 
    _ExpertOrdersSellStop  = 0;    // 
    _ExpertOrdersBuyLimit  = 0;    // 
    _ExpertOrdersSellLimit = 0;    // 
 	// изменяем размеры массивов под текущее кол-во позиций
	// (если _OrdersTotal = 0, меняем размер массивов на 1) 
	int temp_value = MathMax( _OrdersTotal+1, 1 );
	ArrayResize( _OrderTicket,			temp_value );
	ArrayResize( _OrderType,			temp_value );
	ArrayResize( _OrderLots,			temp_value );
	ArrayResize( _OrderOpenPrice,		temp_value );
	ArrayResize( _OrderStopLoss,		temp_value );
	ArrayResize( _OrderTakeProfit,	temp_value );
	ArrayResize( _OrderOpenTime,		temp_value );
	ArrayResize( _OrderProfit,			temp_value );
	ArrayResize( _OrderSwap,			temp_value );
	ArrayResize( _OrderCommission,	temp_value );
	ArrayResize( _OrderComment,		temp_value );
	ArrayResize( _OrderExpiration,	temp_value );
	ArrayResize( _OrderMagicNumber,	temp_value );
	

	// обнуляем массивы
	ArrayInitialize( _OrderTicket,		0 );    
	ArrayInitialize( _OrderType,			0 );
	ArrayInitialize( _OrderLots,			0 );
	ArrayInitialize( _OrderOpenPrice,	0 );
	ArrayInitialize( _OrderStopLoss,		0 );
	ArrayInitialize( _OrderTakeProfit,	0 );
	ArrayInitialize( _OrderOpenTime,		0 );
	ArrayInitialize( _OrderProfit,		0 );
	ArrayInitialize( _OrderSwap,			0 );
	ArrayInitialize( _OrderCommission,	0 );
	ArrayInitialize( _OrderExpiration,	0 );
	ArrayInitialize( _OrderMagicNumber,	0 );
   
 	for ( int z = 0;  z < _OrdersTotal;  z ++ )
 	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError );
			continue;
		}
      if (magic == 0)
      {
		 if (OrderSymbol() == Symbol() )
		 {
			// заполняем массив тикетов ордеров, принадлежащих експерту
			_OrderTicket [_ExpertOrdersTotal] = OrderTicket();
 			_ExpertOrdersTotal ++;
 	   	switch(OrderType())
           {
            case OP_BUY       : _ExpertOrdersBuy++ ;        break; 
            case OP_SELL      : _ExpertOrdersSell++ ;       break;
            case OP_BUYSTOP   : _ExpertOrdersBuyStop++ ;    break;
            case OP_SELLSTOP  : _ExpertOrdersSellStop++ ;   break;
            case OP_BUYLIMIT  : _ExpertOrdersBuyLimit++ ;   break;
            case OP_SELLLIMIT : _ExpertOrdersSellLimit++ ;  break;
           }
		 } // if (OrderSymbol() == Symbol() )
		}  // if (magic == 0)
		else
		if (OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
      {
		 {
			// заполняем массив тикетов ордеров, принадлежащих експерту
			_OrderTicket [_ExpertOrdersTotal] = OrderTicket();
 			_ExpertOrdersTotal ++;
 	   	switch(OrderType())
           {
            case OP_BUY       : _ExpertOrdersBuy++ ;        break; 
            case OP_SELL      : _ExpertOrdersSell++ ;       break;
            case OP_BUYSTOP   : _ExpertOrdersBuyStop++ ;    break;
            case OP_SELLSTOP  : _ExpertOrdersSellStop++ ;   break;
            case OP_BUYLIMIT  : _ExpertOrdersBuyLimit++ ;   break;
            case OP_SELLLIMIT : _ExpertOrdersSellLimit++ ;  break;
           }
		 } // if (OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
		} // else
	} // for ( int z = 0;  z < _OrdersTotal;  z ++ )
	// изменяем размеры массивов под кол-во позиций, принадлежащих эксперту + одна
	// (если _ExpertOrdersTotal = 0, меняем размер массивов на 1)
	temp_value = MathMax( _ExpertOrdersTotal+1, 1 );
	ArrayResize( _OrderTicket,			temp_value );
	ArrayResize( _OrderType,			temp_value );
	ArrayResize( _OrderLots,			temp_value );
	ArrayResize( _OrderOpenPrice,		temp_value );
	ArrayResize( _OrderStopLoss,		temp_value );
	ArrayResize( _OrderTakeProfit,	temp_value );
	ArrayResize( _OrderOpenTime,		temp_value );
	ArrayResize( _OrderProfit,			temp_value );
	ArrayResize( _OrderSwap,			temp_value );
	ArrayResize( _OrderCommission,	temp_value );
	ArrayResize( _OrderComment,		temp_value );
	ArrayResize( _OrderExpiration,	temp_value );
	
	_OrderTicket[_ExpertOrdersTotal] = 99999999;// при сортировке этот пустой элемент будет последним
   ArraySort(_OrderTicket);  // получим хронологический порядок...
//------------------------------------------------------------------------------------------------------------------------
	for (   z = 0;  z < _ExpertOrdersTotal;  z ++ )
 	{
		if ( !OrderSelect( _OrderTicket[z], SELECT_BY_TICKET ) )
		{
			_GetLastError = GetLastError();
			Print("OrderSelect( ", _OrderTicket[z], ", SELECT_BY_TICKET ) - Error #", _GetLastError );
			continue;
		}
 			// заполняем остальные массивы
 			_OrderType			[z] = OrderType();
			_OrderLots			[z] = NormalizeDouble( OrderLots(), 2 );
			_OrderOpenPrice	[z] = NormalizeDouble( OrderOpenPrice(), Digits );
			_OrderStopLoss		[z] = NormalizeDouble( OrderStopLoss(), Digits );
			_OrderTakeProfit	[z] = NormalizeDouble( OrderTakeProfit(), Digits );
			_OrderOpenTime		[z] = OrderOpenTime();
			_OrderProfit		[z] = NormalizeDouble( OrderProfit(), 2 );
			_OrderSwap			[z] = NormalizeDouble( OrderSwap(), 2 );
			_OrderCommission	[z] = NormalizeDouble( OrderCommission(), 2 );
			_OrderComment		[z] = OrderComment();
			_OrderExpiration	[z] = OrderExpiration();
	      _OrderMagicNumber [z] = OrderMagicNumber();
			
  	}
//------------------------------------------------------------------------------------------------------------------------ 
return;	
} // AllOrdersInit( int magic )

//+------------------------------------------------------------------+
//|                                             ServiceFunctions.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 //http://www.mql4.com/ru/users/bstone -Крамарь Роман - автор четырех, следующих ниже функций
//+------------------------------------------------------------------+
//| helper functions   -   Крамарь Роман                                     
//+------------------------------------------------------------------+

int sign( double v )
{
    if( v < 0 ) return( -1 );
    return( 1 );
}

//+------------------------------------------------------------------+
double iif( bool condition, double ifTrue, double ifFalse )
{
    if( condition ) return( ifTrue );
    
    return( ifFalse );
}

//+------------------------------------------------------------------+
string iifStr( bool condition, string ifTrue, string ifFalse )
{
    if( condition ) return( ifTrue );

    return( ifFalse );
}

//+------------------------------------------------------------------+
int orderDirection()
{
    return( 1 - 2 * ( OrderType() % 2 ) );
}
//------------------------------------------------------------------------------------------------------------------------