NLD_Trade

ÿþ//+-------------------------------------------+

//|                             NLD_Trade.mq5 |

//|                     http://www.nelodi.com |

//|             Copyright (c) 2019 NELODI.com |

//+-------------------------------------------+

#property copyright   "2019 © NELODI.com"

#property link        "http://www.nelodi.com"

#property description "NELODI - Trade"



#property strict



#include "NLD_Include.mqh"



enum MB_TPL {

   mbTotal,  // Total

   mbProfit, // Only Profits

   mbLoss,   // Only Losses

   mbBest    // Best Position

};



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

input double  iCommisForex=0.06;    // Forex Commission ($) {0.06}

input double  iCommisStock=0.36;    // Stock Commission ($) {0.36}

input MB_TPL  iMidButton=mbBest;    // BUY/SELL Center {Best Position}



double  iMarginStop=0;        // Low Margin Level (Balance%) {0}



#property indicator_separate_window

#property indicator_buffers 15

#property indicator_plots 10



#property indicator_type1  DRAW_FILLING

#property indicator_type2  DRAW_FILLING

#property indicator_type3  DRAW_FILLING

#property indicator_type4  DRAW_FILLING

#property indicator_type5  DRAW_FILLING



#property indicator_type6  DRAW_LINE



#property indicator_type7  DRAW_LINE

#property indicator_type8  DRAW_LINE

#property indicator_type9  DRAW_LINE

#property indicator_type10 DRAW_LINE



#property indicator_color1  C'0,32,0'

#property indicator_color2  C'32,0,0'

#property indicator_color3  C'0,64,0'

#property indicator_color4  C'64,0,0'

#property indicator_color5  C'128,0,0',C'0,128,0'



#property indicator_color6  C'255,255,0'



#property indicator_color7  C'100,100,100'

#property indicator_color8  C'150,150,150'

#property indicator_color9  C'200,200,200'

#property indicator_color10 C'255,255,255'



#property indicator_style6  STYLE_SOLID



#property indicator_style7  STYLE_SOLID

#property indicator_style8  STYLE_SOLID

#property indicator_style9  STYLE_SOLID

#property indicator_style10 STYLE_SOLID



#property indicator_width6  2



#property indicator_width7  1

#property indicator_width8  1

#property indicator_width9  1

#property indicator_width10 2



int iCostWid=50;

int iBuySellWid=120;

int iAccountWid=100;



int InpShift=0;

bool useDOM=false;



//--- buffers

double ExtHighBuffer[];

double ExtTopBuffer[];

double ExtBotBuffer[];

double ExtLowBuffer[];

double ExtHigh2Buffer[];

double ExtTop2Buffer[];

double ExtBot2Buffer[];

double ExtLow2Buffer[];

double ExtOpenBuffer[];

double ExtCloseBuffer[];



double ExtPivotBuffer[];

double ExtAskBuffer[];

double ExtBidBuffer[];

double ExtAsk2Buffer[];

double ExtBid2Buffer[];



MqlBookInfo  DOM[];

bool DOM_subscribed=false;



double lastAsk,lastBid;

int lastPeriod=PERIOD_CURRENT;



double pixel;



double tgtBuyPrice=0,tgtSellPrice=0;



int iHig=1;

int iHig2=1;

//+------------------------------------------------------------------+

//| Custom indicator initialization function                         |

//|------------------------------------------------------------------|

