static void AnalyseExit(int bar)
{
#region On Time Closing indicators
if (closeTimeExec == ExecutionTime.AtBarClosing &&
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] == 0f)
return;
#endregion
#region Indicator "Account Percent Stop"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "Account Percent Stop")
{
// If there is a transferred position, sends a Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long &&
session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar - 1];
if (stop > Open[bar])
stop = Open[bar];
string note = Language.T("Stop order to position") + " " + (toPos + 1);
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] = stop;
}
else if (session[bar].Summary.PosDir == PosDirection.Short &&
session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar - 1];
if (stop < Open[bar])
stop = Open[bar];
string note = Language.T("Stop order to position") + " " + (toPos + 1);
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] = stop;
}
// If there is a new position, sends a Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double deltaMoney = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * MoneyBalance(bar) / (100 * lots);
double deltaStop = Math.Max(MoneyToPips(deltaMoney, bar), 5) * InstrProperties.Point;
double stop = session[bar].Summary.FormOrdPrice - deltaStop;
string note = Language.T("Stop order to position") + " " + (toPos + 1);
if (Close[bar - 1] > stop && stop > Open[bar])
OrdSellMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if (session[bar].Summary.PosDir == PosDirection.Short && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double deltaMoney = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * MoneyBalance(bar) / (100 * lots);
double deltaStop = Math.Max(MoneyToPips(deltaMoney, bar), 5) * InstrProperties.Point;
double stop = session[bar].Summary.FormOrdPrice + deltaStop;
string note = Language.T("Stop order to position") + " " + (toPos + 1);
if (Open[bar] > stop && stop > Close[bar - 1])
OrdBuyMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Open orders, sends an if order for each of them.
for (int iOrd = 0; iOrd < session[bar].Orders; iOrd++)
{
Order entryOrder = session[bar].Order[iOrd];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double stop = entryOrder.OrdPrice;
double deltaMoney = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * MoneyBalance(bar) / (100 * lots);
double deltaStop = -Math.Max(MoneyToPips(deltaMoney, bar), 5) * InstrProperties.Point;
string note = Language.T("Stop Order to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
stop -= deltaStop;
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
stop += deltaStop;
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
#region Indicator "ATR Stop"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "ATR Stop")
{
double deltaStop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar];
// If there is a transferred position, sends a Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long &&
session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[1].Value[bar - 1];
if (stop > Open[bar])
stop = Open[bar];
string note = Language.T("ATR Stop to position") + " " + (toPos + 1);
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[1].Value[bar] = stop;
}
else if (session[bar].Summary.PosDir == PosDirection.Short &&
session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[1].Value[bar - 1];
if (stop < Open[bar])
stop = Open[bar];
string note = Language.T("ATR Stop to position") + " " + (toPos + 1);
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[1].Value[bar] = stop;
}
// If there is a new position, sends an ATR Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice - deltaStop;
string note = Language.T("ATR Stop to position") + " " + (toPos + 1);
if (Close[bar - 1] > stop && stop > Open[bar])
OrdSellMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if (session[bar].Summary.PosDir == PosDirection.Short && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice + deltaStop;
string note = Language.T("ATR Stop to position") + " " + (toPos + 1);
if (Open[bar] > stop && stop > Close[bar - 1])
OrdBuyMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Open orders, sends an IfOrder ATR Stop for each of them.
for (int iOrd = 0; iOrd < session[bar].Orders; iOrd++)
{
Order entryOrder = session[bar].Order[iOrd];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double stop = entryOrder.OrdPrice;
string note = Language.T("ATR Stop to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
stop -= deltaStop;
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
stop += deltaStop;
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
#region Indicator "Stop Limit"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "Stop Limit")
{
// If there is a position, sends a StopLimit Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice;
double dLimit = session[bar].Summary.FormOrdPrice;
stop -= Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
dLimit += Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[1].Value * InstrProperties.Point;
string note = Language.T("Stop Limit to position") + " " + (toPos + 1);
if (Open[bar] > dLimit && dLimit > Close[bar - 1] || Close[bar - 1] > stop && stop > Open[bar])
OrdSellMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdSellStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if (session[bar].Summary.PosDir == PosDirection.Short)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice;
double dLimit = session[bar].Summary.FormOrdPrice;
stop += Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
dLimit -= Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[1].Value * InstrProperties.Point;
string note = Language.T("Stop Limit to position") + " " + (toPos + 1);
if (Open[bar] > stop && stop > Close[bar - 1] || Close[bar - 1] > dLimit && dLimit > Open[bar])
OrdBuyMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdBuyStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Entry orders, sends an IfOrder stop for each of them.
for (int iOrd = 0; iOrd < session[bar].Orders; iOrd++)
{
Order entryOrder = session[bar].Order[iOrd];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double stop = entryOrder.OrdPrice;
double dLimit = entryOrder.OrdPrice;
string note = Language.T("Stop Limit to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
stop -= Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
dLimit += Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[1].Value * InstrProperties.Point;
OrdSellStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
stop += Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
dLimit -= Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[1].Value * InstrProperties.Point;
OrdBuyStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
#region Indicator "Stop Loss"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "Stop Loss")
{ // The stop is exactly n pips below the entry point (also when add, reduce, reverse)
double deltaStop = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
// If there is a position, sends a Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice - deltaStop;
string note = Language.T("Stop Loss to position") + " " + (toPos + 1);
if (Close[bar - 1] > stop && stop > Open[bar])
OrdSellMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if(session[bar].Summary.PosDir == PosDirection.Short)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice + deltaStop;
string note = Language.T("Stop Loss to position") + " " + (toPos + 1);
if (Open[bar] > stop && stop > Close[bar - 1])
OrdBuyMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Entry orders, sends an IfOrder stop for each of them.
for (int iOrd = 0; iOrd < session[bar].Orders; iOrd++)
{
Order entryOrder = session[bar].Order[iOrd];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double stop = entryOrder.OrdPrice;
string note = Language.T("Stop Loss to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
stop -= deltaStop;
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
stop += deltaStop;
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
#region Indicator "Take Profit"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "Take Profit")
{
double dDeltaLimit = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
// If there is a position, sends a Limit Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double dLimit = session[bar].Summary.FormOrdPrice + dDeltaLimit;
string note = Language.T("Take Profit to position") + " " + (toPos + 1);
if (Open[bar] > dLimit && dLimit > Close[bar - 1])
OrdSellMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdSellLimit(bar, ifOrder, toPos, lots, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if (session[bar].Summary.PosDir == PosDirection.Short)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double dLimit = session[bar].Summary.FormOrdPrice - dDeltaLimit;
string note = Language.T("Take Profit to position") + " " + (toPos + 1);
if (Close[bar - 1] > dLimit && dLimit > Open[bar])
OrdBuyMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdBuyLimit(bar, ifOrder, toPos, lots, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Open orders, sends an IfOrder Limit for each of them.
for (int iOrd = 0; iOrd < session[bar].Orders; iOrd++)
{
Order entryOrder = session[bar].Order[iOrd];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double dLimit = entryOrder.OrdPrice;
string note = Language.T("Take Profit to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
dLimit += dDeltaLimit;
OrdSellLimit(bar, ifOrder, toPos, lots, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
dLimit -= dDeltaLimit;
OrdBuyLimit(bar, ifOrder, toPos, lots, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
#region Indicator "Trailing Stop"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "Trailing Stop")
{
double deltaStop = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
// If there is a transferred position, sends a Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long &&
session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar - 1];
// When the position is modified after the previous bar high
// we do not modify the Trailing Stop
int wayPointOrder = 0;
int wayPointHigh = 0;
for (int wayPoint = 0; wayPoint < WayPoints(bar - 1); wayPoint++)
{
if (WayPoint(bar - 1, wayPoint).OrdNumb == session[bar - 1].Summary.FormOrdNumb)
wayPointOrder = wayPoint;
if (WayPoint(bar - 1, wayPoint).WPType == WayPointType.High)
wayPointHigh = wayPoint;
}
if (wayPointOrder < wayPointHigh && stop < High[bar - 1] - deltaStop)
stop = High[bar - 1] - deltaStop;
if (stop > Open[bar])
stop = Open[bar];
string note = Language.T("Trailing Stop to position") + " " + (toPos + 1);
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] = stop;
}
else if (session[bar].Summary.PosDir == PosDirection.Short &&
session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar - 1];
// When the position is modified after the previous bar low
// we do not modify the Trailing Stop
int wayPointOrder = 0;
int wayPointLow = 0;
for (int wayPoint = 0; wayPoint < WayPoints(bar - 1); wayPoint++)
{
if (WayPoint(bar - 1, wayPoint).OrdNumb == session[bar - 1].Summary.FormOrdNumb)
wayPointOrder = wayPoint;
if (WayPoint(bar - 1, wayPoint).WPType == WayPointType.Low)
wayPointLow = wayPoint;
}
if (wayPointOrder < wayPointLow && stop > Low[bar - 1] + deltaStop)
stop = Low[bar - 1] + deltaStop;
if (stop < Open[bar])
stop = Open[bar];
string note = Language.T("Trailing Stop to position") + " " + (toPos + 1);
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] = stop;
}
// If there is a new position, sends a Trailing Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice - deltaStop;
string note = Language.T("Trailing Stop to position") + " " + (toPos + 1);
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if (session[bar].Summary.PosDir == PosDirection.Short && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice + deltaStop;
string note = Language.T("Trailing Stop to position") + " " + (toPos + 1);
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Open orders, sends an IfOrder Trailing Stop for each of them.
for (int ord = 0; ord < session[bar].Orders; ord++)
{
Order entryOrder = session[bar].Order[ord];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double stop = entryOrder.OrdPrice;
string note = Language.T("Trailing Stop to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
stop -= deltaStop;
OrdSellStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
stop += deltaStop;
OrdBuyStop(bar, ifOrder, toPos, lots, stop, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
#region Indicator "Trailing Stop Limit"
if (Strategy.Slot[Strategy.CloseSlot].IndicatorName == "Trailing Stop Limit")
{
double deltaStop = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[0].Value * InstrProperties.Point;
double dDeltaLimit = Strategy.Slot[Strategy.CloseSlot].IndParam.NumParam[1].Value * InstrProperties.Point;
// If there is a transferred position, sends a Stop Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long && session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar - 1];
double dLimit = session[bar].Summary.FormOrdPrice + dDeltaLimit;
// When the position is modified after the previous bar high
// we do not modify the Trailing Stop
int wayPointOrder = 0;
int iWayPointHigh = 0;
for (int wayPoint = 0; wayPoint < WayPoints(bar - 1); wayPoint++)
{
if (WayPoint(bar - 1, wayPoint).OrdNumb == session[bar - 1].Summary.FormOrdNumb)
wayPointOrder = wayPoint;
if (WayPoint(bar - 1, wayPoint).WPType == WayPointType.High)
iWayPointHigh = wayPoint;
}
if (wayPointOrder < iWayPointHigh && stop < High[bar - 1] - deltaStop)
stop = High[bar - 1] - deltaStop;
if (stop > Open[bar])
stop = Open[bar];
string note = Language.T("Trailing Stop Limit to position") + " " + (toPos + 1);
if (Open[bar] > dLimit && dLimit > Close[bar - 1] || Close[bar - 1] > stop && stop > Open[bar])
OrdSellMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdSellStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] = stop;
}
else if (session[bar].Summary.PosDir == PosDirection.Short && session[bar].Summary.Transaction == Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar - 1];
double dLimit = session[bar].Summary.FormOrdPrice - dDeltaLimit;
// When the position is modified after the previous bar low
// we do not modify the Trailing Stop
int wayPointOrder = 0;
int wayPointLow = 0;
for (int wayPoint = 0; wayPoint < WayPoints(bar - 1); wayPoint++)
{
if (WayPoint(bar - 1, wayPoint).OrdNumb == session[bar - 1].Summary.FormOrdNumb)
wayPointOrder = wayPoint;
if (WayPoint(bar - 1, wayPoint).WPType == WayPointType.Low)
wayPointLow = wayPoint;
}
if (wayPointOrder < wayPointLow && stop > Low[bar - 1] + deltaStop)
stop = Low[bar - 1] + deltaStop;
if (stop < Open[bar])
stop = Open[bar];
string note = Language.T("Trailing Stop Limit to position") + " " + (toPos + 1);
if (Open[bar] > stop && stop > Close[bar - 1] || Close[bar - 1] > dLimit && dLimit > Open[bar])
OrdBuyMarket(bar, ifOrder, toPos, lots, Open[bar], OrderSender.Close, OrderOrigin.Strategy, note);
else
OrdBuyStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
Strategy.Slot[Strategy.CloseSlot].Component[0].Value[bar] = stop;
}
// If there is a new position, sends a Trailing Stop Limit Order for it.
if (session[bar].Summary.PosDir == PosDirection.Long && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice - deltaStop;
double dLimit = session[bar].Summary.FormOrdPrice + dDeltaLimit;
string note = Language.T("Trailing Stop Limit to position") + " " + (toPos + 1);
OrdSellStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
else if (session[bar].Summary.PosDir == PosDirection.Short && session[bar].Summary.Transaction != Transaction.Transfer)
{
int ifOrder = 0;
int toPos = session[bar].Summary.PosNumb;
double lots = session[bar].Summary.PosLots;
double stop = session[bar].Summary.FormOrdPrice + deltaStop;
double dLimit = session[bar].Summary.FormOrdPrice - dDeltaLimit;
string note = Language.T("Trailing Stop Limit to position") + " " + (toPos + 1);
OrdBuyStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
// If there are Open orders, sends an IfOrder Trailing Stop for each of them.
for (int iOrd = 0; iOrd < session[bar].Orders; iOrd++)
{
Order entryOrder = session[bar].Order[iOrd];
if (entryOrder.OrdSender == OrderSender.Open && entryOrder.OrdStatus == OrderStatus.Confirmed)
{
int ifOrder = entryOrder.OrdNumb;
int toPos = 0;
double lots = entryOrder.OrdLots;
double stop = entryOrder.OrdPrice;
double dLimit = entryOrder.OrdPrice;
string note = Language.T("Trailing Stop Limit to order") + " " + (ifOrder + 1);
if (entryOrder.OrdDir == OrderDirection.Buy)
{
stop -= deltaStop;
dLimit += dDeltaLimit;
OrdSellStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
else
{
stop += deltaStop;
dLimit -= dDeltaLimit;
OrdBuyStopLimit(bar, ifOrder, toPos, lots, stop, dLimit, OrderSender.Close, OrderOrigin.Strategy, note);
}
}
}
return;
}
#endregion
// Searching the components to find the exit price for a long position.
double priceExitLong = 0;
foreach (IndicatorComp indComp in Strategy.Slot[Strategy.CloseSlot].Component)
if (indComp.DataType == IndComponentType.CloseLongPrice ||
indComp.DataType == IndComponentType.ClosePrice ||
indComp.DataType == IndComponentType.OpenClosePrice)
{
priceExitLong = indComp.Value[bar];
break;
}
// Searching the components to find the exit price for a short position.
double priceExitShort = 0;
foreach (IndicatorComp indComp in Strategy.Slot[Strategy.CloseSlot].Component)
if (indComp.DataType == IndComponentType.CloseShortPrice ||
indComp.DataType == IndComponentType.ClosePrice ||
indComp.DataType == IndComponentType.OpenClosePrice)
{
priceExitShort = indComp.Value[bar];
break;
}
if (Strategy.CloseFilters == 0)
{
SetExitOrders(bar, priceExitLong, priceExitShort);
return;
}
// If we do not have a position we do not have anything to close.
if (session[bar].Summary.PosDir != PosDirection.Long &&
session[bar].Summary.PosDir != PosDirection.Short)
return;
if (Configs.UseLogicalGroups)
{
foreach (string group in closingLogicGroups)
{
bool isGroupAllowExit = false;
for (int slot = Strategy.CloseSlot + 1; slot < Strategy.Slots; slot++)
{
if (Strategy.Slot[slot].LogicalGroup == group || Strategy.Slot[slot].LogicalGroup == "all")
{
bool isSlotAllowExit = false;
foreach(IndicatorComp component in Strategy.Slot[slot].Component)
{ // We are searching the components for a permission to close the position.
if (component.Value[bar] == 0)
continue;
if (component.DataType == IndComponentType.ForceClose ||
component.DataType == IndComponentType.ForceCloseLong && session[bar].Summary.PosDir == PosDirection.Long ||
component.DataType == IndComponentType.ForceCloseShort && session[bar].Summary.PosDir == PosDirection.Short)
{
isSlotAllowExit = true;
break;
}
}
if (!isSlotAllowExit)
{
isGroupAllowExit = false;
break;
}
else
isGroupAllowExit = true;
}
}
if (isGroupAllowExit)
{
SetExitOrders(bar, priceExitLong, priceExitShort);
break;
}
}
}
else
{
bool stopSearching = false;
for (int slot = Strategy.CloseSlot + 1; slot < Strategy.Slots && !stopSearching; slot++)
{
for (int comp = 0; comp < Strategy.Slot[slot].Component.Length && !stopSearching; comp++)
{ // We are searching the components for a permission to close the position.
if (Strategy.Slot[slot].Component[comp].Value[bar] == 0)
continue;
IndComponentType compDataType = Strategy.Slot[slot].Component[comp].DataType;
if (compDataType == IndComponentType.ForceClose ||
compDataType == IndComponentType.ForceCloseLong && session[bar].Summary.PosDir == PosDirection.Long ||
compDataType == IndComponentType.ForceCloseShort && session[bar].Summary.PosDir == PosDirection.Short)
{
SetExitOrders(bar, priceExitLong, priceExitShort);
stopSearching = true;
}
}
}
}
return;
}
