根据斐波那契数列挂单的网格EA Elite_eFibo_Trader.mq5-MT5 EA-峰汇在线
诚信为本
量力而为
当前位置:峰汇在线 > MetaTrader 5 > MT5 EA > 正文

根据斐波那契数列挂单的网格EA Elite_eFibo_Trader.mq5

Elite_eFibo_Trader EA属于网格挂单EA。

源码:

//+------------------------------------------------------------------+
//|                  Elite eFibo Trader(barabashkakvn's edition).mq5 |
//|                             Copyright © 2007, Elite E Services   |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Elite E Services "
#property link      "http://www.125808047.com"

#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>  
#include <Trade\AccountInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Trade\OrderInfo.mqh>
CPositionInfo  m_position;                   // trade position object
CTrade         m_trade;                      // trading object
CSymbolInfo    m_symbol;                     // symbol info object
CAccountInfo   m_account;                    // account info wrapper
CDealInfo      m_deal;                       // deals object
COrderInfo     m_order;                      // pending orders object

input ulong    MagicNumber       = 100;      // MagicNumber
input ulong    Slippage          = 4;        // Slippage
input bool     Open_Buy          = false;    // Open_Buy
input bool     Open_Sell         = true;     // Open_Sell
input bool     TradeAgainAfterProfit=true;   // TradeAgainAfterProfit   
input ushort   InpLevelDistance  = 20;       // LevelDistance
input ushort   InpStopLoss       = 10;       // ExtStopLoss
input double   MoneyTakeProfit   = 2000;     // Profit (in money)
input double   Lots_Level_1      = 1;        // Level_1
input double   Lots_Level_2      = 1;        // Level_2
input double   Lots_Level_3      = 2;        // Level_3
input double   Lots_Level_4      = 3;        // Level_4
input double   Lots_Level_5      = 5;        // Level_5
input double   Lots_Level_6      = 8;        // Level_6
input double   Lots_Level_7      = 13;       // Level_7
input double   Lots_Level_8      = 21;       // Level_8
input double   Lots_Level_9      = 34;       // Level_9
input double   Lots_Level_10     = 55;       // Level_10
input double   Lots_Level_11     = 89;       // Level_11
input double   Lots_Level_12     = 144;      // Level_12
input double   Lots_Level_13     = 233;      // Level_13
input double   Lots_Level_14     = 377;      // Level_14
//---
bool Trade=true;
datetime FirstTime;
double BestBuySL,BestSellSL;
ulong ticket1,ticket2,ticket3,ticket4,ticket5,ticket6,ticket7,ticket8,ticket9,ticket10,ticket11,ticket12,ticket13,ticket14;

