//+------------------------------------------------------------------+ //| ashix EA //| //| Generated by StrategyQuant 3.9.66 for MetaTrader //| Generated at 06/19/2018 21:06 //+------------------------------------------------------------------+ #property copyright "StrategyQuant.com" #property link "http://www.StrategyQuant.com" #include #include #include #include #include #include #include #include #include const int SLPTTYPE_RANGE = 0; const int SLPTTYPE_LEVEL = 1; //+------------------------------------------------------------------+ // -- Variables //+------------------------------------------------------------------+ int MagicNumber = 12345; //+------------------------------------------------------------------+ // -- SQ Variables // - add word "extern" in front of the variable you want // to make configurable //+------------------------------------------------------------------+ //extern int Expert_ID = 1234; struct Indicator { string name; int handle; int bufferIndex; }; Indicator indys[]; struct LastClosedTrade { string symbol; int magicNumber; datetime closeTime; }; LastClosedTrade lastClosedTrades[]; MqlTick latest_price; // To be used for getting recent/latest price quotes MqlTradeRequest mrequest; // To be used for sending our trade requests MqlTradeResult mresult; // To be used to get our trade results MqlRates mrate[]; // To be used to store the prices, volumes and spread of each bar CTerminalInfo terminalInfo; string sqStrategyName = "ashix"; datetime startTime = TimeCurrent(); datetime lastCheckedTradeTime = startTime; extern bool sqDisplayInfoPanel = true; int sqLabelCorner = 1; int sqOffsetHorizontal = 5; int sqOffsetVertical = 20; color sqLabelColor = clrWhite; int magicNumber; int minBars = 30; int sqMaxSlippage; int sqVerboseMode; int sqMaxRetries = 5; double gPointPow = 0; double gPointCoef = 0; int deviationPoints = 10; int sqTicket = 1; datetime lastBarTime; bool _sqIsBarOpen; string valueIdentificationSymbol = ""; //+------------------------------------------------------------------+ // -- Functions //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit(){ VerboseLog("--------------------------------------------------------"); VerboseLog("Starting the EA"); //initMagicNumber(); if(!initIndicators()) return(INIT_FAILED); double realDigits = _Digits; if(realDigits > 0 && realDigits != 2 && realDigits != 4) { realDigits -= 1; } gPointPow = MathPow(10, realDigits); gPointCoef = 1/gPointPow; //VerboseLog("Broker stop level: ", SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL)); VerboseLog("--------------------------------------------------------"); if(sqDisplayInfoPanel) { sqInitInfoPanel(); } return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { sqDeinitInfoPanel(); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- Do we have enough bars to work with? if(Bars(_Symbol,_Period) < minBars) { // if total bars is less than minBars Alert(StringFormat("NOT ENOUGH DATA: Less Bars than %d", minBars)); return; } if(!SymbolInfoTick(_Symbol, latest_price)) { Alert("Error getting the latest price quote - error:",GetLastError(),"!!"); return; } //--- Get the details of the latest 2 bars if(CopyRates(_Symbol, _Period, 0, 2, mrate) < 2) { Alert("Error copying rates/history data - error:", GetLastError(), "!!"); ResetLastError(); return; } ZeroMemory(mrequest); // Initialization of mrequest structure checkBarOpen(); updateLastTrades(); sqTextFillOpens(); if(_sqIsBarOpen) { sqTextFillTotals(); } sqManagePositions(); ulong _ticket; //------------------------ // Rule: call //------------------------ if (sqHeikenAshi("NULL",0, "Open", 1) < sqHeikenAshi("NULL",0, "Close", 1)) { // Action #1 sqLogToFile("Signalsx.txt", "up"); // Action #2 sqLogToFile("Signals.txt", "up"); } //------------------------ // Rule: down //------------------------ if (sqHeikenAshi("NULL",0, "Open", 1) > sqHeikenAshi("NULL",0, "Close", 1)) { // Action #1 sqLogToFile("Signalsx.txt", "down"); // Action #2 sqLogToFile("Signals.txt", "down"); } } //+------------------------------------------------------------------+ //| Trade transaction event | //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ void updateLastTrades(){ HistorySelect(lastCheckedTradeTime, TimeCurrent()); lastCheckedTradeTime = TimeCurrent(); for(int i=HistoryDealsTotal() - 1; i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); string dealSymbol = HistoryDealGetString(ticket, DEAL_SYMBOL); int dealMagic = HistoryDealGetInteger(ticket, DEAL_MAGIC); datetime dealTime = HistoryDealGetInteger(ticket, DEAL_TIME); if(HistoryDealGetInteger(ticket, DEAL_ENTRY) != DEAL_ENTRY_OUT) continue; int lastTradeIndex = getLastTradeIndex(dealSymbol, dealMagic); if(lastTradeIndex >= 0){ lastClosedTrades[lastTradeIndex].closeTime = dealTime; } else { int prevSize = ArraySize(lastClosedTrades); ArrayResize(lastClosedTrades, prevSize + 1, 10); lastClosedTrades[prevSize].symbol = dealSymbol; lastClosedTrades[prevSize].magicNumber = dealMagic; lastClosedTrades[prevSize].closeTime = dealTime; } } } //+------------------------------------------------------------------+ bool sqTradeRecentlyClosed(string symbol, int magicNumber, bool checkThisBar, bool checkThisMinute) { string tradeSymbol = correctSymbol(symbol); int lastTradeIndex = -1; if(tradeSymbol == "Any" || magicNumber == 0){ for(int a=0; a lastClosedTrades[lastTradeIndex].closeTime){ lastTradeIndex = a; } } } } else { lastTradeIndex = getLastTradeIndex(tradeSymbol, magicNumber); } if(lastTradeIndex >= 0) { if(checkThisBar) { if(lastClosedTrades[lastTradeIndex].closeTime >= getTime(0)) { // order finished this bar return true; } } if(checkThisMinute) { string strCurrentTimeMinutes = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES); string strCloseTimeMinutes = TimeToString(lastClosedTrades[lastTradeIndex].closeTime, TIME_DATE | TIME_MINUTES); if(strCurrentTimeMinutes == strCloseTimeMinutes) { // order finished this minute return true; } } } return false; } //+------------------------------------------------------------------+ int getLastTradeIndex(string symbol, int magicNumber){ for(int a=0; a= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if (PositionSelectByTicket(positionTicket)) { sqManageSL2BE(positionTicket); sqManageTrailingStop(positionTicket); sqManageExitAfterXBars(positionTicket); } if(PositionsTotal() <= 0) return; } if(_sqIsBarOpen) { sqManageOrderExpirations(); } } //+------------------------------------------------------------------+ /* void initMagicNumber(){ int Period_ID = 0; switch ( Period() ) { case PERIOD_MN1: Period_ID = 9; break; case PERIOD_W1: Period_ID = 8; break; case PERIOD_D1: Period_ID = 7; break; case PERIOD_H4: Period_ID = 6; break; case PERIOD_H1: Period_ID = 5; break; case PERIOD_M30: Period_ID = 4; break; case PERIOD_M15: Period_ID = 3; break; case PERIOD_M5: Period_ID = 2; break; case PERIOD_M1: Period_ID = 1; break; } magicNumber = MagicNumber * 10 + Period_ID;//Expert_ID * 10 + Period_ID; } */ //+------------------------------------------------------------------+ void checkBarOpen(){ datetime currentBarTime = mrate[0].time; _sqIsBarOpen = currentBarTime == 0 || currentBarTime != lastBarTime; lastBarTime = currentBarTime; } //+------------------------------------------------------------------+ bool indyCrossesAbove(string indy1, string indy2, int shift1, int shift2) { double buffer1[], buffer2[]; if(!loadIndicatorValues(buffer1, indy1, 2, shift1) || !loadIndicatorValues(buffer2, indy2, 2, shift2)) return false; return buffer1[0] <= buffer2[0] && buffer1[1] > buffer2[1]; } //+------------------------------------------------------------------+ bool indyCrossesBelow(string indy1, string indy2, int shift1, int shift2) { double buffer1[], buffer2[]; if(!loadIndicatorValues(buffer1, indy1, 2, shift1) || !loadIndicatorValues(buffer2, indy2, 2, shift2)) return false; return buffer1[0] >= buffer2[0] && buffer1[1] < buffer2[1]; } //+------------------------------------------------------------------+ bool crossesAbove(string indy, int shift, double value) { double buffer[]; if(!loadIndicatorValues(buffer, indy, 2, shift)) return false; return buffer[0] <= value && buffer[1] > value; } //+------------------------------------------------------------------+ bool crossesBelow(string indy, int shift, double value) { double buffer[]; if(!loadIndicatorValues(buffer, indy, 2, shift)) return false; return buffer[0] >= value && buffer[1] < value; } //+------------------------------------------------------------------+ bool crossesUp(string indy, int shift, double value) { double buffer[]; if(!loadIndicatorValues(buffer, indy, 2, shift)) return false; return buffer[0] < value && buffer[1] > value; } //+------------------------------------------------------------------+ bool crossesDown(string indy, int shift, double value) { double buffer[]; if(!loadIndicatorValues(buffer, indy, 2, shift)) return false; return buffer[0] > value && buffer[1] < value; } //+------------------------------------------------------------------+ bool changesUp(string indy, int shift){ double buffer[]; if(!loadIndicatorValues(buffer, indy, 3, shift)) return false; return buffer[0] > buffer[1] && buffer[1] < buffer[2]; } //+------------------------------------------------------------------+ bool changesDown(string indy, int shift){ double buffer[]; if(!loadIndicatorValues(buffer, indy, 3, shift)) return false; return buffer[0] < buffer[1] && buffer[1] > buffer[2]; } //+------------------------------------------------------------------+ bool sqIsFalling(string indy, int bars, bool allowSameValues, int shift){ double buffer[]; bool atLeastOnce = false; if(!loadIndicatorValues(buffer, indy, bars, shift)) return false; double lastValue = buffer[0]; for(int a=1; a lastValue || (!allowSameValues && buffer[a] == lastValue)) return false; if(buffer[a] < lastValue){ atLeastOnce = true; } lastValue = buffer[a]; } return atLeastOnce; } //+------------------------------------------------------------------+ bool sqIsRising(string indy, int bars, bool allowSameValues, int shift){ double buffer[]; bool atLeastOnce = false; if(!loadIndicatorValues(buffer, indy, bars, shift)) return false; double lastValue = buffer[0]; for(int a=1; a lastValue){ atLeastOnce = true; } lastValue = buffer[a]; } return atLeastOnce; } //+------------------------------------------------------------------+ double sqGetIndicatorValue(string indicatorIdentification, int shift) { double buffer[]; if(!loadIndicatorValues(buffer, indicatorIdentification, 1, shift)) return 0; return buffer[0]; } //+------------------------------------------------------------------+ double sqGetIndicatorValue(string indicatorIdentification, int bufferIndex, int shift) { double buffer[]; ResetLastError(); int index = getIndicatorIndex(indicatorIdentification); if(index >= 0) { waitForData(indys[index].handle, bufferIndex, shift); if(CopyBuffer(indys[index].handle, bufferIndex, shift, 1, buffer) < 0) { int lastError = GetLastError(); PrintFormat("Failed to copy data from the indicator, error code %d", lastError); PrintFormat("Error Description: " + ErrorDescription(lastError)); return(0); } return buffer[0]; } else { PrintFormat("Failed to copy data from the indicator. Indicator '" + indicatorIdentification + "' was not found."); return 0; } } //+------------------------------------------------------------------+ double sqGetIndicatorValue(int handle, int bufferIndex, int shift) { double buffer[]; ResetLastError(); waitForData(handle, bufferIndex, shift); if(CopyBuffer(handle, bufferIndex, shift, 1, buffer) < 0) { int lastError = GetLastError(); PrintFormat("Failed to copy data from the indicator, error code %d", lastError); PrintFormat("Error Description: " + ErrorDescription(lastError)); return(0); } return buffer[0]; } //+------------------------------------------------------------------+ /* Waits until indicator data become available */ void waitForData(int handle, int bufferIndex, int shift){ double buffer[]; int i, copied = CopyBuffer(handle, bufferIndex, shift, 1, buffer); if(copied <= 0){ Sleep(10); for(i=0; i<100; i++){ if(BarsCalculated(handle) > 0) break; Sleep(10); } } } //+------------------------------------------------------------------+ bool loadIndicatorValues(double& buffer[], string indy, int bars, int shift){ //--- reset error code ResetLastError(); //--- fill a part of the Buffer array with values from the indicator buffer that has 0 index int index = getIndicatorIndex(indy); if(index >= 0) { if(CopyBuffer(indys[index].handle, indys[index].bufferIndex, shift, bars, buffer) < 0) { //--- if the copying fails, tell the error code PrintFormat("Failed to copy data from the indicator, error code %d", GetLastError()); //--- quit with zero result - it means that the indicator is considered as not calculated return(false); } //--- everything is fine return(true); } else { ArrayResize(buffer, bars); string params[]; if(!extractParams(indy, params)){ Print("Unknown indicator '" + indy + "'. Cannot parse params"); return(false); } if(StringFind(indy, "sqHeikenAshi", 0) == 0){ for(int a=0; a 0 ? price : SymbolInfoDouble(symbol, type == ORDER_TYPE_BUY ? SYMBOL_BID : SYMBOL_ASK); mrequest.action = (type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_SELL_LIMIT) ? TRADE_ACTION_PENDING : TRADE_ACTION_DEAL; // immediate order execution mrequest.price = NormalizeDouble(curPrice,_Digits); // latest ask price mrequest.sl = NormalizeDouble(slPrice, _Digits); // Stop Loss mrequest.tp = NormalizeDouble(ptPrice, _Digits); // Take Profit mrequest.symbol = correctSymbol(symbol); // currency pair mrequest.volume = volume; // number of lots to trade mrequest.magic = magicNo > 0 ? magicNo : 1234; // Order Magic Number mrequest.type = type; // Buy Order mrequest.type_filling = ORDER_FILLING_FOK; // Order execution type mrequest.deviation = deviation; // Deviation from current price mrequest.comment = comment;//StringLen(comment) > 0 ? comment : StringFormat("SQ ticket: %d", sqTicket++); mrequest.expiration = expiration; //--- send order OrderSend(mrequest,mresult); // get the result code if(mresult.retcode==10009 || mresult.retcode==10008) //Request is completed or order placed { Alert("The order has been successfully placed with Ticket#:",mresult.order,"!!"); return mresult.order; } else { Alert("The order request could not be completed. Error no.: ", GetLastError()); Alert("Error description: " + ErrorDescription(GetLastError())); ResetLastError(); return 0; } } //+------------------------------------------------------------------+ /* int sqOpenOrder(int orderType, string symbol, double size, double price, double stopLoss, double profitTarget, int magicNumber, string comment, datetime expirationInTime, bool replaceExisting, color arrowColor) { if(symbol == "NULL" || symbol == "Current") { symbol = Symbol(); } // check if live order exists if(sqSelectOrder(magicNumber, symbol, sqGetDirectionFromOrderType(orderType), comment)) { Verbose("Order with these parameters already exists, cannot open another one!"); Verbose("----------------------------------"); return(0); } // check if pending order exists if(sqSelectPendingOrderByType(magicNumber, symbol, 0, comment)) { if(!replaceExisting) { Verbose("Pending Order with these parameters already exists, and replace is not allowed!", " ----------------"); return(0); } // close pending order Verbose("Deleting previous pending order"); sqDeletePendingOrder(OrderGetInteger(ORDER_TICKET)); } else { Log("Existing order doesnt exist"); } int ticket = 0; if(sqSupportECNBrokers) { ticket = sqOpenOrderImpl(orderType, symbol, size, price, 0, 0, magicNumber, comment, expirationInTime, arrowColor); } else { ticket = sqOpenOrderImpl(orderType, symbol, size, price, stopLoss, profitTarget, magicNumber, comment, expirationInTime, arrowColor); } if(ticket > 0) { if(sqSupportECNBrokers && (stopLoss != 0 || profitTarget != 0)) { if(!OrderSelect(ticket)) { Verbose("Cannot select order with ticket: ",ticket); } bool result = sqOrderModify(ticket, OrderGetDouble(ORDER_PRICE_OPEN), stopLoss, profitTarget); if(!result) { Verbose("Cannot set SL / PT for this order, deleting it!"); OrderDelete(ticket); } } } // reset global variables for this order sqSetOrderExpiration(ticket, 0); sqSetExitAfterXBars(ticket, 0); sqSetMoveSL2BE(ticket, 0, 0); sqSetSL2BEAddPips(ticket, 0); sqSetTrailingStop(ticket, 0, 0); sqSetTSActivation(ticket, 0); return(ticket); } //+------------------------------------------------------------------+ int sqOpenOrderImpl(int orderType, string symbol, double size, double price, double stopLoss, double profitTarget, int magicNumber, string comment, datetime expiration, color arrowColor) { int ticket = 0; Verbose("Opening order with MagicNumber: ", magicNumber,", type: ", sqGetOrderTypeAsString(orderType), ", size: ", size, ", price: ", price, ", SL: ", stopLoss, ", PT: ", profitTarget, ", comment: ", comment); Verbose("Current Ask: ", SymbolInfoDouble(symbol, SYMBOL_ASK), ", Bid: ", SymbolInfoDouble(symbol, SYMBOL_BID)); if(!sqCheckConnected()) { return(-1); } int digits = SymbolInfoInteger(symbol, SYMBOL_DIGITS); GetLastError(); // clear the global variable. int error = 0; int retries = 0; bool result; while (true) { if (IsTradeAllowed()) { if(orderType == ORDER_TYPE_BUY || orderType == ORDER_TYPE_SELL) { // get newest Ask/Bid price for market order RefreshRates(); if(orderType == ORDER_TYPE_BUY) { price = sqGetAsk(symbol); } else { price = sqGetBid(symbol); } } if (digits > 0) price = NormalizeDouble(price, digits); ticket = openPosition((ENUM_ORDER_TYPE) orderType, symbol, size, price, stopLoss, profitTarget, sqMaxSlippage, comment, magicNumber, expiration); //ticket = OrderSend(symbol, orderType, size, price, sqMaxSlippage, stopLoss, profitTarget, comment, magicNumber, expiration, arrowColor); if(ticket > 0) { Verbose("Order placed cuccessfuly,ticket: ", ticket); return(ticket); } } retries++; if(!sqProcessErrors(retries, GetLastError())) { return(-1); } } Verbose("Retries of opening order finished", " ----------------"); return(-1); } */ //+------------------------------------------------------------------+ void closeAllPositions(){ for (int i=PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); PositionSelectByTicket(ticket); if(sqClosePositionAtMarket(ticket)){ Print(StringFormat("Cannot close position with ticket %d", ticket)); } } } //+------------------------------------------------------------------+ bool closePosition(const ulong ticket, const ulong deviation = 100, const string comment = "", const int magicNo = -1) { ZeroMemory(mrequest); if(!PositionSelectByTicket(ticket)) return(false); string symbol = PositionGetString(POSITION_SYMBOL); if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) { //--- prepare request for close BUY position mrequest.type = ORDER_TYPE_SELL; mrequest.price = NormalizeDouble(latest_price.bid, _Digits); } else { //--- prepare request for close SELL position mrequest.type = ORDER_TYPE_BUY; mrequest.price = NormalizeDouble(latest_price.ask, _Digits); } //--- setting request mrequest.action = TRADE_ACTION_DEAL; mrequest.position = ticket; mrequest.symbol = symbol; mrequest.volume = PositionGetDouble(POSITION_VOLUME); mrequest.magic = magicNo > 0 ? magicNo : magicNumber; mrequest.deviation = deviation; mrequest.comment = StringLen(comment) > 0 ? comment : PositionGetString(POSITION_COMMENT); //--- close position OrderSend(mrequest, mresult); // get the result code if(mresult.retcode==10009 || mresult.retcode==10008) //Request is completed or order placed { Alert("A Buy order has been successfully placed with Ticket#:",mresult.order,"!!"); return true; } else { Alert("The Buy order request could not be completed -error:",GetLastError()); ResetLastError(); return false; } } //+------------------------------------------------------------------+ bool OrderModify(int ticket, double stopLoss, double profitTarget){ ZeroMemory(mrequest); PositionSelectByTicket(ticket); //--- setting request mrequest.action = TRADE_ACTION_SLTP; mrequest.symbol = PositionGetString(POSITION_SYMBOL); mrequest.magic = PositionGetInteger(POSITION_MAGIC); mrequest.position = ticket; mrequest.sl = stopLoss != 0 ? stopLoss : PositionGetDouble(POSITION_SL); mrequest.tp = profitTarget != 0 ? profitTarget : PositionGetDouble(POSITION_TP); //--- action and return the result return(OrderSend(mrequest,mresult)); } //+------------------------------------------------------------------+ /* bool sqOrderModifySL(int ticket,double stopLoss, int type) { if(!OrderSelect(ticket)) { Verbose("Cannot select order with ticket: ",ticket); } double orderOpenPrice = OrderGetDouble(ORDER_PRICE_OPEN); if(type == SLPTTYPE_RANGE) { // convert range to price level if(sqGetDirectionFromOrderType(OrderGetInteger(ORDER_TYPE)) == 1) { // it is long order stopLoss = orderOpenPrice - stopLoss; } else { stopLoss = orderOpenPrice + stopLoss; } } return(sqOrderModify(ticket, orderOpenPrice, stopLoss, OrderGetDouble(ORDER_TP))); } //+------------------------------------------------------------------+ bool sqOrderModifyPT(int ticket,double profitTarget, int type) { if(!OrderSelect(ticket)) { Verbose("Cannot select order with ticket: ",ticket); } ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); double orderOpenPrice = OrderGetDouble(ORDER_PRICE_OPEN); double orderStopLoss = OrderGetDouble(ORDER_SL); if(type == SLPTTYPE_RANGE) { // convert range to price level if(sqGetDirectionFromOrderType(orderType) == 1) { // it is long order profitTarget = orderOpenPrice + profitTarget; } else { profitTarget = orderOpenPrice - profitTarget; } } return(sqOrderModify(ticket, orderOpenPrice, orderStopLoss, profitTarget)); } //+------------------------------------------------------------------+ bool sqOrderModify(int ticket, double price, double stopLoss, double profitTarget) { if(!OrderSelect(ticket)) { Verbose("Cannot select order with ticket: ",ticket); } int digits = SymbolInfoInteger(OrderGetString(ORDER_SYMBOL), SYMBOL_DIGITS); if (digits > 0) { stopLoss = NormalizeDouble(stopLoss, digits); profitTarget = NormalizeDouble(profitTarget, digits); } Verbose("Modifying order with ticket: ", ticket, ", SL: ", stopLoss, " and PT: ", profitTarget); int orderType = OrderGetInteger(ORDER_TYPE); if(!sqCheckConnected()) { return(false); } GetLastError(); // clear the global variable. int error = 0; int retries = 0; bool result; while (true) { if (IsTradeAllowed()) { result = OrderModify(ticket, price, stopLoss, profitTarget, OrderGetInteger(ORDER_TIME_EXPIRATION)); if(result) { Verbose("Order modified successfuly"); return(true); } } retries++; if(!sqProcessErrors(retries, GetLastError())) { return(false); } } } */ //+------------------------------------------------------------------+ ENUM_ORDER_TYPE_FILLING GetFilling( const string Symb, const uint Type = ORDER_FILLING_FOK ) { const ENUM_SYMBOL_TRADE_EXECUTION ExeMode = (ENUM_SYMBOL_TRADE_EXECUTION)::SymbolInfoInteger(Symb, SYMBOL_TRADE_EXEMODE); const int FillingMode = (int)::SymbolInfoInteger(Symb, SYMBOL_FILLING_MODE); if(FillingMode == 0 || (Type >= ORDER_FILLING_RETURN) || ((FillingMode & (Type + 1)) != Type + 1)) { if((ExeMode == SYMBOL_TRADE_EXECUTION_EXCHANGE) || (ExeMode == SYMBOL_TRADE_EXECUTION_INSTANT)) { return ORDER_FILLING_RETURN; } else { if(FillingMode == SYMBOL_FILLING_IOC) { return ORDER_FILLING_IOC; } else { return ORDER_FILLING_FOK; } } } else { return Type; } } //+------------------------------------------------------------------+ double getDealCurrentProfit(long dealTicket) { long orderTicket = HistoryDealGetInteger(dealTicket, DEAL_ORDER); return getOrderCurrentProfit(orderTicket); } //+------------------------------------------------------------------+ double getDealCurrentPriceDifference(long dealTicket){ long orderTicket = HistoryDealGetInteger(dealTicket, DEAL_ORDER); return getOrderCurrentPriceDifference(orderTicket); } //+------------------------------------------------------------------+ double getOrderCurrentProfit(long orderTicket){ if(!OrderSelect(orderTicket)) return(0); ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); string orderSymbol = OrderGetString(ORDER_SYMBOL); double orderVolume = OrderGetDouble(ORDER_VOLUME_INITIAL); double orderOpenPrice = OrderGetDouble(ORDER_PRICE_OPEN); double orderCurrentPrice = OrderGetDouble(ORDER_PRICE_CURRENT); double profit = 0; OrderCalcProfit(orderType, orderSymbol, orderVolume, orderOpenPrice, orderCurrentPrice, profit); return profit; } //+------------------------------------------------------------------+ double getOrderCurrentPriceDifference(long orderTicket){ if(!OrderSelect(orderTicket)) return(0); ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); double orderOpenPrice = OrderGetDouble(ORDER_PRICE_OPEN); double orderCurrentPrice = OrderGetDouble(ORDER_PRICE_CURRENT); return orderType == ORDER_TYPE_BUY ? orderCurrentPrice - orderOpenPrice : orderOpenPrice - orderCurrentPrice; } //+------------------------------------------------------------------+ //| old SQ.mqh functions | //+------------------------------------------------------------------+ double iOpen(string symbol,int tf,int index){ if(index < 0) return(-1); double Arr[]; ENUM_TIMEFRAMES timeframe=TFMigrate(tf); if(CopyOpen(correctSymbol(symbol),timeframe, index, 1, Arr)>0) return(Arr[0]); else return(-1); } //+------------------------------------------------------------------+ double iHigh(string symbol,int tf,int index){ if(index < 0) return(-1); double Arr[]; ENUM_TIMEFRAMES timeframe=TFMigrate(tf); if(CopyHigh(correctSymbol(symbol),timeframe, index, 1, Arr)>0) return(Arr[0]); else return(-1); } //+------------------------------------------------------------------+ double iLow(string symbol,int tf,int index) { if(index < 0) return(-1); double Arr[]; ENUM_TIMEFRAMES timeframe=TFMigrate(tf); if(CopyLow(correctSymbol(symbol),timeframe, index, 1, Arr)>0) return(Arr[0]); else return(-1); } //+------------------------------------------------------------------+ double iClose(string symbol,int tf,int index){ if(index < 0) return(-1); double Arr[]; ENUM_TIMEFRAMES timeframe=TFMigrate(tf); if(CopyClose(correctSymbol(symbol),timeframe, index, 1, Arr)>0) return(Arr[0]); else return(-1); } //+------------------------------------------------------------------+ datetime iTime(string symbol,int tf,int index) { if(index < 0) return(-1); ENUM_TIMEFRAMES timeframe=TFMigrate(tf); datetime Arr[]; if(CopyTime(correctSymbol(symbol), timeframe, index, 1, Arr)>0) return(Arr[0]); else return(-1); } //+------------------------------------------------------------------+ double getOpen(int shift){ return iOpen(_Symbol, _Period, shift); } //+------------------------------------------------------------------+ double getHigh(int shift){ return iHigh(_Symbol, _Period, shift); } //+------------------------------------------------------------------+ double getLow(int shift){ return iLow(_Symbol, _Period, shift); } //+------------------------------------------------------------------+ double getClose(int shift){ return iClose(_Symbol, _Period, shift); } //+------------------------------------------------------------------+ double getTime(int shift){ return iTime(_Symbol, _Period, shift); } //+------------------------------------------------------------------+ int TimeHour(datetime date) { MqlDateTime tm; TimeToStruct(date,tm); return(tm.hour); } //+------------------------------------------------------------------+ int TimeMinute(datetime date) { MqlDateTime tm; TimeToStruct(date,tm); return(tm.min); } //+------------------------------------------------------------------+ ENUM_TIMEFRAMES TFMigrate(int tf) { switch(tf) { case 0: return(PERIOD_CURRENT); case 1: return(PERIOD_M1); case 5: return(PERIOD_M5); case 15: return(PERIOD_M15); case 30: return(PERIOD_M30); case 60: return(PERIOD_H1); case 240: return(PERIOD_H4); case 1440: return(PERIOD_D1); case 10080: return(PERIOD_W1); case 43200: return(PERIOD_MN1); case 2: return(PERIOD_M2); case 3: return(PERIOD_M3); case 4: return(PERIOD_M4); case 6: return(PERIOD_M6); case 10: return(PERIOD_M10); case 12: return(PERIOD_M12); case 16385: return(PERIOD_H1); case 16386: return(PERIOD_H2); case 16387: return(PERIOD_H3); case 16388: return(PERIOD_H4); case 16390: return(PERIOD_H6); case 16392: return(PERIOD_H8); case 16396: return(PERIOD_H12); case 16408: return(PERIOD_D1); case 32769: return(PERIOD_W1); case 49153: return(PERIOD_MN1); default: return(PERIOD_CURRENT); } } //+------------------------------------------------------------------+ void sqCloseWorstPosition(string symbol, int magicNo, int direction, string comment) { double minPL = 100000000; ulong ticket = 0; for(int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if(PositionSelect(positionTicket)) { double positionProfit = PositionGetDouble(POSITION_PROFIT); if(positionProfit < minPL) { // found order with worse profit minPL = positionProfit; ticket = positionTicket; Verbose("Worse position found, ticket: ", ticket,", PL: ", minPL); } } } if(ticket > 0) { sqClosePositionAtMarket(ticket); } } //+------------------------------------------------------------------+ /* void sqManageTrailingStop(int positionTicket) { double tempValue = 0; double tempValue2 = 0; double plValue = 0; double newSL = 0; int error; // Trailing Stop tempValue = sqGetPositionTrailingStop(positionTicket, PositionGetInteger(POSITION_TYPE)); if(tempValue > 0) { tempValue2 = sqGetPositionTSActivation(positionTicket); string positionSymbol = PositionGetString(POSITION_SYMBOL); double positionOpenPrice = PositionGetDouble(POSITION_PRICE_OPEN); double positionStopLoss = PositionGetDouble(POSITION_SL); double positionProfitTarget = PositionGetDouble(POSITION_TP); if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) { plValue = sqGetBid(positionSymbol) - positionOpenPrice; newSL = tempValue; if (plValue >= tempValue2 && (positionStopLoss == 0 || positionStopLoss < newSL) && !sqDoublesAreEqual(positionStopLoss, newSL)) { Verbose("Moving trailing stop for order with ticket: ", positionTicket, " to :", newSL); if(!OrderModify(positionTicket, newSL, positionProfitTarget)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error)); } } } else { // POSITION_TYPE_SELL plValue = positionOpenPrice - sqGetAsk(positionSymbol); newSL = tempValue; if (plValue >= tempValue2 && (positionStopLoss == 0 || positionStopLoss > newSL) && !sqDoublesAreEqual(positionStopLoss, newSL)) { Verbose("Moving trailing stop for order with ticket: ", positionTicket, " to :", newSL); if(!OrderModify(positionTicket, newSL, positionProfitTarget)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(positionSymbol), ", Bid: ", sqGetBid(positionSymbol), " Current SL: ", positionStopLoss); } } } } } */ //+------------------------------------------------------------------+ void sqManageExitAfterXBars(ulong positionTicket) { int exitBars = sqGetExitAfterXBars(positionTicket); if(exitBars > 0) { datetime openTime = PositionGetInteger(POSITION_TIME); if(sqGetOpenBarsForOrder(exitBars+10, openTime) >= exitBars) { Verbose("Exit After ", exitBars, "bars - closing order with ticket: ", positionTicket); sqClosePositionAtMarket(positionTicket); } } } //+------------------------------------------------------------------+ /* void sqManageSL2BE(ulong positionTicket) { double tempValue = 0; double tempValue2 = 0; double newSL = 0; int error; int positionType = PositionGetInteger(POSITION_TYPE); string positionSymbol = PositionGetString(POSITION_SYMBOL); double positionOpenPrice = PositionGetDouble(POSITION_PRICE_OPEN); double positionStopLoss = PositionGetDouble(POSITION_SL); double positionProfitTarget = PositionGetDouble(POSITION_TP); // Move Stop Loss to Break Even tempValue = sqGetOrderBreakEven(positionTicket, positionType); tempValue2 = sqGetBreakEvenAddPips(positionTicket); if(tempValue > 0) { if(positionType == POSITION_TYPE_BUY) { newSL = positionOpenPrice + tempValue2; if (positionOpenPrice <= tempValue && (positionStopLoss == 0 || positionStopLoss < newSL) && !sqDoublesAreEqual(positionStopLoss, newSL)) { Verbose("Moving SL 2 BE for order with ticket: ", positionTicket, " to :", newSL); if(!OrderModify(positionTicket, newSL, positionProfitTarget)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(positionSymbol), ", Bid: ", sqGetBid(positionSymbol), " Current SL: ", positionStopLoss); } } } else { newSL = positionOpenPrice - tempValue2; if (positionOpenPrice >= tempValue && (positionStopLoss == 0 || positionStopLoss > newSL) && !sqDoublesAreEqual(positionStopLoss, newSL)) { Verbose("Moving SL 2 BE for order with ticket: ", positionTicket, " to :", newSL); if(!OrderModify(positionTicket, newSL, positionProfitTarget)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(positionSymbol), ", Bid: ", sqGetBid(positionSymbol), " Current SL: ", positionStopLoss); } } } } } */ //+------------------------------------------------------------------+ bool sqClosePositionAtMarket(ulong positionTicket) { Verbose("Closing order with ticket: ", positionTicket); ENUM_POSITION_TYPE positionType = PositionGetInteger(POSITION_TYPE); string positionSymbol = PositionGetString(POSITION_SYMBOL); if(!sqCheckConnected()) { return(-1); } GetLastError(); // clear the global variable. int error = 0; int retries = 0; bool result; while (true) { if (IsTradeAllowed()) { double price; if(positionType == POSITION_TYPE_BUY) { price = sqGetBid(positionSymbol); } else { price = sqGetAsk(positionSymbol); } result = closePosition(positionTicket, sqMaxSlippage); if(result) { Verbose("Order deleted successfuly"); return(true); } } if(!sqProcessErrors(retries, GetLastError())) { return(-1); } } } //+------------------------------------------------------------------+ bool IsTradeAllowed(){ return terminalInfo.IsTradeAllowed(); } //+------------------------------------------------------------------+ bool sqCheckConnected() { if (!terminalInfo.IsConnected()) { Verbose("Not connected!"); return(false); } if (IsStopped()) { Verbose("EA stopped!"); return(false); } return(true); } //+------------------------------------------------------------------+ double sqGetAsk(string symbol) { symbol = correctSymbol(symbol); return(NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_ASK), _Digits)); } //+------------------------------------------------------------------+ double sqGetBid(string symbol) { symbol = correctSymbol(symbol); return(NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_BID), _Digits)); } //+------------------------------------------------------------------+ bool sqProcessErrors(int retries, int error) { if (retries > sqMaxRetries) { Verbose("Maximum retries ", sqMaxRetries, " reached. Error: ", error, " : " + ErrorDescription(error)); return(false); } if(error == TRADE_RETCODE_PRICE_CHANGED || error == TRADE_RETCODE_REQUOTE) { // continue immediately return(true); } else if(error == TRADE_RETCODE_CONNECTION || error == TRADE_RETCODE_INVALID_PRICE || error == TRADE_RETCODE_TIMEOUT /*error == ERR_OFF_QUOTES || error == ERR_BROKER_BUSY || error == ERR_TRADE_CONTEXT_BUSY*/) { Verbose("Retrying #", retries,", Error: ", error, " : " + ErrorDescription(error)); sqSleep(); return(true); } else { // too serious error Verbose("Non-retriable error. Error: ", error, " : " + ErrorDescription(error)); return(false); } } //+------------------------------------------------------------------+ void sqManageOrderExpirations() { int tempValue = 0; int barsOpen = 0; for (int i = OrdersTotal() - 1; i >= 0; i--) { ulong orderTicket = OrderGetTicket(i); if(!OrderSelect(orderTicket)) continue; ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); datetime openTime = OrderGetInteger(ORDER_TIME_SETUP); // Stop/Limit Order Expiration if(orderType != ORDER_TYPE_BUY && orderType != ORDER_TYPE_SELL) { // handle only pending orders tempValue = sqGetOrderExpiration(orderTicket); if(tempValue > 0) { barsOpen = sqGetOpenBarsForOrder(tempValue + 10, openTime); if(barsOpen >= tempValue) { Verbose("Order with ticket: ", orderTicket, " expired"); sqDeletePendingOrder(orderTicket); } } } } } //---------------------------------------------------------------------------- double sqIndicatorHighest(int period, int nthValue, string indicatorIdentification) { double indicatorValues[200]; int i; for(i=0; i<200; i++) { indicatorValues[i] = -2147483647; } for(i=0; i= period) { return(-1); } return(indicatorValues[index]); } //---------------------------------------------------------------------------- double sqIndicatorLowest(int period, int nthValue, string indicatorIdentification) { double indicatorValues[200]; int i; for(i=0; i<200; i++) { indicatorValues[i] = 2147483647; } for(i=0; i= period) { return(-1); } return(indicatorValues[nthValue]); } //---------------------------------------------------------------------------- double sqIndicatorAverage(int period, int maMethod, string indicatorIdentification) { double indicatorValues[10000]; for(int i=0; i0 && total<=period) return(0); if(shift>total-period-ma_shift) return(0); switch(ma_method) { case MODE_SMA : { total=ArrayCopy(arr,array,0,shift+ma_shift,period); if(ArrayResize(buf,total)<0) return(0); double sum=0; int i,pos=total-1; for(i=1;i=0) { sum+=arr[pos]; buf[pos]=sum/period; sum-=arr[pos+period-1]; pos--; } return(buf[0]); } case MODE_EMA : { if(ArrayResize(buf,total)<0) return(0); double pr=2.0/(period+1); int pos=total-2; while(pos>=0) { if(pos==total-2) buf[pos+1]=array[pos+1]; buf[pos]=array[pos]*pr+buf[pos+1]*(1-pr); pos--; } return(buf[shift+ma_shift]); } case MODE_SMMA : { if(ArrayResize(buf,total)<0) return(0); double sum=0; int i,k,pos; pos=total-period; while(pos>=0) { if(pos==total-period) { for(i=0,k=pos;i=0) { buf[pos]=sum/weight; if(pos==0) break; pos--; i--; price=array[pos]; sum=sum-lsum+price*period; lsum-=array[i]; lsum+=price; } return(buf[shift+ma_shift]); } default: return(0); } return(0); } //---------------------------------------------------------------------------- double sqIndicatorRecent(int barsBack, string indicatorIdentification) { return(sqGetIndicatorValue(indicatorIdentification, barsBack)); } //+------------------------------------------------------------------+ int sqGetOrderExpiration(int ticket) { return (GlobalVariableGet("sqOrderExpiration_"+ticket)); } //+------------------------------------------------------------------+ void sqSetOrderExpiration(int ticket, int bars) { GlobalVariableSet("sqOrderExpiration_"+ticket, bars); } //+------------------------------------------------------------------+ int sqGetExitAfterXBars(int ticket) { return (GlobalVariableGet("sqExitAfterXBars_"+ticket)); } //+------------------------------------------------------------------+ void sqSetExitAfterXBars(int ticket, int bars) { GlobalVariableSet("sqExitAfterXBars_"+ticket, bars); } //+------------------------------------------------------------------+ int sqGetMoveSL2BE(int ticket) { return (GlobalVariableGet("sqMoveSL2BE_"+ticket)); } //+------------------------------------------------------------------+ int sqGetMoveSL2BEType(int ticket) { return (GlobalVariableGet("sqMoveSL2BEType_"+ticket)); } //+------------------------------------------------------------------+ void sqSetMoveSL2BE(int ticket, string value, int type) { GlobalVariableSet("sqMoveSL2BE_"+ticket, sqStringHash(value)); GlobalVariableSet("sqMoveSL2BEType_"+ticket, type); } //+------------------------------------------------------------------+ int sqGetSL2BEAddPips(int ticket) { return (GlobalVariableGet("sqSL2BEAddPips_"+ticket)); } //+------------------------------------------------------------------+ void sqSetSL2BEAddPips(int ticket, string value) { GlobalVariableSet("sqSL2BEAddPips_"+ticket, sqStringHash(value)); } //+------------------------------------------------------------------+ int sqGetTrailingStop(int ticket) { return (GlobalVariableGet("sqTrailingStop"+ticket)); } //+------------------------------------------------------------------+ int sqGetTrailingStopType(int ticket) { return (GlobalVariableGet("sqTrailingStopType"+ticket)); } //+------------------------------------------------------------------+ void sqSetTrailingStop(int ticket, string value, int type) { GlobalVariableSet("sqTrailingStop"+ticket, sqStringHash(value)); GlobalVariableSet("sqTrailingStopType"+ticket, type); } //+------------------------------------------------------------------+ int sqGetTSActivation(int positionTicket) { return (GlobalVariableGet("sqTSActivation"+positionTicket)); } //+------------------------------------------------------------------+ void sqSetTSActivation(int ticket, string value) { GlobalVariableSet("sqTSActivation"+ticket, sqStringHash(value)); } //+------------------------------------------------------------------+ int sqStringHash(string str){ int i, h = 0, k = 0; for (i=0; i0) { FileSeek(handle,0,SEEK_END); FileWrite(handle, TimeToString(TimeCurrent()), " VERBOSE: ", st1, st2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12); FileClose(handle); } } } //+------------------------------------------------------------------+ void VerboseLog(string s1, string s2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) { if(sqVerboseMode != 1) { Log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12); } Verbose(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12); } //+------------------------------------------------------------------+ void Log(string s1, string s2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) { Print(TimeToString(TimeCurrent()), " ", s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12); } //+------------------------------------------------------------------+ void sqLog(string st1, string st2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) { Print(TimeToString(TimeCurrent()), " ", st1, st2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12); } //+------------------------------------------------------------------+ void sqLogToFile(string fileName, string st1, string st2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) { int handle = FileOpen(fileName, FILE_READ | FILE_WRITE, ";"); if(handle>0) { FileSeek(handle,0,SEEK_END); FileWrite(handle, TimeToString(TimeCurrent()), " ", st1, st2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12); FileClose(handle); } } //+------------------------------------------------------------------+ bool sqSelectPosition(int magicNumber, string symbol, int direction, string comment) { for (int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong ticket = PositionGetTicket(cc); if (PositionSelectByTicket(ticket) && positionFits(ticket, symbol, magicNumber, direction, comment)) { return(true); } } return(false); } //+------------------------------------------------------------------+ bool sqSelectOrder(int magicNumber, string symbol, int direction, string comment) { for (int cc = OrdersTotal() - 1; cc >= 0; cc--) { ulong ticket = OrderGetTicket(cc); if (OrderSelect(ticket) && orderFits(ticket, symbol, magicNumber, direction, comment)) { return(true); } } return(false); } //+------------------------------------------------------------------+ bool positionFits(ulong ticket, string symbol, int magicNumber, int direction, string comment){ ENUM_POSITION_TYPE positionType = PositionGetInteger(POSITION_TYPE); string positionSymbol = PositionGetString(POSITION_SYMBOL); string positionComment = PositionGetString(POSITION_COMMENT); int positionMagicNumber = PositionGetInteger(POSITION_MAGIC); if(direction != 0) { if(direction > 0 && positionType != POSITION_TYPE_BUY) return(false); if(direction < 0 && positionType != POSITION_TYPE_SELL) return(false); } if(magicNumber != 0) { if(positionMagicNumber != magicNumber) return(false); } if(symbol != "Any") { if(symbol == "NULL" || symbol == "Current") { symbol = Symbol(); } if(positionSymbol != symbol) return(false); } if(comment != "") { if(StringFind(positionComment, comment) == -1) return(false); } return(true); } //+------------------------------------------------------------------+ bool dealFits(ulong ticket, string symbol, int magicNumber, int direction, string comment){ ENUM_DEAL_TYPE dealType = HistoryDealGetInteger(ticket, DEAL_TYPE); string dealSymbol = HistoryDealGetString(ticket, DEAL_SYMBOL); string dealComment = HistoryDealGetString(ticket, DEAL_COMMENT); int dealMagicNumber = HistoryDealGetInteger(ticket, DEAL_MAGIC); if(direction != 0) { if(direction > 0 && dealType != DEAL_TYPE_BUY) return(false); if(direction < 0 && dealType != DEAL_TYPE_SELL) return(false); } if(magicNumber != 0) { if(dealMagicNumber != magicNumber) return(false); } if(symbol != "Any") { if(symbol == "NULL" || symbol == "Current") { symbol = Symbol(); } if(dealSymbol != symbol) return(false); } if(comment != "") { if(StringFind(dealComment, comment) == -1) return(false); } return(true); } //+------------------------------------------------------------------+ bool orderFits(ulong ticket, string symbol, int magicNumber, int direction, string comment){ ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); string orderSymbol = OrderGetString(ORDER_SYMBOL); string orderComment = OrderGetString(ORDER_COMMENT); int orderMagicNumber = OrderGetInteger(ORDER_MAGIC); if(direction != 0) { if(direction > 0 && orderType != ORDER_TYPE_BUY) return(false); if(direction < 0 && orderType != ORDER_TYPE_SELL) return(false); } if(magicNumber != 0) { if(orderMagicNumber != magicNumber) return(false); } if(symbol != "Any") { if(symbol == "NULL" || symbol == "Current") { symbol = Symbol(); } if(orderSymbol != symbol) return(false); } if(comment != "") { if(StringFind(orderComment, comment) == -1) return(false); } return(true); } //+------------------------------------------------------------------+ void sqCloseAllPositions(string symbol, int magicNumber, int direction, string comment) { int count = 100; // maximum number of positions to close ulong lastTicket = -1; while(count > 0) { count--; if(!sqSelectPosition(magicNumber, symbol, direction, comment)) { // no position found break; } ulong positionTicket = PositionGetInteger(POSITION_TICKET); if(lastTicket == positionTicket) { // trying to close the same position one more time, there must be some error break; } lastTicket = positionTicket; sqClosePositionAtMarket(positionTicket); } } //+------------------------------------------------------------------+ void sqCloseBestPosition(string symbol, int magicNumber, int direction, string comment) { double maxPL = -100000000; ulong ticket = 0; for (int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if(PositionSelectByTicket(positionTicket) && positionFits(positionTicket, symbol, magicNumber, direction, comment)) { double positionProfit = PositionGetDouble(POSITION_PROFIT); if(positionProfit > maxPL) { // found order with better profit maxPL = positionProfit; ticket = positionTicket; Verbose("Better position found, ticket: ", positionTicket,", PL: ", maxPL); } } } if(ticket > 0) { PositionSelectByTicket(ticket); sqClosePositionAtMarket(ticket); } } //+------------------------------------------------------------------+ int sqGetMarketPosition(string symbol, int magicNumber, string comment) { if(sqSelectPosition(magicNumber, symbol, 0, comment)) { ENUM_POSITION_TYPE positionType = PositionGetInteger(POSITION_TYPE); if(positionType == POSITION_TYPE_BUY) { return(1); } else { return(-1); } } /* //check pending orders if(sqSelectOrder(magicNumber, symbol, 0, comment)) { ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); if(orderType != ORDER_TYPE_BUY && orderType != ORDER_TYPE_SELL) { return(-1); } } */ return(0); } //+------------------------------------------------------------------+ double sqGetPositionOpenPrice(string symbol, int magicNumber, int direction, string comment) { if(sqSelectPosition(magicNumber, symbol, direction, comment)) { return(PositionGetDouble(POSITION_PRICE_OPEN)); } return(-1); } //+------------------------------------------------------------------+ double sqGetOrderStopLoss(string symbol, int magicNumber, int direction, string comment) { if(sqSelectPosition(magicNumber, symbol, direction, comment)) { return(PositionGetDouble(POSITION_SL)); } return(-1); } //+------------------------------------------------------------------+ double sqGetOrderProfitTarget(string symbol, int magicNumber, int direction, string comment) { if(sqSelectPosition(magicNumber, symbol, direction, comment)) { return(PositionGetDouble(POSITION_TP)); } return(-1); } //+------------------------------------------------------------------+ double sqGetMarketPositionSize(string symbol, int magicNumber, int direction, string comment) { double lots = 0; for (int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if(PositionSelectByTicket(positionTicket) && positionFits(positionTicket, symbol, magicNumber, direction, comment)) { lots += PositionGetDouble(POSITION_VOLUME); } } return(lots); } //+------------------------------------------------------------------+ double sqGetOpenPL(string symbol, int magicNumber, int direction, string comment) { double pl = 0; for (int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if(PositionSelectByTicket(positionTicket) && positionFits(positionTicket, symbol, magicNumber, direction, comment)) { pl += PositionGetDouble(POSITION_PROFIT); } } return(pl); } //+------------------------------------------------------------------+ double sqGetOpenPLInPips(string symbol, int magicNumber, int direction, string comment) { double priceDelta = 0; for (int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if(PositionSelectByTicket(positionTicket) && positionFits(positionTicket, symbol, magicNumber, direction, comment)) { ENUM_POSITION_TYPE positionType = PositionGetInteger(POSITION_TYPE); double positionOpenPrice = PositionGetDouble(POSITION_PRICE_OPEN); double positionCurrentPrice = PositionGetDouble(POSITION_PRICE_CURRENT); if(positionType == POSITION_TYPE_BUY){ priceDelta += positionCurrentPrice - positionOpenPrice; } else { priceDelta += positionOpenPrice - positionCurrentPrice; } } } return(sqConvertToPips(symbol, priceDelta)); } //+------------------------------------------------------------------+ /* int sqGetClosedPLInPips(string symbol, int magicNumber, int direction, string comment, int shift) { int index = 0; HistorySelect(startTime, getTime(0)); for(int i=HistoryDealsTotal(); i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); if(dealFits(ticket, symbol, magicNumber, direction, comment)) { ENUM_DEAL_TYPE dealType = HistoryDealGetInteger(ticket, DEAL_TYPE); double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT); if(index == shift) { if(dealType == DEAL_TYPE_BUY) { return(sqConvertToPips(correctSymbol(symbol), OrderClosePrice() - OrderOpenPrice())); } else { return(sqConvertToPips(correctSymbol(symbol), OrderOpenPrice() - OrderClosePrice())); } } index++; } } return(0); } //+------------------------------------------------------------------+ double getDealPriceDelta(ulong ticket){ double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT); double volume = HistoryDealGetDouble(ticket, DEAL_VOLUME); string dealSymbol = HistoryDealGetString(ticket, DEAL_SYMBOL); double contractSize = SymbolInfoDouble(dealSymbol, SYMBOL_TRADE_CONTRACT_SIZE); double pointValue = SymbolInfoDouble(dealSymbol, SYMBOL_POINT); return profit * pointValue / contractSize; } */ //+------------------------------------------------------------------+ int sqGetClosedPLInMoney(string symbol, int magicNumber, int direction, string comment, int shift) { int index = 0; HistorySelect(startTime, getTime(0)); for(int i=HistoryDealsTotal(); i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); if(dealFits(ticket, symbol, magicNumber, direction, comment)) { if(index == shift) { return(HistoryDealGetDouble(ticket, DEAL_PROFIT)); } index++; } } return(0); } //+------------------------------------------------------------------+ int sqGetMarketPositionCount(string symbol, int magicNumber, int direction, string comment) { double count = 0; for (int cc = PositionsTotal() - 1; cc >= 0; cc--) { ulong positionTicket = PositionGetTicket(cc); if(PositionSelect(positionTicket) && positionFits(positionTicket, symbol, magicNumber, direction, comment)) { count++; } } return(count); } //+------------------------------------------------------------------+ int sqGetBarsSinceOpen(string symbol, int magicNumber, int direction, string comment) { if(sqSelectPosition(magicNumber, symbol, direction, comment)) { datetime positionOpenTime = PositionGetInteger(POSITION_TIME); int numberOfBars = 0; datetime Time[]; int length = CopyTime(_Symbol, _Period, 0, 10000, Time); if(length <= 0) return 0; ArrayGetAsSeries(Time); for(int i=0; i<10000; i++) { if(positionOpenTime < Time[i]) { numberOfBars++; } } return(numberOfBars); } return(-1); } //+------------------------------------------------------------------+ int sqGetBarsSinceClose(string symbol, int magicNumber, int direction, string comment) { ulong ticket = sqSelectDeal(magicNumber, symbol, direction, comment); if(ticket > 0) { datetime clTime = HistoryDealGetInteger(ticket, DEAL_TIME); datetime Time[]; int length = CopyTime(_Symbol, _Period, 0, 10000, Time); if(length <= 0) return 0; ArrayGetAsSeries(Time); int numberOfBars = 0; for(int i=0; i<10000; i++) { if(clTime < Time[i]) { numberOfBars++; } } return(numberOfBars); } return(-1); } //+------------------------------------------------------------------+ int sqGetLastOrderType(string symbol, int magicNumber, string comment) { ulong ticket = sqSelectDeal(magicNumber, symbol, 0, comment); if(ticket > 0) { ENUM_DEAL_TYPE dealType = HistoryDealGetInteger(ticket, DEAL_TYPE); if(dealType == DEAL_TYPE_BUY) { return(1); } else { return(-1); } } return(0); } //+------------------------------------------------------------------+ ulong sqSelectDeal(int magicNumber, string symbol, int direction, string comment) { HistorySelect(startTime, getTime(0)); for(int i=HistoryDealsTotal() - 1; i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); if (dealFits(ticket, symbol, magicNumber, direction, comment)) { return(ticket); } } return(0); } //+------------------------------------------------------------------+ double sqConvertToPips(string symbol, double value) { if(symbol == "NULL" || symbol == "Current") { return(gPointPow * value); } // recognize point coeficient int realDigits = SymbolInfoInteger(symbol, SYMBOL_DIGITS); if(realDigits == 4 || realDigits == 5) { realDigits -= 1; } double pointPow = MathPow(10, realDigits); return(pointPow * value); } //+------------------------------------------------------------------+ bool sqSelectPendingOrderByType(int magicNo, string symbol, int type, string comment) { Alert("-------- orders total: ", OrdersTotal()); for (int cc = OrdersTotal() - 1; cc >= 0; cc--) { ulong ticket = OrderGetTicket(cc); if (OrderSelect(ticket)) { ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); string orderSymbol = OrderGetString(ORDER_SYMBOL); string orderComment = OrderGetString(ORDER_COMMENT); int orderMagicNumber = OrderGetInteger(ORDER_MAGIC); if(type != 0) { if(orderType != type) continue; } if(magicNo > 0) { if(orderMagicNumber != magicNo) continue; } if(symbol != "Any") { if(symbol == "NULL" || symbol == "Current") { symbol = Symbol(); } if(orderSymbol != symbol) continue; } if(comment != "" && comment != NULL) { if(StringFind(orderComment, comment) == -1) continue; } // otherwise we found the order return(true); } } return(false); } /* //+------------------------------------------------------------------+ bool sqSelectPendingOrderByDir(int magicNumber, string symbol, int direction, string comment) { for (int cc = OrdersTotal() - 1; cc >= 0; cc--) { ulong ticket = OrderGetTicket(cc); if (OrderSelect(ticket)) { ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); string orderSymbol = OrderGetString(ORDER_SYMBOL); string orderComment = OrderGetString(ORDER_COMMENT); double orderVolume = OrderGetDouble(ORDER_VOLUME_INITIAL); double orderOpenPrice = OrderGetDouble(ORDER_PRICE_OPEN); double orderCurrentPrice = OrderGetDouble(ORDER_PRICE_CURRENT); int orderMagicNumber = OrderGetInteger(ORDER_MAGIC); if(direction != 0) { if(direction > 0 && orderType != ORDER_TYPE_BUY_STOP && orderType != ORDER_TYPE_BUY_LIMIT) continue; if(direction < 0 && orderType != ORDER_TYPE_SELL_STOP && orderType != ORDER_TYPE_SELL_LIMIT) continue; } if(magicNumber != 0) { if(orderMagicNumber != magicNumber) continue; } if(symbol != "Any") { if(symbol == "NULL" || symbol == "Current") { symbol = Symbol(); } if(orderSymbol != symbol) continue; } if(comment != "") { if(StringFind(orderComment, comment) == -1) continue; } // otherwise we found the order return(true); } } return(false); } //+------------------------------------------------------------------+ */ bool sqDeletePendingOrder(int ticket) { Verbose(" Deleting pending order, ticket: " + ticket); ENUM_ORDER_TYPE orderType = OrderGetInteger(ORDER_TYPE); if(orderType == ORDER_TYPE_BUY || orderType == ORDER_TYPE_SELL) { Verbose("Trying to delete non-pending order"); return(false); } if(!sqCheckConnected()) { return(false); } GetLastError(); // clear the global variable. int error = 0; int retries = 0; bool result; while (true) { if (IsTradeAllowed()) { result = OrderDelete(ticket); if(result) { Verbose("Order deleted successfuly"); return(true); } } retries++; if(!sqProcessErrors(retries, GetLastError())) { return(-1); } } } bool OrderDelete(ulong ticket){ ZeroMemory(mrequest); mrequest.action = TRADE_ACTION_REMOVE; mrequest.magic = magicNumber; mrequest.order = ticket; //--- action and return the result return(OrderSend(mrequest, mresult)); } bool IsTesting(){ return MQLInfoInteger(MQL_TESTER); } //+------------------------------------------------------------------+ double sleepPeriod = 500; // 0.5 s double maxSleepPeriod = 20000; // 20 s. void sqSleep() { if(IsTesting()) return; Sleep(sleepPeriod); int periods = maxSleepPeriod / sleepPeriod; for(int i=0; i 16383) { // 50% chance of quitting break; } Sleep(sleepPeriod); } } int sqGetDirectionFromOrderType(int orderType) { if(orderType == ORDER_TYPE_BUY || orderType == ORDER_TYPE_BUY_STOP || orderType == ORDER_TYPE_BUY_LIMIT) { return(1); } else { return(-1); } } //+------------------------------------------------------------------+ bool sqIsPendingOrder(int orderType) { if(orderType != ORDER_TYPE_BUY && orderType != ORDER_TYPE_SELL) { return(true); } return(false); } //+------------------------------------------------------------------+ string sqGetOrderTypeAsString(int type) { switch(type) { case ORDER_TYPE_BUY: return("Buy"); case ORDER_TYPE_SELL: return("Sell"); case ORDER_TYPE_BUY_LIMIT: return("Buy Limit"); case ORDER_TYPE_BUY_STOP: return("Buy Stop"); case ORDER_TYPE_SELL_LIMIT: return("Sell Limit"); case ORDER_TYPE_SELL_STOP: return("Sell Stop"); } return("Unknown"); } //+------------------------------------------------------------------+ void sqInitInfoPanel() { ObjectCreate(ChartID(), "line1", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "line1", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "line1", OBJPROP_YDISTANCE, sqOffsetVertical + 0); ObjectSetInteger(ChartID(), "line1", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("line1", sqStrategyName, 9); ObjectCreate(ChartID(), "linec", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "linec", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "linec", OBJPROP_YDISTANCE, sqOffsetVertical + 16 ); ObjectSetInteger(ChartID(), "linec", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("linec", "Generated by StrategyQuant EA Wizard"); ObjectCreate(ChartID(), "line2", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "line2", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "line2", OBJPROP_YDISTANCE, sqOffsetVertical + 28); ObjectSetInteger(ChartID(), "line2", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("line2", "------------------------------------------"); ObjectCreate(ChartID(), "lines", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "lines", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "lines", OBJPROP_YDISTANCE, sqOffsetVertical + 44); ObjectSetInteger(ChartID(), "lines", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("lines", "Last Signal: -", 9); ObjectCreate(ChartID(), "lineopl", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "lineopl", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "lineopl", OBJPROP_YDISTANCE, sqOffsetVertical + 60); ObjectSetInteger(ChartID(), "lineopl", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("lineopl", "Open P/L: -"); ObjectCreate(ChartID(), "linea", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "linea", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "linea", OBJPROP_YDISTANCE, sqOffsetVertical + 76); ObjectSetInteger(ChartID(), "linea", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("linea", "Account Balance: -"); ObjectCreate(ChartID(), "lineto", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "lineto", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "lineto", OBJPROP_YDISTANCE, sqOffsetVertical + 92); ObjectSetInteger(ChartID(), "lineto", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("lineto", "Total profits/losses so far: -/-"); ObjectCreate(ChartID(), "linetp", OBJ_LABEL, 0, 0, 0); ObjectSetInteger(ChartID(), "linetp", OBJPROP_CORNER, sqLabelCorner); ObjectSetInteger(ChartID(), "linetp", OBJPROP_YDISTANCE, sqOffsetVertical + 108); ObjectSetInteger(ChartID(), "linetp", OBJPROP_XDISTANCE, sqOffsetHorizontal); setupLabel("linetp", "Total P/L so far: -"); } //+------------------------------------------------------------------+ void sqDeinitInfoPanel() { ObjectDelete(ChartID(), "line1"); ObjectDelete(ChartID(), "linec"); ObjectDelete(ChartID(), "line2"); ObjectDelete(ChartID(), "lines"); ObjectDelete(ChartID(), "lineopl"); ObjectDelete(ChartID(), "linea"); ObjectDelete(ChartID(), "lineto"); ObjectDelete(ChartID(), "linetp"); } //+------------------------------------------------------------------+ void sqTextFillOpens() { setupLabel("lineopl", "Open P/L: "+DoubleToString(sqGetOpenPLInMoney(0), 2)); setupLabel("linea", "Account Balance: "+DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), 2)); } //+------------------------------------------------------------------+ void setupLabel(string objectName, string text, const string font = "Tahoma", const int fontSize = 8, const color objColor = NULL){ color clr = objColor == NULL ? sqLabelColor : objColor; ObjectSetString(ChartID(), objectName, OBJPROP_TEXT, text); ObjectSetString(ChartID(), objectName, OBJPROP_FONT, font); ObjectSetInteger(ChartID(), objectName, OBJPROP_FONTSIZE, fontSize); ObjectSetInteger(ChartID(), objectName, OBJPROP_COLOR, clr); } //+------------------------------------------------------------------+ void sqTextFillTotals() { setupLabel("lineto", "Total profits/losses so far: "+sqGetTotalProfits(0, 100)+"/"+sqGetTotalLosses(0, 100)); setupLabel("linetp", "Total P/L so far: "+DoubleToString(sqGetTotalClosedPLInMoney(0, 1000), 2)); } //+------------------------------------------------------------------+ double sqGetOpenPLInMoney(int orderMagicNumber) { double pl = 0; for(int i=PositionsTotal(); i>=0; i--) { ulong ticket = PositionGetTicket(i); if(PositionSelectByTicket(ticket)){ int magic = PositionGetInteger(POSITION_MAGIC); double profit = PositionGetDouble(POSITION_PROFIT); if(orderMagicNumber != 0 && magic != orderMagicNumber) continue; pl += profit; } } return(pl); } //+------------------------------------------------------------------+ int sqGetTotalProfits(int orderMagicNumber, int numberOfLastOrders) { int count = 0; int profits = 0; HistorySelect(startTime, getTime(0)); for(int i=HistoryDealsTotal(); i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); if (HistoryDealGetString(ticket, DEAL_SYMBOL) == Symbol() && HistoryDealGetInteger(ticket,DEAL_ENTRY) == DEAL_ENTRY_OUT) { int magic = HistoryDealGetInteger(ticket, DEAL_MAGIC); if(orderMagicNumber == 0 || magic == orderMagicNumber) { // return the P/L of last order // or return the P/L of last order with given Magic Number count++; if(HistoryDealGetDouble(ticket, DEAL_PROFIT) > 0) { profits++; } if(count >= numberOfLastOrders) break; } } } return(profits); } //+------------------------------------------------------------------+ int sqGetTotalLosses(int orderMagicNumber, int numberOfLastOrders) { int count = 0; int losses = 0; HistorySelect(startTime, getTime(0)); for(int i=HistoryDealsTotal(); i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); if (HistoryDealGetString(ticket, DEAL_SYMBOL) == Symbol() && HistoryDealGetInteger(ticket,DEAL_ENTRY) == DEAL_ENTRY_OUT) { int magic = HistoryDealGetInteger(ticket, DEAL_MAGIC); if(orderMagicNumber == 0 || magic == orderMagicNumber) { // return the P/L of last order // or return the P/L of last order with given Magic Number count++; if(HistoryDealGetDouble(ticket, DEAL_PROFIT) < 0) { losses++; } if(count >= numberOfLastOrders) break; } } } return(losses); } //+------------------------------------------------------------------+ double sqGetTotalClosedPLInMoney(int orderMagicNumber, int numberOfLastOrders) { double pl = 0; int count = 0; HistorySelect(startTime, getTime(0)); for(int i=HistoryDealsTotal(); i>=0; i--) { ulong ticket = HistoryDealGetTicket(i); if (HistoryDealGetString(ticket, DEAL_SYMBOL) == Symbol() && HistoryDealGetInteger(ticket,DEAL_ENTRY) == DEAL_ENTRY_OUT) { int magic = HistoryDealGetInteger(ticket, DEAL_MAGIC); if(orderMagicNumber == 0 || magic == orderMagicNumber) { // return the P/L of last order or the P/L of last order with given Magic Number count++; pl = pl + HistoryDealGetDouble(ticket, DEAL_PROFIT); if(count >= numberOfLastOrders) break; } } } return(pl); } //+------------------------------------------------------------------+ double sqMMRiskPercentage(string symbol, int orderType, double price, double sl, double RiskInPercent, double LotsIfNoMM, double MaximumLots, double BaseCurrencyExchangeRate) { Verbose("Computing Money Management for order - Risk fixed % of account balance"); double slSize = sqConvertToPips(symbol, MathAbs(price - sl)); if(slSize <= 0) { Verbose("Computing Money Management - Stop Loss is zero, using Lots if no MM: ", LotsIfNoMM); return(LotsIfNoMM); } Verbose("Price: ", price, ", SL: ", sl, ", SLSize: ", slSize, ", RiskInPercent: ", RiskInPercent); double LotSize=0; if(RiskInPercent < 0 ) { Verbose("Computing Money Management - Incorrect RiskInPercent size, it must be above 0"); return(0); } double riskPerTrade = (BaseCurrencyExchangeRate * AccountInfoDouble(ACCOUNT_BALANCE) * (RiskInPercent / 100.0)); if(slSize <= 0) { Verbose("Computing Money Management - Incorrect StopLossPips size, it must be above 0"); return(0); } Verbose("Risk per trade: ", riskPerTrade); double TickSize = SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_SIZE); double TickValue = SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_VALUE); double PointValue = SymbolInfoDouble(Symbol(), SYMBOL_POINT); double LotStep = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP); if(_Digits == 1 || _Digits == 3 || _Digits == 5) { slSize = 10 * slSize; // conversion from pips to points } Verbose("Computing Money Management - SL: ", slSize, ", Account Balance: ", AccountInfoDouble(ACCOUNT_BALANCE),", Tick value: ", TickValue,", Point: ", PointValue, ", LotStep: ", LotStep,", Tick size: ", TickSize); if(slSize>0 && TickValue>0) { LotSize = TickSize * riskPerTrade / (slSize * TickValue * PointValue ); int err=GetLastError(); if(err==4013) { //ERR_ZERO_DIVIDE Verbose("Err: division by zero: StopLoss:",slSize," TickValue:",TickValue," LotSize:",LotSize); return(-1); } } //--- MAXLOT and MINLOT management double Smallest_Lot = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN); double Largest_Lot = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX); Verbose("Computing Money Management - Smallest_Lot: ", Smallest_Lot, ", Largest_Lot: ", Largest_Lot,", Computed LotSize: ", LotSize); if (LotSize < Smallest_Lot) LotSize = Smallest_Lot; if (LotSize > Largest_Lot) LotSize = Largest_Lot; if(LotSize > MaximumLots) { LotSize = MaximumLots; } //-------------------------------------------- //--- LotSize rounded regarding Broker LOTSTEP if(LotStep==1) { LotSize=NormalizeDouble(LotSize,0); } if(LotStep==0.1) { LotSize=NormalizeDouble(LotSize,1); } if(LotStep==0.01) { LotSize=NormalizeDouble(LotSize,2); } if(LotStep==0.001) { LotSize=NormalizeDouble(LotSize,3); } //-------------------------------------------- return (LotSize); } //+------------------------------------------------------------------+ double sqGetSLLevel(string symbol, int orderType, double price, bool valueInPips, double value) { return(sqGetSLPTLevel(-1.0, symbol, orderType, price, valueInPips, value)); } //+------------------------------------------------------------------+ double sqGetPTLevel(string symbol, int orderType, double price, bool valueInPips, double value) { return(sqGetSLPTLevel(1.0, symbol, orderType, price, valueInPips, value)); } //+------------------------------------------------------------------+ double sqGetSLPTLevel(double SLorPT, string symbol, int orderType, double price, bool valueInPips, double value) { string _symbol = correctSymbol(symbol); if(valueInPips) { // convert from pips to real points value = sqConvertToRealPips(_symbol, value); } if(price == 0) { // price can be zero for market order if(orderType == ORDER_TYPE_BUY) { price = sqGetAsk(_symbol); } else { price = sqGetBid(_symbol); } } if(orderType == ORDER_TYPE_BUY || orderType == ORDER_TYPE_BUY_STOP || orderType == ORDER_TYPE_BUY_LIMIT) { return (price + (SLorPT * value)); } else { return (price - (SLorPT * value)); } } //+------------------------------------------------------------------+ double sqBarRange(string symbol, int timeframe, int shift) { string curSymbol = (symbol == "NULL" || symbol == "Current") ? _Symbol : symbol; return(iHigh(curSymbol, timeframe, shift) - iLow(symbol, timeframe, shift)); } //+------------------------------------------------------------------+ double sqConvertToRealPips(string symbol, double value) { if(symbol == "NULL" || symbol == "Current") { return(gPointCoef * value); } double pointCoef = sqGetPointCoef(symbol); return(pointCoef * value); } //+------------------------------------------------------------------+ double sqGetPointCoef(string symbol) { if(symbol == "NULL" || symbol == "Current") { return(gPointCoef); } // recognize point coeficient double realDigits = SymbolInfoInteger(symbol, SYMBOL_DIGITS); if(realDigits == 4 || realDigits == 5) { realDigits -= 1; } double pointPow = MathPow(10, realDigits); return(1 / pointPow); } //+------------------------------------------------------------------+ bool sqDoublesAreEqual(double n1, double n2) { string st1 = DoubleToString(n1, _Digits); string st2 = DoubleToString(n2, _Digits); return (st1 == st2); } //+------------------------------------------------------------------+ double sqHighest(string symbol, int timeframe, int period, int shift) { double maxnum = -100000000; double val; for(int i=shift; i maxnum) { maxnum = val; } } return(maxnum); } //+------------------------------------------------------------------+ double sqHighestIndex(string symbol, int timeframe, int period, int shift) { double maxnum = -100000000; int index; double val; for(int i=shift; i maxnum) { maxnum = val; index = i; } } return(index); } //+------------------------------------------------------------------+ double sqLowest(string symbol, int timeframe, int period, int shift) { double minnum = 100000000; double val; for(int i=shift; i maxnum) { maxnum = range; } } return(maxnum); } //+------------------------------------------------------------------+ double sqSmallestRange(string symbol, int timeframe, int period, int shift) { double minnum = 100000000; double range; for(int i=shift; i= timeTo && TimeToString(getTime(i+1), TIME_MINUTES) < timeTo)) { //Log("Found timeTo: ", TimeToString(Time[i])); indexTo = i; break; } } if(indexTo == -1) { Log("Not found timeTo"); return(-1); } // find index of bar for timeFrom for(i=indexTo+1; i<=2000; i++) { if(TimeToString(getTime(i), TIME_MINUTES) == timeFrom || (TimeToString(getTime(i), TIME_MINUTES) >= timeFrom && TimeToString(getTime(i+1), TIME_MINUTES) < timeFrom)) { //Log("Found timeFrom: ", TimeToString(Time[i])); indexFrom = i; break; } } if(indexFrom == -1) { Log("Not found time From"); return(-1); } double value = -100000000.0; for(i=indexTo; i<=indexFrom; i++) { if(symbol == "NULL") { value = MathMax(value, iHigh(NULL, timeframe, i)); } else { value = MathMax(value, iHigh(symbol, timeframe, i)); } } return(value); } //+------------------------------------------------------------------+ double sqLowestInRange(string symbol, int timeframe, string timeFrom, string timeTo) { int indexTo = -1; int indexFrom = -1; int i; // find index of bar for timeTo for(i=1; i<=2000; i++) { if(TimeToString(getTime(i), TIME_MINUTES) == timeTo || (TimeToString(getTime(i), TIME_MINUTES) >= timeTo && TimeToString(getTime(i+1), TIME_MINUTES) < timeTo)) { //Log("Found timeTo: ", TimeToString(Time[i])); indexTo = i; break; } } if(indexTo == -1) { Log("Not found timeTo"); return(-1); } // find index of bar for timeFrom for(i=indexTo+1; i<=2000; i++) { if(TimeToString(getTime(i), TIME_MINUTES) == timeFrom || (TimeToString(getTime(i), TIME_MINUTES) >= timeFrom && TimeToString(getTime(i+1), TIME_MINUTES) < timeFrom)) { //Log("Found timeFrom: ", TimeToString(Time[i])); indexFrom = i; break; } } if(indexFrom == -1) { Log("Not found time From"); return(-1); } double value = 100000000.0; for(i=indexTo; i<=indexFrom; i++) { if(symbol == "NULL") { value = MathMin(value, iLow(NULL, timeframe, i)); } else { value = MathMin(value, iLow(symbol, timeframe, i)); } } return(value); } //+------------------------------------------------------------------+ string sqGetDate(int day, int month, int year) { string strYear = year; string strMonth = month; if(month < 10) strMonth = "0"+strMonth; string strDay = day; if(day < 10) strDay = "0"+strDay; return(StringConcatenate(strYear, ".", strMonth, ".", strDay)); } //+------------------------------------------------------------------+ string sqGetTime(int hour, int minute, int second) { string strHour = hour; if(hour < 10) strHour = "0"+strHour; string strMinute = minute; if(minute < 10) strMinute = "0"+strMinute; string strSecond = second; if(second < 10) strSecond = "0"+strSecond; return(StringConcatenate(strHour, ":", strMinute, ":", strSecond)); } //+------------------------------------------------------------------+ double sqSafeDivide(double var1, double var2) { if(var2 == 0) return(100000000); return(var1/var2); } //+------------------------------------------------------------------+ bool sqIsGreaterThanZero(double value) { double diff = value - 0; if(diff > 0.0000000001) { return(true); } return(false); } //+------------------------------------------------------------------+ bool sqIsLowerThanZero(double value) { double diff = 0 - value; if(diff > 0.0000000001) { return(true); } return(false); } //+------------------------------------------------------------------+ //+ Candle Pattern functions //+------------------------------------------------------------------+ bool sqBearishEngulfing(string symbol, int shift) { double O = getOpen(shift); double O1 = getOpen(shift+1); double C = getClose(shift); double C1 = getClose(shift+1); if ((C1>O1)&&(O>C)&&(O>=C1)&&(O1>=C)&&((O-C)>(C1-O1))) { return(true); } return(false); } //+------------------------------------------------------------------+ bool sqBullishEngulfing(string symbol, int shift) { double O = getOpen(shift); double O1 = getOpen(shift+1); double C = getClose(shift); double C1 = getClose(shift+1); if ((O1>C1)&&(C>O)&&(C>=O1)&&(C1>=O)&&((C-O)>(O1-C1))) { return(true); } return(false); } //+------------------------------------------------------------------+ bool sqDarkCloudCover(string symbol, int shift) { double L = getLow(shift); double H = getHigh(shift); double O = getOpen(shift); double O1 = getOpen(shift+1); double C = getClose(shift); double C1 = getClose(shift+1); double CL = H-L; double OC_HL; if((H - L) != 0) { OC_HL = (O-C)/(H-L); } else { OC_HL = 0; } double Piercing_Line_Ratio = 0.5; double Piercing_Candle_Length = 10; if ((C1>O1)&&(((C1+O1)/2)>C)&&(O>C)&&(C>O1)&&(OC_HL>Piercing_Line_Ratio)&&((CL>=Piercing_Candle_Length*sqGetPointCoef(symbol)))) { return(true); } return(false); } //+------------------------------------------------------------------+ bool sqDoji(string symbol, int shift) { if(MathAbs(getOpen(shift) - getClose(shift))*sqGetPointCoef(symbol) < 0.6) { return(true); } return(false); } //+------------------------------------------------------------------+ bool sqHammer(string symbol, int shift) { double H = getHigh(shift); double L = getLow(shift); double L1 = getLow(shift+1); double L2 = getLow(shift+2); double L3 = getLow(shift+3); double O = getOpen(shift); double C = getClose(shift); double CL = H-L; double BodyLow, BodyHigh; double Candle_WickBody_Percent = 0.9; double CandleLength = 12; if (O > C) { BodyHigh = O; BodyLow = C; } else { BodyHigh = C; BodyLow = O; } double LW = BodyLow-L; double UW = H-BodyHigh; double BLa = MathAbs(O-C); double BL90 = BLa*Candle_WickBody_Percent; double pipValue = sqGetPointCoef(symbol); if ((L<=L1)&&(LUW)&&(LW>BL90)&&(CL>=(CandleLength*pipValue))&&(O!=C)&&((LW/3)<=UW)&&((LW/4)<=UW)) { return(true); } if (((LW/3)>UW)&&(LW>BL90)&&(CL>=(CandleLength*pipValue))&&(O!=C)&&((LW/4)<=UW)) { return(true); } if (((LW/4)>UW)&&(LW>BL90)&&(CL>=(CandleLength*pipValue))&&(O!=C)) { return(true); } } return(false); } //+------------------------------------------------------------------+ bool sqPiercingLine(string symbol, int shift) { double L = getLow(shift); double H = getHigh(shift); double O = getOpen(shift); double O1 = getOpen(shift+1); double C = getClose(shift); double C1 = getClose(shift+1); double CL = H-L; double CO_HL; if((H - L) != 0) { CO_HL = (C-O)/(H-L); } else { CO_HL = 0; } double Piercing_Line_Ratio = 0.5; double Piercing_Candle_Length = 10; if ((C1Piercing_Line_Ratio)&&(CL>=(Piercing_Candle_Length*sqGetPointCoef(symbol)))) { return(true); } return(false); } //+------------------------------------------------------------------+ bool sqShootingStar(string symbol, int shift) { double L = getLow(shift); double H = getHigh(shift); double H1 = getHigh(shift+1); double H2 = getHigh(shift+2); double H3 = getHigh(shift+3); double O = getOpen(shift); double C = getClose(shift); double CL = H-L; double BodyLow, BodyHigh; double Candle_WickBody_Percent = 0.9; double CandleLength = 12; if (O > C) { BodyHigh = O; BodyLow = C; } else { BodyHigh = C; BodyLow = O; } double LW = BodyLow-L; double UW = H-BodyHigh; double BLa = MathAbs(O-C); double BL90 = BLa*Candle_WickBody_Percent; double pipValue = sqGetPointCoef(symbol); if ((H>=H1)&&(H>H2)&&(H>H3)) { if (((UW/2)>LW)&&(UW>(2*BL90))&&(CL>=(CandleLength*pipValue))&&(O!=C)&&((UW/3)<=LW)&&((UW/4)<=LW)) { return(true); } if (((UW/3)>LW)&&(UW>(2*BL90))&&(CL>=(CandleLength*pipValue))&&(O!=C)&&((UW/4)<=LW)) { return(true); } if (((UW/4)>LW)&&(UW>(2*BL90))&&(CL>=(CandleLength*pipValue))&&(O!=C)) { return(true); } } return(false); } //+------------------------------------------------------------------+ //| returns runtime error code description | //+------------------------------------------------------------------+ string ErrorDescription(int err_code) { //--- switch(err_code) { //--- Constant Description case ERR_SUCCESS: return("The operation completed successfully"); case ERR_INTERNAL_ERROR: return("Unexpected internal error"); case ERR_WRONG_INTERNAL_PARAMETER: return("Wrong parameter in the inner call of the client terminal function"); case ERR_INVALID_PARAMETER: return("Wrong parameter when calling the system function"); case ERR_NOT_ENOUGH_MEMORY: return("Not enough memory to perform the system function"); case ERR_STRUCT_WITHOBJECTS_ORCLASS: return("The structure contains objects of strings and/or dynamic arrays and/or structure of such objects and/or classes"); case ERR_INVALID_ARRAY: return("Array of a wrong type, wrong size, or a damaged object of a dynamic array"); case ERR_ARRAY_RESIZE_ERROR: return("Not enough memory for the relocation of an array, or an attempt to change the size of a static array"); case ERR_STRING_RESIZE_ERROR: return("Not enough memory for the relocation of string"); case ERR_NOTINITIALIZED_STRING: return("Not initialized string"); case ERR_INVALID_DATETIME: return("Invalid date and/or time"); case ERR_ARRAY_BAD_SIZE: return("Requested array size exceeds 2 GB"); case ERR_INVALID_POINTER: return("Wrong pointer"); case ERR_INVALID_POINTER_TYPE: return("Wrong type of pointer"); case ERR_FUNCTION_NOT_ALLOWED: return("System function is not allowed to call"); //--- Charts case ERR_CHART_WRONG_ID: return("Wrong chart ID"); case ERR_CHART_NO_REPLY: return("Chart does not respond"); case ERR_CHART_NOT_FOUND: return("Chart not found"); case ERR_CHART_NO_EXPERT: return("No Expert Advisor in the chart that could handle the event"); case ERR_CHART_CANNOT_OPEN: return("Chart opening error"); case ERR_CHART_CANNOT_CHANGE: return("Failed to change chart symbol and period"); case ERR_CHART_WRONG_PARAMETER: return("Wrong parameter"); case ERR_CHART_CANNOT_CREATE_TIMER: return("Failed to create timer"); case ERR_CHART_WRONG_PROPERTY: return("Wrong chart property ID"); case ERR_CHART_SCREENSHOT_FAILED: return("Error creating screenshots"); case ERR_CHART_NAVIGATE_FAILED: return("Error navigating through chart"); case ERR_CHART_TEMPLATE_FAILED: return("Error applying template"); case ERR_CHART_WINDOW_NOT_FOUND: return("Subwindow containing the indicator was not found"); case ERR_CHART_INDICATOR_CANNOT_ADD: return("Error adding an indicator to chart"); case ERR_CHART_INDICATOR_CANNOT_DEL: return("Error deleting an indicator from the chart"); case ERR_CHART_INDICATOR_NOT_FOUND: return("Indicator not found on the specified chart"); //--- Graphical Objects case ERR_OBJECT_ERROR: return("Error working with a graphical object"); case ERR_OBJECT_NOT_FOUND: return("Graphical object was not found"); case ERR_OBJECT_WRONG_PROPERTY: return("Wrong ID of a graphical object property"); case ERR_OBJECT_GETDATE_FAILED: return("Unable to get date corresponding to the value"); case ERR_OBJECT_GETVALUE_FAILED: return("Unable to get value corresponding to the date"); //--- MarketInfo case ERR_MARKET_UNKNOWN_SYMBOL: return("Unknown symbol"); case ERR_MARKET_NOT_SELECTED: return("Symbol is not selected in MarketWatch"); case ERR_MARKET_WRONG_PROPERTY: return("Wrong identifier of a symbol property"); case ERR_MARKET_LASTTIME_UNKNOWN: return("Time of the last tick is not known (no ticks)"); case ERR_MARKET_SELECT_ERROR: return("Error adding or deleting a symbol in MarketWatch"); //--- History Access case ERR_HISTORY_NOT_FOUND: return("Requested history not found"); case ERR_HISTORY_WRONG_PROPERTY: return("Wrong ID of the history property"); //--- Global_Variables case ERR_GLOBALVARIABLE_NOT_FOUND: return("Global variable of the client terminal is not found"); case ERR_GLOBALVARIABLE_EXISTS: return("Global variable of the client terminal with the same name already exists"); case ERR_MAIL_SEND_FAILED: return("Email sending failed"); case ERR_PLAY_SOUND_FAILED: return("Sound playing failed"); case ERR_MQL5_WRONG_PROPERTY: return("Wrong identifier of the program property"); case ERR_TERMINAL_WRONG_PROPERTY: return("Wrong identifier of the terminal property"); case ERR_FTP_SEND_FAILED: return("File sending via ftp failed"); case ERR_NOTIFICATION_SEND_FAILED: return("Error in sending notification"); //--- Custom Indicator Buffers case ERR_BUFFERS_NO_MEMORY: return("Not enough memory for the distribution of indicator buffers"); case ERR_BUFFERS_WRONG_INDEX: return("Wrong indicator buffer index"); //--- Custom Indicator Properties case ERR_CUSTOM_WRONG_PROPERTY: return("Wrong ID of the custom indicator property"); //--- Account case ERR_ACCOUNT_WRONG_PROPERTY: return("Wrong account property ID"); case ERR_TRADE_WRONG_PROPERTY: return("Wrong trade property ID"); case ERR_TRADE_DISABLED: return("Trading by Expert Advisors prohibited"); case ERR_TRADE_POSITION_NOT_FOUND: return("Position not found"); case ERR_TRADE_ORDER_NOT_FOUND: return("Order not found"); case ERR_TRADE_DEAL_NOT_FOUND: return("Deal not found"); case ERR_TRADE_SEND_FAILED: return("Trade request sending failed"); //--- Indicators case ERR_INDICATOR_UNKNOWN_SYMBOL: return("Unknown symbol"); case ERR_INDICATOR_CANNOT_CREATE: return("Indicator cannot be created"); case ERR_INDICATOR_NO_MEMORY: return("Not enough memory to add the indicator"); case ERR_INDICATOR_CANNOT_APPLY: return("The indicator cannot be applied to another indicator"); case ERR_INDICATOR_CANNOT_ADD: return("Error applying an indicator to chart"); case ERR_INDICATOR_DATA_NOT_FOUND: return("Requested data not found"); case ERR_INDICATOR_WRONG_HANDLE: return("Wrong indicator handle"); case ERR_INDICATOR_WRONG_PARAMETERS: return("Wrong number of parameters when creating an indicator"); case ERR_INDICATOR_PARAMETERS_MISSING: return("No parameters when creating an indicator"); case ERR_INDICATOR_CUSTOM_NAME: return("The first parameter in the array must be the name of the custom indicator"); case ERR_INDICATOR_PARAMETER_TYPE: return("Invalid parameter type in the array when creating an indicator"); case ERR_INDICATOR_WRONG_INDEX: return("Wrong index of the requested indicator buffer"); //--- Depth of Market case ERR_BOOKS_CANNOT_ADD: return("Depth Of Market can not be added"); case ERR_BOOKS_CANNOT_DELETE: return("Depth Of Market can not be removed"); case ERR_BOOKS_CANNOT_GET: return("The data from Depth Of Market can not be obtained"); case ERR_BOOKS_CANNOT_SUBSCRIBE: return("Error in subscribing to receive new data from Depth Of Market"); //--- File Operations case ERR_TOO_MANY_FILES: return("More than 64 files cannot be opened at the same time"); case ERR_WRONG_FILENAME: return("Invalid file name"); case ERR_TOO_LONG_FILENAME: return("Too long file name"); case ERR_CANNOT_OPEN_FILE: return("File opening error"); case ERR_FILE_CACHEBUFFER_ERROR: return("Not enough memory for cache to read"); case ERR_CANNOT_DELETE_FILE: return("File deleting error"); case ERR_INVALID_FILEHANDLE: return("A file with this handle was closed, or was not opening at all"); case ERR_WRONG_FILEHANDLE: return("Wrong file handle"); case ERR_FILE_NOTTOWRITE: return("The file must be opened for writing"); case ERR_FILE_NOTTOREAD: return("The file must be opened for reading"); case ERR_FILE_NOTBIN: return("The file must be opened as a binary one"); case ERR_FILE_NOTTXT: return("The file must be opened as a text"); case ERR_FILE_NOTTXTORCSV: return("The file must be opened as a text or CSV"); case ERR_FILE_NOTCSV: return("The file must be opened as CSV"); case ERR_FILE_READERROR: return("File reading error"); case ERR_FILE_BINSTRINGSIZE: return("String size must be specified, because the file is opened as binary"); case ERR_INCOMPATIBLE_FILE: return("A text file must be for string arrays, for other arrays - binary"); case ERR_FILE_IS_DIRECTORY: return("This is not a file, this is a directory"); case ERR_FILE_NOT_EXIST: return("File does not exist"); case ERR_FILE_CANNOT_REWRITE: return("File can not be rewritten"); case ERR_WRONG_DIRECTORYNAME: return("Wrong directory name"); case ERR_DIRECTORY_NOT_EXIST: return("Directory does not exist"); case ERR_FILE_ISNOT_DIRECTORY: return("This is a file, not a directory"); case ERR_CANNOT_DELETE_DIRECTORY: return("The directory cannot be removed"); case ERR_CANNOT_CLEAN_DIRECTORY: return("Failed to clear the directory (probably one or more files are blocked and removal operation failed)"); case ERR_FILE_WRITEERROR: return("Failed to write a resource to a file"); //--- String Casting case ERR_NO_STRING_DATE: return("No date in the string"); case ERR_WRONG_STRING_DATE: return("Wrong date in the string"); case ERR_WRONG_STRING_TIME: return("Wrong time in the string"); case ERR_STRING_TIME_ERROR: return("Error converting string to date"); case ERR_STRING_OUT_OF_MEMORY: return("Not enough memory for the string"); case ERR_STRING_SMALL_LEN: return("The string length is less than expected"); case ERR_STRING_TOO_BIGNUMBER: return("Too large number, more than ULONG_MAX"); case ERR_WRONG_FORMATSTRING: return("Invalid format string"); case ERR_TOO_MANY_FORMATTERS: return("Amount of format specifiers more than the parameters"); case ERR_TOO_MANY_PARAMETERS: return("Amount of parameters more than the format specifiers"); case ERR_WRONG_STRING_PARAMETER: return("Damaged parameter of string type"); case ERR_STRINGPOS_OUTOFRANGE: return("Position outside the string"); case ERR_STRING_ZEROADDED: return("0 added to the string end, a useless operation"); case ERR_STRING_UNKNOWNTYPE: return("Unknown data type when converting to a string"); case ERR_WRONG_STRING_OBJECT: return("Damaged string object"); //--- Operations with Arrays case ERR_INCOMPATIBLE_ARRAYS: return("Copying incompatible arrays. String array can be copied only to a string array, and a numeric array - in numeric array only"); case ERR_SMALL_ASSERIES_ARRAY: return("The receiving array is declared as AS_SERIES, and it is of insufficient size"); case ERR_SMALL_ARRAY: return("Too small array, the starting position is outside the array"); case ERR_ZEROSIZE_ARRAY: return("An array of zero length"); case ERR_NUMBER_ARRAYS_ONLY: return("Must be a numeric array"); case ERR_ONEDIM_ARRAYS_ONLY: return("Must be a one-dimensional array"); case ERR_SERIES_ARRAY: return("Timeseries cannot be used"); case ERR_DOUBLE_ARRAY_ONLY: return("Must be an array of type double"); case ERR_FLOAT_ARRAY_ONLY: return("Must be an array of type float"); case ERR_LONG_ARRAY_ONLY: return("Must be an array of type long"); case ERR_INT_ARRAY_ONLY: return("Must be an array of type int"); case ERR_SHORT_ARRAY_ONLY: return("Must be an array of type short"); case ERR_CHAR_ARRAY_ONLY: return("Must be an array of type char"); //--- Operations with OpenCL case ERR_OPENCL_NOT_SUPPORTED: return("OpenCL functions are not supported on this computer"); case ERR_OPENCL_INTERNAL: return("Internal error occurred when running OpenCL"); case ERR_OPENCL_INVALID_HANDLE: return("Invalid OpenCL handle"); case ERR_OPENCL_CONTEXT_CREATE: return("Error creating the OpenCL context"); case ERR_OPENCL_QUEUE_CREATE: return("Failed to create a run queue in OpenCL"); case ERR_OPENCL_PROGRAM_CREATE: return("Error occurred when compiling an OpenCL program"); case ERR_OPENCL_TOO_LONG_KERNEL_NAME: return("Too long kernel name (OpenCL kernel)"); case ERR_OPENCL_KERNEL_CREATE: return("Error creating an OpenCL kernel"); case ERR_OPENCL_SET_KERNEL_PARAMETER: return("Error occurred when setting parameters for the OpenCL kernel"); case ERR_OPENCL_EXECUTE: return("OpenCL program runtime error"); case ERR_OPENCL_WRONG_BUFFER_SIZE: return("Invalid size of the OpenCL buffer"); case ERR_OPENCL_WRONG_BUFFER_OFFSET: return("Invalid offset in the OpenCL buffer"); case ERR_OPENCL_BUFFER_CREATE: return("Failed to create and OpenCL buffer"); //--- User-Defined Errors default: if(err_code>=ERR_USER_ERROR_FIRST && err_code 0) { double newSL = 0; int error; int valueType = sqGetMoveSL2BEType(ticket); int orderType = PositionGetInteger(POSITION_TYPE); if(orderType == ORDER_TYPE_BUY || orderType == ORDER_TYPE_BUY_STOP || orderType == ORDER_TYPE_BUY_LIMIT) { if(valueType == SLPTTYPE_RANGE) { moveSLAtValue = sqGetBid(NULL) - moveSLAtValue; } } else { if(valueType == SLPTTYPE_RANGE) { moveSLAtValue = sqGetAsk(NULL) + moveSLAtValue; } } moveSLAtValue = NormalizeDouble(moveSLAtValue, _Digits); double addPips = sqGetValueByIdentification(sqGetSL2BEAddPips(ticket)); double currentSL = PositionGetDouble(POSITION_SL); double openPrice = PositionGetDouble(POSITION_PRICE_OPEN); double takeProfit = PositionGetDouble(POSITION_TP); if(orderType == ORDER_TYPE_BUY) { newSL = openPrice + addPips; if (openPrice <= moveSLAtValue && (currentSL == 0 || currentSL < newSL) && !sqDoublesAreEqual(currentSL, newSL)) { Verbose("Moving SL 2 BE for order with ticket: ", ticket, " to :", newSL); if(!OrderModify(ticket, newSL, takeProfit)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(NULL), ", Bid: ", sqGetBid(NULL), " Current SL: ", currentSL); } } } else { // orderType == OP_SELL newSL = openPrice - addPips; if (openPrice >= moveSLAtValue && (currentSL == 0 || currentSL > newSL) && !sqDoublesAreEqual(currentSL, newSL)) { Verbose("Moving SL 2 BE for order with ticket: ", ticket, " to :", newSL); if(!OrderModify(ticket, newSL, takeProfit)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(NULL), ", Bid: ", sqGetBid(NULL), " Current SL: ", currentSL); } } } } } // Trailing Stop void sqManageTrailingStop(int ticket) { if(!PositionSelectByTicket(ticket)){ Verbose("Cannot select position with ticket ", ticket); return; } valueIdentificationSymbol = PositionGetString(POSITION_SYMBOL); double tsValue = sqGetValueByIdentification( sqGetTrailingStop(ticket) ); if(tsValue > 0) { double plValue; int error; int valueType = sqGetTrailingStopType(ticket); int orderType = PositionGetInteger(POSITION_TYPE); if(orderType == POSITION_TYPE_BUY) { if(valueType == SLPTTYPE_RANGE) { tsValue = sqGetBid(NULL) - tsValue; } } else { if(valueType == SLPTTYPE_RANGE) { tsValue = sqGetAsk(NULL) + tsValue; } } double tsActivation = sqGetValueByIdentification( sqGetTSActivation(ticket) ); double currentSL = PositionGetDouble(POSITION_SL); double openPrice = PositionGetDouble(POSITION_PRICE_OPEN); double takeProfit = PositionGetDouble(POSITION_TP); if(orderType == POSITION_TYPE_BUY) { plValue = sqGetBid(NULL) - openPrice; if (plValue >= tsActivation && (currentSL == 0 || currentSL < tsValue) && !sqDoublesAreEqual(currentSL, tsValue)) { Verbose("Moving trailing stop for order with ticket: ", ticket, " to :", tsValue); if(!OrderModify(ticket, tsValue, takeProfit)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(NULL), ", Bid: ", sqGetBid(NULL), " Current SL: ", currentSL); } } } else { // orderType == OP_SELL plValue = openPrice - sqGetAsk(NULL); if (plValue >= tsActivation && (currentSL == 0 || currentSL > tsValue) && !sqDoublesAreEqual(currentSL, tsValue)) { Verbose("Moving trailing stop for order with ticket: ", ticket, " to :", tsValue); if(!OrderModify(ticket, tsValue, takeProfit)) { error = GetLastError(); Verbose("Failed, error: ", error, " - ", ErrorDescription(error),", Ask: ", sqGetAsk(NULL), ", Bid: ", sqGetBid(NULL), " Current SL: ", currentSL); } } } } } void sqManageExitAfterXBars(int ticket) { if(!PositionSelectByTicket(ticket)){ Verbose("Exit after bars - Cannot select position with ticket ", ticket); return; } int exitBars = sqGetExitAfterXBars(ticket); if(exitBars > 0) { if (sqGetOpenBarsForOrder(exitBars+10, PositionGetInteger(POSITION_TIME)) >= exitBars) { Verbose("Exit After ", exitBars, " bars - closing order with ticket: ", ticket); if(!sqClosePositionAtMarket(ticket)){ Verbose("Closing position failed, error: ", GetLastError(), " - ", ErrorDescription(GetLastError())); } } } }