RdzGridTraps

#property version   "1.11_Zz"
#property strict
#property description "Developed by: Rdz (Radityo Ardi)"
#property description "NOTE:"
#property description "DYNAMIC GRID TRAP IS FREE AND LICENSED UNDER CHARITYWARE LICENSE STATED ON THE LINK ABOVE. ALL RIGHTS RESERVED."
#property description "ALTHOUGH IT'S FREE, I DEDICATE MY EFFORTS TO ALL PEOPLE IN THE WORLD, SUFFERING FOR HUNGER AND POOR."
#property description "AND FOR KIDS ALL OVER THE WORLD, STRUGGLING FOR EDUCATIONS."
#property description ""
#property description "PLEASE TAKE TIME TOR READ THIS LICENSE AGREEMENT."
#property description ""

#include <stdlib.mqh>
struct OrderInfo
{
   int OrderID;
   int Gaps;
   bool Closed;
};
enum enSlippageMode
{
   SMBoth = 0, //Both
   SMOpenOnly = 1, //Open Only
   SMCloseOnly = 2 //Close Only
};
enum enTargetType
{
   TTFixed = 0, //Fixed
   TTDynamic = 1 //Dynamic
};
enum enLossType
{
   LTNone = 0, //No Stop Loss
   LTFixed = 1, //Fixed
   LTDynamic = 2 //Dynamic
};
enum enContinuousMode
{
   COMContinuous = 0, //Continuous
   COMStopPendingOrders = 1, //Stop Only Pending Orders and outside timeframe
   COMForceStopAll = 2 //Force Stop All Orders when outside Timeframe
};
enum enCloseType
{
   CTStandard = 0, //Target Based (Standard)
   CTAllOrdersExecuted = 1, //Target Based OR All Orders Opened
   CTMiddlePoint = 2, //Target Based OR Middle Point
   CTThreshold = 3, //Target Based OR Threshold
   CTThresholdMiddlePoint = 4, //Target Based OR Threshold OR Middle Point
   CTProfitMinOrders = 5, //Target Based OR Min Profit Open Orders
   CTThresholdAllOrdersExtd = 6 //Target Based OR Threshold OR All Orders Opened
};
enum enOpenType
{
   OTFixedOrder = 0, //Fixed
   OTDynamicRecreationAll = 1, //Dynamic Auto-Expand (All Orders)
   OTDynamicRecreationThreshold = 2 //Dynamic Auto-Expand by Threshold
};
enum enInitialLotsType
{
   ILTFixed = 0, //Fixed Standard
   ILTDynamic = 1, //Dynamic Standard
   ILTFixedGradual = 2, //Fixed Gradual
   ILTDynamicGradual = 3 //Dynamic Gradual
};
enum enDateTimeType
{
   DTTLocalTime = 0, //Local time
   DTTServerTime = 1, //Server (broker) time
   DTTGMTTime = 2 //GMT (UTC) time
};
enum enObjectOperation
{
   LODraw = 0,
   LODelete = 1
};
enum enOrderOperation
{
   StopOrders = 0, //STOP orders
   LimitOrders = 1, //LIMIT orders
   FewLimitOrders = 2, //LIMIT orders then STOP orders
};
enum enCloseMode
{
   CMInternal = 0, //Internal
   CMExtended = 1 //Extended
};
enum enStatusExtendedClose
{
   STNotStarted = 0,
   STInProgress = 1,
   STClosed = 2,
   STError = 3
};
enum enProfitTakingMode
{
   PTMWithCommAndSwap = 0, //Include Commission and Swap
   PTMWithoutCommAndSwap = 1 //Exclude Commission and Swap
};
enum enDynamicBase
{
   DBBalance = 0, //Balance
   DBEquity = 1 //Equity
};
enum enStopTimeMode
{
   STMNothing = 0, //Nothing to do
   STMForceCloseNoOpenOrder = 1, //Force close orders if not opened
   STMForceCloseAll = 2, //Force close all orders
   STMForceCloseProfit = 3 //Force close all orders if in profit
};
enum enCloseDirection
{
   CDOutsideIn = 0, //Outside-In
   CDInsideOut = 1 //Inside-Out
};
enum enDayOfWeek
{
   DOWSunday = 0, //Sunday
   DOWMonday = 1, //Monday
   DOWTuesday = 2, //Tuesday
   DOWWednesday = 3, //Wednesday
   DOWThursday = 4, //Thursday
   DOWFriday = 5, //Friday
   DOWSaturday = 6 //Saturday
};
enum enClCalculationMode
{
   ClNoRecalculate = 0, //No Recalculation
   ClAllRecalculate = 1 //Recalculate Balance & Equity on tick
};
enum enTimeExecutionCodeStatus
{
   TECSIdle = 0, //Idle
   TECSOutOfTimeRangeWaitEx = 1, //Out of Time Range Waiting for Execution
   TECSOutOfTimeRangeExtd = 2, //Out of Time Range Executed
   TECSInTimeRangeWaitEx = 3, //In Time Range Waiting for Execution
   TECSInTimeRangeExtd = 4, //In Time Range Executed
   TECSOutOfTimeRangeInactiveWaitEx = 5 //Out of Time Range and First Inactive Waiting for Execution
};
enum enCloseOrdersMode
{
   COMDefault = 0,
   COMPendingBuy = 1,
   COMPendingSell = 2,
   COMAllBuy = 3,
   COMAllSell = 4
};
enum enGradualOperator
{
   GOMultiply = 0, //Multiply
   GOAdd = 1 //Add

};
enum enTrailingProfit
{
   TRPNone = 0, //None
   TRPDragTrailing = 1 //Trailing (Drag)
};
enum enTrailingProfitStage
{
   TRPSInitial = 0, //Initial Stage
   TRPSTrailing = 1 //Trailing Stage
};

