1675 lines
36 KiB
Plaintext
1675 lines
36 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 XMAN Parser Library
|
|
// -----------------------------------------------
|
|
// Name: XMANParser
|
|
// Description: Parsing XMAN Config ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property library
|
|
#property copyright "Copyright 2023, SaherElm IT Center"
|
|
#property link "https://www.saherelm.ir"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//
|
|
// Candle Timer Config ...
|
|
// candleTimerColor(clrGold)candleTimerCorner(2)
|
|
//
|
|
// Chrt Style ...
|
|
// upColor(clrLime) downColor(clrRed) lineColor(clrLime) bearishColor(clrRed) bullishColor(clrLime) volumesColor(clrGreen) chartMode(1)
|
|
//
|
|
// Market Cycles ...
|
|
//
|
|
// Short ...
|
|
// l1Method(1)l1Period(NULL)
|
|
//
|
|
// Medium ...
|
|
// l2Method(1)l2Period(NULL)
|
|
//
|
|
// Long ...
|
|
// l3Method(1)l3Period(NULL)
|
|
//
|
|
// Hind ...
|
|
// l4Method(1)l4Period(NULL)
|
|
//
|
|
// Fibonacci ...
|
|
// fiboLevel1(0.236)fiboLevel2(0.382)fiboLevel3(0.5)fiboLevel4(0.618)fiboLevel5(0.764)
|
|
//
|
|
// Boundary Detection Mode ...
|
|
// hhMode(2)llMode(1)
|
|
//
|
|
// Trend Detection ...
|
|
// trendMultiplier(3)trendPriceAppliedTo(4)
|
|
//
|
|
// Ribbon Detection ...
|
|
// ribbonMode(5)
|
|
//
|
|
// Hull Trend Detection ...
|
|
// hullDivisor(2.0)hullUpAppliedTo(3)hullDownAppliedTo(4)
|
|
//
|
|
// SSL Channel ...
|
|
// sslcMode(1)sslcUpAppliedTo(3)sslcDownAppliedTo(4)
|
|
//
|
|
// Style Presentation Config ...
|
|
// showCandleTimer(true)showCandles(true)showHKCandles(false)showSMHKCandles(false)
|
|
//
|
|
//
|
|
// PV Presentation Config ...
|
|
// showPeaksAndVales(true)showLevels(false)showConsolidations(false)
|
|
//
|
|
//
|
|
// Trend Presentation Config ...
|
|
// showHull(false)showTrends(false)fillTrends(false)showRibbons(false)showSSLChannel(false)
|
|
//
|
|
//
|
|
// Fibo Presentation Config ...
|
|
// showFibo1Levels(false)showFibo2Levels(false)showFibo3Levels(false)showFibo4Levels(false)showFibo5Levels(false)
|
|
//
|
|
#include "../Libraries/x-saherelm.models.lib.mq5"
|
|
#include "../Libraries/x-saherelm.common.lib.mq5"
|
|
|
|
//
|
|
// XPERIOD Calculation Method ...
|
|
// USED For Multiple Time Frames ...
|
|
enum ENUM_X_PERIOD_METHOD
|
|
{
|
|
//
|
|
X_PERIOD_NOTHING, // Nothing
|
|
X_PERIOD_AUTO, // Auto Select
|
|
X_PERIOD_MANUALLY // Manually
|
|
};
|
|
|
|
//
|
|
enum ENUM_X_MA_METHOD
|
|
{
|
|
X_MA_NOTHING, // Nothing
|
|
X_MA_SMA, // Simple
|
|
X_MA_EMA, // Expotential
|
|
X_MA_SMMA, // Smoothed Simple
|
|
X_MA_LWMA, // Linear Weighted
|
|
X_MA_AMA // Adaptive
|
|
};
|
|
|
|
//
|
|
// PARSERS ...
|
|
|
|
//
|
|
// CTIMER ...
|
|
|
|
//
|
|
string candleTimerColorToken = "candleTimerColor";
|
|
string candleTimerCornerToken = "candleTimerCorner";
|
|
|
|
//
|
|
struct XCTimerConfig
|
|
{
|
|
color candleTimerColor; // Text Color
|
|
ENUM_BASE_CORNER candleTimerCorner; // Text Position
|
|
};
|
|
|
|
//
|
|
string GenerateCTimerConfig(
|
|
color mCandleTimerColor = clrGold, // Text Color
|
|
ENUM_BASE_CORNER mCandleTimerCorner = CORNER_RIGHT_UPPER // Text Position
|
|
)
|
|
{
|
|
//
|
|
string result =
|
|
candleTimerColorToken + "(" + ToString(mCandleTimerColor) + ")" +
|
|
candleTimerCornerToken + "(" + ToString((int)mCandleTimerCorner) + ")";
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XCTimerConfig &config)
|
|
{
|
|
//
|
|
return GenerateCTimerConfig(
|
|
config.candleTimerColor,
|
|
config.candleTimerCorner);
|
|
}
|
|
|
|
//
|
|
XCTimerConfig ParseCTimerConfig(
|
|
string config // Source Config
|
|
)
|
|
{
|
|
//
|
|
XCTimerConfig result;
|
|
|
|
//
|
|
// CandleTimerColor ...
|
|
string candleTimerColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
candleTimerColorToken + "(",
|
|
")");
|
|
//
|
|
;
|
|
if (StringLen(candleTimerColorStr) > 0)
|
|
{
|
|
//
|
|
color mCandleTimerColor = (color)candleTimerColorStr;
|
|
result.candleTimerColor = mCandleTimerColor;
|
|
}
|
|
|
|
//
|
|
// CandleTimerCorner ...
|
|
string candleTimerCornerStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
candleTimerCornerToken + "(",
|
|
")");
|
|
//
|
|
;
|
|
if (StringLen(candleTimerCornerStr) > 0)
|
|
{
|
|
//
|
|
ENUM_BASE_CORNER mCandleTimerCorner = (ENUM_BASE_CORNER)((int)candleTimerCornerStr);
|
|
result.candleTimerCorner = mCandleTimerCorner;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// CHARTSTYLE ...
|
|
|
|
//
|
|
string upColorToken = "upColor";
|
|
string downColorToken = "downColor";
|
|
string lineColorToken = "lineColor";
|
|
string bearishColorToken = "bearishColor";
|
|
string bullishColorToken = "bullishColor";
|
|
string volumesColorToken = "volumesColor";
|
|
string chartModeToken = "chartMode";
|
|
|
|
//
|
|
struct XChartStyleConfig
|
|
{
|
|
color upColor; // Up Color
|
|
color downColor; // Down Color
|
|
color lineColor; // Line mode and Doji candlestick Color
|
|
color bearishColor; // Bullish Color
|
|
color bullishColor; // Bearish Color
|
|
color volumesColor; // Volumes Color
|
|
ENUM_CHART_MODE chartMode; // Chart Mode
|
|
};
|
|
|
|
//
|
|
string GenerateChartStyleConfig(
|
|
color mUpColor = clrLime, // Up Color
|
|
color mDownColor = clrRed, // Down Color
|
|
color mLineColor = clrLime, // Line mode and Doji candlestick Color
|
|
color mBearishColor = clrRed, // Bullish Color
|
|
color mBullishColor = clrLime, // Bearish Color
|
|
color mVolumesColor = clrGreen, // Volumes Color
|
|
ENUM_CHART_MODE mChartMode = CHART_CANDLES // Chart Mode
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
upColorToken + "(" + ToString(mUpColor) + ")" +
|
|
downColorToken + "(" + ToString(mDownColor) + ")" +
|
|
lineColorToken + "(" + ToString(mLineColor) + ")" +
|
|
bearishColorToken + "(" + ToString(mBearishColor) + ")" +
|
|
bullishColorToken + "(" + ToString(mBullishColor) + ")" +
|
|
volumesColorToken + "(" + ToString(mVolumesColor) + ")" +
|
|
chartModeToken + "(" + ToString((int)mChartMode) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XChartStyleConfig &config)
|
|
{
|
|
return GenerateChartStyleConfig(
|
|
config.upColor,
|
|
config.downColor,
|
|
config.lineColor,
|
|
config.bearishColor,
|
|
config.bullishColor,
|
|
config.volumesColor,
|
|
config.chartMode);
|
|
}
|
|
|
|
//
|
|
XChartStyleConfig ParseChartStyleConfig(string config)
|
|
{
|
|
//
|
|
XChartStyleConfig result;
|
|
|
|
//
|
|
string upColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
upColorToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(upColorStr) > 0)
|
|
{
|
|
//
|
|
color mUpColor = (color)upColorStr;
|
|
result.upColor = mUpColor;
|
|
}
|
|
|
|
//
|
|
string downColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
downColorToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(downColorStr) > 0)
|
|
{
|
|
//
|
|
color mDownColor = (color)downColorStr;
|
|
result.downColor = mDownColor;
|
|
}
|
|
|
|
//
|
|
string lineColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
lineColorToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(lineColorStr) > 0)
|
|
{
|
|
//
|
|
color mLineColor = (color)lineColorStr;
|
|
result.lineColor = mLineColor;
|
|
}
|
|
|
|
//
|
|
string bearishColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
bearishColorToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(bearishColorStr) > 0)
|
|
{
|
|
//
|
|
color mBearishColor = (color)bearishColorStr;
|
|
result.bearishColor = mBearishColor;
|
|
}
|
|
|
|
//
|
|
string bullishColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
bullishColorToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(bullishColorStr) > 0)
|
|
{
|
|
//
|
|
color mBullishColor = (color)bullishColorStr;
|
|
result.bullishColor = mBullishColor;
|
|
}
|
|
|
|
//
|
|
string volumesColorStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
volumesColorToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(volumesColorStr) > 0)
|
|
{
|
|
//
|
|
color mVolumesColor = (color)volumesColorStr;
|
|
result.volumesColor = mVolumesColor;
|
|
}
|
|
|
|
//
|
|
string chartModeStr =
|
|
//
|
|
ExtractString(
|
|
config,
|
|
chartModeToken + "(",
|
|
")")
|
|
//
|
|
;
|
|
if (StringLen(chartModeStr) > 0)
|
|
{
|
|
//
|
|
ENUM_CHART_MODE mChartMode = (ENUM_CHART_MODE)((int)chartModeStr);
|
|
result.chartMode = mChartMode;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// MARKETCYCLES ...
|
|
|
|
//
|
|
// SHORT ...
|
|
|
|
//
|
|
string l1MethodToken = "l1Method";
|
|
string l1PeriodToken = "l1Period";
|
|
|
|
//
|
|
struct XSCConfig
|
|
{
|
|
ENUM_X_PERIOD_METHOD l1Method; // How to Find Period
|
|
ENUM_TIMEFRAMES l1Period; // Time Period
|
|
};
|
|
|
|
//
|
|
string GenerateSCConfig(
|
|
ENUM_X_PERIOD_METHOD mML1Method = X_PERIOD_AUTO, // How to Find Period
|
|
ENUM_TIMEFRAMES mML1Period = NULL // Time Period
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
l1MethodToken + "(" + ToString(mML1Method) + ")" +
|
|
l1PeriodToken + "(" + ToString(mML1Period) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XSCConfig &config)
|
|
{
|
|
return GenerateSCConfig(
|
|
config.l1Method,
|
|
config.l1Period);
|
|
}
|
|
|
|
//
|
|
XSCConfig PrseSCConfig(string config)
|
|
{
|
|
//
|
|
XSCConfig result;
|
|
|
|
//
|
|
string l1MethodStr = ExtractString(
|
|
config,
|
|
l1MethodToken + "(",
|
|
")");
|
|
if (StringLen(l1MethodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_X_PERIOD_METHOD mML1Method = (ENUM_X_PERIOD_METHOD)((int)l1MethodStr);
|
|
result.l1Method = mML1Method;
|
|
}
|
|
|
|
//
|
|
string l1PeriodStr = ExtractString(
|
|
config,
|
|
l1PeriodToken + "(",
|
|
")");
|
|
if (StringLen(l1PeriodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES mML1Period = (ENUM_TIMEFRAMES)((int)l1PeriodStr);
|
|
result.l1Period = mML1Period;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// MEDIUM ...
|
|
|
|
//
|
|
string l2MethodToken = "l2Method";
|
|
string l2PeriodToken = "l2Period";
|
|
|
|
//
|
|
struct XMCConfig
|
|
{
|
|
ENUM_X_PERIOD_METHOD l2Method; // How to Find Period
|
|
ENUM_TIMEFRAMES l2Period; // Time Period
|
|
};
|
|
|
|
//
|
|
string GenerateMCConfig(
|
|
ENUM_X_PERIOD_METHOD mML2Method = X_PERIOD_AUTO, // How to Find Period
|
|
ENUM_TIMEFRAMES mML2Period = NULL // Time Period
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
l2MethodToken + "(" + ToString(mML2Method) + ")" +
|
|
l2PeriodToken + "(" + ToString(mML2Period) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XMCConfig &config)
|
|
{
|
|
return GenerateSCConfig(
|
|
config.l2Method,
|
|
config.l2Period);
|
|
}
|
|
|
|
//
|
|
XMCConfig PrseMCConfig(string config)
|
|
{
|
|
//
|
|
XMCConfig result;
|
|
|
|
//
|
|
string l2MethodStr = ExtractString(
|
|
config,
|
|
l2MethodToken + "(",
|
|
")");
|
|
if (StringLen(l2MethodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_X_PERIOD_METHOD mML2Method = (ENUM_X_PERIOD_METHOD)((int)l2MethodStr);
|
|
result.l2Method = mML2Method;
|
|
}
|
|
|
|
//
|
|
string l2PeriodStr = ExtractString(
|
|
config,
|
|
l2PeriodToken + "(",
|
|
")");
|
|
if (StringLen(l2PeriodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES mML2Period = (ENUM_TIMEFRAMES)((int)l2PeriodStr);
|
|
result.l2Period = mML2Period;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// LONG ...
|
|
|
|
//
|
|
string l3MethodToken = "l3Method";
|
|
string l3PeriodToken = "l3Period";
|
|
|
|
//
|
|
struct XLCConfig
|
|
{
|
|
ENUM_X_PERIOD_METHOD l3Method; // How to Find Period
|
|
ENUM_TIMEFRAMES l3Period; // Time Period
|
|
};
|
|
|
|
//
|
|
string GenerateLCConfig(
|
|
ENUM_X_PERIOD_METHOD mML3Method = X_PERIOD_AUTO, // How to Find Period
|
|
ENUM_TIMEFRAMES mML3Period = NULL // Time Period
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
l3MethodToken + "(" + ToString(mML3Method) + ")" +
|
|
l3PeriodToken + "(" + ToString(mML3Period) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XLCConfig &config)
|
|
{
|
|
return GenerateSCConfig(
|
|
config.l3Method,
|
|
config.l3Period);
|
|
}
|
|
|
|
//
|
|
XLCConfig PrseLCConfig(string config)
|
|
{
|
|
//
|
|
XLCConfig result;
|
|
|
|
//
|
|
string l3MethodStr = ExtractString(
|
|
config,
|
|
l3MethodToken + "(",
|
|
")");
|
|
if (StringLen(l3MethodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_X_PERIOD_METHOD mML3Method = (ENUM_X_PERIOD_METHOD)((int)l3MethodStr);
|
|
result.l3Method = mML3Method;
|
|
}
|
|
|
|
//
|
|
string l3PeriodStr = ExtractString(
|
|
config,
|
|
l3PeriodToken + "(",
|
|
")");
|
|
if (StringLen(l3PeriodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES mML3Period = (ENUM_TIMEFRAMES)((int)l3PeriodStr);
|
|
result.l3Period = mML3Period;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// HIND ...
|
|
|
|
//
|
|
string l4MethodToken = "l4Method";
|
|
string l4PeriodToken = "l4Period";
|
|
|
|
//
|
|
struct XHCConfig
|
|
{
|
|
ENUM_X_PERIOD_METHOD l4Method; // How to Find Period
|
|
ENUM_TIMEFRAMES l4Period; // Time Period
|
|
};
|
|
|
|
//
|
|
string GenerateHCConfig(
|
|
ENUM_X_PERIOD_METHOD mML4Method = X_PERIOD_AUTO, // How to Find Period
|
|
ENUM_TIMEFRAMES mML4Period = NULL // Time Period
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
l4MethodToken + "(" + ToString(mML4Method) + ")" +
|
|
l4PeriodToken + "(" + ToString(mML4Period) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XHCConfig &config)
|
|
{
|
|
return GenerateSCConfig(
|
|
config.l4Method,
|
|
config.l4Period);
|
|
}
|
|
|
|
//
|
|
XHCConfig PrseHCConfig(string config)
|
|
{
|
|
//
|
|
XHCConfig result;
|
|
|
|
//
|
|
string l4MethodStr = ExtractString(
|
|
config,
|
|
l4MethodToken + "(",
|
|
")");
|
|
if (StringLen(l4MethodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_X_PERIOD_METHOD mML4Method = (ENUM_X_PERIOD_METHOD)((int)l4MethodStr);
|
|
result.l4Method = mML4Method;
|
|
}
|
|
|
|
//
|
|
string l4PeriodStr = ExtractString(
|
|
config,
|
|
l4PeriodToken + "(",
|
|
")");
|
|
if (StringLen(l4PeriodStr) > 0)
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES mML4Period = (ENUM_TIMEFRAMES)((int)l4PeriodStr);
|
|
result.l4Period = mML4Period;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XFIBONACCI ...
|
|
|
|
//
|
|
string fiboLevel1Token = "fiboLevel1";
|
|
string fiboLevel2Token = "fiboLevel2";
|
|
string fiboLevel3Token = "fiboLevel3";
|
|
string fiboLevel4Token = "fiboLevel4";
|
|
string fiboLevel5Token = "fiboLevel5";
|
|
|
|
//
|
|
struct XFiboConfig
|
|
{
|
|
double fiboLevel1; // Fibio 1st Level
|
|
double fiboLevel2; // Fibio 2st Level
|
|
double fiboLevel3; // Fibio 3rd Level
|
|
double fiboLevel4; // Fibio 4th Level
|
|
double fiboLevel5; // Fibio 5th Level
|
|
};
|
|
|
|
//
|
|
string GenerateFibonacciConfig(
|
|
double mFiboLevel1 = 0.236, // Fibio 1st Level
|
|
double mFiboLevel2 = 0.382, // Fibio 2st Level
|
|
double mFiboLevel3 = 0.5, // Fibio 3rd Level
|
|
double mFiboLevel4 = 0.618, // Fibio 4th Level
|
|
double mFiboLevel5 = 0.764 // Fibio 5th Level
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
fiboLevel1Token + "(" + ToString(mFiboLevel1) + ")" +
|
|
fiboLevel2Token + "(" + ToString(mFiboLevel2) + ")" +
|
|
fiboLevel3Token + "(" + ToString(mFiboLevel3) + ")" +
|
|
fiboLevel4Token + "(" + ToString(mFiboLevel4) + ")" +
|
|
fiboLevel5Token + "(" + ToString(mFiboLevel5) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XFiboConfig &config)
|
|
{
|
|
return GenerateFibonacciConfig(
|
|
config.fiboLevel1,
|
|
config.fiboLevel2,
|
|
config.fiboLevel3,
|
|
config.fiboLevel4,
|
|
config.fiboLevel5);
|
|
}
|
|
|
|
//
|
|
XFiboConfig PrseFiboConfig(string config)
|
|
{
|
|
//
|
|
XFiboConfig result;
|
|
|
|
//
|
|
string fiboLevel1Str = ExtractString(
|
|
config,
|
|
fiboLevel1Token + "(",
|
|
")");
|
|
if (StringLen(fiboLevel1Str) > 0)
|
|
{
|
|
//
|
|
double mFiboLevel1 = (double)fiboLevel1Str;
|
|
result.fiboLevel1 = mFiboLevel1;
|
|
}
|
|
|
|
//
|
|
string fiboLevel2Str = ExtractString(
|
|
config,
|
|
fiboLevel2Token + "(",
|
|
")");
|
|
if (StringLen(fiboLevel2Str) > 0)
|
|
{
|
|
//
|
|
double mFiboLevel2 = (double)fiboLevel2Str;
|
|
result.fiboLevel2 = mFiboLevel2;
|
|
}
|
|
|
|
//
|
|
string fiboLevel3Str = ExtractString(
|
|
config,
|
|
fiboLevel3Token + "(",
|
|
")");
|
|
if (StringLen(fiboLevel3Str) > 0)
|
|
{
|
|
//
|
|
double mFiboLevel3 = (double)fiboLevel3Str;
|
|
result.fiboLevel3 = mFiboLevel3;
|
|
}
|
|
|
|
//
|
|
string fiboLevel4Str = ExtractString(
|
|
config,
|
|
fiboLevel4Token + "(",
|
|
")");
|
|
if (StringLen(fiboLevel4Str) > 0)
|
|
{
|
|
//
|
|
double mFiboLevel4 = (double)fiboLevel4Str;
|
|
result.fiboLevel4 = mFiboLevel4;
|
|
}
|
|
|
|
//
|
|
string fiboLevel5Str = ExtractString(
|
|
config,
|
|
fiboLevel5Token + "(",
|
|
")");
|
|
if (StringLen(fiboLevel5Str) > 0)
|
|
{
|
|
//
|
|
double mFiboLevel5 = (double)fiboLevel5Str;
|
|
result.fiboLevel5 = mFiboLevel5;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// BOUNDARYDETECTION ...
|
|
|
|
//
|
|
string hhModeToken = "hhMode";
|
|
string llModeToken = "llMode";
|
|
|
|
//
|
|
struct XBDConfig
|
|
{
|
|
ENUM_SERIESMODE hhMode; // Highest High Calculation Method
|
|
ENUM_SERIESMODE llMode; // Lowest Low Calculation Method
|
|
};
|
|
|
|
//
|
|
string GenerateBDConfig(
|
|
ENUM_SERIESMODE mHhMode = MODE_HIGH, // Highest High Calculation Method
|
|
ENUM_SERIESMODE mLlMode = MODE_LOW // Lowest Low Calculation Method
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
hhModeToken + "(" + ToString((int)mHhMode) + ")" +
|
|
llModeToken + "(" + ToString((int)mLlMode) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XBDConfig &config)
|
|
{
|
|
return GenerateBDConfig(
|
|
config.hhMode,
|
|
config.llMode);
|
|
}
|
|
|
|
//
|
|
XBDConfig ParseBDConfig(string config)
|
|
{
|
|
//
|
|
XBDConfig result;
|
|
|
|
//
|
|
string hhModeStr = ExtractString(
|
|
config,
|
|
hhModeToken + "(",
|
|
")");
|
|
if (StringLen(hhModeStr) > 0)
|
|
{
|
|
//
|
|
ENUM_SERIESMODE mHhMode = (ENUM_SERIESMODE)((int)hhModeStr);
|
|
result.hhMode = mHhMode;
|
|
}
|
|
|
|
//
|
|
string llModeStr = ExtractString(
|
|
config,
|
|
llModeToken + "(",
|
|
")");
|
|
if (StringLen(llModeStr) > 0)
|
|
{
|
|
//
|
|
ENUM_SERIESMODE mLlMode = (ENUM_SERIESMODE)((int)llModeStr);
|
|
result.llMode = mLlMode;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// TREND ...
|
|
|
|
//
|
|
string trendMultiplierToken = "trendMultiplier";
|
|
string trendPriceAppliedToToken = "trendPriceAppliedTo";
|
|
|
|
//
|
|
struct XTDConfig
|
|
{
|
|
double trendMultiplier; // Multiplier
|
|
ENUM_APPLIED_PRICE trendPriceAppliedTo; // Applied To
|
|
};
|
|
|
|
//
|
|
string GenerateTDConfig(
|
|
double mTrendMultiplier = 3, // Multiplier
|
|
ENUM_APPLIED_PRICE mTrendPriceAppliedTo = PRICE_MEDIAN // Applied To
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
trendMultiplierToken + "(" + ToString(mTrendMultiplier) + ")" +
|
|
trendPriceAppliedToToken + "(" + ToString(mTrendPriceAppliedTo) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XTDConfig &config)
|
|
{
|
|
return GenerateTDConfig(
|
|
config.trendMultiplier,
|
|
config.trendPriceAppliedTo);
|
|
}
|
|
|
|
//
|
|
XTDConfig ParseTDConfig(string config)
|
|
{
|
|
//
|
|
XTDConfig result;
|
|
|
|
//
|
|
string trendMultiplierStr = ExtractString(
|
|
config,
|
|
trendMultiplierToken + "(",
|
|
")");
|
|
if (StringLen(trendMultiplierStr) > 0)
|
|
{
|
|
//
|
|
double mTrendMultiplier = (double)trendMultiplierStr;
|
|
result.trendMultiplier = mTrendMultiplier;
|
|
}
|
|
|
|
//
|
|
string trendPriceAppliedToStr = ExtractString(
|
|
config,
|
|
trendPriceAppliedToToken + "(",
|
|
")");
|
|
if (StringLen(trendPriceAppliedToStr) > 0)
|
|
{
|
|
//
|
|
ENUM_APPLIED_PRICE mTrendPriceAppliedTo = (ENUM_APPLIED_PRICE)((int)trendPriceAppliedToStr);
|
|
//
|
|
result.trendPriceAppliedTo = mTrendPriceAppliedTo;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// RIBBON RB ...
|
|
|
|
//
|
|
string ribbonModeToken = "ribbonMode";
|
|
|
|
//
|
|
struct XRBConfig
|
|
{
|
|
ENUM_X_MA_METHOD ribbonMode; // How to Calculate
|
|
};
|
|
|
|
//
|
|
string GenerateRBConfig(
|
|
ENUM_X_MA_METHOD mRibbonMode = X_MA_AMA // How to Calculate
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
ribbonModeToken + "(" + ToString(mRibbonMode) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XRBConfig &config)
|
|
{
|
|
//
|
|
return GenerateRBConfig(
|
|
config.ribbonMode);
|
|
}
|
|
|
|
//
|
|
XRBConfig ParseRBConfig(string config)
|
|
{
|
|
//
|
|
XRBConfig result;
|
|
|
|
//
|
|
string ribbonModeStr = ExtractString(
|
|
config,
|
|
ribbonModeToken + "(",
|
|
")");
|
|
if (StringLen(ribbonModeStr) > 0)
|
|
{
|
|
//
|
|
ENUM_X_MA_METHOD mRibbonMode = (ENUM_X_MA_METHOD)((int)ribbonModeStr);
|
|
result.ribbonMode = mRibbonMode;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// HULL ...
|
|
|
|
//
|
|
string hullDivisorToken = "hullDivisor";
|
|
string hullUpAppliedToToken = "hullUpAppliedTo";
|
|
string hullDownAppliedToToken = "hullDownAppliedTo";
|
|
|
|
//
|
|
struct XHullConfig
|
|
{
|
|
double hullDivisor; // Divisor (Speed)
|
|
ENUM_APPLIED_PRICE hullUpAppliedTo; // Up Zone Applied to
|
|
ENUM_APPLIED_PRICE hullDownAppliedTo; // Down Zone Applied to
|
|
};
|
|
|
|
//
|
|
string GenerateHullConfig(
|
|
double mHullDivisor = 2.0, // Divisor (Speed)
|
|
ENUM_APPLIED_PRICE mHullUpAppliedTo = PRICE_HIGH, // Up Zone Applied to
|
|
ENUM_APPLIED_PRICE mHullDownAppliedTo = PRICE_LOW // Down Zone Applied to
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
hullDivisorToken + "(" + ToString(mHullDivisor) + ")" +
|
|
hullUpAppliedToToken + "(" + ToString(mHullUpAppliedTo) + ")" +
|
|
hullDownAppliedToToken + "(" + ToString(mHullDownAppliedTo) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XHullConfig &config)
|
|
{
|
|
//
|
|
return GenerateHullConfig(
|
|
config.hullDivisor,
|
|
config.hullUpAppliedTo,
|
|
config.hullDownAppliedTo);
|
|
}
|
|
|
|
//
|
|
XHullConfig ParseHullConfig(string config)
|
|
{
|
|
//
|
|
XHullConfig result;
|
|
|
|
//
|
|
string hullDivisorStr = ExtractString(
|
|
config,
|
|
hullDivisorToken + "(",
|
|
")");
|
|
if (StringLen(hullDivisorStr) > 0)
|
|
{
|
|
//
|
|
double mHullDivisor = (double)hullDivisorStr;
|
|
result.hullDivisor = mHullDivisor;
|
|
}
|
|
|
|
//
|
|
string hullUpAppliedToStr = ExtractString(
|
|
config,
|
|
hullUpAppliedToToken + "(",
|
|
")");
|
|
if (StringLen(hullUpAppliedToStr) > 0)
|
|
{
|
|
//
|
|
ENUM_APPLIED_PRICE mHullUpAppliedTo = (ENUM_APPLIED_PRICE)((int)hullUpAppliedToStr);
|
|
result.hullUpAppliedTo = mHullUpAppliedTo;
|
|
}
|
|
|
|
//
|
|
string hullDownAppliedToStr = ExtractString(
|
|
config,
|
|
hullDownAppliedToToken + "(",
|
|
")");
|
|
if (StringLen(hullDownAppliedToStr) > 0)
|
|
{
|
|
//
|
|
ENUM_APPLIED_PRICE mHullDownAppliedTo = (ENUM_APPLIED_PRICE)((int)hullDownAppliedToStr);
|
|
result.hullDownAppliedTo = mHullDownAppliedTo;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// SSLC ...
|
|
|
|
//
|
|
string sslcModeToken = "sslcMode";
|
|
string sslcUpAppliedToToken = "sslcUpAppliedTo";
|
|
string sslcDownAppliedToToken = "sslcDownAppliedTo";
|
|
|
|
//
|
|
struct XSSLCConfig
|
|
{
|
|
ENUM_X_MA_METHOD sslcMode; // How to Calculate
|
|
ENUM_APPLIED_PRICE sslcUpAppliedTo; // Up Applied To
|
|
ENUM_APPLIED_PRICE sslcDownAppliedTo; // Down Applied To
|
|
};
|
|
|
|
//
|
|
string GenerateSSLCConfig(
|
|
ENUM_X_MA_METHOD mSslcMode = X_MA_SMA, // How to Calculate
|
|
ENUM_APPLIED_PRICE mSslcUpAppliedTo = PRICE_HIGH, // Up Applied To
|
|
ENUM_APPLIED_PRICE mSslcDownAppliedTo = PRICE_LOW // Down Applied To
|
|
)
|
|
{
|
|
//
|
|
string result;
|
|
|
|
//
|
|
result =
|
|
//
|
|
sslcModeToken + "(" + ToString(mSslcMode) + ")" +
|
|
sslcUpAppliedToToken + "(" + ToString(mSslcUpAppliedTo) + ")" +
|
|
sslcDownAppliedToToken + "(" + ToString(mSslcDownAppliedTo) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XSSLCConfig &config)
|
|
{
|
|
return GenerateSSLCConfig(
|
|
config.sslcMode,
|
|
config.sslcUpAppliedTo,
|
|
config.sslcDownAppliedTo);
|
|
}
|
|
|
|
//
|
|
XSSLCConfig ParseSSLCConfig(string config)
|
|
{
|
|
//
|
|
XSSLCConfig result;
|
|
|
|
//
|
|
string sslcModeStr = ExtractString(
|
|
config,
|
|
sslcModeToken + "(",
|
|
")");
|
|
if (StringLen(sslcModeStr) > 0)
|
|
{
|
|
//
|
|
ENUM_X_MA_METHOD mSslcMode = (ENUM_X_MA_METHOD)((int)sslcModeStr);
|
|
result.sslcMode = mSslcMode;
|
|
}
|
|
|
|
//
|
|
string sslcUpAppliedToStr = ExtractString(
|
|
config,
|
|
sslcUpAppliedToToken + "(",
|
|
")");
|
|
if (StringLen(sslcUpAppliedToStr) > 0)
|
|
{
|
|
//
|
|
ENUM_APPLIED_PRICE mSslcUpAppliedTo = (ENUM_APPLIED_PRICE)((int)sslcUpAppliedToStr);
|
|
result.sslcUpAppliedTo = mSslcUpAppliedTo;
|
|
}
|
|
|
|
//
|
|
string sslcDownAppliedToStr = ExtractString(
|
|
config,
|
|
sslcDownAppliedToToken + "(",
|
|
")");
|
|
if (StringLen(sslcDownAppliedToStr) > 0)
|
|
{
|
|
//
|
|
ENUM_APPLIED_PRICE mSslcDownAppliedTo = (ENUM_APPLIED_PRICE)((int)sslcDownAppliedToStr);
|
|
result.sslcDownAppliedTo = mSslcDownAppliedTo;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// PRESENTATION ...
|
|
|
|
//
|
|
string showCandleTimerToken = "showCandleTimer";
|
|
string showCandlesToken = "showCandles";
|
|
string showHKCandlesToken = "showHKCandles";
|
|
string showSMHKCandlesToken = "showSMHKCandles";
|
|
string showPeaksAndValesToken = "showPeaksAndVales";
|
|
string showTrendsToken = "showTrends";
|
|
string fillTrendsToken = "fillTrends";
|
|
string showLevelsToken = "showLevels";
|
|
string showConsolidationsToken = "showConsolidations";
|
|
string showRibbonsToken = "showRibbons";
|
|
string showHullToken = "showHull";
|
|
string showSSLChannelToken = "showSSLChannel";
|
|
string showFibo1LevelsToken = "showFibo1Levels";
|
|
string showFibo2LevelsToken = "showFibo2Levels";
|
|
string showFibo3LevelsToken = "showFibo3Levels";
|
|
string showFibo4LevelsToken = "showFibo4Levels";
|
|
string showFibo5LevelsToken = "showFibo5Levels";
|
|
|
|
//
|
|
struct XStylePresentationConfig
|
|
{
|
|
bool showCandleTimer; // Show Candle Time
|
|
bool showCandles; // Show Candles
|
|
bool showHKCandles; // Draw Hiken Ashi Candle
|
|
bool showSMHKCandles; // Draw Smoothed Hiken Ashi Candle
|
|
};
|
|
|
|
//
|
|
string GenerateStylePresentationConfig(
|
|
bool mShowCandleTimer = true, // Show Candle Time
|
|
bool mShowCandles = true, // Show Candles
|
|
bool mShowHKCandles = false, // Draw Hiken Ashi Candle
|
|
bool mShowSMHKCandles = false // Draw Smoothed Hiken Ashi Candle
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
showCandleTimerToken + "(" + ToString(mShowCandleTimer) + ")" +
|
|
showCandlesToken + "(" + ToString(mShowCandles) + ")" +
|
|
showHKCandlesToken + "(" + ToString(mShowHKCandles) + ")" +
|
|
showSMHKCandlesToken + "(" + ToString(mShowSMHKCandles) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XStylePresentationConfig ParseStylePresentationConfig(string config)
|
|
{
|
|
//
|
|
XStylePresentationConfig result;
|
|
|
|
//
|
|
string showCandleTimerStr = ExtractString(
|
|
config,
|
|
showCandleTimerToken + "(",
|
|
")");
|
|
if (StringLen(showCandleTimerStr) > 0)
|
|
{
|
|
//
|
|
bool mShowCandleTimer = ToBoolean(showCandleTimerStr);
|
|
result.showCandleTimer = mShowCandleTimer;
|
|
}
|
|
|
|
//
|
|
string showCandlesStr = ExtractString(
|
|
config,
|
|
showCandlesToken + "(",
|
|
")");
|
|
if (StringLen(showCandlesStr) > 0)
|
|
{
|
|
//
|
|
bool mShowCandles = ToBoolean(showCandlesStr);
|
|
result.showCandles = mShowCandles;
|
|
}
|
|
|
|
//
|
|
string showHKCandlesStr = ExtractString(
|
|
config,
|
|
showHKCandlesToken + "(",
|
|
")");
|
|
if (StringLen(showHKCandlesStr) > 0)
|
|
{
|
|
//
|
|
bool mShowHKCandles = ToBoolean(showHKCandlesStr);
|
|
result.showHKCandles = mShowHKCandles;
|
|
}
|
|
|
|
//
|
|
string showSMHKCandlesStr = ExtractString(
|
|
config,
|
|
showSMHKCandlesToken + "(",
|
|
")");
|
|
if (StringLen(showSMHKCandlesStr) > 0)
|
|
{
|
|
//
|
|
bool mShowSMHKCandles = ToBoolean(showSMHKCandlesStr);
|
|
result.showSMHKCandles = mShowSMHKCandles;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XStylePresentationConfig &config)
|
|
{
|
|
//
|
|
return GenerateStylePresentationConfig(
|
|
config.showCandleTimer,
|
|
config.showCandles,
|
|
config.showHKCandles,
|
|
config.showSMHKCandles);
|
|
}
|
|
|
|
//
|
|
struct XPVPresentationConfig
|
|
{
|
|
bool showPeaksAndVales; // Show Peaks and Vales
|
|
bool showLevels; // Show Levels
|
|
bool showConsolidations; // Show Consolidations
|
|
};
|
|
|
|
//
|
|
string GeneratePVPresentationConfig(
|
|
bool mShowPeaksAndVales = true, // Show Peaks and Vales
|
|
bool mShowLevels = false, // Show Levels
|
|
bool mShowConsolidations = false // Show Consolidations
|
|
)
|
|
{
|
|
//
|
|
string result;
|
|
|
|
//
|
|
result =
|
|
//
|
|
showPeaksAndValesToken + "(" + ToString(mShowPeaksAndVales) + ")" +
|
|
showLevelsToken + "(" + ToString(mShowLevels) + ")" +
|
|
showConsolidationsToken + "(" + ToString(mShowConsolidations) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XPVPresentationConfig &config)
|
|
{
|
|
//
|
|
return GeneratePVPresentationConfig(
|
|
config.showPeaksAndVales,
|
|
config.showLevels,
|
|
config.showConsolidations);
|
|
}
|
|
|
|
//
|
|
XPVPresentationConfig ParsePVPresentationConfig(string config)
|
|
{
|
|
//
|
|
XPVPresentationConfig result;
|
|
|
|
//
|
|
string showPeaksAndValesStr = ExtractString(
|
|
config,
|
|
showPeaksAndValesToken + "(",
|
|
")");
|
|
if (StringLen(showPeaksAndValesStr) > 0)
|
|
{
|
|
//
|
|
bool mShowPeaksAndVales = ToBoolean(showPeaksAndValesStr);
|
|
result.showPeaksAndVales = mShowPeaksAndVales;
|
|
}
|
|
|
|
//
|
|
string showLevelsStr = ExtractString(
|
|
config,
|
|
showLevelsToken + "(",
|
|
")");
|
|
if (StringLen(showLevelsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowLevels = ToBoolean(showLevelsStr);
|
|
result.showLevels = mShowLevels;
|
|
}
|
|
|
|
//
|
|
string showConsolidationsStr = ExtractString(
|
|
config,
|
|
showConsolidationsToken + "(",
|
|
")");
|
|
if (StringLen(showConsolidationsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowConsolidations = ToBoolean(showConsolidationsStr);
|
|
result.showConsolidations = mShowConsolidations;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
struct XTrendPresentationConfig
|
|
{
|
|
bool showHull; // Show Hull
|
|
bool showTrends; // Show Trends
|
|
bool fillTrends; // Fill Trends
|
|
bool showRibbons; // Show Ribbons
|
|
bool showSSLChannel; // Show SSL Channel
|
|
};
|
|
|
|
//
|
|
string GenerateTrendPresentationConfig(
|
|
bool mShowTrends = true, // Show Trends
|
|
bool mFillTrends = false, // Fill Trends
|
|
bool mShowRibbons = false, // Show Ribbons
|
|
bool mShowHull = false, // Show Hull
|
|
bool mShowSSLChannel = false // Show SSL Channel
|
|
)
|
|
{
|
|
//
|
|
string result;
|
|
|
|
//
|
|
result =
|
|
//
|
|
showTrendsToken + "(" + ToString(mShowTrends) + ")" +
|
|
fillTrendsToken + "(" + ToString(mFillTrends) + ")" +
|
|
showRibbonsToken + "(" + ToString(mShowRibbons) + ")" +
|
|
showHullToken + "(" + ToString(mShowHull) + ")" +
|
|
showSSLChannelToken + "(" + ToString(mShowSSLChannel) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XTrendPresentationConfig &config)
|
|
{
|
|
//
|
|
return GenerateTrendPresentationConfig(
|
|
config.showHull,
|
|
config.showTrends,
|
|
config.fillTrends,
|
|
config.showRibbons,
|
|
config.showSSLChannel);
|
|
}
|
|
|
|
//
|
|
XTrendPresentationConfig ParseTrendPresentationConfig(string config)
|
|
{
|
|
//
|
|
XTrendPresentationConfig result;
|
|
|
|
//
|
|
string showTrendsStr = ExtractString(
|
|
config,
|
|
showTrendsToken + "(",
|
|
")");
|
|
if (StringLen(showTrendsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowTrends = ToBoolean(showTrendsStr);
|
|
result.showTrends = mShowTrends;
|
|
}
|
|
|
|
//
|
|
string fillTrendsStr = ExtractString(
|
|
config,
|
|
fillTrendsToken + "(",
|
|
")");
|
|
if (StringLen(fillTrendsStr) > 0)
|
|
{
|
|
//
|
|
bool mFillTrends = ToBoolean(fillTrendsStr);
|
|
result.fillTrends = mFillTrends;
|
|
}
|
|
|
|
//
|
|
string showRibbonsStr = ExtractString(
|
|
config,
|
|
showRibbonsToken + "(",
|
|
")");
|
|
if (StringLen(showRibbonsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowRibbons = ToBoolean(showRibbonsStr);
|
|
result.showRibbons = mShowRibbons;
|
|
}
|
|
|
|
//
|
|
string showHullStr = ExtractString(
|
|
config,
|
|
showHullToken + "(",
|
|
")");
|
|
if (StringLen(showHullStr) > 0)
|
|
{
|
|
//
|
|
bool mShowHull = ToBoolean(showHullStr);
|
|
result.showHull = mShowHull;
|
|
}
|
|
|
|
//
|
|
string showSSLChannelStr = ExtractString(
|
|
config,
|
|
showSSLChannelToken + "(",
|
|
")");
|
|
if (StringLen(showSSLChannelStr) > 0)
|
|
{
|
|
//
|
|
bool mShowSSLChannel = ToBoolean(showSSLChannelStr);
|
|
result.showSSLChannel = mShowSSLChannel;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
struct XFiboPresentationConfig
|
|
{
|
|
bool showFibo1Levels; // Show Fibo 1st Level
|
|
bool showFibo2Levels; // Show Fibo 2nd Level
|
|
bool showFibo3Levels; // Show Fibo 3rd Level
|
|
bool showFibo4Levels; // Show Fibo 4th Level
|
|
bool showFibo5Levels; // Show Fibo 5th Level
|
|
};
|
|
|
|
//
|
|
string GenerateFiboPresentationConfig(
|
|
bool mShowFibo1Levels = false, // Show Fibo 1st Level
|
|
bool mShowFibo2Levels = false, // Show Fibo 2nd Level
|
|
bool mShowFibo3Levels = false, // Show Fibo 3rd Level
|
|
bool mShowFibo4Levels = false, // Show Fibo 4th Level
|
|
bool mShowFibo5Levels = false // Show Fibo 5th Level
|
|
)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result =
|
|
//
|
|
showFibo1LevelsToken + "(" + ToString(mShowFibo1Levels) + ")" +
|
|
showFibo2LevelsToken + "(" + ToString(mShowFibo2Levels) + ")" +
|
|
showFibo3LevelsToken + "(" + ToString(mShowFibo3Levels) + ")" +
|
|
showFibo4LevelsToken + "(" + ToString(mShowFibo4Levels) + ")" +
|
|
showFibo5LevelsToken + "(" + ToString(mShowFibo5Levels) + ")"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string ToString(XFiboPresentationConfig &config)
|
|
{
|
|
//
|
|
return GenerateFiboPresentationConfig(
|
|
config.showFibo1Levels,
|
|
config.showFibo2Levels,
|
|
config.showFibo3Levels,
|
|
config.showFibo4Levels,
|
|
config.showFibo5Levels);
|
|
}
|
|
|
|
//
|
|
XFiboPresentationConfig ParePresentationConfig(string config)
|
|
{
|
|
//
|
|
XFiboPresentationConfig result;
|
|
|
|
//
|
|
string showFibo1LevelsStr = ExtractString(
|
|
config,
|
|
showFibo1LevelsToken + "(",
|
|
")");
|
|
if (StringLen(showFibo1LevelsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowFibo1Levels = ToBoolean(showFibo1LevelsStr);
|
|
result.showFibo1Levels = mShowFibo1Levels;
|
|
}
|
|
|
|
//
|
|
string showFibo2LevelsStr = ExtractString(
|
|
config,
|
|
showFibo2LevelsToken + "(",
|
|
")");
|
|
if (StringLen(showFibo2LevelsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowFibo2Levels = ToBoolean(showFibo2LevelsStr);
|
|
result.showFibo2Levels = mShowFibo2Levels;
|
|
}
|
|
|
|
//
|
|
string showFibo3LevelsStr = ExtractString(
|
|
config,
|
|
showFibo3LevelsToken + "(",
|
|
")");
|
|
if (StringLen(showFibo3LevelsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowFibo3Levels = ToBoolean(showFibo3LevelsStr);
|
|
result.showFibo3Levels = mShowFibo3Levels;
|
|
}
|
|
|
|
//
|
|
string showFibo4LevelsStr = ExtractString(
|
|
config,
|
|
showFibo4LevelsToken + "(",
|
|
")");
|
|
if (StringLen(showFibo4LevelsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowFibo4Levels = ToBoolean(showFibo4LevelsStr);
|
|
result.showFibo4Levels = mShowFibo4Levels;
|
|
}
|
|
|
|
//
|
|
string showFibo5LevelsStr = ExtractString(
|
|
config,
|
|
showFibo5LevelsToken + "(",
|
|
")");
|
|
if (StringLen(showFibo5LevelsStr) > 0)
|
|
{
|
|
//
|
|
bool mShowFibo5Levels = ToBoolean(showFibo5LevelsStr);
|
|
result.showFibo5Levels = mShowFibo5Levels;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|