void OnInit(void) {

   lastAsk=0;

   lastBid=0;



   PrepareAccount(_Symbol,iCommisForex,iCommisStock,iMarginStop);



   IndicatorSetInteger(INDICATOR_DIGITS,_Digits);

//--- indicator lines

   SetIndexBuffer(0,ExtHigh2Buffer);

   SetIndexBuffer(1,ExtTop2Buffer);

   SetIndexBuffer(2,ExtBot2Buffer);

   SetIndexBuffer(3,ExtLow2Buffer);

   SetIndexBuffer(4,ExtHighBuffer);

   SetIndexBuffer(5,ExtTopBuffer);

   SetIndexBuffer(6,ExtBotBuffer);

   SetIndexBuffer(7,ExtLowBuffer);

   SetIndexBuffer(8,ExtOpenBuffer);

   SetIndexBuffer(9,ExtCloseBuffer);



   SetIndexBuffer(10,ExtPivotBuffer);

   SetIndexBuffer(11,ExtAsk2Buffer);

   SetIndexBuffer(12,ExtBid2Buffer);

   SetIndexBuffer(13,ExtAskBuffer);

   SetIndexBuffer(14,ExtBidBuffer);



//--- initialization done

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(2,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(3,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(4,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(5,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(6,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(7,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(8,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(9,PLOT_EMPTY_VALUE,EMPTY_VALUE);



   PlotIndexSetInteger(0,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(1,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(2,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(3,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(4,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(5,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(6,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(7,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(8,PLOT_SHIFT,InpShift);

   PlotIndexSetInteger(9,PLOT_SHIFT,InpShift);



   pixel=1/MathPow(10,_Digits);



   if(useDOM) {

      DOM_subscribed=MarketBookAdd(_Symbol);

   }



   ChartSetInteger(ChartID(),CHART_SHIFT,true);

   ChartSetInteger(0,CHART_SHOW_DATE_SCALE,false);

   ChartSetInteger(0,CHART_SHOW_PRICE_SCALE,false);

   ChartSetInteger(0,CHART_SHOW_OBJECT_DESCR,false);



   ButtonsCreate();

   EventSetTimer(3);

}

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void OnTimer() {

   int id=ChartWindowFind();

   int oHig=(int)ChartGetInteger(ChartID(),CHART_HEIGHT_IN_PIXELS,id)/8;

   int oHig2=(int)ChartGetInteger(ChartID(),CHART_HEIGHT_IN_PIXELS,id)/5;

   if((iHig!=oHig) || (iHig2!=oHig2)) ButtonsCreate();

}

//+------------------------------------------------------------------+

void ButtonsCreate() {

   int id=ChartWindowFind();

   int iCH=(int)ChartGetInteger(ChartID(),CHART_HEIGHT_IN_PIXELS,id);

   iHig=iCH/8;

   int iHid=iCH-iHig*7-1;

   iHig2=iCH/5;

   int iHid2=iCH-iHig2*4-1;



   ticBtnCreate(id,"Btn_Sell",CORNER_RIGHT_UPPER,iAccountWid+iBuySellWid,0,iBuySellWid,iHig2,clrBlack,C'50,50,50',false,12,"SELL");

   ticBtnCreate(id,"Btn_SellTotal",CORNER_RIGHT_UPPER,iAccountWid+iBuySellWid,iHig2,iBuySellWid,iHig2,clrSilver,clrBlack,false,12);



   ticBtnCreate(id,

                (iMidButton==mbTotal?"Btn_Total": iMidButton==mbProfit?"Btn_Profit": iMidButton==mbLoss?"Btn_Loss": "Btn_Best"),

                CORNER_RIGHT_UPPER,iAccountWid+iBuySellWid,iHig2*2,iBuySellWid,iHid2,clrSilver,clrBlack,false,12);



   ticBtnCreate(id,"Btn_BuyTotal",CORNER_RIGHT_LOWER,iAccountWid+iBuySellWid,iHig2*2,iBuySellWid,iHig2,clrSilver,clrBlack,false,12);

   ticBtnCreate(id,"Btn_Buy",CORNER_RIGHT_LOWER,iAccountWid+iBuySellWid,iHig2,iBuySellWid,iHig2,clrBlack,C'50,50,50',false,12,"BUY");



   ticBtnCreate(id,"Account_Balance",CORNER_RIGHT_UPPER,iAccountWid,iHig*0,iAccountWid,iHig,clrSilver,C'50,50,50',true,9);

   ticBtnCreate(id,"Account_Equity",CORNER_RIGHT_UPPER,iAccountWid,iHig*1,iAccountWid,iHig,clrWhite,C'50,50,50',true,9);



   ticBtnCreate(id,"Account_Margin",CORNER_RIGHT_UPPER,iAccountWid,iHig*2,iAccountWid,iHig,clrYellow,C'50,50,50',true,9);

   ticBtnCreate(id,"Account_Free",CORNER_RIGHT_UPPER,iAccountWid,iHig*3,iAccountWid,iHid,clrOrange,C'50,50,50',true,9);



   ticBtnCreate(id,"Swap_Short",CORNER_RIGHT_LOWER,iCostWid,iHig*4,iCostWid,iHig,clrSilver,C'100,0,50',true,9);

   ticBtnCreate(id,"Swap_Long",CORNER_RIGHT_LOWER,iAccountWid,iHig*4,iCostWid,iHig,clrSilver,C'0,100,50',true,9);



   ticBtnCreate(id,"Trade_Cost",CORNER_RIGHT_LOWER,iAccountWid,iHig*3,iCostWid,iHig,clrBlack,C'100,100,100',true,9);

   ticBtnCreate(id,"Candle_Time_Left",CORNER_RIGHT_LOWER,iCostWid,iHig*3,iCostWid,iHig,clrSilver,clrBlack,false,9);



   ticBtnCreate(id,"Candle_Time_Now",CORNER_RIGHT_LOWER,iAccountWid,iHig*2,iAccountWid,iHig,clrSilver,clrBlack,false,9);

   ticBtnCreate(id,"Symbol_Name",CORNER_RIGHT_LOWER,iAccountWid,iHig*1,iAccountWid,iHig,clrSilver,clrBlack,false,9,_Symbol);



   doUpdateInfo();

   doUpdateChart();

}

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void OnDeinit(const int reason) {

   EventKillTimer();



   if(DOM_subscribed) {

      if(!MarketBookRelease(_Symbol))

         PrintFormat("DOM %s unsubscribe Error %d",_Symbol,GetLastError());

      else

         DOM_subscribed=false;

   }



   if(reason!=REASON_CHARTCHANGE) {

      ObjectDelete(0,"Btn_Sell");

      ObjectDelete(0,"Btn_SellP_BuyL");

      ObjectDelete(0,"Btn_Total");

      ObjectDelete(0,"Btn_BuyP_SellL");

      ObjectDelete(0,"Btn_Buy");



      ObjectDelete(0,"Symbol_Name");

      ObjectDelete(0,"Swap_Short");

      ObjectDelete(0,"Swap_Long");



      ObjectDelete(0,"Trade_Cost");



      ObjectDelete(0,"Candle_Time_Total");

      ObjectDelete(0,"Candle_Time_Left");

      ObjectDelete(0,"Candle_Time_Now");



      ObjectDelete(0,"Account_Balance");

      ObjectDelete(0,"Account_Equity");

      ObjectDelete(0,"Account_Margin");

      ObjectDelete(0,"Account_Free");

   }

}

//+------------------------------------------------------------------+

void MyArrCopy(double &arr[],int copyCount,int copyDistance) {

   int siz=ArraySize(arr),start=(copyCount>0?siz-copyCount:copyDistance);

   if(start<0) start=0;

   if(siz>0) {

      if(start>=copyDistance) ArrayCopy(arr,arr,start-copyDistance,start,copyCount);

      else if(start-(copyDistance-start)>0) ArrayCopy(arr,arr,0,start-(copyDistance-start),copyCount);

   }

}

//+------------------------------------------------------------------+



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[]) {

   if(rates_total<2) return(0);



   ArraySetAsSeries(time,true);

   ArraySetAsSeries(open,true);

   ArraySetAsSeries(high,true);

   ArraySetAsSeries(low,true);

   ArraySetAsSeries(close,true);

   ArraySetAsSeries(tick_volume,true);

   ArraySetAsSeries(spread,true);



   ArraySetAsSeries(ExtHighBuffer,true);

   ArraySetAsSeries(ExtTopBuffer,true);

   ArraySetAsSeries(ExtBotBuffer,true);

   ArraySetAsSeries(ExtLowBuffer,true);

   ArraySetAsSeries(ExtHigh2Buffer,true);

   ArraySetAsSeries(ExtTop2Buffer,true);

   ArraySetAsSeries(ExtBot2Buffer,true);

   ArraySetAsSeries(ExtLow2Buffer,true);

   ArraySetAsSeries(ExtOpenBuffer,true);

   ArraySetAsSeries(ExtCloseBuffer,true);



   ArraySetAsSeries(ExtPivotBuffer,true);

   ArraySetAsSeries(ExtAskBuffer,true);

   ArraySetAsSeries(ExtBidBuffer,true);

   ArraySetAsSeries(ExtAsk2Buffer,true);

   ArraySetAsSeries(ExtBid2Buffer,true);



   if(rates_total==prev_calculated) {

      ArrayCopy(ExtHighBuffer,ExtHighBuffer,1,0,rates_total-1);

      ArrayCopy(ExtTopBuffer,ExtTopBuffer,1,0,rates_total-1);

      ArrayCopy(ExtBotBuffer,ExtBotBuffer,1,0,rates_total-1);

      ArrayCopy(ExtLowBuffer,ExtLowBuffer,1,0,rates_total-1);

      ArrayCopy(ExtHigh2Buffer,ExtHigh2Buffer,1,0,rates_total-1);

      ArrayCopy(ExtTop2Buffer,ExtTop2Buffer,1,0,rates_total-1);

      ArrayCopy(ExtBot2Buffer,ExtBot2Buffer,1,0,rates_total-1);

      ArrayCopy(ExtLow2Buffer,ExtLow2Buffer,1,0,rates_total-1);

      ArrayCopy(ExtOpenBuffer,ExtOpenBuffer,1,0,rates_total-1);

      ArrayCopy(ExtCloseBuffer,ExtCloseBuffer,1,0,rates_total-1);



      ArrayCopy(ExtPivotBuffer,ExtPivotBuffer,1,0,rates_total-1);

      ArrayCopy(ExtAskBuffer,ExtAskBuffer,1,0,rates_total-1);

      ArrayCopy(ExtBidBuffer,ExtBidBuffer,1,0,rates_total-1);

      ArrayCopy(ExtAsk2Buffer,ExtAsk2Buffer,1,0,rates_total-1);

      ArrayCopy(ExtBid2Buffer,ExtBid2Buffer,1,0,rates_total-1);

   }



   int i=0;

   double xc=close[i],bc=close[i],ba=close[i];



   double xo2=open[i+1];

   double xh2=high[i+1];

   double xl2=low[i+1];



   double xo=open[i];

   double xh=high[i];

   double xl=low[i];



   double xz=(high[i+1]+low[i+1]+close[i+1])/3.0;



   long xs=SymbolInfoInteger(_Symbol,SYMBOL_SPREAD);



   double xb=close[i];

   double xa=close[i]+xs*pixel;



   double haveBA=false;



   int nowPeriod=Period();



   tgtBuyPrice=0;

   tgtSellPrice=0;



   doUpdateInfo();

   doUpdateChart();



   if(midBuyPrice>0) tgtBuyPrice=nextBuyTarget(minTradeVol);

   else tgtBuyPrice=0;

   if(midSellPrice>0) tgtSellPrice=nextSellTarget(minTradeVol);

   else tgtSellPrice=0;



   if((lastPeriod!=nowPeriod) || (prev_calculated==0)) {

      ArrayFill(ExtHighBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtTopBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtBotBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtLowBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtHigh2Buffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtTop2Buffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtBot2Buffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtLow2Buffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtOpenBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtCloseBuffer,0,rates_total,EMPTY_VALUE);



      ArrayFill(ExtPivotBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtAskBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtBidBuffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtAsk2Buffer,0,rates_total,EMPTY_VALUE);

      ArrayFill(ExtBidBuffer,0,rates_total,EMPTY_VALUE);



      int cnt=(int)MathMin(rates_total-1,ChartGetInteger(0,CHART_WIDTH_IN_BARS)*(ChartGetInteger(0,CHART_SCALE)+1));

      MqlTick ticks[];

      int gotTicks=CopyTicks(_Symbol,ticks,COPY_TICKS_INFO,0,cnt);

      if(gotTicks>=cnt) {

         if((ticks[gotTicks-1].bid>=close[0]-pixel*xs) && (ticks[gotTicks-1].bid<=close[0]+pixel*xs)) {

            for(int j=gotTicks; j>0; j--) {

               bc=ticks[gotTicks-j].bid;

               ba=ticks[gotTicks-j].ask;



               ExtAskBuffer[j]=ba;

               ExtBidBuffer[j]=bc;

               ExtAsk2Buffer[j]=ba+comSpread;

               ExtBid2Buffer[j]=bc-comSpread;



               ExtHigh2Buffer[j]=xh2;

               ExtTop2Buffer[j]=xo2;

               ExtBot2Buffer[j]=xo2+pixel;

               ExtLow2Buffer[j]=xl2;



               ExtHighBuffer[j]=xh;

               ExtTopBuffer[j]=xo;

               ExtBotBuffer[j]=xo+pixel;

               ExtLowBuffer[j]=xl;



               ExtOpenBuffer[j]=xo;

               ExtCloseBuffer[j]=bc;



               ExtPivotBuffer[j]=xz;

            }

         }

      }

   }



   lastPeriod=nowPeriod;



   ExtHigh2Buffer[i]=xh2;

   ExtTop2Buffer[i]=xo2;



   ExtBot2Buffer[i]=xo2;

   ExtLow2Buffer[i]=xl2;



   ExtHighBuffer[i]=xh;

   ExtTopBuffer[i]=xo;



   ExtBotBuffer[i]=xo;

   ExtLowBuffer[i]=xl;



   ExtOpenBuffer[i]=xo;

   ExtCloseBuffer[i]=xc;



   ExtPivotBuffer[i]=xz;



   ExtAskBuffer[i]=xa;

   ExtBidBuffer[i]=xb;

   ExtAsk2Buffer[i]=xa+comSpread;

   ExtBid2Buffer[i]=xb-comSpread;



   lastAsk=xa;

   lastBid=xb;



   doUpdateMe(time[i]-time[i+1]);



   return(rates_total);

}

//+------------------------------------------------------------------+

void doUpdateMe(datetime tim) {

   double ttv=TradeTickValue();



   long tnow=SymbolInfoInteger(_Symbol,SYMBOL_TIME);

   long timeleft=PeriodSeconds(PERIOD_CURRENT)-((tnow+11*60*60*24)%PeriodSeconds(PERIOD_CURRENT));

   if(PeriodSeconds(PERIOD_CURRENT)==60*60*24*7) timeleft-=60*60*24*1;



   if(timeleft>3600*24)

      ObjectSetString(0,"Candle_Time_Left",OBJPROP_TEXT,IntegerToString(timeleft/(3600*24))+"d "+IntegerToString((timeleft/3600)%24)+"h");

   else if(timeleft>3600)

      ObjectSetString(0,"Candle_Time_Left",OBJPROP_TEXT,IntegerToString(timeleft/3600)+"h "+IntegerToString((timeleft/60)%60)+"m");

   else

      ObjectSetString(0,"Candle_Time_Left",OBJPROP_TEXT,IntegerToString(timeleft/60)+":"+IntegerToString(timeleft%60));



   ObjectSetString(0,"Candle_Time_Now",OBJPROP_TEXT,TimeToString(tnow,TIME_MINUTES|TIME_SECONDS));



   MqlDateTime mdt;

   TimeToStruct(tnow,mdt);

   double mult=1;

   if(mdt.day_of_week==SymbolInfoInteger(_Symbol,SYMBOL_SWAP_ROLLOVER3DAYS)) mult=3;

   double swaplong=ttv*SymbolInfoDouble(_Symbol,SYMBOL_SWAP_LONG)*mult;

   double swapshort=ttv*SymbolInfoDouble(_Symbol,SYMBOL_SWAP_SHORT)*mult;



   ObjectSetString(0,"Swap_Long",OBJPROP_TEXT,DoubleToString(swaplong,2));

   ObjectSetString(0,"Swap_Short",OBJPROP_TEXT,DoubleToString(swapshort,2));



   ObjectSetString(0,"Trade_Cost",OBJPROP_TEXT,DoubleToString(TradeCost(),2));

}

//+------------------------------------------------------------------+

void ticBtnCreate(int cid,const string bname,ENUM_BASE_CORNER bcorn,int xdist,int ydist,int xsize,int ysize,color ctext,color cback,bool braised,int fsize=10,const string btext="") {

   if(ObjectFind(0,bname)!=cid) {

      ObjectCreate(0,bname,OBJ_BUTTON,cid,0,0);



      ObjectSetInteger(0,bname,OBJPROP_COLOR,ctext);

      ObjectSetInteger(0,bname,OBJPROP_BGCOLOR,cback);

      ObjectSetInteger(0,bname,OBJPROP_FONTSIZE,fsize);

      if(braised) {

         ObjectSetInteger(0,bname,OBJPROP_BORDER_TYPE,BORDER_RAISED);

         ObjectSetInteger(0,bname,OBJPROP_BORDER_COLOR,clrNONE);

      } else {

         ObjectSetInteger(0,bname,OBJPROP_BORDER_TYPE,BORDER_FLAT);

         ObjectSetInteger(0,bname,OBJPROP_BORDER_COLOR,clrBlack);

      }

   }



   ObjectSetString(0,bname,OBJPROP_TEXT,btext);



   ObjectSetInteger(0,bname,OBJPROP_ZORDER,1000);

   ObjectSetInteger(0,bname,OBJPROP_SELECTABLE,false);



   ObjectSetInteger(0,bname,OBJPROP_CORNER,bcorn);

   ObjectSetInteger(0,bname,OBJPROP_XSIZE,xsize);

   ObjectSetInteger(0,bname,OBJPROP_YSIZE,ysize);

   ObjectSetInteger(0,bname,OBJPROP_XDISTANCE,xdist);

   ObjectSetInteger(0,bname,OBJPROP_YDISTANCE,ydist);



   ObjectSetInteger(0,bname,OBJPROP_STATE,false);

}

//+------------------------------------------------------------------+