//+------------------------------------------------------------------------------------------------------------------+
#property description                                                                          "[!!!-MT4 X-XARDg-RSI]"
#define Version                                                                                          "[XARDg-RSI]"
//+------------------------------------------------------------------------------------------------------------------+
#property link        "https://forex-station.com/viewtopic.php?p=1294848283#p1294848283"
#property description "THIS IS A FREE INDICATOR"
#property description "                                                      "
#property description "Welcome to the World of Forex"
#property description "Let light shine out of darkness and illuminate your world"
#property description "and with this freedom leave behind your cave of denial"
#property indicator_separate_window
#property indicator_buffers  14
#property indicator_color1   Blue
#property indicator_color2   Maroon
#property indicator_color3   Blue
#property indicator_color4   Maroon
#property indicator_color5   Black
#property indicator_color6   Black
#property indicator_color7   DeepSkyBlue
#property indicator_color8   PaleVioletRed
#property indicator_color9   DimGray
#property indicator_color10  DeepSkyBlue
#property indicator_color11  DeepSkyBlue
#property indicator_color12  PaleVioletRed
#property indicator_color13  PaleVioletRed

#property indicator_width1   3
#property indicator_width2   3
#property indicator_width3   3
#property indicator_width4   3
#property indicator_width5   3
#property indicator_width6   3
#property indicator_width7   1
#property indicator_width8   1
#property indicator_width9   3
#property indicator_width10   3
#property indicator_width11   3
#property indicator_width12   3
#property indicator_minimum  -25
#property indicator_maximum   25
#property indicator_height   180
#define lvl1 "lvl1"
#define lvl2 "lvl2"

//+------------------------------------------------------------------------------------------------------------------+
 string TimeFrame              = "Current time frame";
 extern int    RSIper                 = 20;
 extern ENUM_APPLIED_PRICE Price      = PRICE_CLOSE;
 extern double RSIModifier            = 0.9;
 double LevelUp                =  1.;
 double LevelDn                = -1.;
 extern double SmoothLength           =   5;
 extern double SmoothPhase            =   0;
 extern bool   ShowHistogram          = false;
 bool   Interpolate            = true;
 extern bool   alertsOn               = false;
 extern bool   alertsOnZoneEnter      = true;
 extern bool   alertsOnCurrent        = true;
 extern bool   alertsMessage          = true;
 extern bool   alertsSound            = false;
 extern bool   alertsEmail            = false;
 extern bool   verticalLinesVisible   = false;
 extern string verticalLinesID        = "RsiSmoothLines";
 extern bool   verticalLinesShowBreak   = true;
 extern bool   verticalLinesShowRetrace = false;
 extern color  verticalLinesUpColor   = DeepSkyBlue;
 extern color  verticalLinesDownColor = PaleVioletRed;
 extern ENUM_LINE_STYLE verticalLinesStyle = STYLE_DOT;
 extern int    verticalLinesWidth     = 2;
//+------------------------------------------------------------------------------------------------------------------+
extern string STR05                      = "<<<==== [05] BOXtxt2 Settings ====>>>";
  extern bool showBOXtxt2                 = true;
   extern int PanelBorderWidth           = 1;
 extern color PanelBorderColor           = C'120,120,120';
   extern int moveTxtLR                  = 0,moveTxtUD=0,FontSize=15; int BOXsize2; string ID,BOXtxt2; color BOXclr2;
//+------------------------------------------------------------------------------------------------------------------+
   double rsi[],rsiUa[],rsiUb[],rsiDa[];
   double rsiDb[],rsiHu[],rsiHd[],trend[];
   string indicatorFileName;
   bool   returnBars,calculateValue;
   int    timeFrame;
   double UpBackgroundZone[], DownBackgroundZone[],UpBackgroundZone2[], DownBackgroundZone2[],GrayBackgroundZoneup[],GrayBackgroundZonedn[];