double ExtLevelDistance = 0.0;
double ExtStopLoss      = 0.0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   m_symbol.Name(Symbol());                  // sets symbol name
   m_trade.SetExpertMagicNumber(MagicNumber);    // sets magic number

   if(!RefreshRates())
     {
      Print("Error RefreshRates. Bid=",DoubleToString(m_symbol.Bid(),Digits()),
            ", Ask=",DoubleToString(m_symbol.Ask(),Digits()));
      return(INIT_FAILED);
     }

   m_trade.SetDeviationInPoints(Slippage);

   int digits_adjust=1;
   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
      digits_adjust=10;

   ExtLevelDistance  = InpLevelDistance*digits_adjust;
   ExtStopLoss       = InpStopLoss*digits_adjust;

   FirstTime         = 0;
   BestBuySL         = 0.0;
   BestSellSL        = 0.0;
    Comment("www.125808047.com");
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(TradeAgainAfterProfit)
      Trade=true;
   ticket1 = 0;
   ticket2 = 0;
   ticket3 = 0;
   ticket4 = 0;
   ticket5 = 0;
   ticket6 = 0;
   ticket7 = 0;
   ticket8 = 0;
   ticket9 = 0;
   ticket10 = 0;
   ticket11 = 0;
   ticket12 = 0;
   ticket13 = 0;
   ticket14 = 0;

   if((subTotalOrdersAndPositions()<1) && (Trade))
     {
      subDeleteAllOrders();
      //--- OPEN BUY
      if(Open_Buy && !Open_Sell)
        {
         if(!RefreshRates())
            return;

         double OP=m_symbol.Ask();

         if(ticket1==0)
            ticket1=subOpenPosition(POSITION_TYPE_BUY,Lots_Level_1,ExtStopLoss,0.0);
         if(ticket1>0 && ticket2==0)
            ticket2=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(ExtLevelDistance*Point()),Lots_Level_2,0,ExtStopLoss);
         if(ticket2>0 && ticket3==0)
            ticket3=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(2*ExtLevelDistance*Point()),Lots_Level_3,0,ExtStopLoss);
         if(ticket3>0 && ticket4==0)
            ticket4=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(3*ExtLevelDistance*Point()),Lots_Level_4,0,ExtStopLoss);
         if(ticket4>0 && ticket5==0)
            ticket5=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(4*ExtLevelDistance*Point()),Lots_Level_5,0,ExtStopLoss);
         if(ticket5>0 && ticket6==0)
            ticket6=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(5*ExtLevelDistance*Point()),Lots_Level_6,0,ExtStopLoss);
         if(ticket6>0 && ticket7==0)
            ticket7=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(6*ExtLevelDistance*Point()),Lots_Level_7,0,ExtStopLoss);
         if(ticket7>0 && ticket8==0)
            ticket8=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(7*ExtLevelDistance*Point()),Lots_Level_8,0,ExtStopLoss);
         if(ticket8>0 && ticket9==0)
            ticket9=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(8*ExtLevelDistance*Point()),Lots_Level_9,0,ExtStopLoss);
         if(ticket9>0 && ticket10==0)
            ticket10=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(9*ExtLevelDistance*Point()),Lots_Level_10,0,ExtStopLoss);
         if(ticket10>0 && ticket11==0)
            ticket11=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(10*ExtLevelDistance*Point()),Lots_Level_11,0,ExtStopLoss);
         if(ticket11>0 && ticket12==0)
            ticket12=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(11*ExtLevelDistance*Point()),Lots_Level_12,0,ExtStopLoss);
         if(ticket12>0 && ticket13==0)
            ticket13=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(12*ExtLevelDistance*Point()),Lots_Level_13,0,ExtStopLoss);
         if(ticket13>0 && ticket14==0)
            ticket14=subOpenPendingOrder(ORDER_TYPE_BUY_STOP,OP+(13*ExtLevelDistance*Point()),Lots_Level_14,0,ExtStopLoss);

         if(ticket14>0)
           {
            FirstTime=iTime(0);
            return;
           }
        }

      //--- OPEN SELL
      if(Open_Sell && !Open_Buy)
        {
         if(!RefreshRates())
            return;

         double OP=m_symbol.Bid();

         if(ticket1==0)
            ticket1=subOpenPosition(POSITION_TYPE_SELL,Lots_Level_1,ExtStopLoss,0.0);
         if(ticket1>0 && ticket2==0)
            ticket2=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(ExtLevelDistance*Point()),Lots_Level_2,0,ExtStopLoss);
         if(ticket2>0 && ticket3==0)
            ticket3=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(2*ExtLevelDistance*Point()),Lots_Level_3,0,ExtStopLoss);
         if(ticket3>0 && ticket4==0)
            ticket4=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(3*ExtLevelDistance*Point()),Lots_Level_4,0,ExtStopLoss);
         if(ticket4>0 && ticket5==0)
            ticket5=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(4*ExtLevelDistance*Point()),Lots_Level_5,0,ExtStopLoss);
         if(ticket5>0 && ticket6==0)
            ticket6=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(5*ExtLevelDistance*Point()),Lots_Level_6,0,ExtStopLoss);
         if(ticket6>0 && ticket7==0)
            ticket7=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(6*ExtLevelDistance*Point()),Lots_Level_7,0,ExtStopLoss);
         if(ticket7>0 && ticket8==0)
            ticket8=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(7*ExtLevelDistance*Point()),Lots_Level_8,0,ExtStopLoss);
         if(ticket8>0 && ticket9==0)
            ticket9=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(8*ExtLevelDistance*Point()),Lots_Level_9,0,ExtStopLoss);
         if(ticket9>0 && ticket10==0)
            ticket10=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(9*ExtLevelDistance*Point()),Lots_Level_10,0,ExtStopLoss);
         if(ticket10>0 && ticket11==0)
            ticket11=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(10*ExtLevelDistance*Point()),Lots_Level_11,0,ExtStopLoss);
         if(ticket11>0 && ticket12==0)
            ticket12=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(11*ExtLevelDistance*Point()),Lots_Level_12,0,ExtStopLoss);
         if(ticket12>0 && ticket13==0)
            ticket13=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(12*ExtLevelDistance*Point()),Lots_Level_13,0,ExtStopLoss);
         if(ticket13>0 && ticket14==0)
            ticket14=subOpenPendingOrder(ORDER_TYPE_SELL_STOP,OP-(13*ExtLevelDistance*Point()),Lots_Level_14,0,ExtStopLoss);

         if(ticket14>0)
           {
            FirstTime=iTime(0);
            return;
           }
        }
      FirstTime=iTime(0);
     }
   FirstTime=iTime(0);
