1067 lines
28 KiB
Plaintext
1067 lines
28 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// --------------------------------------
|
|
// Name: XSCXCHKMStrategy
|
|
// Description: provides all based classes for use ...
|
|
//
|
|
//
|
|
// 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
|
|
|
|
//
|
|
// Imports ...
|
|
|
|
//
|
|
// Import(s) Helper(s) ...
|
|
#include "../Helpers/x-saherelm.xpv.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xchm.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xchhk.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xchche.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xchstr.helper.mq5"
|
|
|
|
//
|
|
// Base Classes ...
|
|
#include "../Classes/x-saherelm.xstrategy.class.mq5"
|
|
|
|
//
|
|
// Specific Identifier(s) of XStrategy ...
|
|
string XCHKMStartegyToken = "XCHKM";
|
|
|
|
//
|
|
// XStrategy Class Implementation(s) ...
|
|
class XSCXCHKMStrategy : public XSCBaseStrategy
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Constructor(s) ...
|
|
void XSCXCHKMStrategy(
|
|
//
|
|
// Base ...
|
|
string _symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES _period, // Trading TimeFrame
|
|
ENUM_TIMEFRAMES _analizePeriod, // Important Area Detect Time Frame
|
|
double _volume, // Voluem
|
|
double _r2r, // Risk/Reward Ratio
|
|
int _slippage, // Trader Slippage
|
|
long _magicNumber, // Trader Magic Number
|
|
bool _ignoreSignalExecution = false, // Ignore Signal Execution
|
|
bool _useTPSLAsPoint = false, // Converts TP and SL by Provided Points
|
|
bool _forceMaxTPSLAsPoint = false, // Force Max TP and SL by Provided Points
|
|
double _tpPoint = 0, // TP As Point
|
|
double _slPoint = 0, // SL As Point
|
|
bool _ignoreTP = false, // TP set to 0
|
|
bool _ignoreSL = false, // SL set to 0
|
|
bool _allowLong = true,
|
|
bool _allowShort = true,
|
|
int _maxAllowedLongs = 0,
|
|
int _maxAllowedShorts = 0 //
|
|
) : XSCBaseStrategy(_symbol,
|
|
_period,
|
|
_analizePeriod,
|
|
_volume,
|
|
_r2r,
|
|
_slippage,
|
|
_magicNumber,
|
|
_ignoreSignalExecution,
|
|
_useTPSLAsPoint,
|
|
_forceMaxTPSLAsPoint,
|
|
_tpPoint,
|
|
_slPoint,
|
|
_ignoreTP,
|
|
_ignoreSL,
|
|
_allowLong,
|
|
_allowShort,
|
|
_maxAllowedLongs,
|
|
_maxAllowedShorts //
|
|
)
|
|
{
|
|
//
|
|
SetAlertPrefix(GetTag());
|
|
|
|
//
|
|
PrepareRequirements();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XSCXCHKMStrategy()
|
|
{
|
|
//
|
|
delete pvHelper;
|
|
|
|
//
|
|
delete chmHelper;
|
|
delete chhkHelper;
|
|
delete chstrHelper;
|
|
delete chcheHelper;
|
|
}
|
|
|
|
//
|
|
// Getter / Setter (s) ...
|
|
|
|
//
|
|
bool EnableXCHCHE()
|
|
{
|
|
return mEnableXCHCHE;
|
|
}
|
|
|
|
//
|
|
void EnableXCHCHE(bool value)
|
|
{
|
|
mEnableXCHCHE = value;
|
|
}
|
|
|
|
//
|
|
bool EnableXCHM()
|
|
{
|
|
return mEnableXCHM;
|
|
}
|
|
|
|
//
|
|
void EnableXCHM(bool value)
|
|
{
|
|
mEnableXCHM = value;
|
|
}
|
|
|
|
//
|
|
bool EnableXCHHK()
|
|
{
|
|
return mEnableXCHHK;
|
|
}
|
|
|
|
//
|
|
void EnableXCHHK(bool value)
|
|
{
|
|
mEnableXCHHK = value;
|
|
}
|
|
|
|
//
|
|
bool EnableXCHSTR()
|
|
{
|
|
return mEnableXCHSTR;
|
|
}
|
|
|
|
//
|
|
void EnableXCHSTR(bool value)
|
|
{
|
|
mEnableXCHSTR = value;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
//
|
|
// Customize Strategy Identifier ...
|
|
string GetTag() override
|
|
{
|
|
return XCHKMStartegyToken;
|
|
}
|
|
|
|
//
|
|
// Check Conditions For Signal ...
|
|
bool HasSignal(
|
|
XSignal &signal //
|
|
) override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
signal.Clean();
|
|
|
|
//
|
|
double sl = 0;
|
|
double tp = 0;
|
|
double risk = 0;
|
|
double entry = 0;
|
|
double reward = 0;
|
|
double r2r = R2R();
|
|
ENUM_POSITION_TYPE type = POSITION_TYPE_BUY;
|
|
ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET;
|
|
|
|
//
|
|
bool hasLong = false;
|
|
bool hasShort = false;
|
|
|
|
//
|
|
// Retrieve Conditions ...
|
|
|
|
//
|
|
// XPV ...
|
|
XPVConditions pvConditions;
|
|
result = pvHelper.GetConditions(pvConditions);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHM ...
|
|
XCHMConditions chmConditions;
|
|
result = chmHelper.GetConditions(chmConditions);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHHK ...
|
|
XCHHKConditions chhkConditions;
|
|
result = chhkHelper.GetConditions(chhkConditions);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHSTR ...
|
|
XCHSTRConditions chstrConditions;
|
|
result = chstrHelper.GetConditions(chstrConditions);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHCHE ...
|
|
XCHCHEConditions chcheConditions;
|
|
result = chcheHelper.GetConditions(chcheConditions);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Start Calculations ...
|
|
|
|
//
|
|
double points = GetPoints(mSymbol);
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
// Retrieve Bars ...
|
|
|
|
//
|
|
// Last Bar ...
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Previous Bar of Last Bar ...
|
|
XOHCL pBar;
|
|
result = cBar.GetPreviousBar(pBar);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Last Swing Low Bar ...
|
|
XOHCL lastSwingLow;
|
|
result = cBar.FindLastSwingLow(lastSwingLow);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Last Swing High Bar ...
|
|
XOHCL lastSwingHigh;
|
|
result = cBar.FindLastSwingHigh(lastSwingHigh);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Highest High(s) and Lowest Low(s) ...
|
|
|
|
//
|
|
// Highest High ...
|
|
double hh5 = cBar.FindHighest(
|
|
5,
|
|
MODE_HIGH //
|
|
);
|
|
|
|
//
|
|
// Lowest Low ...
|
|
double ll5 = cBar.FindLowest(
|
|
5,
|
|
MODE_LOW //
|
|
);
|
|
|
|
//
|
|
// For Trend ...
|
|
XOHCL tmpHSW[];
|
|
XOHCL tmpLSW[];
|
|
|
|
//
|
|
// Detect Bullish/Bearish Patterns and Trends ...
|
|
|
|
//
|
|
// Bullish ...
|
|
bool hasBullishPower = cBar.HasBullishPower();
|
|
bool hasBullishPattern = HasBullishPattern(cBar);
|
|
bool hasBullishPressure = cBar.HasBullishPressure();
|
|
bool isBullishTrend = cBar.HasBullishTrend(
|
|
tmpHSW,
|
|
tmpLSW,
|
|
true //
|
|
);
|
|
|
|
//
|
|
// Bearish ...
|
|
bool hasBearishPower = cBar.HasBearishPower();
|
|
bool hasBearishPattern = HasBearishPattern(cBar);
|
|
bool hasBearishPressure = cBar.HasBearishPressure();
|
|
bool isBearishTrend = cBar.HasBearishTrend(
|
|
tmpHSW,
|
|
tmpLSW,
|
|
false //
|
|
);
|
|
|
|
//
|
|
// XCHM ...
|
|
|
|
//
|
|
double chmBullishPower = chmHelper.GetBullishPower(cIndex);
|
|
double chmBearishPower = chmHelper.GetBearishPower(cIndex);
|
|
|
|
//
|
|
double chmMaxBullishFast = chmHelper.GetMaxBullishFast(cIndex);
|
|
double chmMinBullishFast = chmHelper.GetMinBullishFast(cIndex);
|
|
double chmMaxBullishSlow = chmHelper.GetMaxBullishSlow(cIndex);
|
|
double chmMinBullishSlow = chmHelper.GetMinBullishSlow(cIndex);
|
|
double chmMaxBearishFast = chmHelper.GetMaxBearishFast(cIndex);
|
|
double chmMinBearishFast = chmHelper.GetMinBearishFast(cIndex);
|
|
double chmMaxBearishSlow = chmHelper.GetMaxBearishSlow(cIndex);
|
|
double chmMinBearishSlow = chmHelper.GetMinBearishSlow(cIndex);
|
|
|
|
//
|
|
// XCHHK ...
|
|
|
|
//
|
|
double chhkBullishPower = chhkHelper.GetBullishPower(cIndex);
|
|
double chhkBearishPower = chhkHelper.GetBearishPower(cIndex);
|
|
|
|
//
|
|
double chhkMinBearishHigh = chhkHelper.GetMinBearishHigh(cIndex);
|
|
double chhkMaxBearishHigh = chhkHelper.GetMaxBearishHigh(cIndex);
|
|
double chhkMinBearishLow = chhkHelper.GetMinBearishLow(cIndex);
|
|
double chhkMaxBearishLow = chhkHelper.GetMaxBearishLow(cIndex);
|
|
double chhkMaxBullishHigh = chhkHelper.GetMaxBullishHigh(cIndex);
|
|
double chhkMinBullishHigh = chhkHelper.GetMinBullishHigh(cIndex);
|
|
double chhkMaxBullishLow = chhkHelper.GetMaxBullishLow(cIndex);
|
|
double chhkMinBullishLow = chhkHelper.GetMinBullishLow(cIndex);
|
|
|
|
//
|
|
// XCHSTR ...
|
|
|
|
//
|
|
double chstrBullishPower = chstrHelper.GetBullishPower(cIndex);
|
|
double chstrBearishPower = chstrHelper.GetBearishPower(cIndex);
|
|
|
|
//
|
|
double chstrMinBullish = chstrHelper.GetMinBullish(cIndex);
|
|
double chstrMaxBullish = chstrHelper.GetMaxBullish(cIndex);
|
|
double chstrMinBearish = chstrHelper.GetMinBearish(cIndex);
|
|
double chstrMaxBearish = chstrHelper.GetMaxBearish(cIndex);
|
|
|
|
//
|
|
// XCHCHE ...
|
|
|
|
//
|
|
double chcheBullishPower = chcheHelper.GetBullishPower(cIndex);
|
|
double chcheBearishPower = chcheHelper.GetBearishPower(cIndex);
|
|
|
|
//
|
|
double chcheMaxBullish = chcheHelper.GetBullishMax(cIndex);
|
|
double chcheMinBullish = chcheHelper.GetBullishMin(cIndex);
|
|
double chcheMaxBearish = chcheHelper.GetBearishMax(cIndex);
|
|
double chcheMinBearish = chcheHelper.GetBearishMin(cIndex);
|
|
|
|
//
|
|
DetectImportantAreas();
|
|
|
|
//
|
|
int pushers = 0;
|
|
string signallers[];
|
|
|
|
//
|
|
// XCHM ...
|
|
if (mEnableXCHM)
|
|
{
|
|
//
|
|
if (chmConditions.isBullishPowerUp)
|
|
{
|
|
//
|
|
bool chmHasLong =
|
|
//
|
|
hasBullishPower &&
|
|
cBar.IsBullish() &&
|
|
hasBullishPattern &&
|
|
hasBullishPressure &&
|
|
cBar.low > chmMinBullishFast &&
|
|
chmConditions.isBullishPowerUp &&
|
|
chcheConditions.isCStrongBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chmHasLong)
|
|
{
|
|
//
|
|
hasLong = chmHasLong;
|
|
if (hasLong)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHM",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chmMaxBullishFast;
|
|
type = POSITION_TYPE_BUY;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (chmConditions.isBearishPowerUp)
|
|
{
|
|
//
|
|
bool chmHasShort =
|
|
//
|
|
hasBearishPower &&
|
|
cBar.IsBearish() &&
|
|
hasBearishPattern &&
|
|
hasBearishPressure &&
|
|
cBar.high < chmMaxBearishFast &&
|
|
chmConditions.isBearishPowerUp &&
|
|
chcheConditions.isCStrongBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chmHasShort)
|
|
{
|
|
//
|
|
hasShort = chmHasShort;
|
|
if (hasShort)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHM",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chmMinBearishFast;
|
|
type = POSITION_TYPE_SELL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// XCHHK ...
|
|
if (mEnableXCHHK)
|
|
{
|
|
//
|
|
if (chhkConditions.isBullishPowerUp)
|
|
{
|
|
//
|
|
bool chhkHasLong =
|
|
//
|
|
hasBullishPower &&
|
|
cBar.IsBullish() &&
|
|
hasBullishPattern &&
|
|
hasBullishPressure &&
|
|
cBar.low > chhkMinBullishHigh &&
|
|
chhkConditions.isBullishPowerUp &&
|
|
chcheConditions.isCStrongBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chhkHasLong)
|
|
{
|
|
//
|
|
hasLong = chhkHasLong;
|
|
if (hasLong)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHHK",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chhkMaxBullishLow;
|
|
type = POSITION_TYPE_BUY;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (chhkConditions.isBearishPowerUp)
|
|
{
|
|
//
|
|
bool chhkHasShort =
|
|
//
|
|
hasBearishPower &&
|
|
cBar.IsBearish() &&
|
|
hasBearishPattern &&
|
|
hasBearishPressure &&
|
|
cBar.high < chhkMaxBearishLow &&
|
|
chhkConditions.isBearishPowerUp &&
|
|
chcheConditions.isCStrongBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chhkHasShort)
|
|
{
|
|
//
|
|
hasShort = chhkHasShort;
|
|
if (hasShort)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHHK",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chhkMinBearishHigh;
|
|
type = POSITION_TYPE_SELL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// XCHSTR ...
|
|
if (mEnableXCHSTR)
|
|
{
|
|
//
|
|
if (chstrConditions.isBullishPowerUp)
|
|
{
|
|
//
|
|
bool chstrHasLong =
|
|
//
|
|
hasBullishPower &&
|
|
cBar.IsBullish() &&
|
|
hasBullishPattern &&
|
|
hasBullishPressure &&
|
|
cBar.low > chstrMinBullish &&
|
|
chstrConditions.isBullishPowerUp &&
|
|
chcheConditions.isCStrongBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chstrHasLong)
|
|
{
|
|
//
|
|
hasLong = chstrHasLong;
|
|
if (hasLong)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHSTR",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chstrMinBullish;
|
|
type = POSITION_TYPE_BUY;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (chstrConditions.isBearishPowerUp)
|
|
{
|
|
//
|
|
bool chstrHasShort =
|
|
//
|
|
hasBearishPower &&
|
|
cBar.IsBearish() &&
|
|
hasBearishPattern &&
|
|
hasBearishPressure &&
|
|
cBar.high < chstrMaxBearish &&
|
|
chstrConditions.isBearishPowerUp &&
|
|
chcheConditions.isCStrongBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chstrHasShort)
|
|
{
|
|
//
|
|
hasShort = chstrHasShort;
|
|
if (hasShort)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHSTR",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chstrMaxBearish;
|
|
type = POSITION_TYPE_SELL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// XCHCHE ...
|
|
if (mEnableXCHCHE)
|
|
{
|
|
//
|
|
if (chcheConditions.isBullishPowerUp)
|
|
{
|
|
//
|
|
bool chcheHasLong =
|
|
//
|
|
hasBullishPower &&
|
|
cBar.IsBullish() &&
|
|
cBar.low > chcheMinBullish &&
|
|
chcheConditions.isBullishPowerUp &&
|
|
chcheConditions.isCStrongBearish &&
|
|
(chmConditions.hasBullishPower ||
|
|
chhkConditions.hasBullishPower ||
|
|
chstrConditions.hasBullishPower)
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chcheHasLong)
|
|
{
|
|
//
|
|
hasLong = chcheHasLong;
|
|
if (hasLong)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHCHE",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chcheMinBullish;
|
|
type = POSITION_TYPE_BUY;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (chcheConditions.isBearishPowerUp)
|
|
{
|
|
//
|
|
bool chcheHasShort =
|
|
//
|
|
hasBearishPower &&
|
|
cBar.IsBearish() &&
|
|
cBar.high < chcheMaxBearish &&
|
|
chcheConditions.isBearishPowerUp &&
|
|
chcheConditions.isCStrongBearish &&
|
|
(chmConditions.hasBearishPower ||
|
|
chhkConditions.hasBearishPower ||
|
|
chstrConditions.hasBearishPower)
|
|
//
|
|
;
|
|
|
|
//
|
|
if (chcheHasShort)
|
|
{
|
|
//
|
|
hasShort = chcheHasShort;
|
|
if (hasShort)
|
|
{
|
|
//
|
|
pushers++;
|
|
Add(
|
|
"XCHCHE",
|
|
signallers //
|
|
);
|
|
|
|
//
|
|
sl = chcheMaxBearish;
|
|
type = POSITION_TYPE_SELL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
result = hasLong || hasShort;
|
|
if (!result)
|
|
{
|
|
//
|
|
CheckImportantAreasValidation();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
// //
|
|
// result =
|
|
// //
|
|
// (hasLong &&
|
|
// bullishTrend.IsValid())
|
|
// //
|
|
// ||
|
|
// //
|
|
// (!hasLong &&
|
|
// bearishTrend.IsValid())
|
|
// //
|
|
// ;
|
|
// if (!result)
|
|
// {
|
|
// return result;
|
|
// }
|
|
|
|
//
|
|
DestroyImportantAreas();
|
|
|
|
//
|
|
// Retrieve Entry Price based on Position Type ...
|
|
entry = GetEntry(mSymbol, type);
|
|
|
|
//
|
|
// Calculate TP and SL ...
|
|
// based on Strategy ...
|
|
// only when on of TP or SL Provides, using provided R2R ...
|
|
if ((tp <= 0 && sl > 0) || (tp > 0 && sl <= 0))
|
|
{
|
|
CalculateTPSLByPrice(
|
|
sl,
|
|
tp,
|
|
type,
|
|
entry,
|
|
r2r //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Prepare Signal ...
|
|
result = signal.Prepare(
|
|
mSymbol,
|
|
signallers[0],
|
|
mPeriod,
|
|
type,
|
|
mode,
|
|
entry,
|
|
mVolume,
|
|
sl,
|
|
tp //
|
|
);
|
|
if (result)
|
|
{
|
|
signal.pushers = pushers;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
bool mEnableXCHM; // Enable XCHM Signaller
|
|
bool mEnableXCHHK; // Enable XCHHK Signaller
|
|
bool mEnableXCHSTR; // Enable XCHSTR Signaller
|
|
bool mEnableXCHCHE; // Enable XCHCHE Signaller
|
|
|
|
//
|
|
// XPV ...
|
|
XPVInputs pvInputs;
|
|
XSCXPVHelper *pvHelper;
|
|
|
|
//
|
|
// XHK ...
|
|
XCHHKInputs chhkInputs;
|
|
XSCXCHHKHelper *chhkHelper;
|
|
|
|
//
|
|
// XCHMA ...
|
|
XCHMInputs chmInputs;
|
|
XSCXCHMHelper *chmHelper;
|
|
|
|
//
|
|
// XSTR ...
|
|
XCHSTRInputs chstrInputs;
|
|
XSCXCHSTRHelper *chstrHelper;
|
|
|
|
//
|
|
// XCHCHE ...
|
|
XCHCHEInputs chcheInputs;
|
|
XSCXCHCHEHelper *chcheHelper;
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Install all Helpers and Prepare all
|
|
// Configurations for required Indicators ...
|
|
void PrepareRequirements()
|
|
{
|
|
//
|
|
mEnableXCHM = true;
|
|
mEnableXCHHK = true;
|
|
mEnableXCHSTR = true;
|
|
mEnableXCHCHE = true;
|
|
|
|
//
|
|
support.Clean();
|
|
supportTime = NULL;
|
|
isSupportTested = false;
|
|
|
|
//
|
|
resistance.Clean();
|
|
resistanceTime = NULL;
|
|
isResistanceTested = false;
|
|
|
|
//
|
|
// Short ...
|
|
ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period
|
|
ENUM_TIMEFRAMES scPeriod = NULL; // PERIOD_M20; // Time Period
|
|
|
|
//
|
|
// Medium ...
|
|
ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period
|
|
ENUM_TIMEFRAMES mcPeriod = NULL; // PERIOD_M30; // Time Period
|
|
|
|
//
|
|
// Long ...
|
|
ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period
|
|
ENUM_TIMEFRAMES lcPeriod = NULL; // PERIOD_H1; // Time Period
|
|
|
|
//
|
|
// Hind ...
|
|
ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period
|
|
ENUM_TIMEFRAMES hcPeriod = NULL; // PERIOD_H2; // Time Period
|
|
|
|
//
|
|
// XPV ...
|
|
|
|
//
|
|
pvInputs.Default();
|
|
|
|
//
|
|
pvInputs.scMethod = scMethod;
|
|
pvInputs.scPeriod = scPeriod;
|
|
pvInputs.mcMethod = mcMethod;
|
|
pvInputs.mcPeriod = mcPeriod;
|
|
pvInputs.lcMethod = lcMethod;
|
|
pvInputs.lcPeriod = lcPeriod;
|
|
pvInputs.hcMethod = hcMethod;
|
|
pvInputs.hcPeriod = hcPeriod;
|
|
|
|
//
|
|
pvInputs.showPeaksAndVales = false;
|
|
pvInputs.showLevels = false;
|
|
pvInputs.showConsolidations = false;
|
|
pvInputs.showFibo1Levels = false;
|
|
pvInputs.showFibo2Levels = false;
|
|
pvInputs.showFibo3Levels = false;
|
|
pvInputs.showFibo4Levels = false;
|
|
pvInputs.showFibo5Levels = false;
|
|
|
|
//
|
|
pvHelper = new XSCXPVHelper();
|
|
pvHelper.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
pvInputs //
|
|
);
|
|
|
|
//
|
|
// XCHM ...
|
|
|
|
//
|
|
chmInputs.Default();
|
|
|
|
//
|
|
chmInputs.scMethod = scMethod;
|
|
chmInputs.scPeriod = scPeriod;
|
|
chmInputs.mcMethod = mcMethod;
|
|
chmInputs.mcPeriod = mcPeriod;
|
|
chmInputs.lcMethod = lcMethod;
|
|
chmInputs.lcPeriod = lcPeriod;
|
|
chmInputs.hcMethod = hcMethod;
|
|
chmInputs.hcPeriod = hcPeriod;
|
|
|
|
//
|
|
chmInputs.showFast = false;
|
|
chmInputs.showSlow = false;
|
|
chmInputs.showCCFast = false;
|
|
chmInputs.showCCSlow = false;
|
|
chmInputs.showSCFast = false;
|
|
chmInputs.showSCSlow = false;
|
|
chmInputs.showMCFast = false;
|
|
chmInputs.showMCSlow = false;
|
|
chmInputs.showLCFast = false;
|
|
chmInputs.showLCSlow = false;
|
|
chmInputs.showHCFast = false;
|
|
chmInputs.showHCSlow = false;
|
|
|
|
//
|
|
chmHelper = new XSCXCHMHelper();
|
|
chmHelper.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
chmInputs //
|
|
);
|
|
|
|
//
|
|
// XCHHK ...
|
|
|
|
//
|
|
chhkInputs.Default();
|
|
|
|
//
|
|
chhkInputs.scMethod = scMethod;
|
|
chhkInputs.scPeriod = scPeriod;
|
|
chhkInputs.mcMethod = mcMethod;
|
|
chhkInputs.mcPeriod = mcPeriod;
|
|
chhkInputs.lcMethod = lcMethod;
|
|
chhkInputs.lcPeriod = lcPeriod;
|
|
chhkInputs.hcMethod = hcMethod;
|
|
chhkInputs.hcPeriod = hcPeriod;
|
|
|
|
//
|
|
chhkInputs.ignoreShadows = true;
|
|
|
|
//
|
|
chhkInputs.showCurrent = false;
|
|
chhkInputs.showShort = false;
|
|
chhkInputs.showMedium = false;
|
|
chhkInputs.showLong = false;
|
|
chhkInputs.showHind = false;
|
|
|
|
//
|
|
chhkHelper = new XSCXCHHKHelper();
|
|
chhkHelper.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
chhkInputs //
|
|
);
|
|
|
|
//
|
|
// XCHSTR ...
|
|
|
|
//
|
|
chstrInputs.Default();
|
|
|
|
//
|
|
chstrInputs.scMethod = scMethod;
|
|
chstrInputs.scPeriod = scPeriod;
|
|
chstrInputs.mcMethod = mcMethod;
|
|
chstrInputs.mcPeriod = mcPeriod;
|
|
chstrInputs.lcMethod = lcMethod;
|
|
chstrInputs.lcPeriod = lcPeriod;
|
|
chstrInputs.hcMethod = hcMethod;
|
|
chstrInputs.hcPeriod = hcPeriod;
|
|
|
|
//
|
|
chstrInputs.showCurrent = false;
|
|
chstrInputs.showShort = false;
|
|
chstrInputs.showMedium = false;
|
|
chstrInputs.showLong = false;
|
|
chstrInputs.showHind = false;
|
|
|
|
//
|
|
chstrHelper = new XSCXCHSTRHelper();
|
|
chstrHelper.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
chstrInputs //
|
|
);
|
|
|
|
//
|
|
// XCHCHE ...
|
|
|
|
//
|
|
chcheInputs.Default();
|
|
|
|
//
|
|
chcheInputs.showCurrentLE1 = false;
|
|
chcheInputs.showCurrentLE2 = false;
|
|
chcheInputs.showCurrentSE1 = false;
|
|
chcheInputs.showCurrentSE2 = false;
|
|
chcheInputs.showShortLE1 = false;
|
|
chcheInputs.showShortLE2 = false;
|
|
chcheInputs.showShortSE1 = false;
|
|
chcheInputs.showShortSE2 = false;
|
|
chcheInputs.showMediumLE1 = false;
|
|
chcheInputs.showMediumLE2 = false;
|
|
chcheInputs.showMediumSE1 = false;
|
|
chcheInputs.showMediumSE2 = false;
|
|
chcheInputs.showLongLE1 = false;
|
|
chcheInputs.showLongLE2 = false;
|
|
chcheInputs.showLongSE1 = false;
|
|
chcheInputs.showLongSE2 = false;
|
|
chcheInputs.showHindLE1 = false;
|
|
chcheInputs.showHindLE2 = false;
|
|
chcheInputs.showHindSE1 = false;
|
|
chcheInputs.showHindSE2 = false;
|
|
|
|
//
|
|
chcheHelper = new XSCXCHCHEHelper();
|
|
chcheHelper.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
chcheInputs //
|
|
);
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
// |