//+------------------------------------------------------------------------------------------------------------------+
   int init(){IndicatorBuffers(14);
   if(Period()==PERIOD_M1) {RSIper=15.;}
   if(Period()==PERIOD_M5) {RSIper=13.;}
   if(Period()==PERIOD_M15){RSIper=11.;}
   if(Period()==PERIOD_M30){RSIper= 9.;}
   if(Period()==PERIOD_H1) {RSIper= 7.;}
   if(Period()>=PERIOD_H4) {RSIper= 5.;}
   SetIndexBuffer(0,UpBackgroundZone); 
   SetIndexBuffer(1,DownBackgroundZone); 
   SetIndexBuffer(2,UpBackgroundZone2); 
   SetIndexBuffer(3,DownBackgroundZone2);
   SetIndexBuffer(4,GrayBackgroundZoneup);
   SetIndexBuffer(5,GrayBackgroundZonedn);
   SetIndexStyle(0,DRAW_HISTOGRAM); 
   SetIndexStyle(1,DRAW_HISTOGRAM);
   SetIndexStyle(2,DRAW_HISTOGRAM); 
   SetIndexStyle(3,DRAW_HISTOGRAM); 
   SetIndexStyle(4,DRAW_HISTOGRAM);
   SetIndexStyle(5,DRAW_HISTOGRAM); 
  
   SetIndexBuffer(6,rsiHu); SetIndexStyle(6,DRAW_HISTOGRAM);
   SetIndexBuffer(7,rsiHd); SetIndexStyle(7,DRAW_HISTOGRAM);
   SetIndexBuffer(8,rsi);
   SetIndexBuffer(9,rsiUa);
   SetIndexBuffer(10,rsiUb);
   SetIndexBuffer(11,rsiDa);
   SetIndexBuffer(12,rsiDb);
   SetIndexBuffer(13,trend); SetIndexStyle(13,DRAW_NONE);
         RSIper = fmax(RSIper ,1);

         indicatorFileName = WindowExpertName();
         calculateValue    = TimeFrame=="calculateValue"; if (calculateValue) { return(0); }
         returnBars        = TimeFrame=="returnBars";     if (returnBars)     { return(0); }
         timeFrame         = stringToTimeFrame(TimeFrame);
         
         string PriceType;  switch(Price){
         case PRICE_CLOSE:    PriceType = "Close";    break;  // 0
         case PRICE_OPEN:     PriceType = "Open";     break;  // 1
         case PRICE_HIGH:     PriceType = "High";     break;  // 2
         case PRICE_LOW:      PriceType = "Low";      break;  // 3
         case PRICE_MEDIAN:   PriceType = "Median";   break;  // 4
         case PRICE_TYPICAL:  PriceType = "Typical";  break;  // 5
         case PRICE_WEIGHTED: PriceType = "Weighted"; break;} // 6
   ID = "c";  IndicatorShortName("RSI");
   for(int Bufx=0;Bufx<indicator_buffers;Bufx++){SetIndexLabel(Bufx,NULL);}  return(0);}
//+------------------------------------------------------------------------------------------------------------------+
   int deinit(){CleanUpOnIsle6();  string lookFor = verticalLinesID+":";  int lookForLength = StringLen(lookFor);
   for(int i=ObjectsTotal()-1; i>=0; i--){string objectName = ObjectName(i);
   if(StringSubstr(objectName,0,lookForLength) == lookFor) ObjectDelete(objectName);}  return(0);}