//--- TAKE PROFIT
   if(subTotalProfit()>=MoneyTakeProfit)
     {
      Print("Money Take Profit Reached");
      if(!TradeAgainAfterProfit)
         Trade=false;

      subClosePositions();
      subDeleteAllOrders();
     }

   if(subTotalPositions()>0)
     {
      BestSellSL= subBestSellSL();
      BestBuySL = subBestBuySL();

      for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions
         if(m_position.SelectByIndex(i))
            if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber)
               subTrailingStop(m_position.PositionType(),BestSellSL,BestBuySL);

     }
   if(subTotalPositions()<1)
      subDeleteAllOrders();
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int subTotalOrdersAndPositions()
  {
   int total=0;

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber)
            total++;

   for(int i=OrdersTotal()-1;i>=0;i--) // returns the number of current orders
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber)
            total++;

   return(total);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int subTotalPositions()
  {
   int total=0;

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber)
            total++;

   return(total);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double subTotalProfit()
  {
   double Profit=0;
   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber)
            Profit+=m_position.Profit();
   return(Profit);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
ulong subOpenPendingOrder(ENUM_ORDER_TYPE type,double OpenPrice,double Lots,double takeprofit,double stoploss)
  {
   if(!IsTradeAllowed())
      return(0);

   ulong ticket=0;

   int NumberOfTries=10;
   string TicketComment="Andrew EA";

   double
   aStopLoss   = 0.0,
   aTakeProfit = 0.0,
   aOpenPrice  = 0.0,
   bStopLoss   = 0.0,
   bTakeProfit = 0.0;

   if(takeprofit!=0)
     {
      aTakeProfit = NormalizeDouble(OpenPrice+takeprofit*Point(),Digits());
      bTakeProfit = NormalizeDouble(OpenPrice-takeprofit*Point(),Digits());
     }
   if(stoploss!=0)
     {
      aStopLoss   = NormalizeDouble(OpenPrice-stoploss*Point(),Digits());
      bStopLoss   = NormalizeDouble(OpenPrice+stoploss*Point(),Digits());
     }

   if(type==ORDER_TYPE_BUY_STOP)
     {
      for(int c=0;c<NumberOfTries;c++)
        {
         if(m_trade.OrderOpen(Symbol(),ORDER_TYPE_BUY_STOP,Lots,0.0,OpenPrice,aStopLoss,aTakeProfit,0,0,TicketComment))
           {
            ticket=m_trade.ResultOrder();
            if(ticket>0)
               return(ticket);
           }
         else
           {
            Print("BUY_STOP -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of Retcode: ",m_trade.ResultRetcodeDescription(),
                  ", ticket of order: ",m_trade.ResultOrder());
            Sleep(5000);
            continue;
           }
        }
     }
   if(type==ORDER_TYPE_SELL_STOP)
     {
      for(int c=0;c<NumberOfTries;c++)
        {
         if(m_trade.OrderOpen(Symbol(),ORDER_TYPE_SELL_STOP,Lots,0.0,OpenPrice,bStopLoss,bTakeProfit,0,0,TicketComment))
           {
            ticket=m_trade.ResultOrder();
            if(ticket>0)
               return(ticket);
           }
         else
           {
            Print("SELL_STOP -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of Retcode: ",m_trade.ResultRetcodeDescription(),
                  ", ticket of order: ",m_trade.ResultOrder());
            Sleep(5000);
            continue;
           }
        }
     }
   if(type==ORDER_TYPE_BUY_LIMIT)
     {
      for(int c=0;c<NumberOfTries;c++)
        {
         if(m_trade.OrderOpen(Symbol(),ORDER_TYPE_BUY_LIMIT,Lots,0.0,OpenPrice,aStopLoss,aTakeProfit,0,0,TicketComment))
           {
            ticket=m_trade.ResultOrder();
            if(ticket>0)
               return(ticket);
           }
         else
           {
            Print("BUY_LIMIT -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of Retcode: ",m_trade.ResultRetcodeDescription(),
                  ", ticket of order: ",m_trade.ResultOrder());
            Sleep(5000);
            continue;
           }
        }
     }
   if(type==ORDER_TYPE_SELL_LIMIT)
     {
      for(int c=0;c<NumberOfTries;c++)
        {
         if(m_trade.OrderOpen(Symbol(),ORDER_TYPE_SELL_LIMIT,Lots,0.0,OpenPrice,bStopLoss,bTakeProfit,0,0,TicketComment))
           {
            ticket=m_trade.ResultOrder();
            if(ticket>0)
               return(ticket);
           }
         else
           {
            Print("BUY_LIMIT -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of Retcode: ",m_trade.ResultRetcodeDescription(),
                  ", ticket of order: ",m_trade.ResultOrder());
            Sleep(5000);
            continue;
           }
        }
     }
   return(ticket);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
ulong subOpenPosition(ENUM_POSITION_TYPE type,double Lotz,double stoploss,double takeprofit)
  {
   if(!IsTradeAllowed())
      return(0);

   if(!RefreshRates())
      return(0);

   ulong ticket=0;

   int NumberOfTries=10;
   string TicketComment="Hedge EA";

   double
   aStopLoss   = 0.0,
   aTakeProfit = 0.0,
   bStopLoss   = 0.0,
   bTakeProfit = 0.0;

   if(stoploss!=0)
     {
      aStopLoss   = NormalizeDouble(m_symbol.Ask()-stoploss*Point(),Digits());//NormalizeDouble(m_symbol.Ask()-stoploss*Point(),4);
      bStopLoss   = NormalizeDouble(m_symbol.Bid()+stoploss*Point(),Digits());//NormalizeDouble(m_symbol.Bid()+stoploss*Point(),4);
     }

   if(takeprofit!=0)
     {
      aTakeProfit = NormalizeDouble(m_symbol.Ask()+takeprofit*Point(),Digits());//NormalizeDouble(m_symbol.Ask()+takeprofit*Point(),4);
      bTakeProfit = NormalizeDouble(m_symbol.Bid()-takeprofit*Point(),Digits());//NormalizeDouble(m_symbol.Bid()-takeprofit*Point(),4);
     }

   if(type==POSITION_TYPE_BUY)
     {
      for(int c=0;c<NumberOfTries;c++)
        {
         if(m_trade.Buy(Lotz,Symbol(),m_symbol.Ask(),aStopLoss,aTakeProfit,TicketComment))
           {
            ticket=m_trade.ResultDeal();
            if(ticket>0)
               return(ticket);
           }
         else
           {
            Print("Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of result: ",m_trade.ResultRetcodeDescription(),
                  ", ticket of deal: ",m_trade.ResultDeal());
            Sleep(5000);
            continue;
           }
        }
     }

   if(type==POSITION_TYPE_SELL)
     {
      for(int c=0;c<NumberOfTries;c++)
        {
         if(m_trade.Sell(Lotz,Symbol(),m_symbol.Bid(),bStopLoss,bTakeProfit,TicketComment))
           {
            ticket=m_trade.ResultDeal();
            if(ticket>0)
               return(ticket);
           }
         else
           {
            Print("Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of result: ",m_trade.ResultRetcodeDescription(),
                  ", ticket of deal: ",m_trade.ResultDeal());
            Sleep(5000);
            continue;
           }
        }
     }
   return(ticket);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double subBestBuySL()
  {
   double SL=0;
   for(int i=PositionsTotal()-1;i>=0;i--)
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber && m_position.PositionType()==POSITION_TYPE_BUY)
            if(m_position.StopLoss()>SL)
               SL=m_position.StopLoss();
   return(SL);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double subBestSellSL()
  {
   double SL=10000000;
   for(int i=PositionsTotal()-1;i>=0;i--)
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber && m_position.PositionType()==POSITION_TYPE_SELL)
            if(m_position.StopLoss()<SL)
               SL=m_position.StopLoss();
   return(SL);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void subTrailingStop(ENUM_POSITION_TYPE Type,const double best_sell_sl,const double best_buy_sl)
  {
   if(Type==POSITION_TYPE_BUY) // buy position is opened   
     {
      //--- AFTER PROFIT TRAILING STOP      
      if(m_position.StopLoss()<BestBuySL)
        {
         m_trade.PositionModify(m_position.Ticket(),best_buy_sl,m_position.TakeProfit());
         return;
        }

     }
   if(Type==POSITION_TYPE_SELL) // sell position is opened   
     {
      //--- AFTER PROFIT TRAILING STOP      
      if(m_position.StopLoss()>BestSellSL)
        {
         m_trade.PositionModify(m_position.Ticket(),best_sell_sl,m_position.TakeProfit());
         return;
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void subDeleteAllOrders()
  {
   if(!IsTradeAllowed())
      return;

   for(int i=OrdersTotal()-1;i>=0;i--) // returns the number of current orders
      if(m_order.SelectByIndex(i))
         if(m_order.Symbol()==Symbol() && m_order.Magic()==MagicNumber)
            m_trade.OrderDelete(m_order.Ticket());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void subClosePositions()
  {
   if(!IsTradeAllowed())
      return;

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==MagicNumber)
            m_trade.PositionClose(m_position.Ticket());
  }
//+------------------------------------------------------------------+ 
//| Get Time for specified bar index                                 | 
//+------------------------------------------------------------------+ 
datetime iTime(const int index,string symbol=NULL,ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT)
  {
   if(symbol==NULL)
      symbol=Symbol();
   if(timeframe==0)
      timeframe=Period();
   datetime Time[];
   datetime time=0;
   ArraySetAsSeries(Time,true);
   int copied=CopyTime(symbol,timeframe,index,1,Time);
   if(copied>0) time=Time[0];
   return(time);
  }
//+------------------------------------------------------------------+
//| Refreshes the symbol quotes data                                 |
//+------------------------------------------------------------------+
bool RefreshRates()
  {
//--- refresh rates
   if(!m_symbol.RefreshRates())
      return(false);
//--- protection against the return value of "zero"
   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//| Gets the information about permission to trade                   |
//+------------------------------------------------------------------+
bool IsTradeAllowed()
  {
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
     {
      Alert("Check if automated trading is allowed in the terminal settings!");
      return(false);
     }
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
     {
      Alert("Check if automated trading is allowed in the terminal settings!");
      return(false);
     }
   else
     {
      if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
        {
         Alert("Automated trading is forbidden in the program settings for ",__FILE__);
         return(false);
        }
     }
   if(!AccountInfoInteger(ACCOUNT_TRADE_EXPERT))
     {
      Alert("Automated trading is forbidden for the account ",AccountInfoInteger(ACCOUNT_LOGIN),
            " at the trade server side");
      return(false);
     }
   if(!AccountInfoInteger(ACCOUNT_TRADE_ALLOWED))
     {
      Comment("Trading is forbidden for the account ",AccountInfoInteger(ACCOUNT_LOGIN),
              ".\n Perhaps an investor password has been used to connect to the trading account.",
              "\n Check the terminal journal for the following entry:",
              "\n\'",AccountInfoInteger(ACCOUNT_LOGIN),"\': trading has been disabled - investor mode.");
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
打赏
版权所有转载请注明标题及链接:峰汇在线 » 根据斐波那契数列挂单的网格EA Elite_eFibo_Trader.mq5
上一篇:
下一篇:
分享到: 更多 (0)

如您觉得此文不错请扫码打赏!

支付宝扫一扫打赏

微信扫一扫打赏