Hello everyone,
I found this indicator that gives good buy, sell and exit signals with arrows and other symbol like in the attached image.
[attachment file=”185170″]
Please, is there anyone can convert it in prorealtime code?
Thanks
//+------------------------------------------------------------------+
//| SuperSlopeZeroLine.mq4 |
//| Draw the level line of the super slope in the chart window. |
//+------------------------------------------------------------------+
//2021.11.09 ver 1.00 release.
//2021.11.09 ver 1.01 Bug fixes case maxBars > Bars.
//2021.11.09 ver 1.01 The alert function has stopped.
//2021.11.10 ver 1.02 Bug fixes get close count.
//2021.11.11 ver 1.03 The alert function is working.
//2021.11.15 ver 1.04 Bug fixes MTF function.
//2021.11.15 ver 1.04 Output the reason why the line is not drawn to the expert log.
//2021.11.15 ver 1.04 Changed the default value.
//2021.11.15 ver 1.04 Select drawing timing.
//2021.11.19 ver 1.05 Bug fixes Gold line does not redraw.
//2022.01.03 ver 1.10 Draw level line.
// Inputs => Level Line inputs.
// Default value is Do not work.
//2022.01.08 ver 1.20 The color of the line is strong / weak level or cross-up / down.
// Inputs => Zero Line inputs.
// Default value is cross-up / down both are Gold color.
#define ver "1.20"
#property copyright "sukesuke"
#property link ""
#property version ver
#property strict
#property indicator_chart_window
#property indicator_buffers 5
enum ENUM_DRAWING_TIMING {
ON_TICK = 1, //On Tick
ON_TIMER = 2 //On Timer 1 second
};
extern string gen = "----General Inputs----"; //----
extern ENUM_DRAWING_TIMING DrawingTiming = ON_TICK;
extern int maxBars = 2000;
extern ENUM_TIMEFRAMES userTimeFrame = PERIOD_CURRENT; //M1,M5,M30,H1,H4,D1,W1,MN1
extern string spac756 = "---- Slope Inputs ----"; //----
extern double entryLevelCrossValue = 0.5;
extern double exitLevelCrossValue = 0.5;
extern int SlopeMAPeriod = 7;
extern int SlopeATRPeriod = 50;
extern string spac754 = "---- Send Alerts ----"; //----
extern bool sendEntryLevelCrossAlerts = false;
extern bool sendExitLevelCrossAlerts = false;
extern bool PopupAlert = false;
extern bool EmailAlert = false;
extern bool PushAlert = false;
extern string gen2 = "----Arrow Display----"; //----
extern bool showEntryArrows = false;
extern bool showExitArrows = false;
extern color BuyArrowColor = clrGreen;
extern int BuyArrowFontSize = 16;
extern color SellArrowColor = clrTomato;
extern int SellArrowFontSize = 16;
extern color ExitArrowColor = clrGold;
extern int ExitArrowFontSize = 16;
extern string zeroline = "----Zero Line inputs----"; //----
extern bool showZeroLine = true;
extern color LineColorStrongCrossUp = clrGold;
extern int LineWidthStrongCrossUp = 2;
extern int LineStyleStrongCrossUp = 0;
extern color LineColorNormal = clrWhite;
extern int LineWidthNormal = 2;
extern int LineStyleNormal = 0;
extern color LineColorStrongCrossDown = clrGold;
extern int LineWidthStrongCrossDown = 2;
extern int LineStyleStrongCrossDown = 0;
extern string levelline = "----Level Line inputs----"; //----
extern bool showLevelLine = false;
extern double LevelLineValue = 0.5;
extern color LevelLineColor = clrGold;
extern int LevelLineWidth = 1;
extern int LevelLineStyle = 2;
extern string disp = "----Display Inputs----"; //----
extern bool showSlopeValues = false;
extern color colorSlopeValues = clrWhite;
extern int displayTextSize = 16;
extern int horizontalOffset = 10;
extern int verticalOffset = 5;
extern int horizontalShift = 2;
extern int verticalShift = 0;
extern string displayTextFont = "Lucida Console";
//global variables
const string indicatorName = "SuperSlopeZeroLine";
const int windex = 0;
bool _BrokerHasSundayCandles;
int ATRPeriodArrows = 20;
double ATRMultiplierArrows = 1.5;
string BuySellArrowFont = "Wingdings 3";
string ExitArrowFont = "Wingdings 2";
uchar BuyArrowStyle = 219;
uchar SellArrowStyle = 220;
uchar ExitArrowStyle = 80;
bool CanDraw;
string userTimeFrameString;
string ObjSuff;
double closeBuffer[];
double slopeBuffer[];
double slopeZeroLineNormalBuffer[];
double slopeZeroLineStrongCrossUpBuffer[];
double slopeZeroLineStrongCrossDownBuffer[];
double slopeLevelLinePlusBuffer[];
double slopeLevelLineMinusBuffer[];
int cantDrawPeriod;
int limitMTF;
int limitCurrent;
double Lowest;
double Highest;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit() {
//
CanDraw = false;
//
// indicator Name
userTimeFrameString = timeframeStringBy(userTimeFrame);
string shortName = indicatorName + "-" + userTimeFrameString;
IndicatorShortName(shortName);
//
ObjSuff = "_" + userTimeFrameString + "_SSZL";
//
// draw time frame
if (userTimeFrame == PERIOD_CURRENT) {
userTimeFrame = (ENUM_TIMEFRAMES)_Period;
}
if (userTimeFrame < _Period) {
CanDraw = false;
Print("@@@@@ TimeFrame = ", userTimeFrameString, " , warning, Can't Draw, userTimeFrame < Period.");
return(INIT_SUCCEEDED);
}
//
// draw bars count
if (maxBars > Bars) {
maxBars = Bars;
}
cantDrawPeriod = MathMax(SlopeMAPeriod, SlopeATRPeriod + 11);
if(maxBars <= cantDrawPeriod) {
CanDraw = false;
Print("@@@@@ TimeFrame = ", userTimeFrameString, " , warning, Can't Draw, Not enough maxBars.");
return(INIT_SUCCEEDED);
}
limitCurrent = maxBars;
limitMTF = iBarShift(NULL, userTimeFrame, Time[limitCurrent - 1]);
limitMTF = MathMax(limitMTF, cantDrawPeriod) + 1;
//
// check draw bars count
CanDraw = false;
for (int i = limitCurrent - 1; i > 0; i--) {
int MTFBar = iBarShift(NULL, userTimeFrame, Time[i]);
int pLimitCurrent = iBarShift(NULL, 0, iTime(NULL, userTimeFrame, MTFBar));
if (pLimitCurrent <= limitCurrent) {
CanDraw = true;
limitCurrent = pLimitCurrent + 1;
break;
}
}
if (!CanDraw) {
Print("@@@@@ TimeFrame = ", userTimeFrameString, " , warning, Can't Draw, Not enough bars.");
return(INIT_SUCCEEDED);
}
//
// binary search range
int lowestShift = iLowest(NULL, userTimeFrame, MODE_LOW, limitMTF, 0);
Lowest = iLow(NULL, userTimeFrame, lowestShift);
int highestShift = iHighest(NULL, userTimeFrame, MODE_HIGH, limitMTF, 0);
Highest = iHigh(NULL, userTimeFrame, highestShift);
Lowest = Lowest - (_Point * 1000);
Highest = Highest + (_Point * 1000);
//
// slope
_BrokerHasSundayCandles = false;
for (int i = 0; i < 8; i++) {
if ( TimeDayOfWeek( iTime( NULL, PERIOD_D1, i ) ) == 0 ) {
_BrokerHasSundayCandles = true;
break;
}
}
//
// buffer
ArraySetAsSeries(closeBuffer, true);
ArrayResize(closeBuffer, limitMTF);
ArrayInitialize(closeBuffer, EMPTY_VALUE);
ArraySetAsSeries(slopeBuffer, true);
ArrayResize(slopeBuffer, limitCurrent);
ArrayInitialize(slopeBuffer, EMPTY_VALUE);
SetIndexBuffer(0, slopeZeroLineNormalBuffer);
SetIndexStyle(0, DRAW_LINE, LineStyleNormal, LineWidthNormal, LineColorNormal);
SetIndexEmptyValue(0, EMPTY_VALUE);
ArrayInitialize(slopeZeroLineNormalBuffer, EMPTY_VALUE);
SetIndexBuffer(1, slopeZeroLineStrongCrossUpBuffer);
SetIndexStyle(1, DRAW_LINE, LineStyleStrongCrossUp, LineWidthStrongCrossUp, LineColorStrongCrossUp);
SetIndexEmptyValue(1, EMPTY_VALUE);
ArrayInitialize(slopeZeroLineStrongCrossUpBuffer, EMPTY_VALUE);
SetIndexBuffer(2, slopeZeroLineStrongCrossDownBuffer);
SetIndexStyle(2, DRAW_LINE, LineStyleStrongCrossDown, LineWidthStrongCrossDown, LineColorStrongCrossDown);
SetIndexEmptyValue(2, EMPTY_VALUE);
ArrayInitialize(slopeZeroLineStrongCrossDownBuffer, EMPTY_VALUE);
SetIndexBuffer(3, slopeLevelLinePlusBuffer);
SetIndexStyle(3, DRAW_LINE, LevelLineStyle, LevelLineWidth, LevelLineColor);
SetIndexEmptyValue(3, EMPTY_VALUE);
ArrayInitialize(slopeLevelLinePlusBuffer, EMPTY_VALUE);
SetIndexBuffer(4, slopeLevelLineMinusBuffer);
SetIndexStyle(4, DRAW_LINE, LevelLineStyle, LevelLineWidth, LevelLineColor);
SetIndexEmptyValue(4, EMPTY_VALUE);
ArrayInitialize(slopeLevelLineMinusBuffer, EMPTY_VALUE);
//
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
//
if (DrawingTiming == ON_TIMER) {
EventKillTimer();
}
//
for(int i = ObjectsTotal() - 1; i >= 0; i--) {
if(StringFind(ObjectName(i), ObjSuff, 0) > 0) {
ObjectDelete(ObjectName(i));
}
}
//
ArrayFree(closeBuffer);
ArrayFree(slopeBuffer);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
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 (!CanDraw) {
return 0;
}
if (prev_calculated > 0) {
if (DrawingTiming == ON_TICK) {
//
DrawChart();
}
} else {
// INIT
DrawChartForInit();
//
if (DrawingTiming == ON_TIMER) {
EventSetTimer(1);
}
}
return(rates_total);
}
//+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer() {
//
DrawChart();
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void DrawChartForInit() {
//
int pLimitMTF = limitMTF;
int pLimitCurrent = limitCurrent - cantDrawPeriod - 1;
//
DrawChartMain(pLimitMTF, pLimitCurrent);
//
// get close (reset)
ArrayInitialize(closeBuffer, EMPTY_VALUE);
for(int bar = 0; bar < pLimitMTF; bar++) {
closeBuffer[bar] = iClose(NULL, userTimeFrame, bar);
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void DrawChart() {
//
//TODO mtf 1 bar update //2021.11.?? ver 1.?? Improve response.
//
int pLimitMTF = limitMTF;
int pLimitCurrent = limitCurrent - cantDrawPeriod - 1;
//
DrawChartMain(pLimitMTF, pLimitCurrent);
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void DrawChartMain(int pLimitMTF, int pLimitCurrent) {
//
// get close
for(int bar = 0; bar < pLimitMTF; bar++) {
closeBuffer[bar] = iClose(NULL, userTimeFrame, bar);
}
//
// get slope
int barOld = -1;
double slope = 0.0;
for(int i = 0; i < pLimitCurrent; i++) {
int bar = iBarShift(NULL, userTimeFrame, Time[i]);
if (bar != barOld) {
barOld = bar;
slope = GetSlope(bar);
}
slopeBuffer[i] = slope;
}
//
for(int i = 0; i < pLimitCurrent; i++) {
ShowArrows(i);
}
ShowComments(0);
SendAlerts(1);
//
// get zero line
//
if (showZeroLine) {
//
barOld = -1;
double slopeZeroLine = 0.0;
for(int i = 0; i < pLimitCurrent; i++) {
int bar = iBarShift(NULL, userTimeFrame, Time[i]);
if (bar != barOld) {
barOld = bar;
slopeZeroLine = GetSlopeLevelLine(bar, 0.0);
}
// get zero line Normal
slopeZeroLineNormalBuffer[i] = slopeZeroLine;
// get zero line Strong
slopeZeroLineStrongCrossUpBuffer[i] = EMPTY_VALUE;
if (slopeBuffer[i] > MathMax(entryLevelCrossValue, exitLevelCrossValue)) {
slopeZeroLineStrongCrossUpBuffer[i] = slopeZeroLineNormalBuffer[i];
} else if (slopeBuffer[i] < MathMax(entryLevelCrossValue, exitLevelCrossValue) * -1) {
slopeZeroLineStrongCrossDownBuffer[i] = slopeZeroLineNormalBuffer[i];
}
}
}
//
// get level line
//
if (showLevelLine) {
//
for(int bar = 0; bar < pLimitMTF; bar++) {
closeBuffer[bar] = iClose(NULL, userTimeFrame, bar);
}
//
barOld = -1;
double slopeLevelLine = 0.0;
for(int i = 0; i < pLimitCurrent; i++) {
int bar = iBarShift(NULL, userTimeFrame, Time[i]);
if (bar != barOld) {
barOld = bar;
slopeLevelLine = GetSlopeLevelLine(bar, LevelLineValue);
}
slopeLevelLinePlusBuffer[i] = slopeLevelLine;
}
//
for(int bar = 0; bar < pLimitMTF; bar++) {
closeBuffer[bar] = iClose(NULL, userTimeFrame, bar);
}
//
barOld = -1;
slopeLevelLine = 0.0;
for(int i = 0; i < pLimitCurrent; i++) {
int bar = iBarShift(NULL, userTimeFrame, Time[i]);
if (bar != barOld) {
barOld = bar;
slopeLevelLine = GetSlopeLevelLine(bar, -LevelLineValue);
}
slopeLevelLineMinusBuffer[i] = slopeLevelLine;
}
}
//
ChartRedraw();
}
//+------------------------------------------------------------------+
//| binary search
//+------------------------------------------------------------------+
double GetSlopeLevelLine(int pShift, double target) {
//
double left = Lowest;
double right = Highest;
double middle = 0.0;
//
while(left <= right) {
//
middle = NormalizeDouble((left + right) / 2, _Digits);
closeBuffer[pShift] = middle;
double slopeZeroLine = NormalizeDouble(GetSlope(pShift), 3);
if (slopeZeroLine == target) {
return middle;
} else if (target < slopeZeroLine) {
right = NormalizeDouble(middle - _Point, _Digits);
} else {
left = NormalizeDouble(middle + _Point, _Digits);
}
}
return middle;
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
double GetSlope(int pShift) {
//
double dblTma, dblPrev;
int shiftWithoutSunday = pShift;
if ( _BrokerHasSundayCandles && PERIOD_CURRENT == PERIOD_D1 ) {
if ( TimeDayOfWeek( iTime( NULL, PERIOD_D1, pShift ) ) == 0 ) shiftWithoutSunday++;
}
//
double atr = iATR( NULL, userTimeFrame, SlopeATRPeriod, shiftWithoutSunday + 10 ) / 10;
double result = 0.0;
if ( atr != 0 ) {
dblTma = iMAOnArray(closeBuffer, 0, SlopeMAPeriod, 0, MODE_LWMA, shiftWithoutSunday );
dblPrev = ( iMAOnArray(closeBuffer, 0, SlopeMAPeriod, 0, MODE_LWMA, shiftWithoutSunday + 1 ) * 231 + closeBuffer[shiftWithoutSunday] * 20) / 251;
result = ( dblTma - dblPrev ) / atr;
}
//
return ( result );
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void ShowArrows(int pShift) {
if(showEntryArrows || showExitArrows) {
double ATR = 0, ArrowHigh = 0, ArrowLow = 0;
ATR = iATR(_Symbol, _Period, ATRPeriodArrows, pShift);
ArrowHigh = iHigh(_Symbol, _Period, pShift) + ATR * ATRMultiplierArrows;
ArrowLow = iLow(_Symbol, _Period, pShift) - ATR * ATRMultiplierArrows;
string ObjSuffString = TimeToString(iTime(NULL, 0, pShift), TIME_DATE) + "_" + TimeToString(iTime(NULL, 0, pShift), TIME_MINUTES) + ObjSuff;
string objectBuyName = "Buy Arrow " + ObjSuffString;
string objectSellName = "Sell Arrow " + ObjSuffString;
string objectExitName = "Exit Arrow " + ObjSuffString;
if (pShift == 0) {
ObjectDelete(objectBuyName);
ObjectDelete(objectSellName);
ObjectDelete(objectExitName);
}
if (showEntryArrows) {
//Buy
if (slopeBuffer[pShift + 1] < entryLevelCrossValue && slopeBuffer[pShift] > entryLevelCrossValue) {
if(ObjectFind(objectBuyName) == -1) {
TextCreate(objectBuyName, iTime(NULL, 0, pShift), ArrowLow, CharToString(BuyArrowStyle), BuyArrowColor, ANCHOR_LOWER, BuySellArrowFont, BuyArrowFontSize);
}
}
//Sell
if (slopeBuffer[pShift + 1] > -entryLevelCrossValue && slopeBuffer[pShift] < -entryLevelCrossValue) {
if(ObjectFind(objectSellName) == -1) {
TextCreate(objectSellName, iTime(NULL, 0, pShift), ArrowHigh, CharToString(SellArrowStyle), SellArrowColor, ANCHOR_UPPER, BuySellArrowFont, SellArrowFontSize);
}
}
}
//Exit
if (showExitArrows) {
if (slopeBuffer[pShift + 1] > exitLevelCrossValue && slopeBuffer[pShift] < exitLevelCrossValue) {
if(ObjectFind(objectExitName) == -1) {
TextCreate(objectExitName, iTime(NULL, 0, pShift), ArrowHigh, CharToString(ExitArrowStyle), ExitArrowColor, ANCHOR_UPPER, ExitArrowFont, ExitArrowFontSize);
}
}
if (slopeBuffer[pShift + 1] < -exitLevelCrossValue && slopeBuffer[pShift] > -exitLevelCrossValue) {
if(ObjectFind(objectExitName) == -1) {
TextCreate(objectExitName, iTime(NULL, 0, pShift), ArrowLow, CharToString(ExitArrowStyle), ExitArrowColor, ANCHOR_UPPER, ExitArrowFont, ExitArrowFontSize);
}
}
}
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void ShowComments(int pShift) {
if(pShift == 0 && showSlopeValues) {
//header
string objectHeaderName = "column1_tf" + ObjSuff;
if(ObjectFind(objectHeaderName) == -1) {
if(ObjectCreate(objectHeaderName, OBJ_LABEL, windex, 0, 0)) {
ObjectSet(objectHeaderName, OBJPROP_CORNER, 1);
ObjectSet(objectHeaderName, OBJPROP_XDISTANCE, horizontalOffset + horizontalShift * 38);
ObjectSet(objectHeaderName, OBJPROP_YDISTANCE, verticalOffset + verticalShift);
ObjectSet(objectHeaderName, OBJPROP_HIDDEN, true);
}
}
ObjectSetText(objectHeaderName, userTimeFrameString, displayTextSize, displayTextFont, colorSlopeValues);
//value
string objectValueName = "column1_value" + ObjSuff;
if(ObjectFind(objectValueName) == -1) {
if(ObjectCreate(objectValueName, OBJ_LABEL, windex, 0, 0)) {
ObjectSet(objectValueName, OBJPROP_CORNER, 1);
ObjectSet(objectValueName, OBJPROP_XDISTANCE, horizontalOffset);
ObjectSet(objectValueName, OBJPROP_YDISTANCE, verticalOffset + verticalShift);
ObjectSet(objectValueName, OBJPROP_HIDDEN, true);
}
}
ObjectSetText(objectValueName, DoubleToString(slopeBuffer[pShift], 2), displayTextSize, displayTextFont, colorSlopeValues);
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void SendAlerts(int pShift) {
//PopUp alert Stuff
if (pShift == 1 && IsNewBar()) {
if(sendEntryLevelCrossAlerts) {
if(slopeBuffer[pShift + 1] < entryLevelCrossValue && slopeBuffer[pShift] > entryLevelCrossValue) {
fireAlerts(_Symbol + " did a level cross up " + DoubleToStr(entryLevelCrossValue, 2) + " " + userTimeFrameString + " @" + DoubleToStr(Bid, _Digits) + "__" + TimeToStr(TimeCurrent(), TIME_MINUTES));
} else if(slopeBuffer[pShift + 1] > -entryLevelCrossValue && slopeBuffer[pShift] < -entryLevelCrossValue) {
fireAlerts(_Symbol + " did a level cross down " + DoubleToStr(-entryLevelCrossValue, 2) + " " + userTimeFrameString + " @" + DoubleToStr(Bid, _Digits) + "__" + TimeToStr(TimeCurrent(), TIME_MINUTES));
}
}
if(sendExitLevelCrossAlerts) {
if(slopeBuffer[pShift + 1] > exitLevelCrossValue && slopeBuffer[pShift] < exitLevelCrossValue) {
fireAlerts(_Symbol + " did an 'exit buy' level cross down " + DoubleToStr(exitLevelCrossValue, 2) + " " + userTimeFrameString + " @" + DoubleToStr(Bid, _Digits) + "__" + TimeToStr(TimeCurrent(), TIME_MINUTES));
} else if(slopeBuffer[pShift + 1] < -exitLevelCrossValue && slopeBuffer[pShift] > -exitLevelCrossValue) {
fireAlerts(_Symbol + " did an 'exit sell' level cross up " + DoubleToStr(-exitLevelCrossValue, 2) + " " + userTimeFrameString + " @" + DoubleToStr(Bid, _Digits) + "__" + TimeToStr(TimeCurrent(), TIME_MINUTES));
}
}
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void fireAlerts(string sMsg) {
if(PopupAlert)
Alert(sMsg);
if(EmailAlert)
SendMail("Super Slope Zero Line Alert " + "", sMsg);
if(PushAlert)
SendNotification(sMsg);
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void TextCreate(const string pName = "Text", // object name
datetime time = 0, // anchor point time
double price = 0, // anchor point price
const string text = "Text", // the text itself
const color clr = clrRed, // color
const ENUM_ANCHOR_POINT anchor = ANCHOR_LEFT_UPPER, // anchor type
const string font = "Wingdings", // font
const int font_size = 14, // font size
const double angle = 0.0, // text slope
const bool back = true, // in the background
const bool selection = false, // highlight to move
const bool hidden = true, // hidden in the object list
const long z_order = 0
) {
long chart_ID = ChartID();
string name = pName;
if ( ObjectFind( chart_ID, name ) < 0 ) {
if ( !ObjectCreate( chart_ID, name, OBJ_TEXT, 0, time, price ) ) {
Print(__FUNCTION__, ": failed to create "Text" object! Error code = ", GetLastError() );
return;
}
}
ObjectSetString(chart_ID, name, OBJPROP_TEXT, text);
ObjectSetString(chart_ID, name, OBJPROP_FONT, font);
ObjectSetInteger(chart_ID, name, OBJPROP_FONTSIZE, font_size);
ObjectSetDouble(chart_ID, name, OBJPROP_ANGLE, angle);
ObjectSetInteger(chart_ID, name, OBJPROP_ANCHOR, anchor);
ObjectSetInteger(chart_ID, name, OBJPROP_COLOR, clr);
ObjectSetInteger(chart_ID, name, OBJPROP_BACK, back);
ObjectSetInteger(chart_ID, name, OBJPROP_SELECTABLE, selection);
ObjectSetInteger(chart_ID, name, OBJPROP_SELECTED, selection);
ObjectSetInteger(chart_ID, name, OBJPROP_HIDDEN, hidden);
ObjectSetInteger(chart_ID, name, OBJPROP_ZORDER, z_order);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
string timeframeStringBy(ENUM_TIMEFRAMES signalTimeframe) {
string tf = EnumToString(signalTimeframe);
StringReplace(tf, "PERIOD_", "");
if (tf == "CURRENT") {
ENUM_TIMEFRAMES tf2 = (ENUM_TIMEFRAMES)_Period;
tf = timeframeStringBy(tf2);
}
return tf;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool IsNewBar() {
static datetime firstBarTime = Time[1];
datetime time0 = iTime(NULL, _Period, 0);
if(firstBarTime == time0) {
return false;
} else {
firstBarTime = time0;
return true;
}
}
//+------------------------------------------------------------------+
