Need help w/ programming logic

   
   if(int NoOrdersYet; NoOrdersYet < 1)
   {
      OrderSend(Symbol(), 4, LotSize, (Ask+(OrderDistance*Point)), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first long
      OrderSend(Symbol(), 5, LotSize, (Bid-(OrderDistance*Point)), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor); //Sends first short
      NoOrdersYet++;
      
   }
      
   
   //For existing trades
   for (int x = 0; x < OrdersTotal(); x++) 
   {
      if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
      {
         if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
            
         {
            
               if (OrderType()==OP_BUY) 
               { 
                     if(OrderOpenPrice() <= (Ask+(OrderDistance*Point))) 
                     {
                        OrderSend(Symbol(), 4, LotSize, (Ask+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                        LastLongOpenPrice = OrderOpenPrice();
                     }
                     if(OrderOpenPrice() > (Ask + ((OrderDistance*2)*Point)))
                     {
                        OrderSend(Symbol(), 4, LotSize, (Ask+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                        LastLongOpenPrice = OrderOpenPrice();
                     }
                     //NumberLongPendingOrders++;
               }
               else if (OrderType()==OP_SELL) 
               {  
                     if(OrderOpenPrice() == (Bid*(OrderDistance*Point))) 
                     {
                        OrderSend(Symbol(), 4, LotSize, (Bid+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                        LastShortOpenPrice = OrderOpenPrice();
                     }
                     if(OrderOpenPrice() < (Bid + ((OrderDistance*2)*Point)))
                     {
                        OrderSend(Symbol(), 4, LotSize, (Bid+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                        LastShortOpenPrice = OrderOpenPrice();
                     }
               }
            
            //Clearing out orders further than 100 pips  ---DOESN'T SEEM TO WORK
            /*else if (OrderType() == 4 && OrderOpenPrice() >= (Ask + (MaximumPipsPending*Point)))
            {
               OrderDelete(OrderTicket());
            }
            else if (OrderType() == 5 && OrderOpenPrice() <= (Bid + (MaximumPipsPending*Point)))
            {
               OrderDelete(OrderTicket());
            }*/
         }
      }
   }

Quoting flyer415

Disliked

The primary rule I see here that may be causing the issue is that the OrdersTotal() function should never be used in any loop.

Instead use:

int TotalOrders = OrdersTotal()

Now we use TotalOrders in our loop.


Why do this...because every loop will create an order and so OrdersTotal() is called on every loop but it is now larger then when you started. It is ever increasing.

Does that make sense in terms of how i described it?

Ignored

TotalOrders = OrdersTotal();
   for (int x = 0; x < TotalOrders; x++) 
   {

 //For existing trades
   int TotalOrders = OrdersTotal();
   if (OrdersTotal()==2){
      for (int x = 0; x < TotalOrders; x++){
         if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES)){
            if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber)){
               if (OrderType()==OP_BUY){ 
                  if(OrderOpenPrice() <= Ask+(OrderDistance*Point)){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                     LastLongOpenPrice = OrderOpenPrice();
                  }
                  if(OrderOpenPrice() > Ask + (OrderDistance*2)*Point){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                     LastLongOpenPrice = OrderOpenPrice();
                  }
              }
              if (OrderType()==OP_SELL){  
                  if(OrderOpenPrice() >= Bid+(OrderDistance*Point)){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Bid+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                     LastShortOpenPrice = OrderOpenPrice();
                  }
                  if(OrderOpenPrice() < Bid + (OrderDistance*2)*Point){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Bid+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                     LastShortOpenPrice = OrderOpenPrice();
                  }
              }
            }
         }
      }
   } 

Quoting kennyhubbard

Disliked

Here you go.......

[php]...

Ignored

double pipval = MarketInfo(Symbol(),MODE_TICKVALUE);

   double pipval = MarketInfo(Symbol(),MODE_TICKVALUE);
   
   ObjectCreate("Pipval_vari", OBJ_LABEL, 0, 0, 0);
   ObjectSetText("Pipval_vari","$" + pipval * 10 + "USD",10, "Tahoma", Sienna); // "Pipval_vari" will be variable 
   ObjectSet("Pipval_vari", OBJPROP_CORNER, 0);                    // and will change based on pip value of pair
   ObjectSet("Pipval_vari", OBJPROP_XDISTANCE, 85);
   ObjectSet("Pipval_vari", OBJPROP_YDISTANCE, 35);

Quoting kennyhubbard

Disliked

Let me think about it a bit. I can probably throw some ideas your way.

What happens to the order that doesn't activate the TS such a long when the price reverses and picks up the short stop? Does it have a SL?

Ignored

Quoting kennyhubbard

Disliked

bluemele,

One thing to look at. The reason you are having problems with getting an accurate lastorderopenprice is because you are not selecting the order.

You are selecting the previous order and then making a trade. Logic dictates that when you make a trade THAT order becomes the selected one. Unfortunately MQL4 does not do this......it will still retain the previous order.

Try using OrderSelect(OrderTicket(),SELECT_BY_TICKET) and then store the OrderOpenPrice.

Ignored

//+------------------------------------------------------------------+
//|                                               Ben_trail_stop.mq4 |
//|                            Copyright © 2010, www.compu-forex.com |
//|                                              www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, www.compu-forex.com"
#property link      "www.compu-forex.com"

//+------------------------------------------------------------------+
// Added by Robert for better error reporting
#include <stdlib.mqh>
#include <stderror.mqh>
//+------------------------------------------------------------------+

//---- input parameters
extern int        OrderDistance     = 15;       //Distance of order entry to include spread*2 + Minimum Broker Modification distance
extern int        Retracement       = 2;        //# of OrderDistance increments to reenter in opposite direction, ex. (2)Retracement X (15)OrderDistance = 30 total
extern double     LotSize           = 0.01;     //Size of lot to be introduced
extern int        MagicNumber       = 0;
extern bool       Own_Symbol_Only   = true;
extern double     Trail_From        = 10.0;
extern double     Trail_Max         = 50.0;
extern double     Trail_Percent     = 50;
extern int        Slippage          = 3;        //slippage for orders
extern double     StopLoss          = 0.0;      //Take Profit
extern double     TakeProfit        = 0.0;      //Take Profit
extern int        MaximumPipsPending= 100;      //Maixmum pips distance to leave pending orders open
extern int        TotalOrdersToInput = 150;     //Total pending orders in both directions 

string   ArrowColor = "blue";
bool     mod;
int      err; // for better error reporting
double   My_Profit, 
         My_Trail, 
         My_SL, 
         lTrail_Max, 
         lTrail_From,
         Stop_Level,
         Pip,
         LastLongOpenPrice,
         LastShortOpenPrice,
         LastOpenOrderPrice;
int      TotalOrders,NumberofLongPendingOrders,NumberofShortPendingOrders,TotalPendingOrders;




//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
////////////-------------------------------------------------------///
//    THIS SECTION OPENS ORDERS
///////////--------------------------------------------------------///
   int TotalOrders = OrdersTotal();
   double OrderReEntryPrice = ((OrderDistance * 2) * Point);
   
   if(TotalOrders == 0)
   {
      OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
      OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
   }
   else if(TotalOrders > 0)
   {
      for(int x = 0; x < TotalOrders; x++)
      {
         if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
         {
            if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
            {
               if(OrderType() == 4)
               {
                  NumberofLongPendingOrders++;break;
               }  
               if(OrderType() == 5)
               {
                  NumberofShortPendingOrders++;break;
               }     
            }
            
         }
      }
      TotalPendingOrders = NumberofLongPendingOrders + NumberofShortPendingOrders;
      if(TotalPendingOrders < 2)
      {
         for(int d = 0; d < TotalOrders; d++)
         {
            OrderDelete(OrderTicket());
         }
         if(NumberofLongPendingOrders < 1)
         {
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"2nd Entry Long", MagicNumber, 0,ArrowColor);
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Ask-(OrderDistance*Point*Retracement),Digits), Slippage, StopLoss ,TakeProfit ,"Retrace Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
         }
         if(NumberofLongPendingOrders < 1)
         {
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point*Retracement,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Long", MagicNumber, 0,ArrowColor);
         }
      }             
   }
   Comment(
   "Number of Pending Orders: ",(TotalPendingOrders),"n",
   "Long Pending Orders: ",(NumberofLongPendingOrders),"n",
   "Short Pending Orders: ", (NumberofLongPendingOrders));
      
  
   
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   /////////////BEGIN TRAILING STOP /////////////////////////////////
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
         if(OrderLots() != LotSize) // only modifies base lot size for martingaling larger lots
            {break;}
         if(Own_Symbol_Only && OrderSymbol() != Symbol())continue;
         if(OrderMagicNumber() == MagicNumber || MagicNumber == 0){
            RefreshRates();
            Pip = MarketInfo(OrderSymbol(),MODE_POINT);
            if (MarketInfo(OrderSymbol(),MODE_DIGITS) == 3|| MarketInfo(OrderSymbol(),MODE_DIGITS) == 5)Pip*=10;
            lTrail_Max = Trail_Max * Pip;
            lTrail_From = Trail_From * Pip;
            Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
            switch(OrderType()){
               case OP_BUY :  My_Profit = MarketInfo(OrderSymbol(), MODE_BID) - OrderOpenPrice();
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID)-My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(MarketInfo(OrderSymbol(),MODE_BID) - My_SL > Stop_Level){
//+------------------------------------------------------------------+
// This will cause a double OrderModify if OrderStopLoss() returns 0
// Combining both tests fixes the bug that returns error 1.
//
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
//+------------------------------------------------------------------+
                                    if(OrderStopLoss() < My_SL || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                 }
                              }
                              break;
                        
               case OP_SELL : My_Profit = OrderOpenPrice() - MarketInfo(OrderSymbol(), MODE_ASK);
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_ASK)+My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(My_SL - MarketInfo(OrderSymbol(),MODE_ASK) > Stop_Level){
// Combined these as well for cleaner code
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    if(My_SL < OrderStopLoss() || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                 }
                              }
                              break;
               }
// Modified to output a text description of the error
//             if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               if(!mod)
               {
                  err = GetLastError();
                  if (err > 1) Print("Error entering Trailing Stop - Error (" + err + "} " + ErrorDescription(err) );
               }
         }
      }
      else Print("Error selecting order");
   } 