input          string                  NoTradeOnDates             = "2015.01.05,2015.01.06"; //Dates in YYYY.MM.DD format for the EA NOT to trade
input          enDateTimeType          DateTimeType               = DTTLocalTime; //Date and Time base
input          string                  DailyStartTime             = "01:00:00"; //Start Time (HH:mm:ss)
input          string                  DailyStopTime              = "23:00:00"; //Stop Time (HH:mm:ss)
input          enDayOfWeek             WeeklyStartDay             = DOWSunday; //Weekly Start Day
input          string                  WeeklyStartTime            = "00:00:00"; //Weekly Start Time (HH:mm:ss)
input          enDayOfWeek             WeeklyStopDay              = DOWSaturday; //Weekly Stop Day
input          string                  WeeklyStopTime             = "00:00:00"; //Weekly Stop Time (HH:mm:ss)
input          bool                    UseLineStartStop           = false; //Use Stop-Start from Vertical Line
input          string                  LineStartStopKeyword       = "GT"; //Stop-Start Line Keyword
input          enStopTimeMode          StopTimeMode               = STMNothing; //Stop Time Action
input          enOpenType              OpenType                   = OTDynamicRecreationThreshold; //Placing Order Type
input          enOrderOperation        OrderOperation             = LimitOrders; //Order Operation
input          int                     OrderCountPerSide          = 3; //Grid Order Count (each side)
input          bool                    LimitMaxOrderCount         = false; //Enable Max Order
input          int                     MaxOrderCount              = 4; //Max Order Count (total)
input          int                     RecreationCountPerSide     = 9; //Grid Auto-Expand Count (each side)
input          int                     LimitOrdersCount           = 8; //Limit Grid Orders Count
input          int                     RecreationThreshold        = 0; //Auto-Expand Threshold (Points)
input          int                     GridStepPoints             = 70; //Grid Step (Points)
input          int                     CurrentPriceInterval       = 90; //Current Price Interval (Points)
input          int                     MagicNumber                = 8888; //Unique ID (Magic Number)
input          enClCalculationMode     RecalculationMode          = ClNoRecalculate; //Recalculation Mode
input          enDynamicBase           InitialLotsDynamicBase     = DBBalance; //Initial Lots Calculation Source
input          enInitialLotsType       InitialLotsType            = ILTDynamicGradual; //Initial Lots Type
input          double                  InitialLots                = 0.04; //Initial Lots
input          double                  InitialLotsMult            = 0.0001;//Initial Lots Multiplier
input          enGradualOperator       GradualLotsOperator        = GOMultiply; //Gradual Lots Operator
input          double                  GradualLotsMult            = 1.2; //Gradual Lots Multiplier
input          string                  CommentInfo                = ""; //Comment Info
input          enProfitTakingMode      ProfitTakingMode           = PTMWithCommAndSwap; //Profit Taking Mode
input          enTrailingProfit       TrailingMode               = TRPNone; //Profit Trailing Mode
input          enDynamicBase           TargetProfitDynamicBase    = DBBalance; //Target Profit Calculation Source
input          enTargetType            TargetType                 = TTFixed; //Target Type
input          double                  TargetProfit               = 30; //Target Profit
input          double                  TargetProfitMult           = 0.004;//Target Profit Multiplier
input          enDynamicBase           StopLossDynamicBase        = DBBalance; //Stop Loss Calculation Source
input          enLossType              LossType                   = LTNone; //Loss Type
input          double                  StopLoss                   = -100; //Stop Loss
input          double                  StopLossMult               = -0.0001; //Stop Loss Multiplier
input          enCloseType             CloseType                  = CTStandard; //Close Type
input          int                     MiddlePointRange           = 5; // Middle Point Range (Points)
input          int                     CloseMiddlePointAftOrders  = 0; //Middle Point Activation (Order Count)
input          int                     MinProfitOrders            = 2; //Min Open Profit Orders
input          int                     CloseThreshold             = 50; //Close Threshold
input          enCloseDirection        CloseDirection             = CDInsideOut; //Order Closure Direction
input          bool                    EnableMaxCycle             = True; //Enable Max Cycle
input          int                     MaxCycle                   = 8; //Max Cycle
input          enCloseMode             CloseMode                  = CMInternal; //Close Mode
input          int                     CountRunningCloseEA        = 0; //Count of Running EA
input          bool                    CheckIsCorrupted           = false; //Check Corrupted
input          bool                    StopNextCycleOnLoss        = false; //Stop Next on Stop Loss
input          bool                    EnableNotification         = true; // Enable Notification

               int                     BuyCount                   = 0;
               int                     SellCount                  = 0;
               int                     PendingBuyCount            = 0;
               int                     PendingSellCount           = 0;
               int                     HighestBuyCount            = 0;
               int                     HighestSellCount           = 0;
               int                     HighestOpenOrder           = 0;
               int                     AllOrdersCount             = 0;
               int                     CycleCount                 = 0;
               int                     btnLeftAxis                = 15;
               int                     btnTopAxis                 = 20;
               int                     btnInterval                = 110;
               int                     btnWidth                   = 100;
               int                     btnHeight                  = 30;
               string                  btnDefaultFont             = "Impact";
               int                     btnDefaultFontSize         = 10;
               color                   btnColor                   = clrCornflowerBlue;
               color                   btnPressedColor            = clrGray;

               color                   clrEnableTrading           = clrGreen;
               color                   clrDisableTrading          = clrRed;

               bool                    NoCorruptedCheck           = false;
               bool                    AllPositiveProfit          = false;
               datetime                CurrentTime                = 0;
               datetime                DailyStartDateTime         = 0;
               datetime                DailyStopDateTime          = 0;
               datetime                WeeklyStartDateTime        = 0;
               datetime                WeeklyEndDateTime          = 0;
               double                  TotalProfit                = 0;
               bool                    ActiveOrders               = false;
               double                  LastUpperPrice             = 0;
               double                  LastLowerPrice             = 0;
               int                     DyOrderCountPerSide        = 0;
               double                  DyTargetProfit             = 0;
               double                  DyStopLoss                 = 0;
               double                  DyStartingLots             = 0;
               double                  LastGradLots               = 0;
               double                  TrailingProfitDrag         = 0;
               string                  CrLf                       = "\n";
               string                  Space                      = " ";
               string                  CommentFormat              = "";
               double                  BiggestProfit              = 0;
               double                  LastProfit                 = 0;
               double                  LowestProfit               = 1.7976931348623158e+308;
               double                  LowestMarginAvailable      = 1.7976931348623158e+308;
               double                  LowestEquityAvailable      = 1.7976931348623158e+308;

               string                  GVStopNext                 = "";
               string                  GVFastCloseOrders          = "";
               string                  GVFastCloseProfit          = "";
               string                  ConstGVStopNext            = "GTSTOP";
               string                  ConstGVFastCloseOrders     = "GTFASTCLOSE";
               string                  ConstGVFastCloseProfit     = "GTPROFIT";
               string                  ConstGVFinished            = "GTExtClosed";
               string                  btnEnableTrading           = "btnEnableTrading";
               string                  btnForceCloseAll           = "btnForceCloseAll";
               string                  btnStartTrading            = "btnStartTrading";
               string                  lnMidUpperRange            = "lnMidUpperRange";
               string                  lnMidLowerRange            = "lnMidLowerRange";
               string                  lnBID                      = "lnBID";
               string                  lnASK                      = "lnASK";
               string                  lnUPPERPRICE               = "lnUPPERPRICE";
               string                  lnLOWERPRICE               = "lnLOWERPRICE";
               string                  lnUPPERTH                  = "lnUPPERTH";
               string                  lnLOWERTH                  = "lnLOWERTH";
               string                  btnStartManuallyText       = "Start Manually";
               string                  btnKeepGoingText           = "Continue";
               string                  btnStopNextCycleText       = "Stop Next Cycle";
               string                  btnForceCloseAllText       = "Force Close All";
               color                   DefaultButtonTextColor     = clrWhite;
               color                   DefaultButtonBgColor       = clrBlueViolet;
               enTimeExecutionCodeStatus TimeExCodeStatus         = TECSIdle;
               enTrailingProfitStage   TrailingStage              = TRPSInitial;
               color                   clrPlaceBuy                = clrOrange;
               color                   clrPlaceSell               = clrBlue;
               color                   clrCloseProfit             = clrGreen;
               color                   clrCloseLoss               = clrRed;

