Trying to close a "frame" when the "frame" is in profit

Hi,

I am writing a new EA which restricts trading to spans of currency-price which I refer to as "frames." These frames have upper limits, lower limits, a datatime value of when the frame was opened, and a datetime value of when the frame was closed (0 if it is still open).

ex:

--------------------------------------  upper limit = 1.3800

 T R A D E   H E R E  T R A D E   H E R E  TR A D E   H E R E 

 T R A D E   H E R E  T R A D E   H E R E  TR A D E   H E R E 

 T R A D E   H E R E  T R A D E   H E R E  TR A D E   H E R E 

 T R A D E   H E R E  T R A D E   H E R E  TR A D E   H E R E 

-------------------------------------- lower limit = 1.3500

When the price leaves the frame, if I made money within the frame overall I want to close every order within the frame.

Since I only want to close the frame when I have profited inside it, my balance should never drop below the balance when the frame opened. However, there seems to be some bug that is eluding me because the balance DOES in fact drop below the previous value. Can anyone figure this out? I am stumped :(

I got most of this stuff working; please skip to my last post.

I have a couple arrays that I use to keep track of the frame, they are:

double upperHistoryLimit[]; //contains all of the upper limits every opened/open now
double lowerHistoryLimit[]; //contains all of the lower limits every opened/open now
datetime setFrameTime[];    //contains the time the frame was open
datetime closeFrameTime[];  //contains the time the next frame was opened

And here is my code for the relevant portion:

void SetFrame() { //This is how I create the "frame" and how I memorize its variables
      
   int _arraySize = ArraySize(upperHistoryLimit);

   ArrayResize(upperHistoryLimit, _arraySize +1);
   ArrayResize(lowerHistoryLimit, _arraySize +1);
   ArrayResize(freezeOrderNum, _arraySize +1);
   ArrayResize(setFrameTime, _arraySize +1);
   ArrayResize(closeFrameTime, _arraySize +1);
 
   
   if (upperHistoryLimit[_arraySize]!=0) Print ("upperHistoryLimit[_arraySize] = ",upperHistoryLimit[_arraySize]);
   upperHistoryLimit[_arraySize]= Bid * ((100+FrameSize)/100);
   lowerHistoryLimit[_arraySize] = Ask * ((100-FrameSize)/100);
   setFrameTime[_arraySize] = TimeCurrent();
         

   if (firstTime == true) 
   {
      ObjectCreate("upperLimit", OBJ_HLINE, 0, Time[0], upperHistoryLimit[_arraySize] , 0, 0);
      ObjectCreate("lowerLimit", OBJ_HLINE, 0, Time[0], lowerHistoryLimit[_arraySize], 0, 0);
   } 
   else
   {   
      ObjectSet("upperLimit", OBJ_HLINE,  upperHistoryLimit[_arraySize]);
      ObjectSet("lowerLimit", OBJ_HLINE,  lowerHistoryLimit[_arraySize]);
      closeFrameTime[_arraySize-1] = TimeCurrent();
   }
}
//This is in the Start Function:


RefreshRates();
withinFrame_BuyTP = CheckWithinFrame((Ask-Spread*Point)+TakeProfit*Point); //Check if future buy limit's TP is within the frame
withinFrame_SellTP = CheckWithinFrame((Bid+Spread*Point)-TakeProfit*Point); //Check if future sell limit's TP is within the frame 
     
withinFrame_Ask = CheckWithinFrame(Ask); //Check if current Ask price is within the frame
withinFrame_Bid = CheckWithinFrame(Bid); //Check if current Bid price is within the frame    


if ((withinFrame_Ask == false) || (withinFrame_Bid == false))  //if either current price is not in the current frame
      {
     
        if ((withinFrame_BuyTP == false) && (withinFrame_SellTP == false)) //if both future orders' TP is not within the current frame
         {
              
           
            if ((justClosed == false) && getFrameProfit(ArraySize(upperHistoryLimit)-1) >0) //getFrameProfit should return the profit of the most recent frame in the array.
            {
                
              closeOpenOrdersFrame(-1,ArraySize(upperHistoryLimit)-1); //closeOpenOrdersFrame should close every order of the most recent frame in the array.
              justClosed = true;
            }
            
         }
bool CheckWithinFrame(double currentPrice) //returns true if the passed variable is between upperLimit and lowerLimit; else = false
{
   int size = ArraySize(upperHistoryLimit);
   
   if ((currentPrice < upperHistoryLimit[size-1]) && (currentPrice > lowerHistoryLimit[size-1]))
   {
     
      return (true);
   }
   else
   {
   
      return (false);
   }
   
}
   double getFrameProfit(int _index){ //Should return the total profit within the frame (could be positive or negative)
   int cnt;
   double profit = 0;
   int total=OrdersTotal();
   if (total == 0) return (0);
   for(cnt=total;cnt>=0;cnt--){
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if ((OrderOpenPrice() < upperHistoryLimit[_index]) && (OrderOpenPrice() > lowerHistoryLimit[_index]))
      {
         if (OrderOpenTime() < closeFrameTime[_index] || closeFrameTime[_index] == 0)
         {
             if (OrderOpenTime() > setFrameTime[_index])
             {
               profit += OrderProfit();
             }
         }  
     }     
   }
   
   profit = 0;
   total=OrdersHistoryTotal();
   for(cnt=total;cnt>=0;cnt--){
      OrderSelect(cnt, SELECT_BY_POS, MODE_HISTORY);
      if ((OrderOpenPrice() < upperHistoryLimit[_index]) && (OrderOpenPrice() > lowerHistoryLimit[_index]))
      {
         if (OrderOpenTime() < closeFrameTime[_index] || closeFrameTime[_index] == 0)
         {
             if (OrderOpenTime() > setFrameTime[_index])
             {
               profit += OrderProfit();
             }
         }  
     }     
   }
   
   return (profit);
}
void closeOpenOrdersFrame(int magic, int _index){ //This function should close all open orders inside the frame.
   int total, cnt,type;
   double price;
   color clr;
   
   Print ("closeOpenOrdersFrame(" + type + "," + magic + ")");
   while (getNumOpenOrdersInFrame(magic,_index) > 0){
      while (IsTradeContextBusy()){
         Print("closeOpenOrders(): waiting for trade context.");
         Sleep(MathRand()/10);
      }
      
      total=OrdersTotal();
      

      
      for(cnt=0; cnt<total; cnt++){
         RefreshRates();
         OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
         type = OrderType();
         
         if (type == OP_BUY){
            price = Bid;
            clr = CLR_SELL_ARROW;
         }else{
            price = Ask;
            clr = CLR_BUY_ARROW;
         }
                  
         if ((OrderOpenPrice() < upperHistoryLimit[_index]) && (OrderOpenPrice() > lowerHistoryLimit[_index]))
         {
            if (OrderOpenTime() < closeFrameTime[_index] || closeFrameTime[_index] == 0)
            {
               if (OrderOpenTime() > setFrameTime[_index])
               {
                  if((type == -1 || OrderType() == type) && (magic == -1 || OrderMagicNumber() == magic))
                  {
                     if(IsTradeContextBusy())
                     {
                        break; // something else is trading too, back to the while loop.
                     }
                     if (type == OP_BUYSTOP || type == OP_SELLSTOP || type == OP_BUYLIMIT || type == OP_SELLLIMIT)
                     {
                        orderDeleteReliable(OrderTicket());
                     }
                     else
                     {
                        orderCloseReliable(OrderTicket(), OrderLots(), price, 0, clr);
                     }
                     break; // restart the loop from 0 (hello FIFO!)
                  }
               } 
            }
        }
      }
   }
}
int getNumOpenOrders(int type, int magic){ //This should return the number of currently open orders (limits included)
   int cnt;
   int num = 0;
   int total=OrdersTotal();
   for(cnt=total;cnt>=0;cnt--){
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if((magic == -1 || OrderMagicNumber() == magic) && (type == -1 || OrderType() == type)){
         num++;
      }
   }
   return (num);
}