//----
   return(0);
  }
  
void OpenLongs()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
         //LastLongOpenPrice == OrderOpenPrice();
      }
}
void OpenShorts()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
         //LastShortOpenPrice == OrderOpenPrice();
      }
}
void DeleteLongs()
{
   for(int d = 0; d < TotalOrders; d++)
   {
      if (OrderSelect(d,SELECT_BY_POS,MODE_TRADES))
      {
         if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
         {
            //if (OrderType()==OP_BUY)
            //{
               OrderDelete(OrderTicket());
               
            //}
         }
      }
   }
   return(0);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                               Ben_trail_stop.mq4 |
//|                            Copyright © 2010, www.compu-forex.com |
//|                                              www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, www.compu-forex.com"
#property link      "www.compu-forex.com"

//+------------------------------------------------------------------+
// Added by Robert for better error reporting
#include <stdlib.mqh>
#include <stderror.mqh>
//+------------------------------------------------------------------+

//---- input parameters
extern int        OrderDistance     = 15;       //Distance of order entry to include spread*2 + Minimum Broker Modification distance
extern double     Retracement       = 2.0;        //# of OrderDistance increments to reenter in opposite direction, ex. (2)Retracement X (15)OrderDistance = 30 total
extern double     LotSize           = 0.01;     //Size of lot to be introduced
extern int        MagicNumber       = 0;
extern bool       Own_Symbol_Only   = true;
extern double     Trail_From        = 10.0;
extern double     Trail_Max         = 50.0;
extern double     Trail_Percent     = 50;
extern int        Slippage          = 3;        //slippage for orders
extern double     StopLoss          = 0.0;      //Take Profit
extern double     TakeProfit        = 0.0;      //Take Profit
extern int        MaximumPipsPending= 100;      //Maixmum pips distance to leave pending orders open
extern int        TotalOrdersToInput = 150;     //Total pending orders in both directions 

string   ArrowColor = "blue";
bool     mod;
int      err; // for better error reporting
double   My_Profit, 
         My_Trail, 
         My_SL, 
         lTrail_Max, 
         lTrail_From,
         Stop_Level,
         Pip,
         LastLongOpenPrice,
         LastShortOpenPrice,
         LastOpenOrderPrice;
int      TotalOrders,NumberofLongPendingOrders,NumberofShortPendingOrders,TotalPendingOrders;




//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
////////////-------------------------------------------------------///
//    THIS SECTION OPENS ORDERS
///////////--------------------------------------------------------///
   int TotalOrders = OrdersTotal();
   double OrderReEntryPrice = ((OrderDistance * 2) * Point);
   
   if(TotalOrders == 0)
   {
      OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
      OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
   }
   else if(TotalOrders > 0)
   {
      NumberofLongPendingOrders = 0;
      NumberofShortPendingOrders = 0;
      TotalPendingOrders = 0;
      for(int x = 0; x < TotalOrders; x++)
      {
         if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
         {
            if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
            {
               if(OrderType() == 4)
               {
                  NumberofLongPendingOrders++;
               }
               if(OrderType() == 5)
               {
                  NumberofShortPendingOrders++;
               }              
            }
            
         }
      }
      TotalPendingOrders = NumberofLongPendingOrders + NumberofShortPendingOrders;
      if(TotalPendingOrders != 2)
      {
         for(int d = 0; d < TotalOrders; d++)
         {
            if(OrderSelect(d,SELECT_BY_POS,MODE_TRADES))
            {
               OrderDelete(OrderTicket());
            }
         }
         if(NumberofLongPendingOrders < 1)
         {
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"2nd Entry Long", MagicNumber, 0,ArrowColor);
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Ask-(OrderDistance*Point*Retracement),Digits), Slippage, StopLoss ,TakeProfit ,"Retrace Entry Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
         }
         if(NumberofShortPendingOrders < 1)
         {
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"2nd Entry Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point*Retracement,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Long", MagicNumber, 0,ArrowColor);
         }
      }             
   }
   Comment(
   "Number of Pending Orders: ",(TotalPendingOrders),"n",
   "Long Pending Orders: ",(NumberofLongPendingOrders),"n",
   "Short Pending Orders: ", (NumberofLongPendingOrders));
   
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   /////////////BEGIN TRAILING STOP /////////////////////////////////
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
         if(OrderLots() != LotSize) // only modifies base lot size for martingaling larger lots
            {break;}
         if(Own_Symbol_Only && OrderSymbol() != Symbol())continue;
         if(OrderMagicNumber() == MagicNumber || MagicNumber == 0){
            RefreshRates();
            Pip = MarketInfo(OrderSymbol(),MODE_POINT);
            if (MarketInfo(OrderSymbol(),MODE_DIGITS) == 3|| MarketInfo(OrderSymbol(),MODE_DIGITS) == 5)Pip*=10;
            lTrail_Max = Trail_Max * Pip;
            lTrail_From = Trail_From * Pip;
            Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
            switch(OrderType()){
               case OP_BUY :  My_Profit = MarketInfo(OrderSymbol(), MODE_BID) - OrderOpenPrice();
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID)-My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(MarketInfo(OrderSymbol(),MODE_BID) - My_SL > Stop_Level){
//+------------------------------------------------------------------+
// This will cause a double OrderModify if OrderStopLoss() returns 0
// Combining both tests fixes the bug that returns error 1.
//
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
//+------------------------------------------------------------------+
                                    if(OrderStopLoss() < My_SL || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                 }
                              }
                              break;
                        
               case OP_SELL : My_Profit = OrderOpenPrice() - MarketInfo(OrderSymbol(), MODE_ASK);
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_ASK)+My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(My_SL - MarketInfo(OrderSymbol(),MODE_ASK) > Stop_Level){
// Combined these as well for cleaner code
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    if(My_SL < OrderStopLoss() || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                 }
                              }
                              break;
               }