int OnInit()
{
      // код доступен только после оплаты
   }
void OnDeinit(const int reason)
{
   DeleteButton(btnEnableTrading);
   DeleteButton(btnForceCloseAll);
   DeleteButton(btnStartTrading);
   EventKillTimer();

   PrintFormat("Deinit Reason: %s - %s", IntegerToString(reason), GetUninitReasonText(reason));
}
double OnTester()
{
   PrintFormat("HIGHEST OPEN ORDER COUNT: %s", IntegerToString(HighestOpenOrder));
   PrintFormat("BIGGEST PROFIT: %s", DoubleToString(BiggestProfit, 2));
   PrintFormat("LOWEST PROFIT: %s", DoubleToString(LowestProfit, 2));
   PrintFormat("LOWEST EQUITY: %s", DoubleToString(LowestEquityAvailable, 2));
   PrintFormat("LOWEST FREE MARGIN: %s", DoubleToString(LowestMarginAvailable, 2));
   PrintFormat("BUY: %s, SELL: %s", IntegerToString(BuyCount), IntegerToString(SellCount));
   PrintFormat("HIGHEST BUY: %s, SELL: %s", IntegerToString(HighestBuyCount), IntegerToString(HighestSellCount));
   return(INIT_SUCCEEDED);
}

void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{

   if (id == CHARTEVENT_OBJECT_CLICK)
   {
      string clickedObject = sparam;
      if (clickedObject == btnEnableTrading) //Stop Next Cycle
      {
         bool selected = ObjectGetInteger(ChartID(), btnEnableTrading, OBJPROP_STATE);
         if (selected)
         {
            SetButtonColor(btnEnableTrading, clrDisableTrading);
         }
         if (IsStopOnNextCycle())
         {
            SetButtonText(btnEnableTrading, btnStopNextCycleText);
            SetButtonColor(btnEnableTrading, clrEnableTrading, DefaultButtonTextColor);
            SetStopNext(false);
            SetComments();
         }
         else
         {
            SetButtonText(btnEnableTrading, btnKeepGoingText);
            SetButtonColor(btnEnableTrading, clrDisableTrading);
            SetStopNext(true);
            SetComments();
         }
      }
      else if (clickedObject == btnForceCloseAll) //Force Close All
      {
         bool selected = ObjectGetInteger(ChartID(), btnForceCloseAll, OBJPROP_STATE);
         if (selected)
         {
            SetButtonColor(btnEnableTrading, clrGray);
            if (CloseMode == CMInternal)
            {
               CloseOrders();
            }
            else if (CloseMode == CMExtended)
            {
               CloseOrdersFast();
            }
            ResetOnClose();
            CalculateStartingLots();
            CalculateTargetProfit();
            CalculateStopLoss();
            SetComments();
            SetButtonColor(btnEnableTrading, DefaultButtonBgColor, DefaultButtonTextColor);
            PressButton(btnForceCloseAll); //to return the press
         }
      }
      else if (clickedObject == btnStartTrading)
      {
         CreateOrders();
      }
   }
}