//+------------------------------------------------------------------------------------------------------------------+
   int start(){//CreateLVL();  
   int Win=WindowFind("RSI");  if(Win==-1) Win=0;
   int counted_bars=IndicatorCounted();  int i,k,n,limit;

   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;   limit = MathMin(Bars-counted_bars,Bars-1);
   if(returnBars){rsiHu[0] = MathMin(limit+1,Bars-1); return(0);}

   if(calculateValue || timeFrame == _Period){
   if(!calculateValue && trend[limit]== 1) CleanPoint(limit,rsiUa,rsiUb);
   if(!calculateValue && trend[limit]==-1) CleanPoint(limit,rsiDa,rsiDb);
   for(i=limit;i>=0;i--){CleanUpOnIsle6();
       rsi[i] = iSmooth(RSIModifier*(iRSI(NULL,0,RSIper,Price,i)-50.0),SmoothLength,SmoothPhase,i);
   if(ShowHistogram){
       rsiHu[i] = EMPTY_VALUE;
       rsiHd[i] = EMPTY_VALUE;
   if(rsi[i]>0) rsiHu[i] = rsi[i];
   if(rsi[i]<0) rsiHd[i] = rsi[i];} 
       rsiUa[i] = rsiUb[i] = EMPTY_VALUE;
       rsiDa[i] = rsiDb[i] = EMPTY_VALUE;           
       trend[i] = trend[i+1];
       
   if(rsi[i]<LevelUp && rsi[i]>LevelDn) trend[i]= 0;
   BOXtxt2=" WAITING..."; BOXclr2=C'30,40,50'; BOXsize2=124;
   if(rsi[i]>LevelUp){trend[i]= 1; BOXtxt2=" BUYS ONLY - CLOSE ALL SELL TRADES"; BOXclr2=clrBlue; BOXsize2=430;}
   if(rsi[i]<LevelDn){trend[i]=-1; BOXtxt2="SELLS ONLY - CLOSE ALL BUY TRADES"; BOXclr2=clrCrimson; BOXsize2=430;}
   
               UpBackgroundZone[i] = EMPTY_VALUE;
               DownBackgroundZone[i] = EMPTY_VALUE;
               UpBackgroundZone2[i] = EMPTY_VALUE;
               DownBackgroundZone2[i] = EMPTY_VALUE;
               GrayBackgroundZoneup[i] = EMPTY_VALUE;
               GrayBackgroundZonedn[i] = EMPTY_VALUE;
   if(trend[i] ==0) {GrayBackgroundZoneup[i]  = 100; GrayBackgroundZonedn[i]  = -100;}            
   else if(trend[i] ==-1) {DownBackgroundZone[i]  = 100; DownBackgroundZone2[i]  = -100; }
   else if(trend[i] == 1) {UpBackgroundZone[i]  = 100; UpBackgroundZone2[i]  = -100; } 
   
   if(!calculateValue && trend[i] ==  1) PlotPoint(i,rsiUa,rsiUb,rsi);
   if(!calculateValue && trend[i] == -1) PlotPoint(i,rsiDa,rsiDb,rsi);
//+---BOXtxt2 DISPLAY------------------------------------------------------------------------------------------------+
	if(showBOXtxt2){SetPanel2(0,ID+"Drak1",1,0,0,0,BOXsize2,22,BOXclr2,PanelBorderColor,PanelBorderWidth,false);
            ObjectSetInteger(0,ID+"Drak1",OBJPROP_BGCOLOR,BOXclr2);
                   SetLabel2(0,ID+"Drak2",1,0,4,0,BOXtxt2,16,"Arial Bold",clrSilver,0,false,true,0,ANCHOR_LEFT_UPPER);}
//+------------------------------------------------------------------------------------------------------------------+   
       manageLines(i);}  manageAlerts();  return(0);}   
//+------------------------------------------------------------------------------------------------------------------+   
   limit = fmax(limit,fmin(Bars,iCustom(NULL,timeFrame,indicatorFileName,"returnBars",0,0)*timeFrame/_Period));
   for (i=limit;i>=0;i--){int y = iBarShift(NULL,timeFrame,Time[i]);
     rsi[i] = iCustom(NULL,timeFrame,indicatorFileName,"calculateValue",RSIper,Price,RSIModifier,LevelUp,LevelDn,SmoothLength,SmoothPhase,2,y);
   trend[i] = iCustom(NULL,timeFrame,indicatorFileName,"calculateValue",RSIper,Price,RSIModifier,LevelUp,LevelDn,SmoothLength,SmoothPhase,7,y);
   rsiUa[i] = rsiUb[i] = EMPTY_VALUE;
   rsiDa[i] = rsiDb[i] = EMPTY_VALUE;
   if(ShowHistogram){
              rsiHu[i] = EMPTY_VALUE;
              rsiHd[i] = EMPTY_VALUE;
   if(rsi[i]>0) rsiHu[i] = rsi[i];
   if(rsi[i]<0) rsiHd[i] = rsi[i];}            
         manageLines(i);
      
   if(!Interpolate || y==iBarShift(NULL,timeFrame,Time[i-1])) continue;

   datetime time = iTime(NULL,timeFrame,y);
   for(n = 1; i+n < Bars && Time[i+n] >= time; n++) continue;	
   for(k = 1; k < n; k++){
      rsi[i+k] = rsi[i] + (rsi[i+n]-rsi[i])*k/n;
   if(rsiHu[i+k]!=EMPTY_VALUE) rsiHu[i+k] = rsi[i+k];
   if(rsiHd[i+k]!=EMPTY_VALUE) rsiHd[i+k] = rsi[i+k];}}
   for(i=limit;i>=0;i--){
   if(trend[i]== 1) PlotPoint(i,rsiUa,rsiUb,rsi);
   if(trend[i]==-1) PlotPoint(i,rsiDa,rsiDb,rsi);}  manageAlerts();  return(0);}