// Modified to output a text description of the error
//             if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               if(!mod)
               {
                  err = GetLastError();
                  if (err > 1) Print("Error entering Trailing Stop - Error (" + err + "} " + ErrorDescription(err) );
               }
         }
      }
      else Print("Error selecting order");
   } 
//----
   return(0);
  }
  
void OpenLongs()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
         //LastLongOpenPrice == OrderOpenPrice();
      }
}
void OpenShorts()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
         //LastShortOpenPrice == OrderOpenPrice();
      }
}
void DeleteLongs()
{
   for(int d = 0; d < TotalOrders; d++)
   {
      if (OrderSelect(d,SELECT_BY_POS,MODE_TRADES))
      {
         if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
         {
            //if (OrderType()==OP_BUY)
            //{
               OrderDelete(OrderTicket());
               
            //}
         }
      }
   }
   return(0);
}
//+------------------------------------------------------------------+

Quoting kennyhubbard

Disliked

Here's something you can toy with. Should give you a few ideas. I still think you need to find a way to deal with the hanging orders.

Unfortunately, I'm not much one for comments in my code, so ask if there is anything you don't follow.

Ignored

Quoting kennyhubbard

Disliked

Here's something you can toy with. Should give you a few ideas. I still think you need to find a way to deal with the hanging orders.

Unfortunately, I'm not much one for comments in my code, so ask if there is anything you don't follow.

Ignored