void OnTick()
{
      // код доступен только после оплаты
   }

void BeforeOnInsideTimeRange()
{
   CycleCount = 0; //resetting the Cycle before OnInsideTimeRange executed.
}
void OnInsideTimeRange()
{
}
void OnOutsideTimeRange()
{
}
void OnOutsideTimeRangeInactive()
{
}

void OnTimer()
{

   SetComments();
}
void CalculateTrailingProfit()
{
   if (DyTargetProfit < (TotalProfit - TrailingProfitDrag))
   {
      DyTargetProfit = TotalProfit - TrailingProfitDrag;
   }
}
void CalculateStartingLots()
{
   double MaxLots = NormalizeDouble(MarketInfo(Symbol(), MODE_MAXLOT), 2);
   double MinLots = NormalizeDouble(MarketInfo(Symbol(), MODE_MINLOT), 2);
   double LotsStep = NormalizeDouble(MarketInfo(Symbol(),MODE_LOTSTEP), 2);
   if (InitialLotsType == ILTDynamic || InitialLotsType == ILTDynamicGradual)
   {
      double BaseCalc = 0;
      if (InitialLotsDynamicBase == DBBalance)
      {
         BaseCalc = AccountBalance();
      }
      else if (InitialLotsDynamicBase == DBEquity)
      {
         BaseCalc = AccountEquity();
      }

      if (BaseCalc > 0)
      {
         if (LotsStep == 0.01) //standard Lot size increment
         {
            DyStartingLots = NormalizeDouble(BaseCalc * InitialLotsMult, 2);
         }
         else
         {
            double _dyStLots = NormalizeDouble(BaseCalc * InitialLotsMult, 2);
            DyStartingLots = NormalizeDouble(_dyStLots - MathMod(_dyStLots, LotsStep), 2);
         }
      }
      else
      {
         DyStartingLots = MinLots;
      }
   }
   else if (InitialLotsType == ILTFixed || InitialLotsType == ILTFixedGradual)
   {
      DyStartingLots = NormalizeDouble(InitialLots, 2);
   }

   if (DyStartingLots < MinLots) DyStartingLots = MinLots;
   if (DyStartingLots > MaxLots) DyStartingLots = MaxLots;

   LastGradLots = DyStartingLots;
}