//+------------------------------------------------------------------------------------------------------------------+
   void manageAlerts(){if(!calculateValue && alertsOn){if(alertsOnCurrent) 
   int whichBar = 0; else whichBar = 1; whichBar = iBarShift(NULL,0,iTime(NULL,timeFrame,whichBar));
   if(trend[whichBar] != trend[whichBar+1]){
   if(alertsOnZoneEnter && trend[whichBar]   ==  1) doAlert(whichBar, "the Up Zone");
   if(alertsOnZoneEnter && trend[whichBar]   == -1) doAlert(whichBar, "the Down Zone");}}}
//+------------------------------------------------------------------------------------------------------------------+
   void doAlert(int forBar, string doWhat){static string previousAlert="nothing";
   static datetime previousTime; string msg;
   if(previousAlert != doWhat || previousTime != Time[forBar]){previousAlert  = doWhat;   previousTime  = Time[forBar];
      msg=StringConcatenate(Symbol()," ",timeFrameToString(timeFrame)," at ",TimeToStr(TimeLocal(),TIME_SECONDS)," RSI entered ",doWhat);
   if(alertsMessage) Alert(msg);
   if(alertsEmail)   SendMail(StringConcatenate(Symbol(),"rsi"),msg);
   if(alertsSound)   PlaySound("alert2.wav");}}
//+------------------------------------------------------------------------------------------------------------------+
   void manageLines(int i){
   if(!calculateValue && verticalLinesVisible){deleteLine(Time[i]);
   if(trend[i]!=trend[i+1]){
   if(verticalLinesShowBreak){
   if(trend[i] == 1) drawLine(i,verticalLinesUpColor);
   if(trend[i] ==-1) drawLine(i,verticalLinesDownColor);}               
   if(verticalLinesShowRetrace){
   if(trend[i] == 0 && trend[i+1]==-1) drawLine(i,verticalLinesUpColor);
   if(trend[i] == 0 && trend[i+1]== 1) drawLine(i,verticalLinesDownColor);}}}}               
//+------------------------------------------------------------------------------------------------------------------+
   void drawLine(int i,color theColor){string name = verticalLinesID+":"+Time[i];
      ObjectCreate(name,OBJ_VLINE,0,Time[i],0);
         ObjectSet(name,OBJPROP_COLOR,theColor);
         ObjectSet(name,OBJPROP_STYLE,verticalLinesStyle);
         ObjectSet(name,OBJPROP_WIDTH,verticalLinesWidth);
         ObjectSet(name,OBJPROP_BACK,true);}
//+------------------------------------------------------------------------------------------------------------------+
   void deleteLine(datetime time){string lookFor = verticalLinesID+":"+time; ObjectDelete(lookFor);}
//+------------------------------------------------------------------------------------------------------------------+
   void CleanPoint(int i,double& first[],double& second[]){
   if((second[i]!=EMPTY_VALUE) && (second[i+1]!=EMPTY_VALUE)) second[i+1]=EMPTY_VALUE; else
   if((first[i] !=EMPTY_VALUE) && (first[i+1]!=EMPTY_VALUE) && (first[i+2]==EMPTY_VALUE)) first[i+1]=EMPTY_VALUE;}
//+------------------------------------------------------------------------------------------------------------------+
   void PlotPoint(int i,double& first[],double& second[],double& from[]){
   if(first[i+1] == EMPTY_VALUE){
   if(first[i+2] == EMPTY_VALUE){first[i] = from[i];  first[i+1] = from[i+1];
      second[i]   = EMPTY_VALUE;} else {second[i] = from[i];  second[i+1] = from[i+1];
      first[i]    = EMPTY_VALUE;}} else {first[i] = from[i];
      second[i]   = EMPTY_VALUE;}}
//+------------------------------------------------------------------------------------------------------------------+
   string sTfTable[] = {"M1","M5","M15","M30","H1","H4","D1","W1","MN"};
   int    iTfTable[] = {1,5,15,30,60,240,1440,10080,43200};
//+------------------------------------------------------------------------------------------------------------------+
   int stringToTimeFrame(string tfs){tfs = stringUpperCase(tfs);
   for(int i=ArraySize(iTfTable)-1; i>=0; i--)
   if(tfs==sTfTable[i] || tfs==""+iTfTable[i]) return(MathMax(iTfTable[i],Period())); return(Period());}
//+------------------------------------------------------------------------------------------------------------------+
   string timeFrameToString(int tf){for(int i=ArraySize(iTfTable)-1; i>=0; i--) 
   if(tf==iTfTable[i]) return(sTfTable[i]); return("");}
