ironsan2kk-pixel
1657 lines
80 KiB
Plaintext
1657 lines
80 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| Chart Pattern Helper |
|
|
//| Copyright © 2024, EarnForex.com |
|
|
//| https://www.earnforex.com/ |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright © 2024, EarnForex"
|
|
#property link "https://www.earnforex.com/metatrader-expert-advisors/ChartPatternHelper/"
|
|
#property version "1.15"
|
|
#property strict
|
|
|
|
#include <stdlib.mqh>
|
|
|
|
#property description "Uses graphic objects (horizontal/trend lines, channels) to enter trades."
|
|
#property description "Works in two modes:"
|
|
#property description "1. Price is below upper entry and above lower entry. Only one or two pending stop orders are used."
|
|
#property description "2. Price is above upper entry or below lower entry. Only one pending limit order is used."
|
|
#property description "If an object is deleted/renamed after the pending order was placed, order will be canceled."
|
|
#property description "Pending order is removed if opposite entry is triggered."
|
|
#property description "Generally, it is safe to turn off the EA at any point."
|
|
|
|
input group "Objects"
|
|
input string UpperBorderLine = "UpperBorder";
|
|
input string UpperEntryLine = "UpperEntry";
|
|
input string UpperTPLine = "UpperTP";
|
|
input string LowerBorderLine = "LowerBorder";
|
|
input string LowerEntryLine = "LowerEntry";
|
|
input string LowerTPLine = "LowerTP";
|
|
// The pattern may be given as trend/horizontal lines or equidistant channels.
|
|
input string BorderChannel = "Border";
|
|
input string EntryChannel = "Entry";
|
|
input string TPChannel = "TP";
|
|
input group "Order management"
|
|
// In case Channel is used for Entry, pending orders will be removed even if OneCancelsOther = false.
|
|
input bool OneCancelsOther = true; // OneCancelsOther: Remove opposite orders once position is open?
|
|
// If true, spread will be added to Buy entry level and Sell SL/TP levels. It compensates the difference when Ask price is used, while all chart objects are drawn at Bid level.
|
|
input bool UseSpreadAdjustment = false; // UseSpreadAdjustment: Add spread to Buy entry and Sell SL/TP?
|
|
// Not all brokers support expiration.
|
|
input bool UseExpiration = true; // UseExpiration: Use expiration on pending orders?
|
|
input bool DisableBuyOrders = false; // DisableBuyOrders: Disable new and ignore existing buy trades?
|
|
input bool DisableSellOrders = false; // DisableSellOrders: Disable new and ignore existing sell trades?
|
|
// If true, the EA will try to adjust SL after breakout candle is complete as it may no longer qualify for SL; it will make SL more precise but will mess up the money management a bit.
|
|
input bool PostEntrySLAdjustment = false; // PostEntrySLAdjustment: Adjust SL after entry?
|
|
input bool UseDistantSL = false; // UseDistantSL: If true, set SL to pattern's farthest point.
|
|
input group "Trendline trading"
|
|
input bool OpenOnCloseAboveBelowTrendline = false; // Open trade on close above/below trendline.
|
|
input string SLLine = "SL"; // Stop-loss line name for trendline trading.
|
|
input int ThresholdSpreads = 10; // Threshold Spreads: number of spreads for minimum distance.
|
|
input group "Position sizing"
|
|
input bool CalculatePositionSize = true; // CalculatePositionSize: Use money management module?
|
|
input bool UpdatePendingVolume = true; // UpdatePendingVolume: If true, recalculate pending order volume.
|
|
input double FixedPositionSize = 0.01; // FixedPositionSize: Used if CalculatePositionSize = false.
|
|
input double Risk = 1; // Risk: Risk tolerance in percentage points.
|
|
input double MoneyRisk = 0; // MoneyRisk: Risk tolerance in base currency.
|
|
input bool UseMoneyInsteadOfPercentage = false;
|
|
input bool UseEquityInsteadOfBalance = false;
|
|
input double FixedBalance = 0; // FixedBalance: If > 0, trade size calc. uses it as balance.
|
|
input group "Miscellaneous"
|
|
input int Magic = 20200530;
|
|
input int Slippage = 30; // Slippage: Maximum slippage in broker's pips.
|
|
input bool Silent = false; // Silent: If true, does not display any output via chart comment.
|
|
input bool ErrorLogging = true; // ErrorLogging: If true, errors will be logged to file.
|
|
|
|
// Global variables:
|
|
bool UseUpper, UseLower;
|
|
double UpperSL, UpperEntry, UpperTP, LowerSL, LowerEntry, LowerTP;
|
|
int UpperTicket, LowerTicket;
|
|
bool HaveBuyPending = false;
|
|
bool HaveSellPending = false;
|
|
bool HaveBuy = false;
|
|
bool HaveSell = false;
|
|
bool TCBusy = false;
|
|
bool PostBuySLAdjustmentDone = false, PostSellSLAdjustmentDone = false;
|
|
// For tick value adjustment:
|
|
string ProfitCurrency = "", account_currency = "", BaseCurrency = "", ReferenceSymbol = NULL, AdditionalReferenceSymbol = NULL;
|
|
bool ReferenceSymbolMode, AdditionalReferenceSymbolMode;
|
|
int ProfitCalcMode;
|
|
double TickSize;
|
|
|
|
// For error logging:
|
|
string filename;
|
|
|
|
void OnInit()
|
|
{
|
|
FindObjects();
|
|
if (ErrorLogging)
|
|
{
|
|
datetime tl = TimeLocal();
|
|
string mon = IntegerToString(TimeMonth(tl));
|
|
if (StringLen(mon) == 1) mon = "0" + mon;
|
|
string day = IntegerToString(TimeDay(tl));
|
|
if (StringLen(day) == 1) day = "0" + day;
|
|
string hour = IntegerToString(TimeHour(tl));
|
|
if (StringLen(hour) == 1) hour = "0" + hour;
|
|
string min = IntegerToString(TimeMinute(tl));
|
|
if (StringLen(min) == 1) min = "0" + min;
|
|
string sec = IntegerToString(TimeSeconds(tl));
|
|
if (StringLen(sec) == 1) sec = "0" + sec;
|
|
filename = "CPH-Errors-" + IntegerToString(TimeYear(tl)) + mon + day + hour + min + sec + ".log";
|
|
}
|
|
}
|
|
|
|
void OnDeinit(const int reason)
|
|
{
|
|
SetComment("");
|
|
}
|
|
|
|
void OnTick()
|
|
{
|
|
FindOrders();
|
|
FindObjects();
|
|
AdjustOrders(); // And delete the ones no longer needed.
|
|
}
|
|
|
|
// Finds Entry, Border and TP objects. Detects respective levels according to found objects. Outputs found values to chart comment.
|
|
void FindObjects()
|
|
{
|
|
string c1 = FindUpperObjects();
|
|
string c2 = FindLowerObjects();
|
|
|
|
SetComment(c1 + c2);
|
|
}
|
|
|
|
// Adjustment for Ask/Bid spread is made for entry level as Long positions are entered at Ask, while all objects are drawn at Bid.
|
|
string FindUpperObjects()
|
|
{
|
|
string c = ""; // Text for chart comment
|
|
|
|
if (DisableBuyOrders)
|
|
{
|
|
UseUpper = false;
|
|
return "\nBuy orders disabled via input parameters.";
|
|
}
|
|
|
|
UseUpper = true;
|
|
|
|
// Entry
|
|
if (OpenOnCloseAboveBelowTrendline) // Simple trendline entry doesn't need an entry line.
|
|
{
|
|
c = c + "\nUpper entry unnecessary.";
|
|
}
|
|
else if (ObjectFind(UpperEntryLine) > -1)
|
|
{
|
|
if ((ObjectType(UpperEntryLine) != OBJ_HLINE) && (ObjectType(UpperEntryLine) != OBJ_TREND))
|
|
{
|
|
Alert("Upper Entry Line should be either OBJ_HLINE or OBJ_TREND.");
|
|
return("\nWrong Upper Entry Line object type.");
|
|
}
|
|
if (ObjectType(UpperEntryLine) != OBJ_HLINE) UpperEntry = NormalizeDouble(ObjectGetValueByShift(UpperEntryLine, 0), Digits);
|
|
else UpperEntry = NormalizeDouble(ObjectGet(UpperEntryLine, OBJPROP_PRICE1), Digits); // Horizontal line value
|
|
if (UseSpreadAdjustment) UpperEntry = NormalizeDouble(UpperEntry + MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits);
|
|
ObjectSet(UpperEntryLine, OBJPROP_RAY, true);
|
|
c = c + "\nUpper entry found. Level: " + DoubleToStr(UpperEntry, Digits);
|
|
}
|
|
else
|
|
{
|
|
if (ObjectFind(EntryChannel) > -1)
|
|
{
|
|
if (ObjectType(EntryChannel) != OBJ_CHANNEL)
|
|
{
|
|
Alert("Entry Channel should be OBJ_CHANNEL.");
|
|
return "\nWrong Entry Channel object type.";
|
|
}
|
|
UpperEntry = NormalizeDouble(FindUpperEntryViaChannel(), Digits);
|
|
if (UseSpreadAdjustment) UpperEntry = NormalizeDouble(UpperEntry + MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits);
|
|
ObjectSet(EntryChannel, OBJPROP_RAY, true);
|
|
c = c + "\nUpper entry found (via channel). Level: " + DoubleToStr(UpperEntry, Digits);
|
|
}
|
|
else
|
|
{
|
|
c = c + "\nUpper entry not found. No new position will be entered.";
|
|
UseUpper = false;
|
|
}
|
|
}
|
|
|
|
// Border
|
|
if (ObjectFind(UpperBorderLine) > -1)
|
|
{
|
|
if ((ObjectType(UpperBorderLine) != OBJ_HLINE) && (ObjectType(UpperBorderLine) != OBJ_TREND))
|
|
{
|
|
Alert("Upper Border Line should be either OBJ_HLINE or OBJ_TREND.");
|
|
return "\nWrong Upper Border Line object type.";
|
|
}
|
|
// Find upper SL
|
|
UpperSL = FindUpperSL();
|
|
ObjectSet(UpperBorderLine, OBJPROP_RAY, true);
|
|
c = c + "\nUpper border found. Upper stop-loss level: " + DoubleToStr(UpperSL, Digits);
|
|
}
|
|
else // Try to find a channel.
|
|
{
|
|
if (ObjectFind(BorderChannel) > -1)
|
|
{
|
|
if (ObjectType(BorderChannel) != OBJ_CHANNEL)
|
|
{
|
|
Alert("Border Channel should be OBJ_CHANNEL.");
|
|
return "\nWrong Border Channel object type.";
|
|
}
|
|
// Find upper SL
|
|
UpperSL = FindUpperSLViaChannel();
|
|
ObjectSet(BorderChannel, OBJPROP_RAY, true);
|
|
c = c + "\nUpper border found (via channel). Upper stop-loss level: " + DoubleToStr(UpperSL, Digits);
|
|
}
|
|
else
|
|
{
|
|
c = c + "\nUpper border not found.";
|
|
if ((CalculatePositionSize) && (!HaveBuy))
|
|
{
|
|
UseUpper = false;
|
|
c = c + " Cannot trade without stop-loss, while CalculatePositionSize set to true.";
|
|
}
|
|
else
|
|
{
|
|
c = c + " Stop-loss won\'t be applied to new positions.";
|
|
// Track current SL, possibly installed by user.
|
|
if ((OrderSelect(UpperTicket, SELECT_BY_TICKET)) && ((OrderType() == OP_BUYSTOP) || (OrderType() == OP_BUYLIMIT)))
|
|
{
|
|
UpperSL = OrderStopLoss();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Adjust upper SL for tick size granularity.
|
|
TickSize = MarketInfo(Symbol(), MODE_TICKSIZE);
|
|
UpperSL = NormalizeDouble(MathRound(UpperSL / TickSize) * TickSize, _Digits);
|
|
|
|
// Take-profit.
|
|
if (ObjectFind(UpperTPLine) > -1)
|
|
{
|
|
if ((ObjectType(UpperTPLine) != OBJ_HLINE) && (ObjectType(UpperTPLine) != OBJ_TREND))
|
|
{
|
|
Alert("Upper TP Line should be either OBJ_HLINE or OBJ_TREND.");
|
|
return "\nWrong Upper TP Line object type.";
|
|
}
|
|
if (ObjectType(UpperTPLine) != OBJ_HLINE) UpperTP = NormalizeDouble(ObjectGetValueByShift(UpperTPLine, 0), Digits);
|
|
else UpperTP = NormalizeDouble(ObjectGet(UpperTPLine, OBJPROP_PRICE1), Digits); // Horizontal line value
|
|
ObjectSet(UpperTPLine, OBJPROP_RAY, true);
|
|
c = c + "\nUpper take-profit found. Level: " + DoubleToStr(UpperTP, Digits);
|
|
}
|
|
else
|
|
{
|
|
if (ObjectFind(TPChannel) > -1)
|
|
{
|
|
if (ObjectType(TPChannel) != OBJ_CHANNEL)
|
|
{
|
|
Alert("TP Channel should be OBJ_CHANNEL.");
|
|
return "\nWrong TP Channel object type.";
|
|
}
|
|
UpperTP = FindUpperTPViaChannel();
|
|
ObjectSet(TPChannel, OBJPROP_RAY, true);
|
|
c = c + "\nUpper TP found (via channel). Level: " + DoubleToStr(UpperTP, Digits);
|
|
}
|
|
else
|
|
{
|
|
c = c + "\nUpper take-profit not found. Take-profit won\'t be applied to new positions.";
|
|
// Track current TP, possibly installed by user
|
|
if ((OrderSelect(UpperTicket, SELECT_BY_TICKET)) && ((OrderType() == OP_BUYSTOP) || (OrderType() == OP_BUYLIMIT)))
|
|
{
|
|
UpperTP = OrderTakeProfit();
|
|
}
|
|
}
|
|
}
|
|
// Adjust upper TP for tick size granularity.
|
|
UpperTP = NormalizeDouble(MathRound(UpperTP / TickSize) * TickSize, _Digits);
|
|
|
|
return c;
|
|
}
|
|
|
|
// Adjustment for Ask/Bid spread is made for exit levels (SL and TP) as Short positions are exited at Ask, while all objects are drawn at Bid.
|
|
string FindLowerObjects()
|
|
{
|
|
string c = ""; // Text for chart comment
|
|
|
|
if (DisableSellOrders)
|
|
{
|
|
UseLower = false;
|
|
return "\nSell orders disabled via input parameters.";
|
|
}
|
|
|
|
UseLower = true;
|
|
|
|
// Entry.
|
|
if (OpenOnCloseAboveBelowTrendline) // Simple trendline entry doesn't need an entry line.
|
|
{
|
|
c = c + "\nLower entry unnecessary.";
|
|
}
|
|
else if (ObjectFind(LowerEntryLine) > -1)
|
|
{
|
|
if ((ObjectType(LowerEntryLine) != OBJ_HLINE) && (ObjectType(LowerEntryLine) != OBJ_TREND))
|
|
{
|
|
Alert("Lower Entry Line should be either OBJ_HLINE or OBJ_TREND.");
|
|
return "\nWrong Lower Entry Line object type.";
|
|
}
|
|
if (ObjectType(LowerEntryLine) != OBJ_HLINE) LowerEntry = NormalizeDouble(ObjectGetValueByShift(LowerEntryLine, 0), Digits);
|
|
else LowerEntry = NormalizeDouble(ObjectGet(LowerEntryLine, OBJPROP_PRICE1), Digits); // Horizontal line value
|
|
ObjectSet(LowerEntryLine, OBJPROP_RAY, true);
|
|
c = c + "\nLower entry found. Level: " + DoubleToStr(LowerEntry, Digits);
|
|
}
|
|
else
|
|
{
|
|
if (ObjectFind(EntryChannel) > -1)
|
|
{
|
|
if (ObjectType(EntryChannel) != OBJ_CHANNEL)
|
|
{
|
|
Alert("Entry Channel should be OBJ_CHANNEL.");
|
|
return "\nWrong Entry Channel object type.";
|
|
}
|
|
LowerEntry = FindLowerEntryViaChannel();
|
|
ObjectSet(EntryChannel, OBJPROP_RAY, true);
|
|
c = c + "\nLower entry found (via channel). Level: " + DoubleToStr(LowerEntry, Digits);
|
|
}
|
|
else
|
|
{
|
|
c = c + "\nLower entry not found. No new position will be entered.";
|
|
UseLower = false;
|
|
}
|
|
}
|
|
|
|
// Border.
|
|
if (ObjectFind(LowerBorderLine) > -1)
|
|
{
|
|
if ((ObjectType(LowerBorderLine) != OBJ_HLINE) && (ObjectType(LowerBorderLine) != OBJ_TREND))
|
|
{
|
|
Alert("Lower Border Line should be either OBJ_HLINE or OBJ_TREND.");
|
|
return "\nWrong Lower Border Line object type.";
|
|
}
|
|
// Find Lower SL.
|
|
LowerSL = NormalizeDouble(FindLowerSL(), Digits);
|
|
if (UseSpreadAdjustment) LowerSL = NormalizeDouble(LowerSL + MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits);
|
|
ObjectSet(LowerBorderLine, OBJPROP_RAY, true);
|
|
c = c + "\nLower border found. Lower stop-loss level: " + DoubleToStr(LowerSL, Digits);
|
|
}
|
|
else // Try to find a channel.
|
|
{
|
|
if (ObjectFind(BorderChannel) > -1)
|
|
{
|
|
if (ObjectType(BorderChannel) != OBJ_CHANNEL)
|
|
{
|
|
Alert("Border Channel should be OBJ_CHANNEL.");
|
|
return "\nWrong Border Channel object type.";
|
|
}
|
|
// Find Lower SL
|
|
LowerSL = NormalizeDouble(FindLowerSLViaChannel(), Digits);
|
|
if (UseSpreadAdjustment) LowerSL = NormalizeDouble(LowerSL + MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits);
|
|
ObjectSet(BorderChannel, OBJPROP_RAY, true);
|
|
c = c + "\nLower border found (via channel). Lower stop-loss level: " + DoubleToStr(LowerSL, Digits);
|
|
}
|
|
else
|
|
{
|
|
c = c + "\nLower border not found.";
|
|
if ((CalculatePositionSize) && (!HaveSell))
|
|
{
|
|
UseLower = false;
|
|
c = c + " Cannot trade without stop-loss, while CalculatePositionSize set to true.";
|
|
}
|
|
else
|
|
{
|
|
c = c + " Stop-loss won\'t be applied to new positions.";
|
|
// Track current SL, possibly installed by user.
|
|
if ((OrderSelect(LowerTicket, SELECT_BY_TICKET)) && ((OrderType() == OP_SELLSTOP) || (OrderType() == OP_SELLLIMIT)))
|
|
{
|
|
LowerSL = OrderStopLoss();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Adjust lower SL for tick size granularity.
|
|
TickSize = MarketInfo(Symbol(), MODE_TICKSIZE);
|
|
LowerSL = NormalizeDouble(MathRound(LowerSL / TickSize) * TickSize, _Digits);
|
|
|
|
// Take-profit.
|
|
if (ObjectFind(LowerTPLine) > -1)
|
|
{
|
|
if ((ObjectType(LowerTPLine) != OBJ_HLINE) && (ObjectType(LowerTPLine) != OBJ_TREND))
|
|
{
|
|
Alert("Lower TP Line should be either OBJ_HLINE or OBJ_TREND.");
|
|
return "\nWrong Lower TP Line object type.";
|
|
}
|
|
if (ObjectType(LowerTPLine) != OBJ_HLINE) LowerTP = NormalizeDouble(ObjectGetValueByShift(LowerTPLine, 0), Digits);
|
|
else LowerTP = NormalizeDouble(ObjectGet(LowerTPLine, OBJPROP_PRICE1), Digits); // Horizontal line value
|
|
if (UseSpreadAdjustment) LowerTP = NormalizeDouble(LowerTP + MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits);
|
|
ObjectSet(LowerTPLine, OBJPROP_RAY, true);
|
|
c = c + "\nLower take-profit found. Level: " + DoubleToStr(LowerTP, Digits);
|
|
}
|
|
else
|
|
{
|
|
if (ObjectFind(TPChannel) > -1)
|
|
{
|
|
if (ObjectType(TPChannel) != OBJ_CHANNEL)
|
|
{
|
|
Alert("TP Channel should be OBJ_CHANNEL.");
|
|
return "\nWrong TP Channel object type.";
|
|
}
|
|
LowerTP = NormalizeDouble(FindLowerTPViaChannel(), Digits);
|
|
if (UseSpreadAdjustment) LowerTP = NormalizeDouble(LowerTP + MarketInfo(Symbol(), MODE_SPREAD) * Point, Digits);
|
|
ObjectSet(TPChannel, OBJPROP_RAY, true);
|
|
c = c + "\nLower TP found (via channel). Level: " + DoubleToStr(LowerTP, Digits);
|
|
}
|
|
else
|
|
{
|
|
c = c + "\nLower take-profit not found. Take-profit won\'t be applied to new positions.";
|
|
// Track current TP, possibly installed by user.
|
|
if ((OrderSelect(LowerTicket, SELECT_BY_TICKET)) && ((OrderType() == OP_SELLSTOP) || (OrderType() == OP_SELLLIMIT)))
|
|
{
|
|
LowerTP = OrderTakeProfit();
|
|
}
|
|
}
|
|
}
|
|
// Adjust lower TP for tick size granularity.
|
|
LowerTP = NormalizeDouble(MathRound(LowerTP / TickSize) * TickSize, _Digits);
|
|
|
|
return c;
|
|
}
|
|
|
|
// Find SL using a border line - the low of the first bar with major part below border.
|
|
double FindUpperSL()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double SL = -1;
|
|
|
|
// Everything becomes much easier if the EA just needs to find the farthest opposite point of the pattern.
|
|
if (UseDistantSL)
|
|
{
|
|
// Horizontal line.
|
|
if (ObjectType(LowerBorderLine) == OBJ_HLINE)
|
|
{
|
|
return NormalizeDouble(ObjectGetDouble(0, LowerBorderLine, OBJPROP_PRICE1), Digits);
|
|
}
|
|
// Trend line.
|
|
else if (ObjectType(LowerBorderLine) == OBJ_TREND)
|
|
{
|
|
double price1 = ObjectGetDouble(0, LowerBorderLine, OBJPROP_PRICE1);
|
|
double price2 = ObjectGetDouble(0, LowerBorderLine, OBJPROP_PRICE2);
|
|
if (price1 < price2) return NormalizeDouble(price1, Digits);
|
|
else return NormalizeDouble(price2, Digits);
|
|
}
|
|
}
|
|
|
|
// Easy stop-loss via a separate horizontal line when using trendline trading.
|
|
if (OpenOnCloseAboveBelowTrendline)
|
|
{
|
|
if (ObjectFind(0, SLLine) < 0) return -1;
|
|
return NormalizeDouble(ObjectGetDouble(0, SLLine, OBJPROP_PRICE1), Digits);
|
|
}
|
|
|
|
for (int i = 0; i < Bars; i++)
|
|
{
|
|
double Border, Entry;
|
|
if (ObjectType(UpperBorderLine) != OBJ_HLINE) Border = ObjectGetValueByShift(UpperBorderLine, i);
|
|
else Border = ObjectGet(UpperBorderLine, OBJPROP_PRICE1); // Horizontal line value
|
|
if (ObjectType(UpperEntryLine) != OBJ_HLINE) Entry = ObjectGetValueByShift(UpperEntryLine, i);
|
|
else Entry = ObjectGet(UpperEntryLine, OBJPROP_PRICE1); // Horizontal line value
|
|
// Additional condition (Entry) checks whether _current_ candle may still have a bigger part within border before triggering entry.
|
|
// It is not possible if the current height inside border is not bigger than the distance from border to entry.
|
|
// It should not be checked for candles already completed.
|
|
// Additionally, if skipped the first bar because it could not potentially qualify, next bar's Low should be lower or equal to that of the first bar.
|
|
if ((Border - Low[i] > High[i] - Border) && ((Entry - Border < Border - Low[i]) || (i != 0)) && (Low[i] <= Low[0])) return NormalizeDouble(Low[i], Digits);
|
|
}
|
|
|
|
return SL;
|
|
}
|
|
|
|
// Find SL using a border line - the high of the first bar with major part above border.
|
|
double FindLowerSL()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double SL = -1;
|
|
|
|
// Everything becomes much easier if the EA just needs to find the farthest opposite point of the pattern.
|
|
if (UseDistantSL)
|
|
{
|
|
// Horizontal line.
|
|
if (ObjectType(UpperBorderLine) == OBJ_HLINE)
|
|
{
|
|
return NormalizeDouble(ObjectGetDouble(0, UpperBorderLine, OBJPROP_PRICE1), Digits);
|
|
}
|
|
// Trend line.
|
|
else if (ObjectType(UpperBorderLine) == OBJ_TREND)
|
|
{
|
|
double price1 = ObjectGetDouble(0, UpperBorderLine, OBJPROP_PRICE1);
|
|
double price2 = ObjectGetDouble(0, UpperBorderLine, OBJPROP_PRICE2);
|
|
if (price1 > price2) return NormalizeDouble(price1, Digits);
|
|
else return NormalizeDouble(price2, Digits);
|
|
}
|
|
}
|
|
|
|
// Easy stop-loss via a separate horizontal line when using trendline trading.
|
|
if (OpenOnCloseAboveBelowTrendline)
|
|
{
|
|
if (ObjectFind(0, SLLine) < 0) return -1;
|
|
return NormalizeDouble(ObjectGetDouble(0, SLLine, OBJPROP_PRICE1), Digits);
|
|
}
|
|
|
|
for (int i = 0; i < Bars; i++)
|
|
{
|
|
double Border, Entry;
|
|
if (ObjectType(LowerBorderLine) != OBJ_HLINE) Border = ObjectGetValueByShift(LowerBorderLine, i);
|
|
else Border = ObjectGet(LowerBorderLine, OBJPROP_PRICE1); // Horizontal line value
|
|
if (ObjectType(LowerEntryLine) != OBJ_HLINE) Entry = ObjectGetValueByShift(LowerEntryLine, i);
|
|
else Entry = ObjectGet(LowerEntryLine, OBJPROP_PRICE1); // Horizontal line value
|
|
// Additional condition (Entry) checks whether _current_ candle may still have a bigger part within border before triggering entry.
|
|
// It is not possible if the current height inside border is not bigger than the distance from border to entry.
|
|
// It should not be checked for candles already completed.
|
|
// Additionally, if skipped the first bar because it could not potentially qualify, next bar's High should be higher or equal to that of the first bar.
|
|
if ((High[i] - Border > Border - Low[i]) && ((Border - Entry < High[i] - Border) || (i != 0)) && (High[i] >= High[0]))
|
|
{
|
|
return NormalizeDouble(High[i], Digits);
|
|
}
|
|
}
|
|
|
|
return SL;
|
|
}
|
|
|
|
// Find SL using a border channel - the low of the first bar with major part below upper line.
|
|
double FindUpperSLViaChannel()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double SL = -1;
|
|
|
|
// Easy stop-loss via a separate horizontal line when using trendline trading.
|
|
if (OpenOnCloseAboveBelowTrendline)
|
|
{
|
|
if (ObjectFind(0, SLLine) < 0) return -1;
|
|
return NormalizeDouble(ObjectGetDouble(0, SLLine, OBJPROP_PRICE1), Digits);
|
|
}
|
|
|
|
for (int i = 0; i < Bars(_Symbol, _Period); i++)
|
|
{
|
|
// Get the upper of main and auxiliary lines
|
|
double Border = MathMax(ObjectGetValueByTime(0, BorderChannel, Time[i], 0), ObjectGetValueByTime(0, BorderChannel, Time[i], 1));
|
|
|
|
// Additional condition (Entry) checks whether _current_ candle may still have a bigger part within border before triggering entry.
|
|
// It is not possible if the current height inside border is not bigger than the distance from border to entry.
|
|
// It should not be checked for candles already completed.
|
|
// Additionally, if skipped the first bar because it could not potentially qualify, next bar's Low should be lower or equal to that of the first bar.
|
|
if ((Border - Low[i] > High[i] - Border) && ((UpperEntry - Border < Border - Low[i]) || (i != 0)) && (Low[i] <= Low[0])) return(NormalizeDouble(Low[i], _Digits));
|
|
}
|
|
|
|
return(SL);
|
|
}
|
|
|
|
// Find SL using a border channel - the high of the first bar with major part above upper line.
|
|
double FindLowerSLViaChannel()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double SL = -1;
|
|
|
|
// Easy stop-loss via a separate horizontal line when using trendline trading.
|
|
if (OpenOnCloseAboveBelowTrendline)
|
|
{
|
|
if (ObjectFind(0, SLLine) < 0) return(-1);
|
|
return NormalizeDouble(ObjectGetDouble(0, SLLine, OBJPROP_PRICE1), Digits);
|
|
}
|
|
|
|
for (int i = 0; i < Bars(_Symbol, _Period); i++)
|
|
{
|
|
// Get the lower of main and auxiliary lines
|
|
double Border = MathMin(ObjectGetValueByTime(0, BorderChannel, Time[i], 0), ObjectGetValueByTime(0, BorderChannel, Time[i], 1));
|
|
|
|
// Additional condition (Entry) checks whether _current_ candle may still have a bigger part within border before triggering entry.
|
|
// It is not possible if the current height inside border is not bigger than the distance from border to entry.
|
|
// It should not be checked for candles already completed.
|
|
// Additionally, if skipped the first bar because it could not potentially qualify, next bar's High should be higher or equal to that of the first bar.
|
|
if ((High[i] - Border > Border - Low[i]) && ((Border - LowerEntry < High[i] - Border) || (i != 0)) && (High[i] >= High[0])) return(NormalizeDouble(High[i], _Digits));
|
|
}
|
|
|
|
return SL;
|
|
}
|
|
|
|
// Find entry point using the entry channel.
|
|
double FindUpperEntryViaChannel()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double Entry = -1;
|
|
|
|
// Get the upper of main and auxiliary lines
|
|
Entry = MathMax(ObjectGetValueByTime(0, EntryChannel, Time[0], 0), ObjectGetValueByTime(0, EntryChannel, Time[0], 1));
|
|
|
|
return NormalizeDouble(Entry, _Digits);
|
|
}
|
|
|
|
// Find entry point using the entry channel.
|
|
double FindLowerEntryViaChannel()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double Entry = -1;
|
|
|
|
// Get the lower of main and auxiliary lines
|
|
Entry = MathMin(ObjectGetValueByTime(0, EntryChannel, Time[0], 0), ObjectGetValueByTime(0, EntryChannel, Time[0], 1));
|
|
|
|
return NormalizeDouble(Entry, _Digits);
|
|
}
|
|
|
|
// Find TP using the TP channel.
|
|
double FindUpperTPViaChannel()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double TP = -1;
|
|
|
|
// Get the upper of main and auxiliary lines.
|
|
TP = MathMax(ObjectGetValueByTime(0, TPChannel, Time[0], 0), ObjectGetValueByTime(0, TPChannel, Time[0], 1));
|
|
|
|
return NormalizeDouble(TP, _Digits);
|
|
}
|
|
|
|
// Find TP using the TP channel.
|
|
double FindLowerTPViaChannel()
|
|
{
|
|
// Invalid value will prevent order from executing in case something goes wrong.
|
|
double TP = -1;
|
|
|
|
// Get the lower of main and auxiliary lines.
|
|
TP = MathMin(ObjectGetValueByTime(0, TPChannel, Time[0], 0), ObjectGetValueByTime(0, TPChannel, Time[0], 1));
|
|
return NormalizeDouble(TP, _Digits);
|
|
}
|
|
|
|
void AdjustOrders()
|
|
{
|
|
AdjustObjects(); // Rename objects if pending orders got executed.
|
|
AdjustUpperAndLowerOrders();
|
|
}
|
|
|
|
// Sets flags according to found pending orders and positions.
|
|
void FindOrders()
|
|
{
|
|
HaveBuyPending = false;
|
|
HaveSellPending = false;
|
|
HaveBuy = false;
|
|
HaveSell = false;
|
|
for (int i = 0; i < OrdersTotal(); i++)
|
|
{
|
|
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) == false) continue;
|
|
if (((OrderType() == OP_BUYSTOP) || (OrderType() == OP_BUYLIMIT)) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic))
|
|
{
|
|
HaveBuyPending = true;
|
|
UpperTicket = OrderTicket();
|
|
}
|
|
else if (((OrderType() == OP_SELLSTOP) || (OrderType() == OP_SELLLIMIT)) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic))
|
|
{
|
|
HaveSellPending = true;
|
|
LowerTicket = OrderTicket();
|
|
}
|
|
else if ((OrderType() == OP_BUY) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic)) HaveBuy = true;
|
|
else if ((OrderType() == OP_SELL) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic)) HaveSell = true;
|
|
}
|
|
}
|
|
|
|
// Renaming objects prevents new position opening.
|
|
void AdjustObjects()
|
|
{
|
|
if (((HaveBuy) && (!HaveBuyPending)))
|
|
{
|
|
if ((ObjectFind(0, UpperBorderLine) >= 0) || (ObjectFind(0, EntryChannel) >= 0))
|
|
{
|
|
Print("Buy position found, renaming chart objects...");
|
|
RenameObject(UpperBorderLine);
|
|
RenameObject(UpperEntryLine);
|
|
RenameObject(EntryChannel);
|
|
}
|
|
if (OneCancelsOther)
|
|
{
|
|
if ((ObjectFind(0, LowerBorderLine) >= 0) || (ObjectFind(0, BorderChannel) >= 0))
|
|
{
|
|
Print("OCO is on, renaming opposite chart objects...");
|
|
RenameObject(LowerBorderLine);
|
|
RenameObject(LowerEntryLine);
|
|
RenameObject(BorderChannel);
|
|
}
|
|
}
|
|
}
|
|
if (((HaveSell) && (!HaveSellPending)))
|
|
{
|
|
if ((ObjectFind(0, LowerEntryLine) >= 0) || (ObjectFind(0, EntryChannel) >= 0))
|
|
{
|
|
Print("Sell position found, renaming chart objects...");
|
|
RenameObject(LowerBorderLine);
|
|
RenameObject(LowerEntryLine);
|
|
RenameObject(EntryChannel);
|
|
}
|
|
if (OneCancelsOther)
|
|
{
|
|
if ((ObjectFind(0, UpperBorderLine) >= 0) || (ObjectFind(0, BorderChannel) >= 0))
|
|
{
|
|
Print("OCO is on, renaming opposite chart objects...");
|
|
RenameObject(UpperBorderLine);
|
|
RenameObject(UpperEntryLine);
|
|
RenameObject(BorderChannel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenameObject(string Object)
|
|
{
|
|
if (ObjectFind(0, Object) > -1) // If exists
|
|
{
|
|
Print("Renaming ", Object, ".");
|
|
// Get object's type, price/time coordinates, style properties.
|
|
ENUM_OBJECT OT = (ENUM_OBJECT)ObjectGetInteger(0, Object, OBJPROP_TYPE);
|
|
double Price1 = ObjectGetDouble(0, Object, OBJPROP_PRICE, 0);
|
|
datetime Time1 = 0;
|
|
double Price2 = 0;
|
|
datetime Time2 = 0;
|
|
double Price3 = 0;
|
|
datetime Time3 = 0;
|
|
if ((OT == OBJ_TREND) || (OT == OBJ_CHANNEL))
|
|
{
|
|
Time1 = (datetime)ObjectGetInteger(0, Object, OBJPROP_TIME, 0);
|
|
Price2 = ObjectGetDouble(0, Object, OBJPROP_PRICE, 1);
|
|
Time2 = (datetime)ObjectGetInteger(0, Object, OBJPROP_TIME, 1);
|
|
if (OT == OBJ_CHANNEL)
|
|
{
|
|
Price3 = ObjectGetDouble(0, Object, OBJPROP_PRICE, 2);
|
|
Time3 = (datetime)ObjectGetInteger(0, Object, OBJPROP_TIME, 2);
|
|
}
|
|
}
|
|
color Color = (color)ObjectGetInteger(0, Object, OBJPROP_COLOR);
|
|
ENUM_LINE_STYLE Style = (ENUM_LINE_STYLE)ObjectGetInteger(0, Object, OBJPROP_STYLE);
|
|
int Width = (int)ObjectGetInteger(0, Object, OBJPROP_WIDTH);
|
|
|
|
// Delete object.
|
|
ObjectDelete(0, Object);
|
|
string NewObject = Object + IntegerToString(Magic);
|
|
// Create the same object with new name and set the old style properties.
|
|
ObjectCreate(0, NewObject, OT, 0, Time1, Price1, Time2, Price2, Time3, Price3);
|
|
ObjectSetInteger(0, NewObject, OBJPROP_COLOR, Color);
|
|
ObjectSetInteger(0, NewObject, OBJPROP_STYLE, Style);
|
|
ObjectSetInteger(0, NewObject, OBJPROP_WIDTH, Width);
|
|
ObjectSetInteger(0, NewObject, OBJPROP_RAY, true);
|
|
}
|
|
}
|
|
|
|
// The main trading procedure. Sends, Modifies and Deletes orders.
|
|
void AdjustUpperAndLowerOrders()
|
|
{
|
|
double NewVolume;
|
|
int last_error;
|
|
datetime expiration;
|
|
int order_type;
|
|
string order_type_string;
|
|
|
|
if ((!IsTradeAllowed()) || (IsTradeContextBusy()) || (!IsConnected()) || (!MarketInfo(Symbol(), MODE_TRADEALLOWED)))
|
|
{
|
|
if (!TCBusy) Output("Trading context is busy or disconnected.");
|
|
TCBusy = true;
|
|
return;
|
|
}
|
|
else if (TCBusy)
|
|
{
|
|
Output("Trading context is no longer busy or disconnected.");
|
|
TCBusy = false;
|
|
}
|
|
|
|
double StopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
|
|
double FreezeLevel = MarketInfo(Symbol(), MODE_FREEZELEVEL) * Point;
|
|
double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
|
|
int LotStep_digits = CountDecimalPlaces(LotStep);
|
|
|
|
if (UseExpiration)
|
|
{
|
|
// Set expiration to the end of the current bar.
|
|
expiration = Time[0] + Period() * 60;
|
|
// If expiration is less than 11 minutes from now, set it to at least 11 minutes from now.
|
|
// (Brokers have such limit.)
|
|
if (expiration - TimeCurrent() < 660) expiration = TimeCurrent() + 660;
|
|
}
|
|
else expiration = 0;
|
|
|
|
if (OpenOnCloseAboveBelowTrendline) // Simple case.
|
|
{
|
|
double BorderLevel;
|
|
if ((LowerTP > 0) && (!HaveSell) && (UseLower)) // SELL.
|
|
{
|
|
if (ObjectFind(0, LowerBorderLine) >= 0) // Line.
|
|
{
|
|
if (ObjectGetInteger(ChartID(), LowerBorderLine, OBJPROP_TYPE) == OBJ_HLINE) BorderLevel = NormalizeDouble(ObjectGetDouble(0, LowerBorderLine, OBJPROP_PRICE1), _Digits);
|
|
else BorderLevel = NormalizeDouble(ObjectGetValueByShift(LowerBorderLine, 1), _Digits);
|
|
}
|
|
else // Channel
|
|
{
|
|
BorderLevel = MathMin(ObjectGetValueByTime(0, BorderChannel, Time[1], 0), ObjectGetValueByTime(0, BorderChannel, Time[1], 1));
|
|
}
|
|
BorderLevel = NormalizeDouble(MathRound(BorderLevel / TickSize) * TickSize, _Digits);
|
|
|
|
// Previous candle close significantly lower than the border line.
|
|
if (BorderLevel - Close[1] >= SymbolInfoInteger(Symbol(), SYMBOL_SPREAD) * _Point * ThresholdSpreads)
|
|
{
|
|
RefreshRates();
|
|
NewVolume = GetPositionSize(Bid, LowerSL);
|
|
LowerTicket = ExecuteMarketOrder(OP_SELL, NewVolume, Bid, LowerSL, LowerTP);
|
|
}
|
|
}
|
|
else if ((UpperTP > 0) && (!HaveBuy) && (UseUpper)) // BUY.
|
|
{
|
|
if (ObjectFind(0, UpperBorderLine) >= 0) // Line.
|
|
{
|
|
if (ObjectGetInteger(ChartID(), UpperBorderLine, OBJPROP_TYPE) == OBJ_HLINE) BorderLevel = NormalizeDouble(ObjectGetDouble(0, UpperBorderLine, OBJPROP_PRICE1), _Digits);
|
|
else BorderLevel = NormalizeDouble(ObjectGetValueByShift(UpperBorderLine, 1), _Digits);
|
|
}
|
|
else // Channel
|
|
{
|
|
BorderLevel = MathMax(ObjectGetValueByTime(0, BorderChannel, Time[1], 0), ObjectGetValueByTime(0, BorderChannel, Time[1], 1));
|
|
}
|
|
BorderLevel = NormalizeDouble(MathRound(BorderLevel / TickSize) * TickSize, _Digits);
|
|
|
|
// Previous candle close significantly higher than the border line.
|
|
if (Close[1] - BorderLevel >= SymbolInfoInteger(Symbol(), SYMBOL_SPREAD) * _Point * ThresholdSpreads)
|
|
{
|
|
RefreshRates();
|
|
NewVolume = GetPositionSize(Ask, UpperSL);
|
|
UpperTicket = ExecuteMarketOrder(OP_BUY, NewVolume, Ask, UpperSL, UpperTP);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
int OT = OrdersTotal();
|
|
for (int i = OT - 1; i >= 0; i--)
|
|
{
|
|
double prevOrderOpenPrice, prevOrderStopLoss, prevOrderTakeProfit;
|
|
double SL;
|
|
if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
|
|
RefreshRates();
|
|
// BUY
|
|
if (((OrderType() == OP_BUYSTOP) || (OrderType() == OP_BUYLIMIT)) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic) && (!DisableBuyOrders))
|
|
{
|
|
// Current price is below Sell entry - pending Sell Limit will be used instead of two stop orders.
|
|
if ((LowerEntry - Bid > StopLevel) && (UseLower)) continue;
|
|
|
|
NewVolume = GetPositionSize(UpperEntry, UpperSL);
|
|
// Delete existing pending order
|
|
if ((HaveBuy) || ((HaveSell) && (OneCancelsOther)) || (!UseUpper))
|
|
{
|
|
if (!OrderDelete(OrderTicket()))
|
|
{
|
|
last_error = GetLastError();
|
|
Output("OrderDelete() error. Order ticket = " + IntegerToString(OrderTicket()) + ". Error = " + IntegerToString(last_error));
|
|
}
|
|
}
|
|
// If volume needs to be updated - delete and recreate order with new volume.
|
|
// Also check if EA will be able to create new pending order at current price.
|
|
else if ((UpdatePendingVolume) && (MathAbs(OrderLots() - NewVolume) > LotStep / 2))
|
|
{
|
|
if ((UpperEntry - Ask > StopLevel) || (Ask - UpperEntry > StopLevel)) // Order can be re-created.
|
|
{
|
|
if (!OrderDelete(OrderTicket()))
|
|
{
|
|
last_error = GetLastError();
|
|
Output("OrderDelete() error. Order ticket = " + IntegerToString(OrderTicket()) + ". Error = " + IntegerToString(last_error));
|
|
}
|
|
Sleep(5000); // Wait 5 seconds before opening a new order.
|
|
}
|
|
else continue;
|
|
// Ask could change after deletion, check if there is still no error 130 present.
|
|
RefreshRates();
|
|
if (UpperEntry - Ask > StopLevel) // Current price below entry.
|
|
{
|
|
order_type = OP_BUYSTOP;
|
|
order_type_string = "Stop";
|
|
}
|
|
else if (Ask - UpperEntry > StopLevel) // Current price above entry.
|
|
{
|
|
order_type = OP_BUYLIMIT;
|
|
order_type_string = "Limit";
|
|
}
|
|
else continue;
|
|
if (UseExpiration)
|
|
{
|
|
// Set expiration to the end of the current bar.
|
|
expiration = Time[0] + Period() * 60;
|
|
// If expiration is less than 11 minutes extra seconds from now, set it to at least 11 minutes from now.
|
|
// (Brokers have such limit.)
|
|
if (expiration - TimeCurrent() < 660) expiration = TimeCurrent() + 661;
|
|
}
|
|
else expiration = 0;
|
|
UpperTicket = OrderSend(Symbol(), order_type, NewVolume, UpperEntry, Slippage, UpperSL, UpperTP, "ChartPatternHelper", Magic, expiration);
|
|
last_error = GetLastError();
|
|
if ((UpperTicket == -1) && (last_error != 128)) // Ignore time-out errors.
|
|
{
|
|
Output("StopLevel = " + DoubleToStr(StopLevel, 8));
|
|
Output("FreezeLevel = " + DoubleToStr(FreezeLevel, 8));
|
|
Output("Error Recreating Buy " + order_type_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("Volume = " + DoubleToStr(NewVolume, LotStep_digits) + " Entry = " + DoubleToStr(UpperEntry, Digits) + " SL = " + DoubleToStr(UpperSL, Digits) + " TP = " + DoubleToStr(UpperTP, Digits) + " Bid/Ask = " + DoubleToStr(Bid, Digits) + "/" + DoubleToStr(Ask, Digits) + " Exp: " + TimeToStr(expiration, TIME_DATE | TIME_SECONDS));
|
|
}
|
|
continue;
|
|
}
|
|
// Otherwise, update entry/SL/TP if at least one of them has changed.
|
|
else if ((MathAbs(OrderOpenPrice() - UpperEntry) > _Point / 2) || (MathAbs(OrderStopLoss() - UpperSL) > _Point / 2) || (MathAbs(OrderTakeProfit() - UpperTP) > _Point / 2))
|
|
{
|
|
// Avoid error 130 based on entry.
|
|
if (UpperEntry - Ask > StopLevel) // Current price below entry.
|
|
{
|
|
order_type_string = "Stop";
|
|
}
|
|
else if (Ask - UpperEntry > StopLevel) // Current price above entry.
|
|
{
|
|
order_type_string = "Limit";
|
|
}
|
|
else if (MathAbs(OrderOpenPrice() - UpperEntry) > _Point / 2) continue;
|
|
// Avoid error 130 based on stop-loss.
|
|
if (UpperEntry - UpperSL <= StopLevel)
|
|
{
|
|
Output("Skipping Modify Buy " + order_type_string + " because stop-loss is too close to entry. StopLevel = " + DoubleToStr(StopLevel, Digits) + " Entry = " + DoubleToStr(UpperEntry, Digits) + " SL = " + DoubleToStr(UpperSL, Digits));
|
|
continue;
|
|
}
|
|
// Avoid frozen context. In all modification cases.
|
|
if ((FreezeLevel != 0) && (MathAbs(OrderOpenPrice() - Ask) <= FreezeLevel))
|
|
{
|
|
Output("Skipping Modify Buy " + order_type_string + " because open price is too close to Ask. FreezeLevel = " + DoubleToStr(FreezeLevel, Digits) + " OpenPrice = " + DoubleToStr(OrderOpenPrice(), Digits) + " Ask = " + DoubleToStr(Ask, Digits));
|
|
continue;
|
|
}
|
|
if (UseExpiration)
|
|
{
|
|
expiration = OrderExpiration();
|
|
if (expiration - TimeCurrent() < 660) expiration = TimeCurrent() + 660;
|
|
}
|
|
else expiration = 0;
|
|
prevOrderOpenPrice = OrderOpenPrice();
|
|
prevOrderStopLoss = OrderStopLoss();
|
|
prevOrderTakeProfit = OrderTakeProfit();
|
|
if (!OrderModify(OrderTicket(), UpperEntry, UpperSL, UpperTP, expiration))
|
|
{
|
|
last_error = GetLastError();
|
|
if (last_error != 128) // Ignore time out errors.
|
|
{
|
|
if (last_error == 1)
|
|
{
|
|
Output("PREV: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " SL = " + DoubleToStr(OrderStopLoss(), Digits) + " TP = " + DoubleToStr(OrderTakeProfit(), Digits));
|
|
}
|
|
Output("StopLevel = " + DoubleToStr(StopLevel, 8));
|
|
Output("FreezeLevel = " + DoubleToStr(FreezeLevel, 8));
|
|
Output("Error Modifying Buy " + order_type_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("FROM: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " SL = " + DoubleToStr(OrderStopLoss(), Digits) + " TP = " + DoubleToStr(OrderTakeProfit(), Digits) + " -> TO: Entry = " + DoubleToStr(UpperEntry, 8) + " SL = " + DoubleToStr(UpperSL, 8) + " TP = " + DoubleToStr(UpperTP, 8) + " Bid/Ask = " + DoubleToStr(Bid, Digits) + "/" + DoubleToStr(Ask, Digits) + " OrderTicket = " + IntegerToString(OrderTicket()) + " OrderExpiration = " + TimeToStr(OrderExpiration(), TIME_DATE | TIME_SECONDS) + " -> " + TimeToStr(expiration, TIME_DATE | TIME_SECONDS));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((OrderType() == OP_BUY) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic) && (!DisableBuyOrders))
|
|
{
|
|
// PostEntrySLAdjustment - a procedure to correct SL if breakout candle become too long and no longer qualifies for SL rule.
|
|
if ((OrderOpenTime() > Time[1]) && (OrderOpenTime() < Time[0]) && (PostEntrySLAdjustment) && (PostBuySLAdjustmentDone == false))
|
|
{
|
|
SL = AdjustPostBuySL();
|
|
if (SL != -1)
|
|
{
|
|
// Avoid frozen context. In all modification cases.
|
|
if ((FreezeLevel != 0) && (MathAbs(OrderOpenPrice() - Ask) <= FreezeLevel))
|
|
{
|
|
Output("Skipping Modify Buy Stop SL because open price is too close to Ask. FreezeLevel = " + DoubleToStr(FreezeLevel, Digits) + " OpenPrice = " + DoubleToStr(OrderOpenPrice(), 8) + " Ask = " + DoubleToStr(Ask, Digits));
|
|
continue;
|
|
}
|
|
if (NormalizeDouble(SL, Digits) == NormalizeDouble(OrderStopLoss(), Digits)) PostBuySLAdjustmentDone = true;
|
|
else
|
|
{
|
|
if (!OrderModify(OrderTicket(), OrderOpenPrice(), SL, OrderTakeProfit(), OrderExpiration()))
|
|
{
|
|
last_error = GetLastError();
|
|
if (last_error != 128) // Ignore time out errors.
|
|
{
|
|
Output("Error Modifying Buy SL: " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("FROM: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " SL = " + DoubleToStr(OrderStopLoss(), Digits) + " -> TO: Entry = " + DoubleToStr(OrderOpenPrice(), 8) + " SL = " + DoubleToStr(SL, 8) + " Ask = " + DoubleToStr(Ask, Digits));
|
|
}
|
|
}
|
|
else PostBuySLAdjustmentDone = true;
|
|
}
|
|
}
|
|
}
|
|
// Adjust TP only.
|
|
if (MathAbs(OrderTakeProfit() - UpperTP) > _Point / 2)
|
|
{
|
|
// Avoid frozen context. In all modification cases.
|
|
if ((FreezeLevel != 0) && (MathAbs(OrderOpenPrice() - Ask) <= FreezeLevel))
|
|
{
|
|
Output("Skipping Modify Buy Stop TP because open price is too close to Ask. FreezeLevel = " + DoubleToStr(FreezeLevel, Digits) + " OpenPrice = " + DoubleToStr(OrderOpenPrice(), 8) + " Ask = " + DoubleToStr(Ask, Digits));
|
|
continue;
|
|
}
|
|
if (!OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), UpperTP, OrderExpiration()))
|
|
{
|
|
last_error = GetLastError();
|
|
if (last_error != 128) // Ignore time out errors.
|
|
{
|
|
Output("Error Modifying Buy TP: " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("FROM: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " TP = " + DoubleToStr(OrderTakeProfit(), Digits) + " -> TO: Entry = " + DoubleToStr(OrderOpenPrice(), 8) + " TP = " + DoubleToStr(UpperTP, 8) + " Ask = " + DoubleToStr(Ask, Digits));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// SELL
|
|
else if (((OrderType() == OP_SELLSTOP) || (OrderType() == OP_SELLLIMIT)) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic) && (!DisableSellOrders))
|
|
{
|
|
// Current price is above Buy entry - pending Buy Limit will be used instead of two stop orders.
|
|
if ((Ask - UpperEntry > StopLevel) && (UseUpper)) continue;
|
|
|
|
NewVolume = GetPositionSize(LowerEntry, LowerSL);
|
|
// Delete existing pending order.
|
|
if (((HaveBuy) && (OneCancelsOther)) || (HaveSell) || (!UseLower))
|
|
{
|
|
if (!OrderDelete(OrderTicket()))
|
|
{
|
|
last_error = GetLastError();
|
|
Output("OrderDelete() error. Order ticket = " + IntegerToString(OrderTicket()) + ". Error = " + IntegerToString(last_error));
|
|
}
|
|
}
|
|
// If volume needs to be updated - delete and recreate order with new volume. Also check if EA will be able to create new pending order at current price.
|
|
else if ((UpdatePendingVolume) && (MathAbs(OrderLots() - NewVolume) > LotStep / 2))
|
|
{
|
|
if ((Bid - LowerEntry > StopLevel) || (LowerEntry - Bid > StopLevel)) // Order can be re-created
|
|
{
|
|
if (!OrderDelete(OrderTicket()))
|
|
{
|
|
last_error = GetLastError();
|
|
Output("OrderDelete() error. Order ticket = " + IntegerToString(OrderTicket()) + ". Error = " + IntegerToString(last_error));
|
|
}
|
|
}
|
|
else continue;
|
|
|
|
// Bid could change after deletion, check if there is still no error 130 present.
|
|
RefreshRates();
|
|
if (Bid - LowerEntry > StopLevel) // Current price above entry.
|
|
{
|
|
order_type = OP_BUYSTOP;
|
|
order_type_string = "Stop";
|
|
}
|
|
else if (LowerEntry - Bid > StopLevel) // Current price below entry.
|
|
{
|
|
order_type = OP_BUYLIMIT;
|
|
order_type_string = "Limit";
|
|
}
|
|
else continue;
|
|
if (UseExpiration)
|
|
{
|
|
// Set expiration to the end of the current bar.
|
|
expiration = Time[0] + Period() * 60;
|
|
// If expiration is less than 11 minutes extra seconds from now, set it to at least 11 minutes from now.
|
|
// (Brokers have such limit.)
|
|
if (expiration - TimeCurrent() < 660) expiration = TimeCurrent() + 661;
|
|
}
|
|
else expiration = 0;
|
|
LowerTicket = OrderSend(Symbol(), order_type, NewVolume, LowerEntry, Slippage, LowerSL, LowerTP, "ChartPatternHelper", Magic, expiration);
|
|
last_error = GetLastError();
|
|
if ((LowerTicket == -1) && (last_error != 128)) // Ignore time-out errors.
|
|
{
|
|
Output("StopLevel = " + DoubleToStr(StopLevel, 8));
|
|
Output("FreezeLevel = " + DoubleToStr(FreezeLevel, 8));
|
|
Output("Error Recreating Sell " + order_type_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("Volume = " + DoubleToStr(NewVolume, LotStep_digits) + " Entry = " + DoubleToStr(LowerEntry, Digits) + " SL = " + DoubleToStr(LowerSL, Digits) + " TP = " + DoubleToStr(LowerTP, Digits) + " Bid/Ask = " + DoubleToStr(Bid, Digits) + "/" + DoubleToStr(Ask, Digits) + " Exp: " + TimeToStr(expiration, TIME_DATE | TIME_SECONDS));
|
|
}
|
|
continue;
|
|
}
|
|
// Otherwise, just update what needs to be updated.
|
|
else if ((MathAbs(OrderOpenPrice() - LowerEntry) > _Point / 2) || (MathAbs(OrderStopLoss() - LowerSL) > _Point / 2) || (MathAbs(OrderTakeProfit() - LowerTP) > _Point / 2))
|
|
{
|
|
// Avoid error 130 based on entry.
|
|
if (Bid - LowerEntry > StopLevel) // Current price above entry.
|
|
{
|
|
order_type_string = "Stop";
|
|
}
|
|
else if (LowerEntry - Bid > StopLevel) // Current price below entry.
|
|
{
|
|
order_type_string = "Limit";
|
|
}
|
|
else if (MathAbs(OrderOpenPrice() - LowerEntry) > _Point / 2) continue;
|
|
// Avoid error 130 based on stop-loss.
|
|
if (LowerSL - LowerEntry <= StopLevel)
|
|
{
|
|
Output("Skipping Modify Sell " + order_type_string + " because stop-loss is too close to entry. StopLevel = " + DoubleToStr(StopLevel, Digits) + " Entry = " + DoubleToStr(LowerEntry, Digits) + " SL = " + DoubleToStr(LowerSL, Digits));
|
|
continue;
|
|
}
|
|
// Avoid frozen context. In all modification cases.
|
|
if ((FreezeLevel != 0) && (MathAbs(Bid - OrderOpenPrice()) <= FreezeLevel))
|
|
{
|
|
Output("Skipping Modify Sell " + order_type_string + " because open price is too close to Bid. FreezeLevel = " + DoubleToStr(FreezeLevel, Digits) + " OpenPrice = " + DoubleToStr(OrderOpenPrice(), Digits) + " Bid = " + DoubleToStr(Bid, Digits));
|
|
continue;
|
|
}
|
|
if (UseExpiration)
|
|
{
|
|
expiration = OrderExpiration();
|
|
if (expiration - TimeCurrent() < 660) expiration = TimeCurrent() + 660;
|
|
}
|
|
else expiration = 0;
|
|
prevOrderOpenPrice = OrderOpenPrice();
|
|
prevOrderStopLoss = OrderStopLoss();
|
|
prevOrderTakeProfit = OrderTakeProfit();
|
|
if (!OrderModify(OrderTicket(), LowerEntry, LowerSL, LowerTP, expiration))
|
|
{
|
|
last_error = GetLastError();
|
|
if (last_error != 128) // Ignore time out errors.
|
|
{
|
|
if (last_error == 1)
|
|
{
|
|
Output("PREV: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " SL = " + DoubleToStr(OrderStopLoss(), Digits) + " TP = " + DoubleToStr(OrderTakeProfit(), Digits));
|
|
}
|
|
Output("StopLevel = " + DoubleToStr(StopLevel, 8));
|
|
Output("FreezeLevel = " + DoubleToStr(FreezeLevel, 8));
|
|
Output("Error Modifying Sell " + order_type_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("FROM: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " SL = " + DoubleToStr(OrderStopLoss(), Digits) + " TP = " + DoubleToStr(OrderTakeProfit(), Digits) + " -> TO: Entry = " + DoubleToStr(LowerEntry, 8) + " SL = " + DoubleToStr(LowerSL, 8) + " TP = " + DoubleToStr(LowerTP, 8) + " Bid/Ask = " + DoubleToStr(Bid, Digits) + "/" + DoubleToStr(Ask, Digits) + " OrderTicket = " + IntegerToString(OrderTicket()) + " OrderExpiration = " + TimeToStr(OrderExpiration(), TIME_DATE | TIME_SECONDS) + " -> " + TimeToStr(expiration, TIME_DATE | TIME_SECONDS));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((OrderType() == OP_SELL) && (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic) && (!DisableSellOrders))
|
|
{
|
|
// PostEntrySLAdjustment - a procedure to correct SL if breakout candle become too long and no longer qualifies for SL rule.
|
|
if ((OrderOpenTime() > Time[1]) && (OrderOpenTime() < Time[0]) && (PostEntrySLAdjustment) && (PostSellSLAdjustmentDone == false))
|
|
{
|
|
SL = AdjustPostSellSL();
|
|
if (SL != -1)
|
|
{
|
|
// Avoid frozen context. In all modification cases.
|
|
if ((FreezeLevel != 0) && (MathAbs(Bid - OrderOpenPrice()) <= FreezeLevel))
|
|
{
|
|
Output("Skipping Modify Sell Stop SL because open price is too close to Bid. FreezeLevel = " + DoubleToStr(FreezeLevel, Digits) + " OpenPrice = " + DoubleToStr(OrderOpenPrice(), 8) + " Bid = " + DoubleToStr(Bid, Digits));
|
|
continue;
|
|
}
|
|
if (NormalizeDouble(SL, Digits) == NormalizeDouble(OrderStopLoss(), Digits)) PostSellSLAdjustmentDone = true;
|
|
else
|
|
{
|
|
if (!OrderModify(OrderTicket(), OrderOpenPrice(), SL, OrderTakeProfit(), OrderExpiration()))
|
|
{
|
|
last_error = GetLastError();
|
|
if (last_error != 128) // Ignore time out errors.
|
|
{
|
|
Output("Error Modifying Sell SL: " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("FROM: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " SL = " + DoubleToStr(OrderStopLoss(), Digits) + " -> TO: Entry = " + DoubleToStr(OrderOpenPrice(), 8) + " SL = " + DoubleToStr(SL, 8) + " Bid = " + DoubleToStr(Bid, Digits));
|
|
}
|
|
}
|
|
else PostSellSLAdjustmentDone = true;
|
|
}
|
|
}
|
|
}
|
|
// Adjust TP only.
|
|
if (MathAbs(OrderTakeProfit() - LowerTP) > _Point / 2)
|
|
{
|
|
// Avoid frozen context. In all modification cases.
|
|
if ((FreezeLevel != 0) && (MathAbs(Bid - OrderOpenPrice()) <= FreezeLevel))
|
|
{
|
|
Output("Skipping Modify Sell Stop TP because open price is too close to Bid. FreezeLevel = " + DoubleToStr(FreezeLevel, Digits) + " OpenPrice = " + DoubleToStr(OrderOpenPrice(), 8) + " Bid = " + DoubleToStr(Bid, Digits));
|
|
continue;
|
|
}
|
|
if (!OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), LowerTP, OrderExpiration()))
|
|
{
|
|
last_error = GetLastError();
|
|
if (last_error != 128) // Ignore time out errors.
|
|
{
|
|
Output("Error Modifying Sell Stop TP: " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("FROM: Entry = " + DoubleToStr(OrderOpenPrice(), Digits) + " TP = " + DoubleToStr(OrderTakeProfit(), Digits) + " -> TO: Entry = " + DoubleToStr(OrderOpenPrice(), 8) + " TP = " + DoubleToStr(LowerTP, 8) + " Bid = " + DoubleToStr(Bid, Digits));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// BUY
|
|
// If we do not already have Long position or Long pending order and if we can enter Long
|
|
// and the current price is not below the Sell entry (in that case, only pending Sell Limit order will be used).
|
|
if ((!HaveBuy) && (!HaveBuyPending) && (UseUpper) && ((LowerEntry - Bid <= StopLevel) || (!UseLower)))
|
|
{
|
|
// Avoid error 130 based on stop-loss.
|
|
if (UpperEntry - UpperSL <= StopLevel)
|
|
{
|
|
Output("Skipping Send Pending Buy because stop-loss is too close to entry. StopLevel = " + DoubleToStr(StopLevel, Digits) + " Entry = " + DoubleToStr(UpperEntry, Digits) + " SL = " + DoubleToStr(UpperSL, Digits));
|
|
}
|
|
else
|
|
{
|
|
if (UpperEntry - Ask > StopLevel) // Current price below entry.
|
|
{
|
|
order_type = OP_BUYSTOP;
|
|
order_type_string = "Stop";
|
|
}
|
|
else if (Ask - UpperEntry > StopLevel) // Current price above entry.
|
|
{
|
|
order_type = OP_BUYLIMIT;
|
|
order_type_string = "Limit";
|
|
}
|
|
else
|
|
{
|
|
order_type = -1;
|
|
Output("Skipping Send Pending Buy because entry is too close to Ask. StopLevel = " + DoubleToStr(StopLevel, Digits) + " Entry = " + DoubleToStr(UpperEntry, Digits) + " Ask = " + DoubleToStr(Ask, Digits));
|
|
}
|
|
if (order_type > -1)
|
|
{
|
|
NewVolume = GetPositionSize(UpperEntry, UpperSL);
|
|
UpperTicket = OrderSend(Symbol(), order_type, NewVolume, UpperEntry, Slippage, UpperSL, UpperTP, "ChartPatternHelper", Magic, expiration);
|
|
last_error = GetLastError();
|
|
if ((UpperTicket == -1) && (last_error != 128)) // Ignore time-out errors
|
|
{
|
|
Output("Error Sending Buy " + order_type_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("Volume = " + DoubleToStr(NewVolume, LotStep_digits) + " Entry = " + DoubleToStr(UpperEntry, Digits) + " SL = " + DoubleToStr(UpperSL, Digits) + " TP = " + DoubleToStr(UpperTP, Digits) + " Ask = " + DoubleToStr(Ask, Digits) + " Exp: " + TimeToStr(expiration, TIME_DATE | TIME_SECONDS));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// SELL
|
|
// If we do not already have Short position or Short pending order and if we can enter Short
|
|
// and the current price is not above the Buy entry (in that case, only pending Buy Limit order will be used).
|
|
if ((!HaveSell) && (!HaveSellPending) && (UseLower) && ((Ask - UpperEntry <= StopLevel) || (!UseUpper)))
|
|
{
|
|
// Avoid error 130 based on stop-loss.
|
|
if (LowerSL - LowerEntry <= StopLevel)
|
|
{
|
|
Output("Skipping Send Pending Sell because stop-loss is too close to entry. StopLevel = " + DoubleToStr(StopLevel, Digits) + " Entry = " + DoubleToStr(LowerEntry, Digits) + " SL = " + DoubleToStr(LowerSL, Digits));
|
|
}
|
|
else
|
|
{
|
|
if (Bid - LowerEntry > StopLevel) // Current price above entry.
|
|
{
|
|
order_type = OP_SELLSTOP;
|
|
order_type_string = "Stop";
|
|
}
|
|
else if (LowerEntry - Bid > StopLevel) // Current price below entry.
|
|
{
|
|
order_type = OP_SELLLIMIT;
|
|
order_type_string = "Limit";
|
|
}
|
|
else
|
|
{
|
|
order_type = -1;
|
|
Output("Skipping Send Pending Sell because entry is too close to Bid. StopLevel = " + DoubleToStr(StopLevel, Digits) + " Entry = " + DoubleToStr(LowerEntry, Digits) + " Bid = " + DoubleToStr(Bid, Digits));
|
|
}
|
|
if (order_type > -1)
|
|
{
|
|
NewVolume = GetPositionSize(LowerEntry, LowerSL);
|
|
LowerTicket = OrderSend(Symbol(), order_type, NewVolume, LowerEntry, Slippage, LowerSL, LowerTP, "ChartPatternHelper", Magic, expiration);
|
|
last_error = GetLastError();
|
|
if ((LowerTicket == -1) && (last_error != 128)) // Ignore time-out errors
|
|
{
|
|
Output("Error Sending Sell " + order_type_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("Volume = " + DoubleToStr(NewVolume, LotStep_digits) + " Entry = " + DoubleToStr(LowerEntry, Digits) + " SL = " + DoubleToStr(LowerSL, Digits) + " TP = " + DoubleToStr(LowerTP, Digits) + " Bid = " + DoubleToStr(Bid, Digits) + " Exp: " + TimeToStr(expiration, TIME_DATE | TIME_SECONDS));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetComment(string c)
|
|
{
|
|
if (!Silent) Comment(c);
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------------------+
|
|
//| Calculates necessary adjustments for cases when ProfitCurrency != AccountCurrency.|
|
|
//+-----------------------------------------------------------------------------------+
|
|
#define FOREX_SYMBOLS_ONLY 0
|
|
#define NONFOREX_SYMBOLS_ONLY 1
|
|
double CalculateAdjustment()
|
|
{
|
|
double add_coefficient = 1; // Might be necessary for correction coefficient calculation if two pairs are used for profit currency to account currency conversion. This is handled differently in MT5 version.
|
|
if (ReferenceSymbol == NULL)
|
|
{
|
|
ReferenceSymbol = GetSymbolByCurrencies(ProfitCurrency, account_currency, FOREX_SYMBOLS_ONLY);
|
|
if (ReferenceSymbol == NULL) ReferenceSymbol = GetSymbolByCurrencies(ProfitCurrency, account_currency, NONFOREX_SYMBOLS_ONLY);
|
|
ReferenceSymbolMode = true;
|
|
// Failed.
|
|
if (ReferenceSymbol == NULL)
|
|
{
|
|
// Reversing currencies.
|
|
ReferenceSymbol = GetSymbolByCurrencies(account_currency, ProfitCurrency, FOREX_SYMBOLS_ONLY);
|
|
if (ReferenceSymbol == NULL) ReferenceSymbol = GetSymbolByCurrencies(account_currency, ProfitCurrency, NONFOREX_SYMBOLS_ONLY);
|
|
ReferenceSymbolMode = false;
|
|
}
|
|
if (ReferenceSymbol == NULL)
|
|
{
|
|
// The condition checks whether we are caclulating conversion coefficient for the chart's symbol or for some other.
|
|
// The error output is OK for the current symbol only because it won't be repeated ad infinitum.
|
|
// It should be avoided for non-chart symbols because it will just flood the log.
|
|
Print("Couldn't detect proper currency pair for adjustment calculation. Profit currency: ", ProfitCurrency, ". Account currency: ", account_currency, ". Trying to find a possible two-symbol combination.");
|
|
if ((FindDoubleReferenceSymbol("USD")) // USD should work in 99.9% of cases.
|
|
|| (FindDoubleReferenceSymbol("EUR")) // For very rare cases.
|
|
|| (FindDoubleReferenceSymbol("GBP")) // For extremely rare cases.
|
|
|| (FindDoubleReferenceSymbol("JPY"))) // For extremely rare cases.
|
|
{
|
|
Print("Converting via ", ReferenceSymbol, " and ", AdditionalReferenceSymbol, ".");
|
|
}
|
|
else
|
|
{
|
|
Print("Adjustment calculation critical failure. Failed both simple and two-pair conversion methods.");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
if (AdditionalReferenceSymbol != NULL) // If two reference pairs are used.
|
|
{
|
|
// Calculate just the additional symbol's coefficient and then use it in final return's multiplication.
|
|
MqlTick tick;
|
|
SymbolInfoTick(AdditionalReferenceSymbol, tick);
|
|
add_coefficient = GetCurrencyCorrectionCoefficient(tick, AdditionalReferenceSymbolMode);
|
|
}
|
|
MqlTick tick;
|
|
SymbolInfoTick(ReferenceSymbol, tick);
|
|
return GetCurrencyCorrectionCoefficient(tick, ReferenceSymbolMode) * add_coefficient;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------+
|
|
//| Returns a currency pair with specified base currency and profit currency. |
|
|
//+---------------------------------------------------------------------------+
|
|
string GetSymbolByCurrencies(const string base_currency, const string profit_currency, const uint symbol_type)
|
|
{
|
|
// Cycle through all symbols.
|
|
for (int s = 0; s < SymbolsTotal(false); s++)
|
|
{
|
|
// Get symbol name by number.
|
|
string symbolname = SymbolName(s, false);
|
|
string b_cur;
|
|
|
|
// Normal case - Forex pairs:
|
|
if (MarketInfo(symbolname, MODE_PROFITCALCMODE) == 0)
|
|
{
|
|
if (symbol_type == NONFOREX_SYMBOLS_ONLY) continue; // Avoid checking symbols of a wrong type.
|
|
// Get its base currency.
|
|
b_cur = SymbolInfoString(symbolname, SYMBOL_CURRENCY_BASE);
|
|
if (b_cur == "RUR") b_cur = "RUB";
|
|
}
|
|
else // Weird case for brokers that set conversion pairs as CFDs.
|
|
{
|
|
if (symbol_type == FOREX_SYMBOLS_ONLY) continue; // Avoid checking symbols of a wrong type.
|
|
// Get its base currency as the initial three letters - prone to huge errors!
|
|
b_cur = StringSubstr(symbolname, 0, 3);
|
|
}
|
|
|
|
// Get its profit currency.
|
|
string p_cur = SymbolInfoString(symbolname, SYMBOL_CURRENCY_PROFIT);
|
|
if (p_cur == "RUR") p_cur = "RUB";
|
|
|
|
// If the currency pair matches both currencies, select it in Market Watch and return its name.
|
|
if ((b_cur == base_currency) && (p_cur == profit_currency))
|
|
{
|
|
// Select if necessary.
|
|
if (!(bool)SymbolInfoInteger(symbolname, SYMBOL_SELECT)) SymbolSelect(symbolname, true);
|
|
|
|
return symbolname;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------+
|
|
//| Finds reference symbols using 2-pair method. |
|
|
//| Results are returned via reference parameters. |
|
|
//| Returns true if found the pairs, false otherwise. |
|
|
//+----------------------------------------------------------------------------+
|
|
bool FindDoubleReferenceSymbol(const string cross_currency)
|
|
{
|
|
// A hypothetical example for better understanding:
|
|
// The trader buys CAD/CHF.
|
|
// account_currency is known = SEK.
|
|
// cross_currency = USD.
|
|
// profit_currency = CHF.
|
|
// I.e., we have to buy dollars with francs (using the Ask price) and then sell those for SEKs (using the Bid price).
|
|
|
|
ReferenceSymbol = GetSymbolByCurrencies(cross_currency, account_currency, FOREX_SYMBOLS_ONLY);
|
|
if (ReferenceSymbol == NULL) ReferenceSymbol = GetSymbolByCurrencies(cross_currency, account_currency, NONFOREX_SYMBOLS_ONLY);
|
|
ReferenceSymbolMode = true; // If found, we've got USD/SEK.
|
|
|
|
// Failed.
|
|
if (ReferenceSymbol == NULL)
|
|
{
|
|
// Reversing currencies.
|
|
ReferenceSymbol = GetSymbolByCurrencies(account_currency, cross_currency, FOREX_SYMBOLS_ONLY);
|
|
if (ReferenceSymbol == NULL) ReferenceSymbol = GetSymbolByCurrencies(account_currency, cross_currency, NONFOREX_SYMBOLS_ONLY);
|
|
ReferenceSymbolMode = false; // If found, we've got SEK/USD.
|
|
}
|
|
if (ReferenceSymbol == NULL)
|
|
{
|
|
Print("Error. Couldn't detect proper currency pair for 2-pair adjustment calculation. Cross currency: ", cross_currency, ". Account currency: ", account_currency, ".");
|
|
return false;
|
|
}
|
|
|
|
AdditionalReferenceSymbol = GetSymbolByCurrencies(cross_currency, ProfitCurrency, FOREX_SYMBOLS_ONLY);
|
|
if (AdditionalReferenceSymbol == NULL) AdditionalReferenceSymbol = GetSymbolByCurrencies(cross_currency, ProfitCurrency, NONFOREX_SYMBOLS_ONLY);
|
|
AdditionalReferenceSymbolMode = false; // If found, we've got USD/CHF. Notice that mode is swapped for cross/profit compared to cross/acc, because it is used in the opposite way.
|
|
|
|
// Failed.
|
|
if (AdditionalReferenceSymbol == NULL)
|
|
{
|
|
// Reversing currencies.
|
|
AdditionalReferenceSymbol = GetSymbolByCurrencies(ProfitCurrency, cross_currency, FOREX_SYMBOLS_ONLY);
|
|
if (AdditionalReferenceSymbol == NULL) AdditionalReferenceSymbol = GetSymbolByCurrencies(ProfitCurrency, cross_currency, NONFOREX_SYMBOLS_ONLY);
|
|
AdditionalReferenceSymbolMode = true; // If found, we've got CHF/USD. Notice that mode is swapped for profit/cross compared to acc/cross, because it is used in the opposite way.
|
|
}
|
|
if (AdditionalReferenceSymbol == NULL)
|
|
{
|
|
Print("Error. Couldn't detect proper currency pair for 2-pair adjustment calculation. Cross currency: ", cross_currency, ". Chart's pair currency: ", ProfitCurrency, ".");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get profit correction coefficient based on current prices. |
|
|
//| Valid for loss calculation only. |
|
|
//+------------------------------------------------------------------+
|
|
double GetCurrencyCorrectionCoefficient(MqlTick &tick, const bool ref_symbol_mode)
|
|
{
|
|
if ((tick.ask == 0) || (tick.bid == 0)) return -1; // Data is not yet ready.
|
|
// Reverse quote.
|
|
if (ref_symbol_mode)
|
|
{
|
|
// Using Buy price for reverse quote.
|
|
return tick.ask;
|
|
}
|
|
// Direct quote.
|
|
else
|
|
{
|
|
// Using Sell price for direct quote.
|
|
return (1 / tick.bid);
|
|
}
|
|
}
|
|
|
|
// Taken from PositionSizeCalculator indicator.
|
|
double GetPositionSize(double Entry, double StopLoss)
|
|
{
|
|
double Size, RiskMoney, UnitCost, PositionSize = 0;
|
|
ProfitCurrency = SymbolInfoString(Symbol(), SYMBOL_CURRENCY_PROFIT);
|
|
BaseCurrency = SymbolInfoString(Symbol(), SYMBOL_CURRENCY_BASE);
|
|
ProfitCalcMode = (int)MarketInfo(Symbol(), MODE_PROFITCALCMODE);
|
|
account_currency = AccountCurrency();
|
|
|
|
// A rough patch for cases when account currency is set as RUR instead of RUB.
|
|
if (account_currency == "RUR") account_currency = "RUB";
|
|
if (ProfitCurrency == "RUR") ProfitCurrency = "RUB";
|
|
if (BaseCurrency == "RUR") BaseCurrency = "RUB";
|
|
|
|
double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
|
|
int LotStep_digits = CountDecimalPlaces(LotStep);
|
|
|
|
double SL = MathAbs(Entry - StopLoss);
|
|
|
|
if (!CalculatePositionSize) return FixedPositionSize;
|
|
|
|
if (AccountCurrency() == "") return 0;
|
|
|
|
if (FixedBalance > 0)
|
|
{
|
|
Size = FixedBalance;
|
|
}
|
|
else if (UseEquityInsteadOfBalance)
|
|
{
|
|
Size = AccountEquity();
|
|
}
|
|
else
|
|
{
|
|
Size = AccountBalance();
|
|
}
|
|
|
|
if (!UseMoneyInsteadOfPercentage) RiskMoney = Size * Risk / 100;
|
|
else RiskMoney = MoneyRisk;
|
|
|
|
// If Symbol is CFD.
|
|
if (ProfitCalcMode == 1)
|
|
UnitCost = SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_SIZE) * SymbolInfoDouble(Symbol(), SYMBOL_TRADE_CONTRACT_SIZE); // Apparently, it is more accurate than taking TICKVALUE directly in some cases.
|
|
else UnitCost = MarketInfo(Symbol(), MODE_TICKVALUE); // Futures or Forex.
|
|
|
|
if (ProfitCalcMode != 0) // Non-Forex might need to be adjusted.
|
|
{
|
|
// If profit currency is different from account currency.
|
|
if (ProfitCurrency != account_currency)
|
|
{
|
|
double CCC = CalculateAdjustment(); // Valid only for loss calculation.
|
|
// Adjust the unit cost.
|
|
UnitCost *= CCC;
|
|
}
|
|
}
|
|
|
|
// If account currency == pair's base currency, adjust UnitCost to future rate (SL). Works only for Forex pairs.
|
|
if ((account_currency == BaseCurrency) && (ProfitCalcMode == 0))
|
|
{
|
|
double current_rate = 1, future_rate = StopLoss;
|
|
RefreshRates();
|
|
if (StopLoss < Entry)
|
|
{
|
|
current_rate = Ask;
|
|
}
|
|
else if (StopLoss > Entry)
|
|
{
|
|
current_rate = Bid;
|
|
}
|
|
UnitCost *= (current_rate / future_rate);
|
|
}
|
|
|
|
if ((SL != 0) && (UnitCost != 0) && (TickSize != 0)) PositionSize = NormalizeDouble(RiskMoney / (SL * UnitCost / TickSize), LotStep_digits);
|
|
|
|
if (PositionSize < MarketInfo(Symbol(), MODE_MINLOT)) PositionSize = MarketInfo(Symbol(), MODE_MINLOT);
|
|
else if (PositionSize > MarketInfo(Symbol(), MODE_MAXLOT)) PositionSize = MarketInfo(Symbol(), MODE_MAXLOT);
|
|
double steps = PositionSize / SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
|
if (MathFloor(steps) < steps) PositionSize = MathFloor(steps) * MarketInfo(Symbol(), MODE_LOTSTEP);
|
|
return PositionSize;
|
|
}
|
|
|
|
// Prints and writes to file error info and context data.
|
|
void Output(string s)
|
|
{
|
|
Print(s);
|
|
if (!ErrorLogging) return;
|
|
int file = FileOpen(filename, FILE_CSV | FILE_READ | FILE_WRITE);
|
|
if (file == -1) Print("Failed to create an error log file: ", GetLastError(), ".");
|
|
else
|
|
{
|
|
FileSeek(file, 0, SEEK_END);
|
|
s = TimeToStr(TimeCurrent(), TIME_DATE | TIME_SECONDS) + " - " + s;
|
|
FileWrite(file, s);
|
|
FileClose(file);
|
|
}
|
|
}
|
|
|
|
// Runs only one time to adjust SL to appropriate bar's Low if breakout bar's part outside the pattern turned out to be longer than the one inside.
|
|
// Works only if PostEntrySLAdjustment = true.
|
|
double AdjustPostBuySL()
|
|
{
|
|
double SL = -1;
|
|
string smagic = IntegerToString(Magic);
|
|
double Border;
|
|
|
|
// Border.
|
|
if (ObjectFind(UpperBorderLine + smagic) > -1)
|
|
{
|
|
if ((ObjectType(UpperBorderLine + smagic) != OBJ_HLINE) && (ObjectType(UpperBorderLine + smagic) != OBJ_TREND)) return SL;
|
|
// Starting from 1 because it is new bar after breakout bar.
|
|
for (int i = 1; i < Bars; i++)
|
|
{
|
|
if (ObjectType(UpperBorderLine + smagic) != OBJ_HLINE) Border = ObjectGetValueByShift(UpperBorderLine + smagic, i);
|
|
else Border = ObjectGet(UpperBorderLine + smagic, OBJPROP_PRICE1); // Horizontal line value
|
|
// Major part inside pattern but and SL not closer than breakout bar's SL.
|
|
if ((Border - Low[i] > High[i] - Border) && (Low[i] <= Low[1])) return NormalizeDouble(Low[i], Digits);
|
|
}
|
|
}
|
|
else // Try to find a channel.
|
|
{
|
|
if (ObjectFind(BorderChannel + smagic) > -1)
|
|
{
|
|
if (ObjectType(BorderChannel + smagic) != OBJ_CHANNEL) return SL;
|
|
for (int i = 1; i < Bars; i++)
|
|
{
|
|
// Get the upper of main and auxiliary lines.
|
|
Border = MathMax(ObjectGetValueByTime(0, BorderChannel + smagic, Time[i], 0), ObjectGetValueByTime(0, BorderChannel + smagic, Time[i], 1));
|
|
// Major part inside pattern but and SL not closer than breakout bar's SL.
|
|
if ((Border - Low[i] > High[i] - Border) && (Low[i] <= Low[0])) return NormalizeDouble(Low[i], _Digits);
|
|
}
|
|
}
|
|
}
|
|
return SL;
|
|
}
|
|
|
|
// Runs only one time to adjust SL to appropriate bar's High if breakout bar's part outside the pattern turned out to be longer than the one inside.
|
|
// Works only if PostEntrySLAdjustment = true.
|
|
double AdjustPostSellSL()
|
|
{
|
|
double SL = -1;
|
|
string smagic = IntegerToString(Magic);
|
|
double Border;
|
|
|
|
// Border.
|
|
if (ObjectFind(LowerBorderLine + smagic) > -1)
|
|
{
|
|
if ((ObjectType(LowerBorderLine + smagic) != OBJ_HLINE) && (ObjectType(LowerBorderLine + smagic) != OBJ_TREND)) return SL;
|
|
// Starting from 1 because it is new bar after breakout bar.
|
|
for (int i = 1; i < Bars; i++)
|
|
{
|
|
if (ObjectType(LowerBorderLine + smagic) != OBJ_HLINE) Border = ObjectGetValueByShift(LowerBorderLine + smagic, i);
|
|
else Border = ObjectGet(LowerBorderLine + smagic, OBJPROP_PRICE1); // Horizontal line value
|
|
// Major part inside pattern but and SL not closer than breakout bar's SL.
|
|
if ((High[i] - Border > Border - Low[i]) && (High[i] >= High[0])) return NormalizeDouble(High[i], Digits);
|
|
}
|
|
}
|
|
else // Try to find a channel.
|
|
{
|
|
if (ObjectFind(BorderChannel + smagic) > -1)
|
|
{
|
|
if (ObjectType(BorderChannel + smagic) != OBJ_CHANNEL) return SL;
|
|
for (int i = 1; i < Bars; i++)
|
|
{
|
|
// Get the lower of main and auxiliary lines.
|
|
Border = MathMin(ObjectGetValueByTime(0, BorderChannel + smagic, Time[i], 0), ObjectGetValueByTime(0, BorderChannel + smagic, Time[i], 1));
|
|
// Major part inside pattern but and SL not closer than breakout bar's SL.
|
|
if ((High[i] - Border > Border - Low[i]) && (High[i] >= High[0])) return NormalizeDouble(High[i], _Digits);
|
|
}
|
|
}
|
|
}
|
|
return SL;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Counts decimal places. |
|
|
//+------------------------------------------------------------------+
|
|
int CountDecimalPlaces(double number)
|
|
{
|
|
// 100 as maximum length of number.
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
double pwr = MathPow(10, i);
|
|
if (MathRound(number * pwr) / pwr == number) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Execute a markte order (depends on symbol's trade execution mode.|
|
|
//+------------------------------------------------------------------+
|
|
int ExecuteMarketOrder(const int order_type, const double volume, const double price, const double sl, const double tp)
|
|
{
|
|
double order_sl = sl;
|
|
double order_tp = tp;
|
|
|
|
double StopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
|
|
double FreezeLevel = MarketInfo(Symbol(), MODE_FREEZELEVEL) * Point;
|
|
double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
|
|
int LotStep_digits = CountDecimalPlaces(LotStep);
|
|
|
|
ENUM_SYMBOL_TRADE_EXECUTION Execution_Mode = (ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(Symbol(), SYMBOL_TRADE_EXEMODE);
|
|
|
|
// Market execution mode - preparation.
|
|
if (Execution_Mode == SYMBOL_TRADE_EXECUTION_MARKET)
|
|
{
|
|
// No SL/TP allowed on instant orders.
|
|
order_sl = 0;
|
|
order_tp = 0;
|
|
}
|
|
|
|
int ticket = OrderSend(Symbol(), order_type, volume, price, Slippage, order_sl, order_tp, "Chart Pattern Helper", Magic);
|
|
if (ticket == -1)
|
|
{
|
|
int last_error = GetLastError();
|
|
string order_string = "";
|
|
if (order_type == OP_BUY) order_string = "Buy";
|
|
else if (order_type == OP_SELL) order_string = "Sell";
|
|
Output("Error Sending " + order_string + ": " + IntegerToString(last_error) + " (" + ErrorDescription(last_error) + ")");
|
|
Output("Volume = " + DoubleToStr(volume, LotStep_digits) + " Entry = " + DoubleToStr(price, Digits) + " SL = " + DoubleToStr(order_sl, Digits) + " TP = " + DoubleToStr(order_tp, Digits));
|
|
}
|
|
else
|
|
{
|
|
Output("Order executed. Ticket: " + IntegerToString(ticket) + ".");
|
|
}
|
|
|
|
// Market execution mode - applying SL/TP.
|
|
if (Execution_Mode == SYMBOL_TRADE_EXECUTION_MARKET)
|
|
{
|
|
if (!OrderSelect(ticket, SELECT_BY_TICKET))
|
|
{
|
|
Output("Failed to find the order to apply SL/TP.");
|
|
return 0;
|
|
}
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
bool result = OrderModify(ticket, OrderOpenPrice(), sl, tp, OrderExpiration());
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Output("Error modifying the order: " + IntegerToString(GetLastError()));
|
|
}
|
|
}
|
|
}
|
|
|
|
return ticket;
|
|
}
|
|
//+------------------------------------------------------------------+ |