void CalculateTargetProfit()
{
   if (TargetType == TTDynamic)
   {
      double BaseCalc = 0;
      if (TargetProfitDynamicBase == DBBalance)
      {
         BaseCalc = AccountBalance();
      }
      else if (TargetProfitDynamicBase == DBEquity)
      {
         BaseCalc = AccountEquity();
      }

      if (BaseCalc > 0)
      {
         DyTargetProfit = BaseCalc * TargetProfitMult;
      }
   }
}
void RecalculateTargetProfit()
{
   if (RecalculationMode == ClAllRecalculate)
   {
      CalculateTargetProfit();
   }
}

void CalculateStopLoss()
{
   if (LossType == LTDynamic)
   {
      double BaseCalc = 0;
      if (StopLossDynamicBase == DBBalance)
      {
         BaseCalc = AccountBalance();
      }
      else if (StopLossDynamicBase == DBEquity)
      {
         BaseCalc = AccountEquity();
      }

      if (BaseCalc > 0)
      {
         DyStopLoss = BaseCalc * StopLossMult;
      }
   }
}
void RecalculateStopLoss()
{
   if (RecalculationMode == ClAllRecalculate)
   {
      CalculateStopLoss();
   }
}

void CreateOrders()
{
   NoCorruptedCheck = true;
   bool InitialCreation = false;
   double CurrentUpperPrice = 0;
   double CurrentLowerPrice = 0;
   double AskTH = 0, BidTH = 0;
   int CreationCount = 0;
   double OrderLotSize = 0;

   if (IsStartOfCycle()) //First Cycle creation
   {
      InitialCreation = true;
      RefreshRates();
      TrailingStage = TRPSInitial;
      CurrentUpperPrice = Ask;
      CurrentLowerPrice = Bid;

      DrawLine(lnASK, Ask, clrRed, 1, STYLE_DOT);
      DrawLine(lnBID, Bid, clrGray, 1, STYLE_DOT);

      AskTH = AddPoints(Ask, MiddlePointRange);
      BidTH = AddPoints(Bid, 0 - MiddlePointRange);

      DrawLine(lnMidUpperRange, AskTH, clrBlue, 1, STYLE_DOT);
      DrawLine(lnMidLowerRange, BidTH, clrBlue, 1, STYLE_DOT);

      CurrentUpperPrice = AddPoints(CurrentUpperPrice, CurrentPriceInterval);
      CurrentLowerPrice = AddPoints(CurrentLowerPrice, 0 - CurrentPriceInterval);

      DyOrderCountPerSide = OrderCountPerSide;
      CreationCount = OrderCountPerSide;

      CalculateTargetProfit();
      CalculateStopLoss();

      CalculateStartingLots();
   }
   else if (LastLowerPrice > 0 && LastUpperPrice > 0 && OpenType != OTFixedOrder) //subsequent recreation
   {
      CurrentUpperPrice = LastUpperPrice;
      CurrentLowerPrice = LastLowerPrice;

      DyOrderCountPerSide += RecreationCountPerSide;
      CreationCount = RecreationCountPerSide;
   }

   for(int i = 0; i < CreationCount; i++)
   {
      if (LimitMaxOrderCount && AllOrdersCount >= MaxOrderCount) break;
      if (i == 0) ActiveOrders = true;

      double PriceTP = 0; double PriceSL = 0; int slp = 0;

      if ((InitialLotsType == ILTDynamicGradual || InitialLotsType == ILTFixedGradual) && !(i == 0 && InitialCreation))
      {
         if (GradualLotsOperator == GOAdd)
         {
            LastGradLots = LastGradLots + GradualLotsMult;
         }
         else if (GradualLotsOperator == GOMultiply)
         {
            LastGradLots = LastGradLots * GradualLotsMult;
         }
      }
      else if (InitialLotsType == ILTDynamic || InitialLots == ILTFixed)
      {
         LastGradLots = DyStartingLots;
      }

      OrderLotSize = NormalizeDouble(LastGradLots, 2);

      int Chk = 0;
      if (OrderOperation == StopOrders || (OrderOperation == FewLimitOrders && AllOrdersCount >= LimitOrdersCount))
      {
         Chk = 0;
         Chk = OrderSend(Symbol(), OP_BUYSTOP, OrderLotSize, CurrentUpperPrice, slp, PriceSL, PriceTP, CommentInfo, MagicNumber, 0, clrPlaceBuy);
         if (Chk == -1)
            Alert(StringFormat("ERROR: %s, Lots: %s on Price: %s", GetErrorMessages("CreateOrders"), DoubleToString(OrderLotSize, 2), DoubleToString(CurrentUpperPrice, Digits)));
         else
         {
            PendingBuyCount += 1; AllOrdersCount += 1;
         }

         Chk = 0;
         Chk = OrderSend(Symbol(), OP_SELLSTOP, OrderLotSize, CurrentLowerPrice, slp, PriceSL, PriceTP, CommentInfo, MagicNumber, 0, clrPlaceSell);
         if (Chk == -1)
            Alert(StringFormat("ERROR: %s, Lots: %s on Price: %s", GetErrorMessages("CreateOrders"), DoubleToString(OrderLotSize, 2), DoubleToString(CurrentLowerPrice, Digits)));
         else
         {
            PendingSellCount += 1; AllOrdersCount += 1;
         }
      }
      else if (OrderOperation == LimitOrders || (OrderOperation == FewLimitOrders && i < LimitOrdersCount))
      {
         Chk = 0;
         Chk = OrderSend(Symbol(), OP_SELLLIMIT, OrderLotSize, CurrentUpperPrice, slp, PriceSL, PriceTP, CommentInfo, MagicNumber, 0, clrPlaceSell);
         if (Chk == -1)
            Alert(StringFormat("ERROR: %s, Lots: %s on Price: %s", GetErrorMessages("CreateOrders"), DoubleToString(OrderLotSize, 2), DoubleToString(CurrentUpperPrice, Digits)));
         else
         {
            PendingSellCount += 1; AllOrdersCount += 1;
         }

         Chk = 0;
         Chk = OrderSend(Symbol(), OP_BUYLIMIT, OrderLotSize, CurrentLowerPrice, slp, PriceSL, PriceTP, CommentInfo, MagicNumber, 0, clrPlaceBuy);
         if (Chk == -1)
            Alert(StringFormat("ERROR: %s, Lots: %s on Price: %s", GetErrorMessages("CreateOrders"), DoubleToString(OrderLotSize, 2), DoubleToString(CurrentLowerPrice, Digits)));
         else
         {
            PendingBuyCount += 1; AllOrdersCount += 1;
         }
      }

      CurrentUpperPrice = AddPoints(CurrentUpperPrice, GridStepPoints);
      CurrentLowerPrice = AddPoints(CurrentLowerPrice, 0 - GridStepPoints);

      LastUpperPrice = CurrentUpperPrice;
      LastLowerPrice = CurrentLowerPrice;
   }

   DrawLine(lnUPPERPRICE, LastUpperPrice, clrYellow, 1, STYLE_DOT);
   DrawLine(lnLOWERPRICE, LastLowerPrice, clrYellow, 1, STYLE_DOT);

   NoCorruptedCheck = false;

   if (InitialCreation)
   {
      CycleCount += 1;
   }
}