//+------------------------------------------------------------------------------------------------------------------+
   string stringUpperCase(string str){string s = str;
   for(int length=StringLen(str)-1; length>=0; length--){int tchar = StringGetChar(s,length);
   if((tchar > 96 && tchar < 123) || (tchar > 223 && tchar < 256))  s = StringSetChar(s,length,tchar-32); else 
   if(tchar > -33 && tchar < 0)  s = StringSetChar(s,length,tchar + 224);} return(s);}
//+------------------------------------------------------------------------------------------------------------------+
double wrk[][10];
#define bsmax  5
#define bsmin  6
#define volty  7
#define vsum   8
#define avolty 9
//+------------------------------------------------------------------------------------------------------------------+
   double iSmooth(double price, double length, double phase, int i, int s=0){
   if(length <=1) return(price);
   if(ArrayRange(wrk,0) != Bars) ArrayResize(wrk,Bars);
   
   int r = Bars-i-1; 
   if (r==0) { for(int k=0; k<7; k++) wrk[r][k+s]=price; for(; k<10; k++) wrk[r][k+s]=0; return(price); }

   double len1   = MathMax(MathLog(MathSqrt(0.5*(length-1)))/MathLog(2.0)+2.0,0);
   double pow1   = MathMax(len1-2.0,0.5);
   double del1   = price - wrk[r-1][bsmax+s];
   double del2   = price - wrk[r-1][bsmin+s];
   double div    = 1.0/(10.0+10.0*(MathMin(MathMax(length-10,0),100))/100);
   int    forBar = MathMin(r,10);
	
      wrk[r][volty+s] = 0;
            if(MathAbs(del1) > MathAbs(del2)) wrk[r][volty+s] = MathAbs(del1); 
            if(MathAbs(del1) < MathAbs(del2)) wrk[r][volty+s] = MathAbs(del2); 
      wrk[r][vsum+s] =	wrk[r-1][vsum+s] + (wrk[r][volty+s]-wrk[r-forBar][volty+s])*div;
   
      wrk[r][avolty+s] = wrk[r-1][avolty+s]+(2.0/(MathMax(4.0*length,30)+1.0))*(wrk[r][vsum+s]-wrk[r-1][avolty+s]);
            if(wrk[r][avolty+s] > 0)
            double dVolty = wrk[r][volty+s]/wrk[r][avolty+s]; else dVolty = 0;   
	         if(dVolty > MathPow(len1,1.0/pow1)) dVolty = MathPow(len1,1.0/pow1);
            if(dVolty < 1)                      dVolty = 1.0;
	        
	double pow2 = MathPow(dVolty, pow1);
   double len2 = MathSqrt(0.5*(length-1))*len1;
   double Kv   = MathPow(len2/(len2+1), MathSqrt(pow2));

   if(del1 > 0) wrk[r][bsmax+s] = price; else wrk[r][bsmax+s] = price - Kv*del1;
   if(del2 < 0) wrk[r][bsmin+s] = price; else wrk[r][bsmin+s] = price - Kv*del2;
      
   double R     = MathMax(MathMin(phase,100),-100)/100.0 + 1.5;
   double beta  = 0.45*(length-1)/(0.45*(length-1)+2);
   double alpha = MathPow(beta,pow2);

         wrk[r][0+s] = price + alpha*(wrk[r-1][0+s]-price);
         wrk[r][1+s] = (price - wrk[r][0+s])*(1-beta) + beta*wrk[r-1][1+s];
         wrk[r][2+s] = (wrk[r][0+s] + R*wrk[r][1+s]);
         wrk[r][3+s] = (wrk[r][2+s] - wrk[r-1][4+s])*MathPow((1-alpha),2) + MathPow(alpha,2)*wrk[r-1][3+s];
         wrk[r][4+s] = (wrk[r-1][4+s] + wrk[r][3+s]); 

   return(wrk[r][4+s]);}
//+------------------------------------------------------------------------------------------------------------------+
   void Createlevel(string objName,double start,double start2,double end,double end2,color clr){
   static int window=-1; if(window<0) window=WindowFind("RSI");
   ObjectCreate(objName,OBJ_RECTANGLE,1,0,start,Time[0],end,Time[0]);
      ObjectSet(objName,OBJPROP_COLOR,clr);
      ObjectSet(objName,OBJPROP_WIDTH,1);
      ObjectSet(objName,OBJPROP_RAY,false);
      ObjectSet(objName,OBJPROP_BACK,1);}