bool IsTimeToClose()
{
   bool IsTime = false;

   if (ActiveOrders)
   {
      RefreshRates();
      double MUpperRange = 0;
      double MLowerRange = 0;
      MUpperRange = GetLinePrice(lnMidUpperRange);
      MLowerRange = GetLinePrice(lnMidLowerRange);

      bool IsTargetReached = ((TotalProfit >= TargetProfit && TargetType == TTFixed) || (TotalProfit >= DyTargetProfit && TargetType == TTDynamic));
      bool IsLossAccepted = ((LossType == LTFixed && TotalProfit <= StopLoss && StopLoss < 0) || (LossType == LTDynamic && TotalProfit <= DyStopLoss && DyStopLoss < 0));
      bool IsInMiddlePoint = (Ask <= MUpperRange && Bid >= MLowerRange);
      bool IsMidPointActivated = (((BuyCount + SellCount) >= CloseMiddlePointAftOrders && CloseMiddlePointAftOrders > 0) || CloseMiddlePointAftOrders <= 0);
      bool IsProfitMaxOrderActivated = (((BuyCount + SellCount) >= MinProfitOrders && MinProfitOrders > 0) || MinProfitOrders <= 0);
      bool IsReachingThreshold = (AddPoints(LastUpperPrice, 0 - GridStepPoints - CloseThreshold) <= Ask || AddPoints(LastLowerPrice, GridStepPoints + CloseThreshold) > Bid);

      if (TrailingMode == TRPDragTrailing && IsTargetReached && TrailingStage == TRPSInitial)
      {
         TrailingStage = TRPSTrailing;
         if (TargetType == TTFixed)
         {
            TrailingProfitDrag = TargetProfit;
         }
         else if (TargetType == TTDynamic)
         {
            TrailingProfitDrag = DyTargetProfit;
         }
         DyTargetProfit = 0;
         IsTargetReached = false; //set the target back to false,assuming the Trailing starts here
      } else if (TrailingMode == TRPDragTrailing && TrailingStage == TRPSTrailing && TotalProfit <= DyTargetProfit)
      {
         Is

Показано первые 50% кода (символов: 44449)