//+------------------------------------------------------------------------------------------------------------------+
   void DeleteCreatelevel(){ObjectDelete(lvl1); ObjectDelete(lvl2);}
//+------------------------------------------------------------------------------------------------------------------+

//+----SetPanel2 Function---------------------------------------------------------------------------------------------+
   void SetPanel2(long IDchart=0,string name="PanelZ",int window=0,int corner=0,int PosX=0,int PosY=0,int width=0,int height=0,
   int bg_color=0,int border_color=0,int border_width=1,bool bg=true,bool del=false){if(StringLen(name)<1)return;
   if(del) ObjectDelete(IDchart,name); window=MathMax(window,0);
   if(bg_color<0) bg_color=White; if(border_color<0) border_color=White;
   if (ObjectCreate(IDchart,name,OBJ_RECTANGLE_LABEL,window,0,0)){
   ObjectSetInteger(IDchart,name,OBJPROP_XDISTANCE,PosX);
   ObjectSetInteger(IDchart,name,OBJPROP_YDISTANCE,PosY);
   ObjectSetInteger(IDchart,name,OBJPROP_XSIZE,width);
   ObjectSetInteger(IDchart,name,OBJPROP_YSIZE,height);
   ObjectSetInteger(IDchart,name,OBJPROP_COLOR,border_color);
   ObjectSetInteger(IDchart,name,OBJPROP_BORDER_TYPE,BORDER_FLAT);
   ObjectSetInteger(IDchart,name,OBJPROP_WIDTH,border_width);
   ObjectSetInteger(IDchart,name,OBJPROP_CORNER,corner);
   ObjectSetInteger(IDchart,name,OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(IDchart,name,OBJPROP_BACK,bg);
   ObjectSetInteger(IDchart,name,OBJPROP_SELECTABLE,0);
   ObjectSetInteger(IDchart,name,OBJPROP_SELECTED,0);
   ObjectSetInteger(IDchart,name,OBJPROP_HIDDEN,true);
   ObjectSetInteger(IDchart,name,OBJPROP_ZORDER,0);
   ObjectSetInteger(IDchart,name,OBJPROP_BGCOLOR,bg_color);}}
//+----SetLabel2 Function---------------------------------------------------------------------------------------------+
   void SetLabel2(long IDchart=0,string name="LabelZ",int window=0,int corner=0,int PosX=0,int PosY=0,string thetext=" ",
   int fontsize=12,string fontname="Arial",int colour=0,double angle=0,bool back=true,bool del=false,int vis=0,
   int align=ANCHOR_LEFT_UPPER,bool HideObjects=true){if(del) ObjectDelete(IDchart,name);
   corner=MathMax(corner,0);  window=MathMax(window,0);
   if(colour<0) colour = White;
   if(fontsize==0) fontsize = 8;
   if(fontname=="")  fontname = "Arial";
      if(ObjectFind(IDchart,name) < 0)
       ObjectCreate(IDchart,name,OBJ_LABEL,window,0,0,0,0);
   ObjectSetInteger(IDchart,name,OBJPROP_CORNER,corner);
   ObjectSetInteger(IDchart,name,OBJPROP_XDISTANCE,PosX);
   ObjectSetInteger(IDchart,name,OBJPROP_YDISTANCE,PosY);
    ObjectSetString(IDchart,name, OBJPROP_TEXT, thetext);
   ObjectSetInteger(IDchart,name,OBJPROP_FONTSIZE,fontsize);
    ObjectSetString(IDchart,name, OBJPROP_FONT, fontname);
   ObjectSetInteger(IDchart,name,OBJPROP_COLOR,colour);
    ObjectSetDouble(IDchart,name,OBJPROP_ANGLE,angle);
   ObjectSetInteger(IDchart,name,OBJPROP_BACK,back);
   ObjectSetInteger(IDchart,name,OBJPROP_TIMEFRAMES,vis);
   ObjectSetInteger(IDchart,name,OBJPROP_ANCHOR,align);
   ObjectSetInteger(IDchart,name,OBJPROP_HIDDEN,HideObjects);}
//+----Clean Chart Function------------------------------------------------------------------------------------------+
   void CleanUpOnIsle6(){string namek; for(int m=ObjectsTotal()-1; m>=0; m--){namek=ObjectName(m);
   if(StringSubstr(namek,0,StringLen(ID))==ID) {ObjectDelete(namek);}}}//EOF
//+----END OF FILE---------------------------------------------------------------------------------------------------+