Backup WorkSpace ...

This commit is contained in:
2024-06-05 03:56:37 +03:30
parent 83c000fdd6
commit d5b6d8717f
60 changed files with 59416 additions and 0 deletions
@@ -0,0 +1,404 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCBaseInd
// Description: provides Indicator implementation
// requirements ...
//
//
// 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 ...
#include "../../Classes/x-saherelm.xind.class.mq5"
//
// XSCMid Indicator Buffers ...
enum ENUM_XSCMID_BUFFERS
{
XSCMID_MAIN_LINE = 0, // Main Buffer ...
XSCMID_STATE_LINE = 1, // State Buffer ...
};
//
string GetTitle(ENUM_XSCMID_BUFFERS bufferLine)
{
//
string result = NULL;
//
switch (bufferLine)
{
//
case XSCMID_MAIN_LINE:
result = "XMID";
break;
//
case XSCMID_STATE_LINE:
result = "XSTATE";
break;
}
//
return result;
}
//
// XSCMid Indicator Inputs ...
struct XSCMidInputs
{
//
// Props ...
string version;
//
// Constructor ...
XSCMidInputs()
{
Clean();
}
//
// Tools ...
//
// Initial Inputs ...
bool Init()
{
//
bool result = false;
//
result = IsValid();
//
return result;
}
//
// Cleanup ...
void Clean()
{
}
//
// Default ...
void Default()
{
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
true
//
;
//
return result;
}
//
// Retrieve Max Length ...
int Max()
{
//
int result = 0;
//
result = 0;
//
return result;
}
};
//
// a Simple Indicator ...
class XSCMid : public XSCBaseInd
{
//
// Public ...
public:
//
// Props ...
//
// Constructor(s) ...
void XSCMid(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period // Trading TimeFrame
) : XSCBaseInd(symbol, period)
{
//
mSymbol = symbol;
mPeriod = period;
//
mCalculatedBars = 0;
}
//
// Deconstructor ...
void ~XSCMid() {}
//
// Initialize Indicator ...
bool Init(
XSCMidInputs &inputs // Indicator Inputs ...
)
{
//
bool result = false;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
// Set Inputs ...
this.mInputs = inputs;
//
// Validate Indicator State ...
result = this.IsValid();
if (!result)
{
return result;
}
//
// Register Required Buffers ...
XBuffer main;
string mTitle = GetTitle(XSCMID_MAIN_LINE);
result = main.Init(
mTitle,
mSymbol,
mPeriod //
);
if (!result)
{
return result;
}
//
result = SetBuffer(main);
if (!result)
{
return result;
}
//
// Calculate First Time ...
Calculate();
//
return result;
}
//
// Property Getter(s) / Setter(s) ...
//
XSCMidInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XSCMidInputs &inputs // Indicator Inputs
)
{
return Init(inputs);
}
//
// Override(s) ...
//
// Get Tag ...
string GetTag() override
{
//
string result = NULL;
//
result = GetToken();
//
return result;
}
//
// Get Token ...
string GetToken() override
{
//
string result = NULL;
//
result = GetSpecificToken(this);
//
return result;
}
//
// Validate Inputs ...
bool IsValidInputs() override
{
return mInputs.IsValid();
}
//
// Calculate Buffers ...
void Calculate() override
{
//
int max = mInputs.Max();
int limit = CountLimit();
int totalBars = CountBars();
int prevCalculated = GetCalculatedBars();
//
// Prepare Buffers Index ...
int mainIDX = GetBufferIndexByLine(XSCMID_MAIN_LINE);
//
// Print("Total: ", totalBars, ", prevCalculated: ", prevCalculated, ", Limit: ", limit);
//
// Only Calculate Last Item ...
bool onlyLast = false;
if (prevCalculated == totalBars - 1)
{
onlyLast = true;
}
//
int start = totalBars - prevCalculated - 1;
for (int i = start; i >= 0; i--)
{
//
int barIndex = i - 1;
// Print("barIndex: ", barIndex, ", onlyLast: ", onlyLast);
if (barIndex < 0 && !onlyLast)
{
continue;
}
//
if (onlyLast)
{
barIndex = 0;
}
//
datetime iBarTime = iTime(
mSymbol,
mPeriod,
barIndex - 1
//
);
int iBarIndex = iBarShift(
mSymbol,
mPeriod,
iBarTime //
);
//
double iValue = iClose(mSymbol, mPeriod, iBarIndex);
//
Print("Bar: ", barIndex, ", Bar Time: ", iBarTime, ", Bar Index: ", iBarIndex, ", iValue: ", iValue);
if (iValue != 0.0)
{
//
// Print("Bar: ", barIndex, ", Bar Time: ", iBarTime, ", Bar Index: ", iBarIndex, ", iValue: ", iValue);
mBuffers[mainIDX].Add(barIndex, iValue);
}
}
//
// Prevent Double Calculation Same Bars ...
mCalculatedBars = totalBars - 1;
}
//
// De Initialize Class ...
void DeInit(int reason)
{
}
//
// Tools ...
//
int GetBufferIndexByLine(
ENUM_XSCMID_BUFFERS bufferLine // Specified Buffer Line
)
{
//
string mTitle = GetTitle(bufferLine);
return GetBufferIndex(mTitle);
}
//
bool GetBufferByLine(
ENUM_XSCMID_BUFFERS bufferLine, // Specified Buffer Line
XBuffer &buffer // Hold Result
)
{
//
string mTitle = GetTitle(bufferLine);
return GetBuffer(mTitle, buffer);
}
// //
// double GetBufferValueByLine(
// ENUM_XSCMID_BUFFERS bufferLine, // Specified Buffer Line
// datetime time = NULL // Time
// )
// {
// //
// string mTitle = GetTitle(bufferLine);
// return GetBufferValue(mTitle, time);
// }
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
//
// Inputs ...
XSCMidInputs mInputs;
};
@@ -0,0 +1,49 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// --------------------------------------
// Name: XBaseClass
// 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
//
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// XBase Class ...
class XSCBase
{
//
// Public ...
public:
//
// Protected ...
//
// Represent Basic Unique Tag ...
virtual string GetTag();
//
// Retrieve Class Token ...
virtual string GetToken();
protected:
//
// Private ...
private:
};
//
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,660 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCX121EA
// Description: provides all X121 EA requirements ...
// - X5 Provider;
//
//
// 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 ...
#include "../Classes/x-saherelm.xea.class.mq5"
#include "../Classes/x-saherelm.x121.provider.class.mq5"
//
// Define On Signal Event Handler Type Specified for X5 ...
typedef void (*TX121OnSignal)(X121ProviderDescriptor &descriptor);
//
// Class Definition ...
class XSCX121EA : public XSCBaseEA
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCX121EA(
//
// XTrade Class Requirements ...
int slippage, // Specify Slippage
ulong magicNumber, // Specify Magic Number
int manageInterval, // Manager Check Intervals Seconds
double maxAllowedSpread, // Max Allowed Spred for Opening Trades
int maxAllowedPositions, // Max Allowed Positions
double maxAllowedDrawdownFactor, // Max Allowed Drawdown Factor
double staticVolume, // Static Volume for Positions
//
// Position Management ...
bool allowLong = true, // Allow Long Trades
bool allowShort = true, // Allow Short Trades
double minProfitPerTrade = 0, // Min Profit Per Trade based On Volume Factor (Hedge)
double minProfitPerVolumeFactor = 0, // Min Volume Factor for Calculating Profit (Hedge)
//
// Event Handlers ...
TOnStopLoss onStopLossTriggered = NULL, // On StopLoass Triggered Event Handler
TOnTakeProfit onTakeProfitTriggered = NULL, // On TakeProfit Triggered Event Handler
TOnDealsChanged onDealsChangedHandler = NULL, // On Deals Changed Event Handler
TOnOrdersChanged onOrdersChangedHandler = NULL, // On Orders Changed Event Handler
TOnPositionsChanged onPositionsChangedHandler = NULL, // On Positions Changed Event Handler
TOnTradeStateChanged onTradeStateChangedHandler = NULL, // On Trade State Changed Event Handler
//
TOnSignal onSignalHandler = NULL, // On Signal Event Handler
//
// Log Handler ...
bool enableAlerts = true, // Enable Alerts
bool logAlerts = true, // Log Alerts
bool terminalAlerts = false, // Terminal Alerts
bool mailAlerts = false, // Mail Alerts
bool pushAlerts = false // Push Alerts
) : XSCBaseEA(slippage,
magicNumber,
manageInterval,
maxAllowedSpread,
maxAllowedPositions,
maxAllowedDrawdownFactor,
staticVolume,
allowLong,
allowShort,
minProfitPerTrade,
minProfitPerVolumeFactor,
onStopLossTriggered,
onTakeProfitTriggered,
onDealsChangedHandler,
onOrdersChangedHandler,
onPositionsChangedHandler,
onTradeStateChangedHandler,
enableAlerts,
logAlerts,
terminalAlerts,
mailAlerts,
pushAlerts //
)
{
}
//
// Deconstructor ...
~XSCX121EA() {}
//
// Properties Getter(s) / Setter(s) ...
//
// Add X5 Specified Signal Event Handler ...
void AddOnSignalEventHandler(TX121OnSignal listener)
{
//
Add(
listener,
mX121OnSignalEventHandlers
//
);
}
//
// Add Specified X5 Provider ...
bool AddProvider(X121ProviderDescriptor &descriptor)
{
//
bool result = false;
//
// Validate Inputs ...
result = descriptor.Init();
if (!result)
{
return result;
}
//
AddRef(
descriptor,
mDescriptors //
);
//
return result;
}
//
// Overrides ...
//
// Customize Token ...
string GetToken() override
{
return GetSpecificToken(this);
}
//
string GetTag() override
{
return this.GetToken();
}
//
void Draw() override
{
//
int descriptorsCount = CountDescriptors();
if (descriptorsCount <= 0)
{
return;
}
//
for (int i = 0; i < descriptorsCount; i++)
{
//
X121ProviderDescriptor iDescriptor = mDescriptors[i];
//
iDescriptor.provider.Draw();
}
}
//
// Check Provider for any Guards ...
bool CheckForGuard(XGuard &guards[]) override
{
//
bool result = false;
//
Clean(guards);
//
int descriptorsCount = CountDescriptors();
result = descriptorsCount > 0;
if (!result)
{
return result;
}
//
for (int i = 0; i < descriptorsCount; i++)
{
//
X121ProviderDescriptor iDescriptor = mDescriptors[i];
//
XGuard iGuards[];
bool iHasGuard = iDescriptor.HasGuard(iGuards);
if (iHasGuard)
{
//
Copy(
iGuards,
guards,
false //
);
}
}
//
result = ArraySize(guards) > 0;
//
return result;
}
//
// Request Provider to Collect all
// Potentially Signals and then
// filters theme here and passed them
// for Executing ...
int RequestForSignal(
XSignal &signals[] // Holds Signals ...
) override
{
//
bool result = 0;
//
Clean(signals);
//
int descriptorsCount = CountDescriptors();
if (descriptorsCount <= 0)
{
return result;
}
//
for (int i = 0; i < descriptorsCount; i++)
{
//
X121ProviderDescriptor iDescriptor = mDescriptors[i];
//
bool iHasSignal = iDescriptor.HasSignal();
if (iHasSignal)
{
//
// Here we Can double check Signals by Conditions
// for Score Base Filtering ...
//
AddRef(
iDescriptor.signal,
signals
//
);
//
NotifyX121OnSignalEventHandlers(iDescriptor);
}
}
//
result = ArraySize(signals);
//
return result;
}
//
// Request for Support Signals using Guard ...
bool RequestForSupport(
XSignal &support, // Holds Support Signal, if Provided
string provider, // Positions Provided by Specific Provider
string symbol, // Trading Symbol
ENUM_POSITION_TYPE type, // Trading Type
ENUM_TIMEFRAMES period // Specified Time Frame
) override
{
//
// TODO: Implement this ...
//
// Support Senario ...
// Check Support Position Exists or not ...
// Check Positions for Support based on Types ...
// Update Untriggered Positions ...
return false;
}
//
// Tools ...
//
// Protected ...
protected:
//
// Tools ...
//
void NotifyX121OnSignalEventHandlers(X121ProviderDescriptor &descriptor)
{
//
int listenersCount = ArraySize(mX121OnSignalEventHandlers);
if (listenersCount <= 0)
{
return;
}
//
for (int i = 0; i < listenersCount; i++)
{
//
TX121OnSignal iListener = mX121OnSignalEventHandlers[i];
//
iListener(descriptor);
}
}
//
// Protect Specified Position ...
void ProtectPosition(XPosition &position)
{
//
// Here i Can Protect Position ...
// This Protect Include One Position in Market Mode ...
// If Provided ...
// the Positions Selection must passed Some conditions ...
//
string message = "For (" + position.symbol + ") Max In Drawdown Position is: (" +
ToString(position.ticket) + "), by Profit: " + ToString(position.profit);
//
mAlert.Alert(message);
}
//
// Private ...
private:
//
// Props ...
//
// Collection of Signal Event Listeners ...
TX121OnSignal mX121OnSignalEventHandlers[];
//
// a Collection of X5 Provider Descriptors ...
X121ProviderDescriptor mDescriptors[];
//
int CountDescriptors()
{
return ArraySize(mDescriptors);
}
//
// Find Specifc Descriptor ...
int FindDescriptorIndex(
string symbol,
ENUM_TIMEFRAMES period //
)
{
//
int result = -1;
//
if (!IsValid(symbol) ||
!IsValid(period))
{
return result;
}
//
int descriptorsCount = CountDescriptors();
if (!IsValidSize(descriptorsCount))
{
return result;
}
//
for (int i = 0; i < descriptorsCount; i++)
{
//
X121ProviderDescriptor iDescriptor = mDescriptors[i];
//
bool isPassed =
//
iDescriptor.symbol == symbol &&
iDescriptor.period == period
//
;
if (isPassed)
{
//
result = i;
break;
}
}
//
return result;
}
template <typename T>
int FindDescriptorIndex(
T &item //
)
{
return FindDescriptorIndex(
item.symbol,
item.period //
);
}
//
// Trails Holding ...
//
XTrail mSLTrails[];
XTrail mTPTrails[];
//
int CountSLTrails()
{
return ArraySize(mSLTrails);
}
int CountTPTrails()
{
return ArraySize(mTPTrails);
}
//
bool RemoveTrail(ulong ticket)
{
//
bool isSLRemoved = RemoveSLTrail(ticket);
bool isTPRemoved = RemoveTPTrail(ticket);
//
bool result = isSLRemoved || isTPRemoved;
//
return result;
}
bool RemoveSLTrail(ulong ticket)
{
//
bool result = false;
//
int idx = FindSLTrailIndex(ticket);
result = idx >= 0;
if (!result)
{
return result;
}
//
result = ArrayRemove(
mSLTrails,
idx,
1 //
);
//
return result;
}
bool RemoveTPTrail(ulong ticket)
{
//
bool result = false;
//
int idx = FindTPTrailIndex(ticket);
result = idx >= 0;
if (!result)
{
return result;
}
//
result = ArrayRemove(
mTPTrails,
idx,
1 //
);
//
return result;
}
//
int FindSLTrailIndex(ulong ticket)
{
//
int result = -1;
//
int trailsCount = CountSLTrails();
if (ticket <= 0 || trailsCount <= 0)
{
return result;
}
//
for (int i = 0; i < trailsCount; i++)
{
//
XTrail iTrail = mSLTrails[i];
//
if (iTrail.ticket == ticket)
{
//
result = i;
break;
}
}
//
return result;
}
int FindTPTrailIndex(ulong ticket)
{
//
int result = -1;
//
int trailsCount = CountTPTrails();
if (ticket <= 0 || trailsCount <= 0)
{
return result;
}
//
for (int i = 0; i < trailsCount; i++)
{
//
XTrail iTrail = mTPTrails[i];
//
if (iTrail.ticket == ticket)
{
//
result = i;
break;
}
}
//
return result;
}
//
bool GetSLTrail(
ulong ticket,
XTrail &trail //
)
{
//
bool result = false;
//
int idx = FindSLTrailIndex(ticket);
result = idx >= 0;
if (!result)
{
return result;
}
//
trail = mSLTrails[idx];
//
return result;
}
bool GetTPTrail(
ulong ticket,
XTrail &trail //
)
{
//
bool result = false;
//
int idx = FindTPTrailIndex(ticket);
result = idx >= 0;
if (!result)
{
return result;
}
//
trail = mTPTrails[idx];
//
return result;
}
//
void AddSLTrail(
XTrail &trail //
)
{
//
if (!trail.IsValid())
{
return;
}
//
AddRef(
trail,
mSLTrails //
);
}
void AddTPTrail(
XTrail &trail //
)
{
//
if (!trail.IsValid())
{
return;
}
//
AddRef(
trail,
mTPTrails //
);
}
//
// Tools ...
};
//
// Tools ...
//
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,398 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCAccount
// Description: provides all Account requirements ...
//
//
// 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
//
// START Definitions ...
//
//
// END Definitions ...
//
//
// START Import and Inclused requirements ...
//
//
// Includes ...
#include <Trade/AccountInfo.mqh>
#include "../Classes/x-saherelm.base.class.mq5"
//
// END Import and Inclused requirements ...
//
//
// START Overrides ...
//
//
// END Overrides ...
//
//
// a Class for Manage Account ...
class XSCAccount : public XSCBase
{
//
// Public ...
public:
//
// Constructor ...
void XSCAccount()
{
//
mAccountInfo = new CAccountInfo();
}
//
// Deconstructor ...
void ~XSCAccount()
{
}
//
// START Provided Functions ...
//
//
// User Account ...
long GetUserAccount()
{
return mAccountInfo.Login();
}
//
// Account Leverage ...
long GetLeverage()
{
return mAccountInfo.Leverage();
}
//
// Get Trade Expert State ...
bool CanExpertTrade()
{
return mAccountInfo.TradeExpert();
}
//
// User Account Trade Mopde (ENUM_ACCOUNT_TRADE_MODE) ...
// --------------------------
// ACCOUNT_TRADE_MODE_DEMO
// ACCOUNT_TRADE_MODE_CONTEST
// ACCOUNT_TRADE_MODE_REAL
ENUM_ACCOUNT_TRADE_MODE GetTradeMode()
{
return mAccountInfo.TradeMode();
}
//
// Get Account Balance ...
double GetBalance()
{
return mAccountInfo.Balance();
}
//
// Get the amount of give Credit ...
double GetCredit()
{
return mAccountInfo.Credit();
}
//
// Get the amount of current Profit on account ...
double GetProfit()
{
return mAccountInfo.Profit();
}
//
// Get the amount of current Equity on account ...
double GetEquity()
{
return mAccountInfo.Equity();
}
//
// Get the amount of reserved Margin ...
double GetMargin()
{
return mAccountInfo.Margin();
}
//
// Get the amount of free Margin ...
double GetFreeMargin()
{
return mAccountInfo.FreeMargin();
}
//
// Get the Level of Margin ...
double GetMarginLevel()
{
return mAccountInfo.MarginLevel();
}
//
// Get the Level Of Margin for a Deposit ...
double GetMarginCall()
{
return mAccountInfo.MarginCall();
}
//
// Get the Level of Margin for Stop out ...
double GetMarginStopOut()
{
return mAccountInfo.MarginStopOut();
}
//
// Get the Client Name ...
string GetName()
{
return mAccountInfo.Name();
}
//
// Get the Trade Server Name ...
string GetServerName()
{
return mAccountInfo.Server();
}
//
// Get deposit Currency Name ...
string GetCurrency()
{
return mAccountInfo.Currency();
}
//
// Get the Company Name that serves an Account ...
string GetCompany()
{
return mAccountInfo.Company();
}
//
// Calculate Profits for the current account based on passed parameters ...
double CalculateTradeProfit(
const string symbol, // trading symbol
ENUM_ORDER_TYPE type, // order type
double volume, // volume
double entry, // open price
double exit // close price
)
{
//
double result = mAccountInfo.OrderProfitCheck(
symbol,
type,
volume,
entry,
exit);
//
return result;
}
//
// Calculate amount of margin which required for trade operation ...
double CalculateMarging(
const string symbol, // trading symbol
ENUM_ORDER_TYPE type, // order type
double volume, // volume
double entry // open price
)
{
//
double result = mAccountInfo.MarginCheck(
symbol,
type,
volume,
entry);
//
return result;
}
//
// Calculate amount of free margin left after trade operation ...
double CalculateFreeMarging(
const string symbol, // trading symbol
ENUM_ORDER_TYPE type, // order type
double volume, // volume
double entry // open price
)
{
//
double result = mAccountInfo.FreeMarginCheck(
symbol,
type,
volume,
entry);
//
return result;
}
//
// Calculate the Maximum possible volume of trade operation ...
double CalculateMaxVolume(
const string symbol, // trading symbol
ENUM_ORDER_TYPE type, // order type
double entry, // open price
double percent = 100 // percent of available margin
)
{
//
double result = mAccountInfo.MaxLotCheck(
symbol,
type,
entry,
percent);
//
return result;
}
//
// Calculate Point Value for Given Symbol based on Account ...
double GetPointValue(
string symbol // trading symbol
)
{
//
double result = 0;
//
double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
//
double ticksPerPoint = tickSize / point;
//
result = tickValue / ticksPerPoint;
//
return result;
}
//
// Calculate Risk Amount based on account Currency by Providing:
// Points and Volume ...
double CalculateRiskAmount(
string symbol, // trading symbol
double points, // amount of Risk Points
double volume // position Volume
)
{
//
double result = 0;
//
double pointValue = GetPointValue(symbol);
//
result = pointValue * volume * points;
//
return result;
}
//
// Calculate Risk Points based on account Currency by Providing:
// Volume and Amount ...
double CalculateRiskPoints(
string symbol, // trading symbol
double volume, // position Volume
double amount // amount of Risk based on Account Currency
)
{
//
double result = 0;
//
double pointValue = GetPointValue(symbol);
//
result = amount / (pointValue * volume);
//
return result;
}
//
// Calculate Volume based on account Currency by Providing:
// Amount and Risk Points ...
double CalculateVolume(
string symbol, // trading symbol
double amount, // amount of Risk based on Account Currency
double points // amount of Risk Points
)
{
//
double result = 0;
//
points =
points <= 0
? 10
: points;
//
double pointValue = GetPointValue(symbol);
//
result = amount / (pointValue * points);
//
return result;
}
//
// END Provided Functions ...
//
//
// Protected ...
protected:
//
// Private ...
private:
//
// Account Info ...
CAccountInfo mAccountInfo;
};
//
// START Usefull Functions ...
//
//
// END Usefull Functions ...
//
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,481 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCDataCollector
// Description: provides Data Collection Requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.base.class.mq5"
//
template <typename T>
class XSCDataCollector : public XSCBase
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
void XSCDataCollector(
string path = NULL, // Base Folder for Data Store
string fileName = NULL // File Name for Data Store
)
{
//
if (!IsValid(path))
{
path = GetType();
}
//
if (!IsValid(fileName))
{
fileName = GetType() + ".txt";
}
//
Path(path);
FileName(fileName);
}
//
// Deconstructor ...
void ~XSCDataCollector() {}
//
// Properties ...
//
bool Path(string value)
{
//
bool result = false;
//
result = IsValid(value);
if (!result)
{
return result;
}
//
result = value != mPath;
if (!result)
{
return result;
}
//
mPath = value;
//
return result;
}
//
string Path()
{
return mPath;
}
//
bool FileName(string value)
{
//
bool result = false;
//
result = IsValid(value);
if (!result)
{
return result;
}
//
result = value != mFileName;
if (!result)
{
return result;
}
//
mFileName = value;
//
return result;
}
//
string FileName()
{
return mFileName;
}
//
// Tools ...
//
// Clear Exists Collected Data ...
void Clear()
{
//
ResetLastError();
//
string dataStorePath = GetStorePath();
//
// Check Data Store Exists or not ...
bool isExists = FileIsExist(dataStorePath);
if (!isExists)
{
return;
}
//
FileDelete(dataStorePath);
}
//
// Collect All Stored Items ...
int Collect(
T &items[] // Hold Result
)
{
//
int result = 0;
//
Clean(items);
//
// Reading Store Whole Content ...
//
string storePath = GetStorePath();
int mFileHandler = FileOpen(
storePath,
FILE_READ | FILE_TXT);
result = mFileHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
// Parse Store Content and Read Data ...
while (!FileIsEnding(mFileHandler))
{
//
// Each Line Represent One Model ...
string content = FileReadString(mFileHandler);
//
T iItem;
bool isValid = iItem.ParseModel(content);
if (isValid)
{
//
AddRef(
iItem,
items
//
);
}
}
//
// Close File ...
FileClose(mFileHandler);
//
result = ArraySize(items);
//
return result;
}
//
// Add Item ...
bool Add(
T &item // Item to Store
)
{
//
bool result = false;
//
result = item.IsModelValid();
if (!result)
{
return result;
}
//
string content = item.ToModelString();
result = IsValid(content);
if (!result)
{
return result;
}
//
string storePath = GetStorePath();
int mFileHandler = FileOpen(
storePath,
FILE_READ | FILE_WRITE | FILE_TXT);
result = mFileHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
FileSeek(mFileHandler, 0, SEEK_END);
FileWrite(mFileHandler, content);
FileFlush(mFileHandler);
FileClose(mFileHandler);
//
return result;
}
//
// Add Item ...
bool Add(
string content // Content
)
{
//
bool result = false;
//
result = IsValid(content);
if (!result)
{
return result;
}
//
string storePath = GetStorePath();
int mFileHandler = FileOpen(
storePath,
FILE_READ | FILE_WRITE | FILE_TXT);
result = mFileHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
FileSeek(mFileHandler, 0, SEEK_END);
FileWrite(mFileHandler, content);
FileFlush(mFileHandler);
FileClose(mFileHandler);
//
return result;
}
//
// Add Items ...
int Add(
T &items[] // Items to Add ...
)
{
//
int result = 0;
//
int itemsCount = ArraySize(items);
if (itemsCount <= 0)
{
return result;
}
//
for (int i = 0; i < itemsCount; i++)
{
//
T iItem = items[i];
//
if (!iItem.IsModelValid())
{
continue;
}
//
bool isAdded = Add(iItem);
if (isAdded)
{
result++;
}
}
//
return result;
}
//
// Remove Item ...
bool Remove(
T &item // Item to Remove
)
{
//
bool result = false;
//
result = item.IsModelValid();
if (!result)
{
return result;
}
//
T items[];
int itemsCount = Collect(items);
if (itemsCount <= 0)
{
return result;
}
//
int itemIndex = item.FindIndex(items);
result = ArrayRemove(
items,
itemIndex,
1);
if (!result)
{
return result;
}
//
Clear();
//
int itemsAdded = Add(items);
//
result = itemsAdded == ArraySize(items);
//
return result;
}
//
// Protected ...
protected:
//
// Tools ...
//
// Retrieve Type of Class as String ...
string GetType()
{
//
string mType = (string) typename(T);
//
string result = mType;
//
string parts[];
int partsCount = SplitContent(
parts,
result,
" "
//
);
if (partsCount <= 0)
{
//
result = mType;
return result;
}
//
bool hasLastPart = GetLastItem(
result,
parts
//
);
if (!hasLastPart)
{
//
result = mType;
return result;
}
//
return result;
}
//
// Pricate ...
private:
//
// Props ...
//
string mPath; // Path
string mFileName; // Data Store File Name
//
// Tools ...
//
// Generate Full File Path ...
string GetFilePath(string fileName)
{
//
string result = "";
//
result =
//
Path() + "\\" + fileName
//
;
//
return result;
}
//
// Retrieve Data Store File Address ...
string GetStorePath()
{
//
string result = NULL;
//
result = GetFilePath(mFileName);
//
return result;
}
};
//
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,148 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCBaseHelper
// Description: provides all Base Indicator
// Helper requirements ...
//
//
// 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
//
// Includes ...
#include "../Classes/x-saherelm.base.class.mq5"
//
// Definitions ...
//
// a Class for Handle base requirements ...
// for indicators ...
class XSCBaseHelper : public XSCBase
{
//
// Public ...
public:
//
// Constructor ...
void XSCBaseHelper(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period // Trading Time Frame
)
{
//
mSymbol = symbol;
mPeriod = period;
}
//
// Deconstructor ...
void ~XSCBaseHelper()
{
//
IndicatorRelease(mHandler);
}
//
// Setter(s) / Getter(s) ...
//
// Symbol ...
string GetSymbol()
{
return mSymbol;
}
//
// Period ...
ENUM_TIMEFRAMES GetPeriod()
{
return mPeriod;
}
//
// Retrieve Bars ...
int CountBars()
{
//
int result =
Bars(
mSymbol,
mPeriod
//
);
//
return result;
}
//
// Retrieve Indicator Calculated Bars ...
int CountCalculatedBars()
{
return BarsCalculated(mHandler);
}
//
// Generate Tag ...
virtual string GetTag()
{
//
string result = NULL;
//
result =
//
GetToken() +
"[" +
GetSymbol() + "|" +
ToString(GetPeriod()) +
"]"
//
;
//
return result;
}
//
// Functions ...
//
// Protected ...
protected:
//
// Props ...
//
// Symbol ...
string mSymbol;
//
// Period ...
ENUM_TIMEFRAMES mPeriod;
//
// Indicator Handler ...
int mHandler;
//
// Private ...
private:
//
};
//
// Tools ....
@@ -0,0 +1,373 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCHttp
// Description: provides all HTTP requirements ...
//
//
// 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
//
// Definitions ...
//
enum X_HTTP_METHOD
{
X_HTTP_GET,
X_HTTP_POST
};
//
// Imports ...
//
// Includes ...
#include "../Classes/x-saherelm.base.class.mq5"
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// a Class for Manage Account ...
class XSCHttp : public XSCBase
{
//
// Public ...
public:
//
// Constructor ...
void XSCHttp()
{
XSCHttp("", 10000);
}
void XSCHttp(
string path, // Base Folder to Store Data
int timeout // base timeout for Requests
)
{
//
Path(path);
Timeout(timeout);
}
//
// Deconstructor ...
void ~XSCHttp()
{
}
//
// Properties Getter(s) / Setter(s) ...
//
// Path ...
void Path(string value)
{
//
mPath = value;
//
if (!IsValid(mPath))
{
mPath = GetTag();
}
}
string Path()
{
return mPath;
}
//
// Timeout ...
void Timeout(int value)
{
mTimeout = value;
}
//
int Timeout()
{
return mTimeout;
}
//
// Error ...
int Error()
{
return mError;
}
//
// Response ...
string Response()
{
return mResponse;
}
//
// Overrides ...
string GetTag() override
{
return GetSpecificToken(this);
}
//
// Tools ...
//
// Send Global Request ...
int SendRequest(
X_HTTP_METHOD method, // Httm Request Method
const string url, // Server Address
const string headers, // Headers providing
const char &payload[], // the Data which needs to Send
char &response[], // Response of request
string responseHeaders, // Response Headers
int timeout = 500 // Timeout for response default is 500
)
{
//
int result = -1;
//
string strMethod = ToString(method);
if (StringLen(strMethod) == 0)
{
return result;
}
//
// Reset State ...
ResetState();
//
result = WebRequest(
strMethod,
url,
headers,
timeout,
payload,
response,
responseHeaders);
//
if (result < 0)
{
mError = GetLastError();
}
else
{
mResponse = CharArrayToString(response);
}
//
return result;
}
//
// Get Request ...
int GetRequest(
const string url, // Server Address
const string headers, // Headers providing
const char &payload[], // the Data which needs to Send
char &response[], // Response of request
string responseHeaders, // Response Headers
int timeout = 500 // Timeout for response default is 500
)
{
//
int result = SendRequest(
X_HTTP_GET,
url,
headers,
payload,
response,
responseHeaders,
timeout);
//
return result;
}
//
// Post Request ...
int PostRequest(
const string url, // Server Address
const string headers, // Headers providing
const char &payload[], // the Data which needs to Send
char &response[], // Response of request
string responseHeaders, // Response Headers
int timeout = 500 // Timeout for response default is 500
)
{
//
int result = SendRequest(
X_HTTP_POST,
url,
headers,
payload,
response,
responseHeaders,
timeout);
//
return result;
}
//
// Handle Download Specific URL Content to Specific Path and File Name ...
bool Download(
string url, // the URL address which going to download
string fileName // Specify Destination file name to Store Response
)
{
//
bool result = false;
//
string filePath = GetFilePath(fileName);
string cookie = NULL;
string referer = NULL;
int timeout = Timeout();
//
char payload[];
string headers;
char response[];
string responseHeaders;
//
// Send Request ...
int requestResult = GetRequest(
url,
headers,
payload,
response,
responseHeaders,
timeout);
//
// Define File Handler ...
int mFileHandler = FileOpen(
filePath,
FILE_WRITE | FILE_BIN);
if (mFileHandler == INVALID_HANDLE)
{
//
mError = GetLastError();
return result;
}
//
// Write Response to File ...
uint writed = FileWriteArray(
mFileHandler,
response,
0,
ArraySize(response));
FileFlush(mFileHandler);
FileClose(mFileHandler);
//
result = writed > 0;
//
return result;
}
//
// END Provided Functions ...
//
//
// Protected ...
protected:
//
// Destintion Folder Path ...
string mPath;
//
// WEB Request Timeout Value ...
int mTimeout;
//
// WEB Request's Response ...
string mResponse;
//
// Error Value ...
int mError;
//
// Private ...
private:
//
// Reset Errors State ...
void ResetState()
{
//
// Reset Errors ...
mError = -1;
mResponse = "";
ResetLastError();
}
//
// Generate Full File Path ...
string GetFilePath(string fileName)
{
//
string result = "";
//
result =
//
Path() + "\\" + fileName
//
;
//
return result;
}
};
//
// Tools ...
//
// Convert enum to String ...
string ToString(X_HTTP_METHOD method)
{
//
string result = "";
//
switch (method)
{
//
case X_HTTP_GET:
result = "GET";
break;
//
case X_HTTP_POST:
result = "POST";
break;
}
//
return result;
}
//
@@ -0,0 +1,652 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCBaseInd
// Description: provides all Indicator requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.base.class.mq5"
#include "../Libraries/x-saherelm.draw.lib.mq5"
#include "../Classes/x-saherelm.xalert.class.mq5"
//
// Definitions ...
//
struct XBuffer
{
//
string title; // Buffer Title
string symbol; // Buffer Symbol
double values[]; // Buffer Values
ENUM_TIMEFRAMES period; // Buffer Period
datetime times[]; // Buffer Values Time
//
// Constructor ...
XBuffer()
{
Clean();
}
//
// Tools ...
bool Init(
string mTitle, // Title
string mSymbol, // Symbol
ENUM_TIMEFRAMES mPeriod // TimeFrame
)
{
//
bool result = false;
//
result = IsValid(mTitle) &&
IsValid(mSymbol) &&
IsValid(mPeriod);
if (!result)
{
return result;
}
//
Clean();
//
this.symbol = mSymbol;
this.period = mPeriod;
//
result = StringToLower(mTitle);
if (!result)
{
return result;
}
//
this.title = mTitle;
//
result = IsValid();
//
return result;
}
//
// Cleanup ...
void Clean()
{
//
Clean(values);
Clean(times);
//
title = NULL;
symbol = NULL;
period = NULL;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
IsValid(title) &&
IsValid(period) &&
IsValid(symbol)
//
;
//
return result;
}
//
// Check Owwn ...
bool IsOwn(
string mTitle // Checking Title
)
{
//
bool result = false;
//
result = IsValid(mTitle);
if (!result)
{
return result;
}
//
result = StringToLower(mTitle);
if (!result)
{
return result;
}
//
result = this.title == mTitle;
//
return result;
}
//
// Count Size ...
int Count()
{
return ArraySize(values);
}
//
// Add Value to Buffer ...
int Add(
int index,
double value //
)
{
//
int result = -1;
//
if (!IsValid())
{
return result;
}
//
if (index > 0)
{
Add(value, values);
}
else
{
values[Count() - 1] = value;
}
//
result = Count();
//
return result;
}
//
// Get Specified Index Value ...
double Get(
int index // Specified Index
)
{
//
double result = EMPTY_VALUE;
//
NormalizeIndex(
index,
values //
);
//
result = values[index];
//
return result;
}
//
// Remove Specified Index Value ...
bool Remove(int index)
{
//
bool result = false;
//
int count = Count();
result = IsValidSize(count);
if (!result)
{
return result;
}
//
result = index > 0 && index < count - 1;
if (!result)
{
return result;
}
//
result = ArrayRemove(
values,
index,
1 //
);
//
return result;
}
};
//
// Base Indicator Class ...
class XSCBaseInd : public XSCBaseAlert
{
//
// Public ...
public:
//
// Props ...
//
// Indicators Buffers ...
XBuffer mBuffers[];
//
// Constructor(s) ...
void XSCBaseInd(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period // Trading TimeFrame
) : XSCBaseAlert()
{
//
mSymbol = symbol;
mPeriod = period;
//
mCalculatedBars = 0;
}
//
// Deconstructor ...
void ~XSCBaseInd() {}
//
// Property Getter(s) / Setter(s) ...
//
string GetSymbol()
{
return mSymbol;
}
//
ENUM_TIMEFRAMES GetPeriod()
{
return mPeriod;
}
//
// Overrides ...
//
virtual string GetTag();
//
virtual string GetToken();
//
virtual void DeInit(int reason); // Indicator DeInitialization
//
// Validate Inputs ...
virtual bool IsValidInputs()
{
return false;
}
//
// Calculate ...
virtual void Calculate() {}
//
// Tools ...
//
datetime GetBarTime(
datetime time = NULL //
)
{
//
NormalizeTime(time);
//
datetime result = GetPeriodStartTime(
mSymbol,
mPeriod,
time //
);
//
return result;
}
//
int GetBarIndex(
datetime time = NULL //
)
{
//
datetime iBarTime = GetBarTime(time);
//
int result = iBarShift(
mSymbol,
mPeriod,
iBarTime //
);
//
return result;
}
//
// Retrieve Calculate Bars ...
int GetCalculatedBars()
{
return mCalculatedBars;
}
//
// Count available Bars ...
int CountBars()
{
//
return iBars(
mSymbol,
mPeriod //
);
}
//
// Validate Indicator States ...
bool IsValid()
{
//
bool result = false;
//
result = IsValidInputs();
if (!result)
{
return result;
}
//
result =
//
IsSpecifiedValid(mSymbol) &&
IsSpecifiedValid(mPeriod)
//
;
//
return result;
}
//
// Calculate Limit ...
// this means Required Bars for Calculation ...
int CountLimit()
{
//
int result = 0;
//
int totalBars = CountBars();
int calculatedBars = GetCalculatedBars();
result = MathAbs(totalBars - calculatedBars);
//
return result;
}
//
// Buffer Registrations ...
//
// Count Registered Buffers ...
int CountBuffers()
{
return ArraySize(mBuffers);
}
//
// Retrieve Specified Buffer Index ...
int GetBufferIndex(
string title // Specified Buffer Title
)
{
//
int result = -1;
//
if (!IsSpecifiedValid(title))
{
return result;
}
//
int buffersCount = CountBuffers();
if (!IsValidSize(buffersCount))
{
return result;
}
//
for (int i = 0; i < buffersCount; i++)
{
//
XBuffer iBuffer = mBuffers[i];
//
bool isOwn = iBuffer.IsOwn(title);
if (isOwn)
{
//
result = i;
break;
}
}
//
return result;
}
//
// Check Contains Specific Buffer or not ...
bool HasBuffer(
string title // Specified Buffer Title
)
{
//
bool result = false;
//
int bufferIndex = GetBufferIndex(title);
result = bufferIndex >= 0;
//
return result;
}
//
// Retrieve Specified Buffer ...
bool GetBuffer(
string title, // Specified Buffer Title
XBuffer &buffer // Hold Result
)
{
//
bool result = false;
//
int idx = GetBufferIndex(title);
result = idx >= 0;
if (!result)
{
return result;
}
//
buffer = mBuffers[idx];
//
result = buffer.IsValid();
//
return result;
}
//
// Register Specified Buffer ...
bool SetBuffer(
XBuffer &buffer // Specified Buffer for Registration
)
{
//
bool result = false;
//
// Validate buffer ...
result = buffer.IsValid();
if (!result)
{
return result;
}
//
// Check Buffer Doesn't Exists before ...
int idx = GetBufferIndex(buffer.title);
result = idx == -1;
if (!result)
{
return result;
}
//
AddRef(
buffer,
mBuffers //
);
//
return result;
}
//
double GetBufferValue(
string mTitle, // Required Buffer Title
int index // Bar Index
)
{
//
double result = EMPTY_VALUE;
//
// Validate State ...
if (!IsValid())
{
return result;
}
//
int bufferIDX = GetBufferIndex(mTitle);
if (bufferIDX < 0)
{
return result;
}
//
Calculate();
//
result = mBuffers[bufferIDX].Get(index);
//
return result;
}
//
int CopyBufferValue(
string mTitle,
double &buffer[],
int start,
int count //
)
{
//
int result = 0;
//
if (!IsValid())
{
return result;
}
//
int sourceIDX = GetBufferIndex(mTitle);
if (sourceIDX < 0)
{
return result;
}
//
Calculate();
//
result = ArrayCopy(
buffer,
mBuffers[sourceIDX].values,
start,
start,
count //
);
//
return result;
}
//
// Protected ...
protected:
//
// Props ...
//
string mSymbol; // Trading Symbol
ENUM_TIMEFRAMES mPeriod; // Trading TimeFrame
//
int mCalculatedBars; // Calculated Bars
//
// Tools ...
//
// Private ...
private:
//
// Props ...
};
@@ -0,0 +1,441 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCMD5
// Description: Provides MD5 Hashing Requirements ...
//
//
// 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
//
// START Definitions ...
//
//
static uchar _md5_PADDING[64] =
{
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
//
#define _md5_F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define _md5_G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define _md5_H(x, y, z) ((x) ^ (y) ^ (z))
#define _md5_I(x, y, z) ((y) ^ ((x) | (~z)))
#define _md5_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
//
#define _md5_FF(a, b, c, d, x, s, ac) \
{ \
(a) += _md5_F((b), (c), (d)) + (x) + (uint)(ac); \
(a) = _md5_ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
//
#define _md5_GG(a, b, c, d, x, s, ac) \
{ \
(a) += _md5_G((b), (c), (d)) + (x) + (uint)(ac); \
(a) = _md5_ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
//
#define _md5_HH(a, b, c, d, x, s, ac) \
{ \
(a) += _md5_H((b), (c), (d)) + (x) + (uint)(ac); \
(a) = _md5_ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
//
#define _md5_II(a, b, c, d, x, s, ac) \
{ \
(a) += _md5_I((b), (c), (d)) + (x) + (uint)(ac); \
(a) = _md5_ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
//
#define _md5_INIT_STATE_0 0x67452301
#define _md5_INIT_STATE_1 0xefcdab89
#define _md5_INIT_STATE_2 0x98badcfe
#define _md5_INIT_STATE_3 0x10325476
//
#define _md5_S11 7
#define _md5_S12 12
#define _md5_S13 17
#define _md5_S14 22
//
#define _md5_S21 5
#define _md5_S22 9
#define _md5_S23 14
#define _md5_S24 20
//
#define _md5_S31 4
#define _md5_S32 11
#define _md5_S33 16
#define _md5_S34 23
//
#define _md5_S41 6
#define _md5_S42 10
#define _md5_S43 15
#define _md5_S44 21
//
// END Definitions ...
//
//
// XCMD5 a library for Hashing ...
class XSCMD5
{
//
// Public Provides ...
public:
//
// Protected Provides ...
//
// Constructor ...
XSCMD5(void) {}
//
// Deconstructor ...
~XSCMD5(void) {}
//
// Hash Specified Char Array ...
string Hash(
uchar &mSource[], // Specify Char Array to Hash
int mLength = 0 // Specify Length of Char Array which required to hash
)
{
//
string result = "";
//
int sourceCount = ArraySize(mSource);
//
// Validate Args ...
if (
sourceCount <= 0 ||
(sourceCount > 0 && mLength > sourceCount))
{
return result;
}
//
// Normalize Args ...
if (mLength == 0)
{
mLength = sourceCount;
}
//
// Init MD5 ...
MD5Init();
//
// Update Buffer ...
MD5Update(mSource, mLength);
//
// Calculate Result ...
result = MD5Final();
//
return result;
}
//
// Hash Specified String ...
string Hash(
string mSource // Specified String
)
{
//
string result = "";
//
// Converts String to Char Array ...
uchar bytes[];
StringToCharArray(
mSource,
bytes,
0,
StringLen(mSource));
//
result = Hash(
bytes,
ArraySize(bytes));
//
return result;
}
protected:
//
// Private Provides ...
private:
//
uint m_lMD5[4];
uint m_nCount[2];
uchar m_lpszBuffer[64];
//
// Convert Byte to DWord ...
void ByteToDWord(int &out[], uint &in[], uint len)
{
//
uint i = 0;
uint j = 0;
//
for (; j < len; i++, j += 4)
{
out[i] = (int)in[j] | (int)in[j + 1] << 8 | (int)in[j + 2] << 16 | (int)in[j + 3] << 24;
}
}
//
// Convert DWord to Byte ...
void DWordToByte(uchar &out[], int &in[], uint len)
{
//
uint i = 0;
uint j = 0;
//
for (; j < len; i++, j += 4)
{
//
out[j] = (uchar)(in[i] & 0xff);
out[j + 1] = (uchar)((in[i] >> 8) & 0xff);
out[j + 2] = (uchar)((in[i] >> 16) & 0xff);
out[j + 3] = (uchar)((in[i] >> 24) & 0xff);
}
}
//
// Init MD5 Array ...
void MD5Init()
{
//
ArrayInitialize(m_lpszBuffer, 64);
//
m_nCount[0] = m_nCount[1] = 0;
m_lMD5[0] = _md5_INIT_STATE_0;
m_lMD5[1] = _md5_INIT_STATE_1;
m_lMD5[2] = _md5_INIT_STATE_2;
m_lMD5[3] = _md5_INIT_STATE_3;
}
//
// Update MD5 ...
void MD5Update(uchar &inBuf[], uint inLen)
{
//
int i, ii;
int mdi;
//
uint in[16];
int i0 = 0;
//
mdi = (int)((m_nCount[0] >> 3) & 0x3F);
//
if ((m_nCount[0] + ((uint)inLen << 3)) < m_nCount[0])
{
m_nCount[1]++;
}
//
m_nCount[0] += ((uint)inLen << 3);
m_nCount[1] += ((uint)inLen >> 29);
//
while ((inLen--) > 0)
{
//
m_lpszBuffer[mdi++] = inBuf[i0++];
if (mdi == 0x40)
{
//
for (i = 0, ii = 0; i < 16; i++, ii += 4)
{
in[i] = (((uint)m_lpszBuffer[ii + 3]) << 24) | (((uint)m_lpszBuffer[ii + 2]) << 16) | (((uint)m_lpszBuffer[ii + 1]) << 8) | ((uint)m_lpszBuffer[ii]);
}
//
Transform(m_lMD5, in);
//
mdi = 0;
}
}
}
//
// Finalize an MD5 Expression ...
string MD5Final()
{
//
uchar bits[8];
int nIndex;
uint nPadLen;
const int nMD5Size = 16;
uchar lpszMD5[16];
string temp;
string out = "";
int i;
//
DWordToByte(bits, m_nCount, 8);
nIndex = (int)((m_nCount[0] >> 3) & 0x3f);
nPadLen = (nIndex < 56) ? (56 - nIndex) : (120 - nIndex);
MD5Update(_md5_PADDING, nPadLen);
MD5Update(bits, 8);
DWordToByte(lpszMD5, m_lMD5, nMD5Size);
//
for (i = 0; i < nMD5Size; i++)
{
//
if (lpszMD5[i] == 0)
{
temp = "00";
}
else if (lpszMD5[i] <= 15)
{
temp = StringFormat("0%x", lpszMD5[i]);
}
else
{
temp = StringFormat("%x", lpszMD5[i]);
}
//
out += temp;
}
//
lpszMD5[0] = '\0';
//
return (out);
}
//
// Transform Buffers ...
void Transform(uint &buf[], uint &in[])
{
//
uint a = buf[0], b = buf[1], c = buf[2], d = buf[3];
//
_md5_FF(a, b, c, d, in[0], _md5_S11, 0xD76AA478);
_md5_FF(d, a, b, c, in[1], _md5_S12, 0xE8C7B756);
_md5_FF(c, d, a, b, in[2], _md5_S13, 0x242070DB);
_md5_FF(b, c, d, a, in[3], _md5_S14, 0xC1BDCEEE);
_md5_FF(a, b, c, d, in[4], _md5_S11, 0xF57C0FAF);
_md5_FF(d, a, b, c, in[5], _md5_S12, 0x4787C62A);
_md5_FF(c, d, a, b, in[6], _md5_S13, 0xA8304613);
_md5_FF(b, c, d, a, in[7], _md5_S14, 0xFD469501);
_md5_FF(a, b, c, d, in[8], _md5_S11, 0x698098D8);
_md5_FF(d, a, b, c, in[9], _md5_S12, 0x8B44F7AF);
_md5_FF(c, d, a, b, in[10], _md5_S13, 0xFFFF5BB1);
_md5_FF(b, c, d, a, in[11], _md5_S14, 0x895CD7BE);
_md5_FF(a, b, c, d, in[12], _md5_S11, 0x6B901122);
_md5_FF(d, a, b, c, in[13], _md5_S12, 0xFD987193);
_md5_FF(c, d, a, b, in[14], _md5_S13, 0xA679438E);
_md5_FF(b, c, d, a, in[15], _md5_S14, 0x49B40821);
//
_md5_GG(a, b, c, d, in[1], _md5_S21, 0xF61E2562);
_md5_GG(d, a, b, c, in[6], _md5_S22, 0xC040B340);
_md5_GG(c, d, a, b, in[11], _md5_S23, 0x265E5A51);
_md5_GG(b, c, d, a, in[0], _md5_S24, 0xE9B6C7AA);
_md5_GG(a, b, c, d, in[5], _md5_S21, 0xD62F105D);
_md5_GG(d, a, b, c, in[10], _md5_S22, 0x02441453);
_md5_GG(c, d, a, b, in[15], _md5_S23, 0xD8A1E681);
_md5_GG(b, c, d, a, in[4], _md5_S24, 0xE7D3FBC8);
_md5_GG(a, b, c, d, in[9], _md5_S21, 0x21E1CDE6);
_md5_GG(d, a, b, c, in[14], _md5_S22, 0xC33707D6);
_md5_GG(c, d, a, b, in[3], _md5_S23, 0xF4D50D87);
_md5_GG(b, c, d, a, in[8], _md5_S24, 0x455A14ED);
_md5_GG(a, b, c, d, in[13], _md5_S21, 0xA9E3E905);
_md5_GG(d, a, b, c, in[2], _md5_S22, 0xFCEFA3F8);
_md5_GG(c, d, a, b, in[7], _md5_S23, 0x676F02D9);
_md5_GG(b, c, d, a, in[12], _md5_S24, 0x8D2A4C8A);
//
_md5_HH(a, b, c, d, in[5], _md5_S31, 0xFFFA3942);
_md5_HH(d, a, b, c, in[8], _md5_S32, 0x8771F681);
_md5_HH(c, d, a, b, in[11], _md5_S33, 0x6D9D6122);
_md5_HH(b, c, d, a, in[14], _md5_S34, 0xFDE5380C);
_md5_HH(a, b, c, d, in[1], _md5_S31, 0xA4BEEA44);
_md5_HH(d, a, b, c, in[4], _md5_S32, 0x4BDECFA9);
_md5_HH(c, d, a, b, in[7], _md5_S33, 0xF6BB4B60);
_md5_HH(b, c, d, a, in[10], _md5_S34, 0xBEBFBC70);
_md5_HH(a, b, c, d, in[13], _md5_S31, 0x289B7EC6);
_md5_HH(d, a, b, c, in[0], _md5_S32, 0xEAA127FA);
_md5_HH(c, d, a, b, in[3], _md5_S33, 0xD4EF3085);
_md5_HH(b, c, d, a, in[6], _md5_S34, 0x04881D05);
_md5_HH(a, b, c, d, in[9], _md5_S31, 0xD9D4D039);
_md5_HH(d, a, b, c, in[12], _md5_S32, 0xE6DB99E5);
_md5_HH(c, d, a, b, in[15], _md5_S33, 0x1FA27CF8);
_md5_HH(b, c, d, a, in[2], _md5_S34, 0xC4AC5665);
//
_md5_II(a, b, c, d, in[0], _md5_S41, 0xF4292244);
_md5_II(d, a, b, c, in[7], _md5_S42, 0x432AFF97);
_md5_II(c, d, a, b, in[14], _md5_S43, 0xAB9423A7);
_md5_II(b, c, d, a, in[5], _md5_S44, 0xFC93A039);
_md5_II(a, b, c, d, in[12], _md5_S41, 0x655B59C3);
_md5_II(d, a, b, c, in[3], _md5_S42, 0x8F0CCC92);
_md5_II(c, d, a, b, in[10], _md5_S43, 0xFFEFF47D);
_md5_II(b, c, d, a, in[1], _md5_S44, 0x85845DD1);
_md5_II(a, b, c, d, in[8], _md5_S41, 0x6FA87E4F);
_md5_II(d, a, b, c, in[15], _md5_S42, 0xFE2CE6E0);
_md5_II(c, d, a, b, in[6], _md5_S43, 0xA3014314);
_md5_II(b, c, d, a, in[13], _md5_S44, 0x4E0811A1);
_md5_II(a, b, c, d, in[4], _md5_S41, 0xF7537E82);
_md5_II(d, a, b, c, in[11], _md5_S42, 0xBD3AF235);
_md5_II(c, d, a, b, in[2], _md5_S43, 0x2AD7D2BB);
_md5_II(b, c, d, a, in[9], _md5_S44, 0xEB86D391);
//
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
};
@@ -0,0 +1,170 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: XSCBaseProvider
// Description: provides all Base Provider
// requirements ...
//
//
// 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
//
// Includes ...
#include "../Classes/x-saherelm.xalert.class.mq5"
#include "../Libraries/x-saherelm.xtrade.lib.mq5"
//
// Class ...
//
// Base Provider Class ...
class XSCBaseProvider : public XSCBaseAlert
{
//
// Public ...
public:
//
// Props ...
//
// Constructor ...
XSCBaseProvider(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period // Trading Period
)
{
//
// Initialize Cycle ...
mCycle.Init(
symbol,
period,
X_MARKET_CYCLE_SHORT,
X_PERIOD_MANUALLY,
period,
"HOST Period"
//
);
}
//
// Deconstructor ...
~XSCBaseProvider()
{
DeInit();
}
//
// Properties Gettr(s) / Setter(s) ...
//
// DeInit all Requirements ...
virtual void DeInit();
//
// Functions ...
//
string GetSymbol()
{
return mCycle.symbol;
}
//
ENUM_TIMEFRAMES GetPeriod()
{
return mCycle.hostPeriod;
}
//
// Count Bars ...
int CountBars()
{
//
return mCycle
.CountBars();
}
//
// Check New Bar ...
bool IsNewBar()
{
//
return mCycle
.IsNewBar();
}
//
// Can Ignore Process ...
bool CanIgnoreProcess()
{
//
bool result = false;
//
result =
//
IsRunningOnTestMode()
? !IsNewBar()
: !IsNewBar() && mWaitsUntilNewBar
//
;
//
if (!result)
{
mWaitsUntilNewBar = false;
}
//
return result;
}
//
// Toggle Waititng Until New Candle ...
void ToggleWaitingUntilNewBar()
{
mWaitsUntilNewBar = !mWaitsUntilNewBar;
}
//
void SetWaitsUntilNewBar(bool value)
{
mWaitsUntilNewBar = value;
}
//
// Protected ...
protected:
//
// Props ...
//
XMarketCycle mCycle;
//
bool mWaitsUntilNewBar;
//
// Private ...
private:
//
// Props ...
//
// Tools ...
};
//
// Tools ...
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,317 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXAMAHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XAMA_BUFFERS
{
XAMA_MAIN_LINE = 0
};
//
// Input Models ...
struct XAMAInputs
{
//
// Props ...
//
// Market ...
int length; // Period
int fastEMA; // Fast EMA Period
int slowEMA; // Slow EMA Period
int maShift; // Shift
ENUM_APPLIED_PRICE appliedTo; // Applied To
//
// Presentation ...
bool showLine; // Show Line
//
// Constructor(s) ...
XAMAInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
length = 0;
fastEMA = 0;
slowEMA = 0;
maShift = 0;
showLine = false;
appliedTo = PRICE_CLOSE;
}
//
// Default ...
void Default()
{
//
length = 18;
fastEMA = 2;
slowEMA = 30;
maShift = 0;
showLine = true;
appliedTo = PRICE_CLOSE;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
length > 0 &&
fastEMA > 0 &&
slowEMA > 0 &&
slowEMA > fastEMA
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(length, length);
//
return result;
}
};
//
// Class ...
class XSCXAMAHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXAMAHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXAMAHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XAMAInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(mainBuffer, true);
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xama",
//
// Inputs ...
//
// Market ...
"",
mInputs.length, // Period
mInputs.fastEMA, // Fast EMA Period
mInputs.slowEMA, // Slow EMA Period
mInputs.maShift, // Shift
mInputs.appliedTo, // Applied To
//
// Presentation ...
"",
mInputs.showLine // Show Line
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XAMAInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XAMAInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Buffers ...
//
double GetMain(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(mainBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return mainBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyMain(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
mainBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XAMAInputs mInputs; // Inputs ...
//
// Buffers ...
double mainBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Main Buffer ...
CopyBuffer(
mHandler,
XAMA_MAIN_LINE,
0,
totalBars,
mainBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,245 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXCCHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
// Input Models ...
struct XCCInputs
{
//
// Props ...
//
// Chart Style ...
ENUM_CHART_MODE mode; // Mode
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
//
// Presentation ...
bool showCandles; // Show Candles
//
// Constructor(s) ...
XCCInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
mode = CHART_CANDLES;
//
upColor = CLR_NONE;
downColor = CLR_NONE;
lineColor = CLR_NONE;
bearishColor = CLR_NONE;
bullishColor = CLR_NONE;
volumesColor = CLR_NONE;
//
showCandles = false;
}
//
// Default ...
void Default()
{
//
mode = CHART_CANDLES;
//
upColor = clrLime;
downColor = clrRed;
lineColor = clrLime;
bearishColor = clrRed;
bullishColor = clrLime;
volumesColor = clrGreen;
//
showCandles = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
true
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(0, 0);
//
return result;
}
};
//
// Class ...
class XSCXCCHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXCCHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXCCHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XCCInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xcc",
//
// Inputs ...
//
// Chart Style ...
"",
mInputs.mode, // Mode
mInputs.upColor, // Up Color
mInputs.downColor, // Down Color
mInputs.lineColor, // Line mode and Doji candlestick Color
mInputs.bearishColor, // Bullish Color
mInputs.bullishColor, // Bearish Color
mInputs.volumesColor, // Volumes Color
//
// Presentation ...
"",
mInputs.showCandles // Show Candles
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XCCInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XCCInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XCCInputs mInputs; // Inputs ...
};
//
// Tools ...
@@ -0,0 +1,514 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXCHEHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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
//
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XCHE_BUFFERS
{
X_CHE_LONG_EXIT_1_LINE = 0,
X_CHE_SHORT_EXIT_1_LINE = 1,
X_CHE_LONG_EXIT_2_LINE = 2,
X_CHE_SHORT_EXIT_2_LINE = 3,
};
//
// Input Models ...
struct XCHEInputs
{
//
// Props ...
//
// Market ...
int length; // Length
int loopback; // Loopback
double multiplier1; // 1st Multiplier
double multiplier2; // 2nd Multiplier
//
// Calculation ...
ENUM_APPLIED_PRICE upAppliedTo; // Up Zone Applied To
ENUM_APPLIED_PRICE downAppliedTo; // Down Zone Applied To
//
// Presentation ...
bool showLongExit1Line; // Show 1st Long Exit
bool showShortExit1Line; // Show 1st Short Exit
bool showLongExit2Line; // Show 2st Long Exit
bool showShortExit2Line; // Show 2st Short Exit
//
// Constructor(s) ...
XCHEInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
length = 0;
loopback = 0;
multiplier1 = 0;
multiplier2 = 0;
//
upAppliedTo = PRICE_HIGH;
downAppliedTo = PRICE_LOW;
//
showLongExit1Line = false;
showShortExit1Line = false;
showLongExit2Line = false;
showShortExit2Line = false;
}
//
// Default ...
void Default()
{
//
length = 35;
loopback = 26;
multiplier1 = 3.0;
multiplier2 = 3.5;
//
upAppliedTo = PRICE_HIGH;
downAppliedTo = PRICE_LOW;
//
showLongExit1Line = true;
showShortExit1Line = true;
showLongExit2Line = true;
showShortExit2Line = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
length > 0 &&
loopback < length &&
multiplier1 > 0 &&
multiplier2 > multiplier1
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(length, loopback);
//
return result;
}
};
//
// Class ...
class XSCXCHEHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXCHEHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXCHEHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XCHEInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(longExit1Buffer, true);
ArraySetAsSeries(longExit2Buffer, true);
ArraySetAsSeries(shortExit1Buffer, true);
ArraySetAsSeries(shortExit2Buffer, true);
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xche",
//
// Inputs ...
//
// Market ...
"",
mInputs.length,
mInputs.loopback,
mInputs.multiplier1,
mInputs.multiplier2,
//
// Calculations ...
"",
mInputs.upAppliedTo,
mInputs.downAppliedTo,
//
// Presentation ...
"",
mInputs.showLongExit1Line, // Show 1st Long Exit,
mInputs.showShortExit1Line, // Show 1st Short Exit,
mInputs.showLongExit2Line, // Show 2st Long Exit,
mInputs.showShortExit2Line // Show 2st Short Exit
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XCHEInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XCHEInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs);
}
//
// Buffers ...
//
double GetLongExit1(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return longExit1Buffer[barIndex];
}
//
// Copy Required Long Exits 1 ...
int CopyLongExit1(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
longExit1Buffer,
buffer,
forceClean
//
);
}
//
double GetLongExit2(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return longExit2Buffer[barIndex];
}
//
// Copy Required Long Exits 2 ...
int CopyLongExit2(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
longExit2Buffer,
buffer,
forceClean
//
);
}
//
double GetShortExit1(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return shortExit1Buffer[barIndex];
}
//
// Copy Required Short Exits 1 ...
int CopyShortExit1(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
shortExit1Buffer,
buffer,
forceClean
//
);
}
//
double GetShortExit2(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return shortExit2Buffer[barIndex];
}
//
// Copy Required Short Exits 2 ...
int CopyShortExit2(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
shortExit2Buffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XCHEInputs mInputs; // Inputs ...
//
// Buffers ...
//
double longExit1Buffer[];
double longExit2Buffer[];
double shortExit1Buffer[];
double shortExit2Buffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
int calculatedBars = CountCalculatedBars();
//
// Long Exit 1 ...
CopyBuffer(
mHandler,
X_CHE_LONG_EXIT_1_LINE,
0,
totalBars,
longExit1Buffer
//
);
//
// Long Exit 2 ...
CopyBuffer(
mHandler,
X_CHE_LONG_EXIT_2_LINE,
0,
totalBars,
longExit2Buffer
//
);
//
// Short Exit 1 ...
CopyBuffer(
mHandler,
X_CHE_SHORT_EXIT_1_LINE,
0,
totalBars,
shortExit1Buffer
//
);
//
// Short Exit 2 ...
CopyBuffer(
mHandler,
X_CHE_SHORT_EXIT_2_LINE,
0,
totalBars,
shortExit2Buffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,220 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXCTHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
// Input Models ...
struct XCTInputs
{
//
// Props ...
//
color clr; // Text Color
ENUM_BASE_CORNER corner; // Text Position
//
// Presentation ...
bool showCandleTime; // Show Candle Time
//
// Constructor(s) ...
XCTInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
clr = CLR_NONE;
corner = CORNER_RIGHT_LOWER;
//
// Presentation ...
showCandleTime = false;
}
//
// Default ...
void Default()
{
//
clr = clrYellow;
corner = CORNER_RIGHT_LOWER;
//
// Presentation ...
showCandleTime = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
true
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(0, 0);
//
return result;
}
};
//
// Class ...
class XSCXCTHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXCTHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXCTHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XCTInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xct",
//
// Inputs ...
mInputs.clr, // Text Color
mInputs.corner, // Text Position
//
// Presentation ...
"",
mInputs.showCandleTime // Show Candle Time
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XCTInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XCTInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XCTInputs mInputs; // Inputs ...
};
//
// Tools ...
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,399 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXHULLHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XHULLC_BUFFERS
{
XHULLC_UP_LINE = 0,
XHULLC_DOWN_LINE = 2,
};
//
// Input Models ...
struct XHULLInputs
{
//
// Props ...
//
// Market ...
int length; // Length
double divisor; // Divisor (Speed)
//
// Calculation ...
ENUM_APPLIED_PRICE upAppliedTo; // Up Zone Applied to
ENUM_APPLIED_PRICE downAppliedTo; // Down Zone Applied to
//
// Presentation ...
bool showUpZone; // Show Up Zone
bool showDownZone; // Show Down Zone
//
// Constructor(s) ...
XHULLInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
// Market ...
length = 0;
divisor = 0;
//
// Calculation ...
upAppliedTo = PRICE_HIGH;
downAppliedTo = PRICE_LOW;
//
// Presentation ...
showUpZone = false;
showDownZone = false;
}
//
// Default ...
void Default()
{
//
// Market ...
length = 72;
divisor = 2.0;
//
// Calculation ...
upAppliedTo = PRICE_HIGH;
downAppliedTo = PRICE_LOW;
//
// Presentation ...
showUpZone = true;
showDownZone = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
length >= 9 &&
divisor >= 0.5
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(0, length);
//
return result;
}
};
//
// Class ...
class XSCXHULLHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXHULLHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXHULLHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XHULLInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
// ArraySetAsSeries(mainBuffer, true);
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xhull",
//
// Inputs ...
//
// Market ...
"",
mInputs.length, // Length
mInputs.divisor, // Divisor (Speed)
//
// Calculation ...
"",
mInputs.upAppliedTo, // Up Zone Applied to
mInputs.downAppliedTo, // Down Zone Applied to
//
// Presentation ...
"",
mInputs.showUpZone, // Show Up Zone
mInputs.showDownZone // Show Down Zone
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XHULLInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XHULLInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Buffers ...
//
double GetUp(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(upBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return upBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyUp(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
upBuffer,
buffer,
forceClean
//
);
}
//
double GetDown(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(downBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return downBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyDown(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
downBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XHULLInputs mInputs; // Inputs ...
//
// Buffers ...
double upBuffer[];
double downBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Up Buffer ...
CopyBuffer(
mHandler,
XHULLC_UP_LINE,
0,
totalBars,
upBuffer
//
);
//
// Down Buffer ...
CopyBuffer(
mHandler,
XHULLC_DOWN_LINE,
0,
totalBars,
downBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,817 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXICHHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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
//
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
// Ichimoku Lines Calculator Mode ...
enum ENUM_XICH_CALCULATION_MODE
{
//
X_XICH_HH_LL_MODE = 1, // Highest High and Lowest Low
X_XICH_HO_LC_MODE = 2, // Highest Open and Lowest Close
};
//
enum ENUM_XICH_BUFFERS
{
X_ICH_TEANKANSEN_LINE = 0,
X_ICH_KIJUNSEN_LINE = 1,
X_ICH_CHIKOUSPAN_LINE = 4,
X_ICH_SENKOUSPANA_LINE = 5,
X_ICH_SENKOUSPANB_LINE = 6,
};
//
// Input Models ...
struct XICHInputs
{
//
// Props ...
//
// Market ...
//
// Tenkan Sen ...
int tenkanSenLength; // Length
ENUM_XICH_CALCULATION_MODE tenkanSenMode; // Calculation Mode
//
// Kijun Sen ...
int kijunSenLength; // Length
ENUM_XICH_CALCULATION_MODE kijunSenMode; // Calculation Mode
//
// Senkou Span B ...
int senkouSpanBLength; // Length
ENUM_XICH_CALCULATION_MODE senkouSpanBMode; // Calculation Mode
//
// Chikou Span ...
ENUM_APPLIED_PRICE chikuoSpanAppliedTo; // Price Type
//
// Presentation ...
bool showTenkanSen; // Show Tenkan Sen
bool showKijunSen; // Show Kijun Sen
bool showKijunSenPlus; // Show Kijun Sen +
bool showKijunSenNegative; // Show Kijun Sen -
bool showChikouSpan; // Show Chikou Span
bool showSenkouSpanA; // Show Senkou Span A
bool showSenkouSpanB; // Show Senkou Span B
bool showKumo; // Show Kumo
bool shiftKumo; // Shift Kumo to Future
//
// Constructor(s) ...
XICHInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
kijunSenLength = 0;
tenkanSenLength = 0;
senkouSpanBLength = 0;
//
kijunSenMode = X_XICH_HH_LL_MODE;
tenkanSenMode = X_XICH_HH_LL_MODE;
senkouSpanBMode = X_XICH_HH_LL_MODE;
//
chikuoSpanAppliedTo = PRICE_CLOSE;
//
showTenkanSen = false;
showKijunSen = false;
showKijunSenPlus = false;
showKijunSenNegative = false;
showChikouSpan = false;
showSenkouSpanA = false;
showSenkouSpanB = false;
showKumo = false;
shiftKumo = true;
}
//
// Default ...
void Default()
{
//
kijunSenLength = 26;
tenkanSenLength = 9;
senkouSpanBLength = 52;
//
kijunSenMode = X_XICH_HH_LL_MODE;
tenkanSenMode = X_XICH_HH_LL_MODE;
senkouSpanBMode = X_XICH_HH_LL_MODE;
//
chikuoSpanAppliedTo = PRICE_CLOSE;
//
showTenkanSen = true;
showKijunSen = true;
showKijunSenPlus = false;
showKijunSenNegative = false;
showChikouSpan = true;
showSenkouSpanA = true;
showSenkouSpanB = true;
showKumo = true;
shiftKumo = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
tenkanSenLength > 2 &&
kijunSenLength > tenkanSenLength &&
senkouSpanBLength > kijunSenLength
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(result, tenkanSenLength);
result = MathMax(result, kijunSenLength);
result = MathMax(result, senkouSpanBLength);
//
return result;
}
};
//
// Class ...
class XSCXICHHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXICHHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXICHHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XICHInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(tenkanSenBuffer, true);
ArraySetAsSeries(kijunSenBuffer, true);
ArraySetAsSeries(chikouSpanBuffer, true);
ArraySetAsSeries(senkouSpanABuffer, true);
ArraySetAsSeries(senkouSpanBBuffer, true);
ArraySetAsSeries(futureSenkouSpanABuffer, true);
ArraySetAsSeries(futureSenkouSpanBBuffer, true);
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xich",
//
// Inputs ...
//
// TenkanSen ...
"",
mInputs.tenkanSenLength,
mInputs.tenkanSenMode,
//
// KijunSen ...
"",
mInputs.kijunSenLength,
mInputs.kijunSenMode,
//
// SenkouSpan B ...
"",
mInputs.senkouSpanBLength,
mInputs.senkouSpanBMode,
//
// ChikouSpan ...
"",
mInputs.chikuoSpanAppliedTo,
//
// Presentation ...
"",
mInputs.showTenkanSen, // Show Tenkan Sen
mInputs.showKijunSen, // Show Kijun Sen
mInputs.showKijunSenPlus, // Show Kijun Sen +
mInputs.showKijunSenNegative, // Show Kijun Sen -
mInputs.showChikouSpan, // Show Chikou Span
mInputs.showSenkouSpanA, // Show Senkou Span A
mInputs.showSenkouSpanB, // Show Senkou Span B
mInputs.showKumo, // Show Kumo
mInputs.shiftKumo // Shift Kumo to Future
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XICHInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XICHInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs);
}
//
// Buffers ...
//
// TenkanSen ...
//
double GetTenkanSen(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return tenkanSenBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyTenkanSen(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
tenkanSenBuffer,
buffer,
forceClean
//
);
}
//
bool IsSameTenkanSen(
int barIndex, // Start Bar Index
int verifier = 71 // Number of Verifiers
)
{
//
// Update Calculations ...
Calculate();
//
return IsSame(
tenkanSenBuffer,
verifier,
barIndex //
);
}
//
// KijunSen ...
//
double GetKijunSen(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return kijunSenBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyKijunSen(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
kijunSenBuffer,
buffer,
forceClean
//
);
}
//
bool IsSameKijunSen(
int barIndex, // Start Bar Index
int verifier = 71 // Number of Verifiers
)
{
//
// Update Calculations ...
Calculate();
//
return IsSame(
kijunSenBuffer,
verifier,
barIndex //
);
}
//
// ChikouSpan ...
//
double GetChikouSpan(
int barIndex // Bar Index
)
{
//
barIndex -= mInputs.kijunSenLength;
//
if (barIndex < 0)
{
barIndex = 0;
}
//
if (barIndex > ArraySize(chikouSpanBuffer))
{
barIndex = ArraySize(chikouSpanBuffer) - 1;
}
//
Calculate();
//
return chikouSpanBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyChikouSpan(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start - mInputs.kijunSenLength,
count,
chikouSpanBuffer,
buffer,
forceClean
//
);
}
//
// SenkouSpanA ...
//
double GetSenkouSpanA(
int barIndex // Bar Index
)
{
//
Calculate();
//
return senkouSpanABuffer[barIndex];
}
//
// Copy Required Items ...
int CopySenkouSpanA(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
senkouSpanABuffer,
buffer,
forceClean
//
);
}
//
bool IsSameSenkouSpanA(
int barIndex, // Start Bar Index
int verifier = 71 // Number of Verifiers
)
{
//
// Update Calculations ...
Calculate();
//
return IsSame(
senkouSpanABuffer,
verifier,
barIndex //
);
}
//
// SenkouSpanB ...
//
double GetSenkouSpanB(
int barIndex // Bar Index
)
{
//
Calculate();
//
return senkouSpanBBuffer[barIndex + mInputs.kijunSenLength];
}
//
// Copy Required Items ...
int CopySenkouSpanB(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
senkouSpanBBuffer,
buffer,
forceClean
//
);
}
//
bool IsSameSenkouSpanB(
int barIndex, // Start Bar Index
int verifier = 71 // Number of Verifiers
)
{
//
// Update Calculations ...
Calculate();
//
return IsSame(
senkouSpanBBuffer,
verifier,
barIndex //
);
}
//
// Future SenkouSpanA ...
//
double GetFutureSenkouSpanA(
int barIndex // Bar Index
)
{
//
barIndex -= mInputs.kijunSenLength;
//
Calculate();
//
return senkouSpanABuffer[barIndex];
}
//
// Copy Required Items ...
int CopyFutureSenkouSpanA(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start - mInputs.kijunSenLength,
count,
futureSenkouSpanABuffer,
buffer,
forceClean
//
);
}
//
// Future SenkouSpanB ...
//
double GetFutureSenkouSpanB(
int barIndex // Bar Index
)
{
//
barIndex -= mInputs.kijunSenLength;
//
Calculate();
//
return senkouSpanBBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyFutureSenkouSpanB(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start - mInputs.kijunSenLength,
count,
futureSenkouSpanBBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XICHInputs mInputs; // Inputs ...
//
// Buffers ...
double tenkanSenBuffer[];
double kijunSenBuffer[];
double chikouSpanBuffer[];
double senkouSpanABuffer[];
double senkouSpanBBuffer[];
double futureSenkouSpanABuffer[];
double futureSenkouSpanBBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
int calculatedBars = CountCalculatedBars();
//
// TenkanSen ...
CopyBuffer(
mHandler,
X_ICH_TEANKANSEN_LINE,
0,
totalBars,
tenkanSenBuffer
//
);
//
// KijunSen ...
CopyBuffer(
mHandler,
X_ICH_KIJUNSEN_LINE,
0,
totalBars,
kijunSenBuffer
//
);
//
// ChikouSpan ...
CopyBuffer(
mHandler,
X_ICH_CHIKOUSPAN_LINE,
0,
totalBars,
chikouSpanBuffer
//
);
//
// SenkouSpan A ...
CopyBuffer(
mHandler,
X_ICH_SENKOUSPANA_LINE,
0,
totalBars,
senkouSpanABuffer
//
);
//
// SenkouSpan B ...
CopyBuffer(
mHandler,
X_ICH_SENKOUSPANB_LINE,
0,
totalBars,
senkouSpanBBuffer
//
);
//
// SenkouSpan A ...
CopyBuffer(
mHandler,
X_ICH_SENKOUSPANA_LINE,
0 - mInputs.kijunSenLength,
totalBars,
futureSenkouSpanABuffer
//
);
//
// SenkouSpan B ...
CopyBuffer(
mHandler,
X_ICH_SENKOUSPANB_LINE,
0 - mInputs.kijunSenLength,
totalBars,
futureSenkouSpanBBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,496 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXMCHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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
//
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XMC_BUFFERS
{
X_MC_FAST_LINE = 0,
X_MC_SLOW_LINE = 1,
X_MC_VERIFIER_LINE = 2,
};
//
// Input Models ...
struct XMCInputs
{
//
// Props ...
//
// Market ...
//
// Fast ...
int fastLength; // Length
int fastShift; // Shift
ENUM_MA_METHOD fastMethod; // Method
ENUM_APPLIED_PRICE fastAppliedTo; // Applied To
//
// Slow ...
int slowLength; // Length
int slowShift; // Shift
ENUM_MA_METHOD slowMethod; // Method
ENUM_APPLIED_PRICE slowAppliedTo; // Applied To
//
// Verifier ...
int verifierLength; // Length
int verifierShift; // Shift
ENUM_MA_METHOD verifierMethod; // Method
ENUM_APPLIED_PRICE verifierAppliedTo; // Applied To
//
// Presentation ...
bool showFastMa; // Show Fast
bool showSlowMa; // Show Slow
bool showVerifierMa; // Show Verifier
//
// Constructor(s) ...
XMCInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
fastLength = 0;
fastShift = 0;
fastMethod = 0;
fastAppliedTo = PRICE_CLOSE;
//
slowLength = 0;
slowShift = 0;
slowMethod = 0;
slowAppliedTo = PRICE_CLOSE;
//
verifierLength = 0;
verifierShift = 0;
verifierMethod = 0;
verifierAppliedTo = PRICE_CLOSE;
//
showFastMa = false;
showSlowMa = false;
showVerifierMa = false;
}
//
// Default ...
void Default()
{
//
fastLength = 9;
fastShift = 0;
fastMethod = MODE_EMA;
fastAppliedTo = PRICE_CLOSE;
//
slowLength = 18;
slowShift = 0;
slowMethod = MODE_EMA;
slowAppliedTo = PRICE_CLOSE;
//
verifierLength = 200;
verifierShift = 0;
verifierMethod = MODE_EMA;
verifierAppliedTo = PRICE_CLOSE;
//
showFastMa = true;
showSlowMa = true;
showVerifierMa = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
fastLength > 1 &&
slowLength > fastLength &&
verifierLength > slowLength
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(fastLength, slowLength);
result = MathMax(result, verifierLength);
//
return result;
}
};
//
// Class ...
class XSCXMCHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXMCHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXMCHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XMCInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(fastBuffer, true);
ArraySetAsSeries(slowBuffer, true);
ArraySetAsSeries(verifierBuffer, true);
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xmc",
//
// Inputs ...
//
// Fast ...
"",
mInputs.fastLength,
mInputs.fastShift,
mInputs.fastMethod,
mInputs.fastAppliedTo,
//
// Slow ...
"",
mInputs.slowLength,
mInputs.slowShift,
mInputs.slowMethod,
mInputs.slowAppliedTo,
//
// Verifier ...
"",
mInputs.verifierLength,
mInputs.verifierShift,
mInputs.verifierMethod,
mInputs.verifierAppliedTo,
//
// Presentation ...
"",
mInputs.showFastMa, // Show Fast,
mInputs.showSlowMa, // Show Slow,
mInputs.showVerifierMa // Show Verifier
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XMCInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XMCInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs);
}
//
// Buffers ...
//
// Fast ...
//
double GetFast(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return fastBuffer[barIndex];
}
//
// Copy Required Buffer ...
int CopyFast(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
fastBuffer,
buffer,
forceClean
//
);
}
//
// Slow ...
//
double GetSlow(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return slowBuffer[barIndex];
}
//
// Copy Required Buffer ...
int CopySlow(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
slowBuffer,
buffer,
forceClean
//
);
}
//
// Verifier ...
//
double GetVerifier(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return verifierBuffer[barIndex];
}
//
// Copy Required Buffer ...
int CopyVerifier(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
verifierBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XMCInputs mInputs; // Inputs ...
//
// Buffers ...
//
double fastBuffer[];
double slowBuffer[];
double verifierBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Fast ...
CopyBuffer(
mHandler,
X_MC_FAST_LINE,
0,
totalBars,
fastBuffer
//
);
//
// Slow ...
CopyBuffer(
mHandler,
X_MC_SLOW_LINE,
0,
totalBars,
slowBuffer
//
);
//
// Verifier ...
CopyBuffer(
mHandler,
X_MC_VERIFIER_LINE,
0,
totalBars,
verifierBuffer
//
);
}
};
//
// Tools ...
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,408 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXSSLCHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XSSLC_BUFFERS
{
XSSLC_UP_LINE = 0,
XSSLC_DOWN_LINE = 1,
};
//
// Input Models ...
struct XSSLCInputs
{
//
// Props ...
//
// Market ...
int length; // Length
//
// Calculation ...
ENUM_MA_METHOD method; // Method
ENUM_APPLIED_PRICE upAppliedTo; // Up Applied To
ENUM_APPLIED_PRICE downAppliedTo; // Down Applied To
//
// Presentation ...
bool showUp; // Show Up
bool showDown; // Show Down
//
// Constructor(s) ...
XSSLCInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
// Market ...
length = 0;
//
// Calculation ...
method = MODE_SMA;
upAppliedTo = PRICE_HIGH;
downAppliedTo = PRICE_LOW;
//
// Presentation ...
showUp = false;
showDown = false;
}
//
// Default ...
void Default()
{
//
// Market ...
length = 36;
//
// Calculation ...
method = MODE_SMA;
upAppliedTo = PRICE_HIGH;
downAppliedTo = PRICE_LOW;
//
// Presentation ...
showUp = true;
showDown = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
length > 2
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(0, 0);
//
return result;
}
};
//
// Class ...
class XSCXSSLCHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXSSLCHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXSSLCHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XSSLCInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(upBuffer, true);
ArraySetAsSeries(downBuffer, true);
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xsslc",
//
// Inputs ...
//
// Market ...
"",
mInputs.length, // Length
//
// Calculation ...
"",
mInputs.method, // Method
mInputs.upAppliedTo, // Up Applied To
mInputs.downAppliedTo, // Down Applied To
//
// Presentation ...
"",
mInputs.showUp, // Show Up
mInputs.showDown // Show Down
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XSSLCInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XSSLCInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Buffers ...
//
// Up ...
//
double GetUp(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(upBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return upBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyUp(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
upBuffer,
buffer,
forceClean
//
);
}
//
// Down ...
//
double GetDown(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(downBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return downBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyDown(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
downBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XSSLCInputs mInputs; // Inputs ...
//
// Buffers ...
double upBuffer[];
double downBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Up ...
CopyBuffer(
mHandler,
XSSLC_UP_LINE,
0,
totalBars,
upBuffer
//
);
//
// Down ...
CopyBuffer(
mHandler,
XSSLC_DOWN_LINE,
0,
totalBars,
downBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,421 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXSTRHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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
//
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XSTR_BUFFERS
{
X_STR_TREND_LINE = 0,
X_STR_STATE_LINE = 5,
};
//
enum ENUM_XSTR_TREND_STATES
{
X_STR_BULLISH = 1, // Bullish
X_STR_BEARISH = -1, // Bearish
};
//
// Input Models ...
struct XSTRInputs
{
//
// Props ...
//
// Market ...
int length; // Length
double multiplier; // Multiplier
ENUM_APPLIED_PRICE appliedTo; // Applied To
//
// Presentation ...
bool showTrends; // Show Trends
bool fillTrends; // Fill Trends
//
// Constructor(s) ...
XSTRInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
length = 0;
multiplier = 0;
appliedTo = PRICE_CLOSE;
//
showTrends = false;
fillTrends = false;
}
//
// Default ...
void Default()
{
//
length = 14;
multiplier = 3.5;
appliedTo = PRICE_MEDIAN;
//
showTrends = true;
fillTrends = false;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
length > 0 &&
multiplier > 0
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = length;
//
return result;
}
};
//
// Class ...
class XSCXSTRHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXSTRHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXSTRHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XSTRInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(trendBuffer, true);
ArraySetAsSeries(stateBuffer, true);
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xstr",
//
// Inputs ...
//
// ATR ...
"",
mInputs.length, // Length
mInputs.multiplier, // Multiplier
mInputs.appliedTo, // Applied To
//
// Presentation ...
"",
mInputs.showTrends, // Show Trends
mInputs.fillTrends // Fill Trends
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XSTRInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XSTRInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs);
}
//
// Buffers ...
//
// Trend ...
//
double GetTrend(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return trendBuffer[barIndex];
}
//
// Copy Required Buffer ...
int CopyTrend(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
trendBuffer,
buffer,
forceClean
//
);
}
//
// State ...
//
ENUM_XSTR_TREND_STATES GetState(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
return (ENUM_XSTR_TREND_STATES)((int)stateBuffer[barIndex]);
}
//
// Copy Required Buffer ...
int CopyState(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
stateBuffer,
buffer,
forceClean
//
);
}
//
// Tools ...
//
ENUM_XSTR_TREND_STATES ToState(double state)
{
return (ENUM_XSTR_TREND_STATES)((int)state);
}
//
bool IsBullish(double state)
{
//
bool result = false;
//
result =
//
ToState(state) == X_STR_BULLISH;
//
;
//
return result;
}
//
bool IsBearish(double state)
{
//
bool result = false;
//
result =
//
ToState(state) == X_STR_BEARISH;
//
;
//
return result;
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XSTRInputs mInputs; // Inputs ...
//
// Buffers ...
double trendBuffer[];
double stateBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
int calculatedBars = CountCalculatedBars();
//
// Trend ...
CopyBuffer(
mHandler,
X_STR_TREND_LINE,
0,
totalBars,
trendBuffer
//
);
//
// State ...
CopyBuffer(
mHandler,
X_STR_STATE_LINE,
0,
totalBars,
stateBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,458 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXTDHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XTD_BUFFERS
{
XTD_BULLISH_LINE = 0,
XTD_BEARISH_LINE = 1,
XTD_SIGNAL_LINE = 2,
};
//
// Input Models ...
struct XTDInputs
{
//
// Props ...
//
int length; // Market Length
bool drawCrosses; // Draw Cross Arrows
//
// Bullish ...
uchar bullishArrowCode; // Cross Over Arrow Code
color bullishArrowColor; // Cross Over Arrow Color
//
// Bearish ...
uchar bearishArrowCode; // Cross Under Arrow Code
color bearishArrowColor; // Cross Under Arrow Color
//
// Constructor(s) ...
XTDInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
length = 0;
drawCrosses = false;
//
// Bullish ...
bullishArrowCode = 228;
bullishArrowColor = CLR_NONE;
//
// Bearish ...
bearishArrowCode = 230;
bearishArrowColor = CLR_NONE;
}
//
// Default ...
void Default()
{
//
length = 14;
drawCrosses = false;
//
// Bullish ...
bullishArrowCode = 228;
bullishArrowColor = CLR_NONE;
//
// Bearish ...
bearishArrowCode = 230;
bearishArrowColor = CLR_NONE;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
length >= 2
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(result, length);
//
return result;
}
};
//
// Class ...
class XSCXTDHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXTDHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXTDHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XTDInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(bullishBuffer, true);
ArraySetAsSeries(bearishBuffer, true);
ArraySetAsSeries(signalBuffer, true);
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xtd",
//
// Inputs ...
//
mInputs.length, // Market Length
mInputs.drawCrosses, // Draw Cross Arrows
//
// Bullish ...
mInputs.bullishArrowCode, // Cross Over Arrow Code
mInputs.bullishArrowColor, // Cross Over Arrow Color
//
// Bearish ...
mInputs.bearishArrowCode, // Cross Under Arrow Code
mInputs.bearishArrowColor // Cross Under Arrow Color
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XTDInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XTDInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Buffers ...
//
double GetBullish(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(bullishBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return bullishBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyBullish(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
bullishBuffer,
buffer,
forceClean
//
);
}
//
double GetBearish(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(bearishBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return bearishBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyBearish(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
bearishBuffer,
buffer,
forceClean
//
);
}
//
double GetSignal(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(signalBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return signalBuffer[barIndex];
}
//
// Copy Required Items ...
int CopySignal(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
signalBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XTDInputs mInputs; // Inputs ...
//
// Buffers ...
double bullishBuffer[];
double bearishBuffer[];
double signalBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Bullish ...
CopyBuffer(
mHandler,
XTD_BULLISH_LINE,
0,
totalBars,
bullishBuffer
//
);
//
// Bearish ...
CopyBuffer(
mHandler,
XTD_BEARISH_LINE,
0,
totalBars,
bearishBuffer
//
);
//
// Signal ...
CopyBuffer(
mHandler,
XTD_SIGNAL_LINE,
0,
totalBars,
signalBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,310 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXTMHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
enum ENUM_XTM_BUFFERS
{
XTM_MAIN_LINE = 0
};
//
// Input Models ...
struct XTMInputs
{
//
// Props ...
//
// Market ...
int maPeriod; // Period
int maShift; // Shift
ENUM_MA_METHOD maMethod; // Method
ENUM_APPLIED_PRICE maAppliedTo; // Applied To
//
// Presentation ...
bool showLine; // Show Line
//
// Constructor(s) ...
XTMInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
maShift = 0;
maPeriod = 0;
showLine = false;
maMethod = MODE_SMA;
maAppliedTo = PRICE_CLOSE;
}
//
// Default ...
void Default()
{
//
maShift = 0;
maPeriod = 14;
showLine = true;
maMethod = MODE_SMA;
maAppliedTo = PRICE_CLOSE;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
maPeriod >= 2
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(result, maPeriod);
//
return result;
}
};
//
// Class ...
class XSCXTMHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXTMHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXTMHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XTMInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(mainBuffer, true);
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xtm",
//
// Inputs ...
//
// Market ...
"",
mInputs.maPeriod, // Period
mInputs.maShift, // Shift
mInputs.maMethod, // Method
mInputs.maAppliedTo, // Applied To
//
// Presentation ...
"",
mInputs.showLine // Show Line
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XTMInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XTMInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Buffers ...
//
double GetMain(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(mainBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return mainBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyMain(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
mainBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XTMInputs mInputs; // Inputs ...
//
// Buffers ...
double mainBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Main Buffer ...
CopyBuffer(
mHandler,
XTM_MAIN_LINE,
0,
totalBars,
mainBuffer
//
);
}
};
//
// Tools ...
@@ -0,0 +1,527 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XSCXZGHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// 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 ...
#include "../Classes/x-saherelm.xhelper.class.mq5"
//
// Definitions ...
//
// How to Calculate Up and Down Price ...
enum ENUM_X_ZG_PRICE_MODE
{
//
X_ZG_PRICE_HIGH_LOW_MODE = 1,
X_ZG_PRICE_OPEN_CLOSE_MODE = 2,
};
//
enum ENUM_XZG_BUFFERS
{
//
XZG_MAIN_LINE = 0,
XZG_PEAKSANDVALES_LINE = 2,
XZG_HIGHS_LINE = 4,
XZG_LOWS_LINE = 5,
};
//
// Input Models ...
struct XZGInputs
{
//
// Props ...
//
// Market ...
int depth; // Depth
int deviation; // Deviation
int backStep; // Back Step
ENUM_X_ZG_PRICE_MODE mode; // Mode
//
// Presentation ...
bool showZigZag; // Show ZigZag
bool showPeaksAndVales; // Show Peaks and Vales
//
// Constructor(s) ...
XZGInputs()
{
//
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
//
// Market ...
depth = 0;
deviation = 0;
backStep = 0;
mode = X_ZG_PRICE_HIGH_LOW_MODE;
//
// Presentation ...
showZigZag = false;
showPeaksAndVales = false;
}
//
// Default ...
void Default()
{
//
// Market ...
depth = 12;
deviation = 5;
backStep = 3;
mode = X_ZG_PRICE_HIGH_LOW_MODE;
//
// Presentation ...
showZigZag = true;
showPeaksAndVales = true;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
depth > 0 &&
deviation > 0 &&
backStep > 0
//
;
//
return result;
}
//
// Retrieve MAx Length ...
int Max()
{
//
int result = 0;
//
result = MathMax(backStep, depth);
//
return result;
}
};
//
// Class ...
class XSCXZGHelper : public XSCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Constructors ...
XSCXZGHelper() : XSCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XSCXZGHelper() {}
//
// Tools ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XZGInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
mInputs = inputs;
//
ArraySetAsSeries(mainBuffer, true);
ArraySetAsSeries(PeaksAndValesBuffer, true);
ArraySetAsSeries(highsBuffer, true);
ArraySetAsSeries(lowsBuffer, true);
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xzg",
//
// Inputs ...
//
// Market ...
"",
mInputs.depth, // Depth
mInputs.deviation, // Deviation
mInputs.backStep, // Back Step
mInputs.mode, // Mode
//
// Presentation ...
"",
mInputs.showZigZag, // Show ZigZag
mInputs.showPeaksAndVales // Show Peaks and Vales
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XZGInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XZGInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs
//
);
}
//
// Buffers ...
//
double GetMain(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(mainBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return mainBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyMain(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
mainBuffer,
buffer,
forceClean
//
);
}
//
double GetPeaksAndVales(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(PeaksAndValesBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return PeaksAndValesBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyPeaksAndVales(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
PeaksAndValesBuffer,
buffer,
forceClean
//
);
}
//
double GetHigh(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(highsBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return highsBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyHigh(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
highsBuffer,
buffer,
forceClean
//
);
}
//
double GetLow(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate();
//
int count = ArraySize(lowsBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return lowsBuffer[barIndex];
}
//
// Copy Required Items ...
int CopyLow(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate();
//
// Copy Items ...
return Copy(
start,
count,
lowsBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XZGInputs mInputs; // Inputs ...
//
// Buffers ...
double mainBuffer[];
double PeaksAndValesBuffer[];
double highsBuffer[];
double lowsBuffer[];
//
// Tools ...
//
// Calculate Values Until Now ...
void Calculate()
{
//
int totalBars = CountBars();
//
// Main Buffer ...
CopyBuffer(
mHandler,
XZG_MAIN_LINE,
0,
totalBars,
mainBuffer
//
);
//
// Peaks and Vales Buffer ...
CopyBuffer(
mHandler,
XZG_PEAKSANDVALES_LINE,
0,
totalBars,
PeaksAndValesBuffer
//
);
//
// Highs Buffer ...
CopyBuffer(
mHandler,
XZG_HIGHS_LINE,
0,
totalBars,
highsBuffer
//
);
//
// Lows Buffer ...
CopyBuffer(
mHandler,
XZG_LOWS_LINE,
0,
totalBars,
lowsBuffer
//
);
}
};
//
// Tools ...
Binary file not shown.
@@ -0,0 +1,348 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 XAMA Indicator
// ---------------------------------------------
// Name: XAMA
// Description: Trend Magic Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XAMA Indicator"
#property strict
//
// Constants ...
#define ShortName "XAMA"
//
// Indicator States ...
enum ENUM_X_XAMA_STATES
{
X_XAMA_BULLISH = 1,
X_XAMA_BEARISH = -1,
X_XAMA_NEUTURAL = 0,
};
//
// Inputs ...
//
// Market ...
input group "Market";
input int length = 18; // Period
input int fastEMA = 2; // Fast EMA Period
input int slowEMA = 30; // Slow EMA Period
input int maShift = 0; // Shift
input ENUM_APPLIED_PRICE appliedTo = PRICE_CLOSE; // Applied To
//
// Presentation ...
input group "Presentation";
input bool showLine = true; // Show Line
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// START Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 3
#property indicator_plots 1
//
// maBuffer ...
#define maBufferIndex 0
#define maColorBufferIndex 1
#define stateBufferIndex 2
double maBuffer[];
double maColorBuffer[];
double stateBuffer[];
#property indicator_label1 "XAMA"
#property indicator_type1 DRAW_COLOR_LINE
#property indicator_color1 clrLime, clrGray, clrRed, CLR_NONE
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
int maHandler = INVALID_HANDLE;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Initializing MA Handler ...
maHandler = iAMA(
_Symbol,
_Period,
length,
fastEMA,
slowEMA,
maShift,
appliedTo);
if (maHandler == INVALID_HANDLE)
{
//
return INIT_FAILED;
}
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
IndicatorRelease(maHandler);
}
//
// Calculations ...
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
int maxLength = MathMax(fastEMA, slowEMA);
maxLength = MathMax(maxLength, length);
//
// Check Calculated Bars ...
int maCalculatedBars = BarsCalculated(maHandler);
if (maCalculatedBars < maxLength)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
int copiedMas = CopyBuffer(maHandler, 0, 0, limit, maBuffer);
if (copiedMas <= 0)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
//
// Do Buffers Calculation ...
CalculateBuffers(i);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
// Validate Args ...
if (length >= 2)
{
result = true;
}
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
string maBufferLabel = "XAMA " + "(" + (string)length + ")";
//
// Ma Buffer ...
ArraySetAsSeries(maBuffer, true);
SetIndexBuffer(maBufferIndex, maBuffer, INDICATOR_DATA);
PlotIndexSetString(maBufferIndex, PLOT_LABEL, maBufferLabel);
//
// Ma Color Buffer ...
ArraySetAsSeries(maColorBuffer, true);
SetIndexBuffer(maColorBufferIndex, maColorBuffer, INDICATOR_COLOR_INDEX);
//
// State Buffer ...
ArraySetAsSeries(stateBuffer, true);
SetIndexBuffer(stateBufferIndex, stateBuffer, INDICATOR_CALCULATIONS);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
//
string indicatorShortName = "";
StringConcatenate(indicatorShortName, ShortName, " ", "(", length, ")");
//
IndicatorSetString(INDICATOR_SHORTNAME, indicatorShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(int bar_index)
{
//
// Requirements ...
XOHCL candle;
candle.Init(
_Symbol,
_Period,
bar_index);
//
double maValue = maBuffer[bar_index];
//
double lineColorIndex =
maValue < candle.low ? 0 : maValue > candle.high ? 2
: 1;
//
// Define State Value ...
// lineColorIndex == 0 => Bullish => 1;
// lineColorIndex == 1 => Neutural => 0;
// lineColorIndex == 2 => Bearish => -1;
double stateValue =
lineColorIndex == 0 ? X_XAMA_BULLISH : lineColorIndex == 2 ? X_XAMA_BEARISH
: X_XAMA_NEUTURAL;
//
// Set Ma Buffer Color Index ...
maColorBuffer[bar_index] = showLine ? lineColorIndex : 3;
//
// Set State Buffer Value ...
stateBuffer[bar_index] = stateValue;
}
//
// END Functions ...
//
+458
View File
@@ -0,0 +1,458 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Candle Styles
// ---------------------------------------------------
// Name: XCC
// Description: Candle Styles ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XCC Indicator"
#property strict
//
// START Constants ...
//
//
// Indicator Short Name ...
#define ShortName "XCC"
//
// Holds an SnapShot of Charts Configuration ...
struct XChartStyle
{
//
// chart's ID ...
long chartId;
//
// chart's mode ...
ENUM_CHART_MODE mode;
//
// show bid line ...
bool showBidLine;
//
// show ask line ...
bool showAskLine;
//
// show grids on chart ...
bool showGrid;
//
// show volumes ...
bool showVolumes;
//
// Displaying trade levels in the chart (levels of open positions, Stop Loss, Take Profit and pending orders) ...
bool showTradeLevels;
//
// chart autoscroll ...
bool autoScroll;
//
// chart quick navigation state ...
bool quickNavigation;
//
// chart's foreground color ...
color foreGroundColor;
//
// chart's background color ...
color backGroundColor;
//
// Up Color ...
color upColor;
//
// Down Color ...
color downColor;
//
// Bullish color ...
color bullishColor;
//
// Bearish color ...
color bearishColor;
//
// grid color ...
color gridColor;
//
// bid line color ...
color bidLineColor;
//
// ask line color ...
color askLineColor;
//
// line mode and doji candlestick color ...
color lineColor;
//
// Color of stop order levels (Stop Loss and Take Profit) ...
color stopColor;
//
// volumes color ...
color volumesColor;
};
//
// END Constants ...
//
//
// START Inputs ...
//
//
input group "Chart Style";
input ENUM_CHART_MODE mode = CHART_CANDLES; // Mode
input color upColor = clrLime; // Up Color
input color downColor = clrRed; // Down Color
input color lineColor = clrLime; // Line mode and Doji candlestick Color
input color bearishColor = clrRed; // Bullish Color
input color bullishColor = clrLime; // Bearish Color
input color volumesColor = clrGreen; // Volumes Color
//
input group "Presentation";
input bool showCandles = true; // Show Candles
//
// END Inputs ...
//
//
// START Includes and Imports ...
//
//
// Includes Draw Library ...
#include "../Libraries/x-saherelm.draw.lib.mq5"
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START Buffers ...
//
//
#property indicator_chart_window
//
#property indicator_buffers 0
#property indicator_plots 0
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
XChartStyle chartStyle;
XChartStyle clearStyle;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
drawPrefix = ShortName;
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Apply Chart Style ...
ApplyCustomChartStyle();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
}
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[]
//
)
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = true;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index // Selected Bar Index
)
{
}
//
// Apply Custom Chart Style ...
void ApplyCustomChartStyle()
{
//
// Read Current Chart Config and Store it ...
ReadChartStyle();
//
// After Reading Current Chart Style ...
// we have to Save Configs and Change Styles ...
clearStyle = chartStyle;
//
clearStyle.upColor = CLR_NONE;
clearStyle.downColor = CLR_NONE;
clearStyle.lineColor = CLR_NONE;
clearStyle.bullishColor = CLR_NONE;
clearStyle.bearishColor = CLR_NONE;
//
// Decide to Show or not Candles based on User Input ...
if (showCandles)
{
SetChartStyle(chartStyle);
}
else
{
SetChartStyle(clearStyle);
}
}
//
// Read Previous Chart Style ...
void ReadChartStyle()
{
//
// Retrieve Current Chart ID ...
long chartId = ChartID();
chartStyle.chartId = chartId;
//
// Retrieve Chart Mode ...
chartStyle.mode = (ENUM_CHART_MODE)ChartGetInteger(chartId, CHART_MODE);
//
chartStyle.showBidLine = (bool)ChartGetInteger(chartId, CHART_SHOW_BID_LINE);
chartStyle.showAskLine = (bool)ChartGetInteger(chartId, CHART_SHOW_ASK_LINE);
chartStyle.showGrid = (bool)ChartGetInteger(chartId, CHART_SHOW_GRID);
chartStyle.showVolumes = (bool)ChartGetInteger(chartId, CHART_SHOW_VOLUMES);
chartStyle.showTradeLevels = (bool)ChartGetInteger(chartId, CHART_SHOW_TRADE_LEVELS);
chartStyle.autoScroll = (bool)ChartGetInteger(chartId, CHART_AUTOSCROLL);
chartStyle.quickNavigation = (bool)ChartGetInteger(chartId, CHART_QUICK_NAVIGATION);
//
chartStyle.foreGroundColor = (color)ChartGetInteger(chartId, CHART_COLOR_FOREGROUND);
chartStyle.backGroundColor = (color)ChartGetInteger(chartId, CHART_COLOR_BACKGROUND);
chartStyle.upColor = (color)ChartGetInteger(chartId, CHART_COLOR_CHART_UP);
chartStyle.downColor = (color)ChartGetInteger(chartId, CHART_COLOR_CHART_DOWN);
chartStyle.bullishColor = (color)ChartGetInteger(chartId, CHART_COLOR_CANDLE_BULL);
chartStyle.bearishColor = (color)ChartGetInteger(chartId, CHART_COLOR_CANDLE_BEAR);
chartStyle.gridColor = (color)ChartGetInteger(chartId, CHART_COLOR_GRID);
chartStyle.bidLineColor = (color)ChartGetInteger(chartId, CHART_COLOR_BID);
chartStyle.askLineColor = (color)ChartGetInteger(chartId, CHART_COLOR_ASK);
chartStyle.stopColor = (color)ChartGetInteger(chartId, CHART_COLOR_STOP_LEVEL);
chartStyle.lineColor = (color)ChartGetInteger(chartId, CHART_COLOR_CHART_LINE);
chartStyle.volumesColor = (color)ChartGetInteger(chartId, CHART_COLOR_VOLUME);
//
chartStyle.mode = mode;
chartStyle.upColor = upColor;
chartStyle.downColor = downColor;
chartStyle.lineColor = lineColor;
chartStyle.bearishColor = bearishColor;
chartStyle.bullishColor = bullishColor;
chartStyle.volumesColor = volumesColor;
}
//
// Set Chart Style ...
void SetChartStyle(
XChartStyle &mChartStyle // Chart Style to Apply
)
{
//
ApplyChartStyle(
mChartStyle.chartId,
mChartStyle.mode,
mChartStyle.showBidLine,
mChartStyle.showAskLine,
mChartStyle.showGrid,
mChartStyle.showVolumes,
mChartStyle.showTradeLevels,
mChartStyle.autoScroll,
mChartStyle.quickNavigation,
mChartStyle.foreGroundColor,
mChartStyle.backGroundColor,
mChartStyle.upColor,
mChartStyle.downColor,
mChartStyle.bullishColor,
mChartStyle.bearishColor,
mChartStyle.gridColor,
mChartStyle.bidLineColor,
mChartStyle.askLineColor,
mChartStyle.lineColor,
mChartStyle.stopColor,
mChartStyle.volumesColor);
}
//
// END Functions ...
//
@@ -0,0 +1,631 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XCHE
// Description: Chandelier Exit Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XCHE Indicator"
#property strict
//
// START Constants ...
//
//
#define ShortName "XCHE"
//
// END Constants ...
//
//
// START Inputs ...
//
//
input group "Market";
input int length = 35; // Length
input int loopback = 26; // Loopback
input double multiplier1 = 3.0; // 1st Multiplier
input double multiplier2 = 3.5; // 2nd Multiplier
//
input group "Calculation";
input ENUM_APPLIED_PRICE upAppliedTo = PRICE_HIGH; // Up Zone Applied to
input ENUM_APPLIED_PRICE downAppliedTo = PRICE_LOW; // Down Zone Applied to
//
input group "Presentation";
input bool showLongExit1Line = true; // Show 1st Long Exit
input bool showShortExit1Line = true; // Show 1st Short Exit
input bool showLongExit2Line = true; // Show 2st Long Exit
input bool showShortExit2Line = true; // Show 2st Short Exit
//
// END Inputs ...
//
//
// START Includes and Imports ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START Buffers ...
//
//
#property indicator_chart_window
//
#property indicator_buffers 8
#property indicator_plots 8
//
// Long Exit 1 ...
#define longExit1BufferIndex 0
double longExit1Buffer[];
//
#property indicator_label1 "XCHE LE 1"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrLime
#property indicator_style1 STYLE_DOT
//
// Short Exit 1 ...
#define shortExit1BufferIndex 1
double shortExit1Buffer[];
//
#property indicator_label2 "XCHE SE 1"
#property indicator_type2 DRAW_LINE
#property indicator_style2 STYLE_DOT
#property indicator_color2 clrRed
//
// Long Exit 2 ...
#define longExit2BufferIndex 2
double longExit2Buffer[];
//
#property indicator_label3 "XCHE LE 2"
#property indicator_type3 DRAW_LINE
#property indicator_style2 STYLE_DOT
#property indicator_color3 clrAqua
//
// Short Exit 2 ...
#define shortExit2BufferIndex 3
double shortExit2Buffer[];
//
#property indicator_label4 "XCHE SE 2"
#property indicator_type4 DRAW_LINE
#property indicator_style2 STYLE_DOT
#property indicator_color4 clrMagenta
//
// START Arrows ...
//
// Long Exit 1 Start ...
#define longExit1StartBufferIndex 4
double longExit1StartBuffer[];
//
#property indicator_label5 "XCHE LES 1"
#property indicator_type5 DRAW_ARROW
#property indicator_color5 clrLime
//
// Short Exit 1 Start ...
#define shortExit1StartBufferIndex 5
double shortExit1StartBuffer[];
//
#property indicator_label6 "XCHE SES 1"
#property indicator_type6 DRAW_ARROW
#property indicator_color6 clrRed
//
// Long Exit 2 Start ...
#define longExit2StartBufferIndex 6
double longExit2StartBuffer[];
//
#property indicator_label7 "XCHE LES 2"
#property indicator_type7 DRAW_ARROW
#property indicator_color7 clrAqua
//
// Short Exit 2 Start ...
#define shortExit2StartBufferIndex 7
double shortExit2StartBuffer[];
//
#property indicator_label8 "XCHE SES 2"
#property indicator_type8 DRAW_ARROW
#property indicator_color8 clrMagenta
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
// Working Array ...
double work[][6];
#define hi1Idx 0
#define lo1Idx 1
#define hi2Idx 2
#define lo2Idx 3
#define trend1Idx 4
#define trend2Idx 5
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart mPeriod is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
}
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
if (Bars(_Symbol, _Period) < rates_total)
{
return (prev_calculated);
}
//
if (ArrayRange(work, 0) != rates_total)
{
ArrayResize(work, rates_total);
}
//
// this counts Available Bars ...
int limit;
//
limit = prev_calculated - 1;
if (limit < 0)
{
limit = 0;
}
//
// Main Loop ...
for (int i = limit; i < rates_total && !IsStopped(); i++)
{
CalculateBuffers(
i,
prev_calculated,
rates_total,
//
open,
high,
low,
close);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = true;
//
result =
length >= 9 &&
loopback >= 0;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = MathMax(length, loopback);
//
return result;
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
uint arrowCode = 159;
//
// LEVEL 1 ...
//
// Long Exit 1 ...
//
// Draw Type ...
ENUM_DRAW_TYPE longExit1DrawType = showLongExit1Line ? DRAW_LINE : DRAW_NONE;
ENUM_DRAW_TYPE longExit1StartDrawType = showLongExit1Line ? DRAW_ARROW : DRAW_NONE;
//
// Buffer ...
SetIndexBuffer(longExit1BufferIndex, longExit1Buffer, INDICATOR_DATA);
PlotIndexSetInteger(longExit1BufferIndex, PLOT_SHOW_DATA, showLongExit1Line);
PlotIndexSetInteger(longExit1BufferIndex, PLOT_DRAW_TYPE, longExit1DrawType);
//
// Start Buffer ...
SetIndexBuffer(longExit1StartBufferIndex, longExit1StartBuffer, INDICATOR_DATA);
PlotIndexSetInteger(longExit1StartBufferIndex, PLOT_ARROW, arrowCode);
PlotIndexSetInteger(longExit1StartBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(longExit1StartBufferIndex, PLOT_DRAW_TYPE, longExit1StartDrawType);
//
// Short Exit 1 ...
//
// Draw Type ...
ENUM_DRAW_TYPE shortExit1DrawType = showShortExit1Line ? DRAW_LINE : DRAW_NONE;
ENUM_DRAW_TYPE shortExit1StartDrawType = showShortExit1Line ? DRAW_ARROW : DRAW_NONE;
//
// Buffer ...
SetIndexBuffer(shortExit1BufferIndex, shortExit1Buffer, INDICATOR_DATA);
PlotIndexSetInteger(shortExit1BufferIndex, PLOT_SHOW_DATA, showShortExit1Line);
PlotIndexSetInteger(shortExit1BufferIndex, PLOT_DRAW_TYPE, shortExit1DrawType);
//
// Start Buffer ...
SetIndexBuffer(shortExit1StartBufferIndex, shortExit1StartBuffer, INDICATOR_DATA);
PlotIndexSetInteger(shortExit1StartBufferIndex, PLOT_ARROW, arrowCode);
PlotIndexSetInteger(shortExit1StartBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(shortExit1StartBufferIndex, PLOT_DRAW_TYPE, shortExit1StartDrawType);
//
// LEVEL 2 ...
//
// Long Exit 2 ...
//
// Draw Type ...
ENUM_DRAW_TYPE longExit2DrawType = showLongExit2Line ? DRAW_LINE : DRAW_NONE;
ENUM_DRAW_TYPE longExit2StartDrawType = showLongExit2Line ? DRAW_ARROW : DRAW_NONE;
//
// Buffer ...
SetIndexBuffer(longExit2BufferIndex, longExit2Buffer, INDICATOR_DATA);
PlotIndexSetInteger(longExit2BufferIndex, PLOT_SHOW_DATA, showLongExit2Line);
PlotIndexSetInteger(longExit2BufferIndex, PLOT_DRAW_TYPE, longExit2DrawType);
//
// Start Buffer ...
SetIndexBuffer(longExit2StartBufferIndex, longExit2StartBuffer, INDICATOR_DATA);
PlotIndexSetInteger(longExit2StartBufferIndex, PLOT_ARROW, arrowCode);
PlotIndexSetInteger(longExit2StartBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(longExit2StartBufferIndex, PLOT_DRAW_TYPE, longExit2StartDrawType);
//
// Short Exit 2 ...
//
// Draw Type ...
ENUM_DRAW_TYPE shortExit2DrawType = showShortExit2Line ? DRAW_LINE : DRAW_NONE;
ENUM_DRAW_TYPE shortExit2StartDrawType = showShortExit2Line ? DRAW_ARROW : DRAW_NONE;
//
// Buffer ...
SetIndexBuffer(shortExit2BufferIndex, shortExit2Buffer, INDICATOR_DATA);
PlotIndexSetInteger(shortExit2BufferIndex, PLOT_SHOW_DATA, showShortExit2Line);
PlotIndexSetInteger(shortExit2BufferIndex, PLOT_DRAW_TYPE, shortExit2DrawType);
//
// Start Buffer ...
SetIndexBuffer(shortExit2StartBufferIndex, shortExit2StartBuffer, INDICATOR_DATA);
PlotIndexSetInteger(shortExit2StartBufferIndex, PLOT_ARROW, arrowCode);
PlotIndexSetInteger(shortExit2StartBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(shortExit2StartBufferIndex, PLOT_DRAW_TYPE, shortExit2StartDrawType);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index, // Selected Bar Index
int prevCalculated, // Previous Calculated
int ratesTotal, // Total Rates
const double &open[], // Rates Open ...
const double &high[], // Rates High ...
const double &low[], // Rates Low ...
const double &close[] // Rates Close ...
)
{
//
// Cleanup Buffers ...
longExit1Buffer[bar_index] = longExit1StartBuffer[bar_index] = shortExit1Buffer[bar_index] = shortExit1StartBuffer[bar_index] = EMPTY_VALUE;
longExit2Buffer[bar_index] = longExit2StartBuffer[bar_index] = shortExit2Buffer[bar_index] = shortExit2StartBuffer[bar_index] = EMPTY_VALUE;
//
int start = MathMax(bar_index - loopback, 0);
//
// Calculate ATR Value ...
double atrValue = 0;
for (int k = 1; k <= length && (bar_index - k - 1) >= 0; k++)
{
//
atrValue += MathMax(high[bar_index - k], close[MathMax(bar_index - k - 1, 0)]) -
MathMin(low[bar_index - k], close[MathMax(bar_index - k - 1, 0)]);
}
atrValue /= (double)length;
//
// Retrieve Highest High and Lowest Lows ...
double loopbackMax = high[ArrayMaximum(high, start, loopback)];
double loopbackMin = low[ArrayMinimum(low, start, loopback)];
//
// Fill Multi Dimesional Working Array ...
work[bar_index][hi1Idx] = loopbackMax - multiplier1 * atrValue;
work[bar_index][lo1Idx] = loopbackMin + multiplier1 * atrValue;
work[bar_index][hi2Idx] = loopbackMax - multiplier2 * atrValue;
work[bar_index][lo2Idx] = loopbackMin + multiplier2 * atrValue;
work[bar_index][trend1Idx] = (bar_index > 0) ? work[bar_index - 1][trend1Idx] : 0;
work[bar_index][trend2Idx] = (bar_index > 0) ? work[bar_index - 1][trend2Idx] : 0;
//
if (bar_index > 0)
{
//
// Calculate Trends ...
if (close[bar_index] > work[bar_index - 1][lo1Idx])
{
work[bar_index][trend1Idx] = 1;
}
//
if (close[bar_index] < work[bar_index - 1][hi1Idx])
{
work[bar_index][trend1Idx] = -1;
}
//
if (close[bar_index] > work[bar_index - 1][lo2Idx])
{
work[bar_index][trend2Idx] = 1;
}
//
if (close[bar_index] < work[bar_index - 1][hi2Idx])
{
work[bar_index][trend2Idx] = -1;
}
//
// Calculate Exit Values ...
//
// Exit 1 ...
//
// Long ...
if (multiplier1 > 0 && work[bar_index][trend1Idx] == 1)
{
//
if (work[bar_index][hi1Idx] < work[bar_index - 1][hi1Idx])
{
work[bar_index][hi1Idx] = work[bar_index - 1][hi1Idx];
}
//
longExit1Buffer[bar_index] = work[bar_index][hi1Idx];
//
if (longExit1Buffer[bar_index - 1] == EMPTY_VALUE)
{
longExit1StartBuffer[bar_index] = longExit1Buffer[bar_index];
}
}
//
// Short ...
if (multiplier1 > 0 && work[bar_index][trend1Idx] == -1)
{
//
if (work[bar_index][lo1Idx] > work[bar_index - 1][lo1Idx])
{
work[bar_index][lo1Idx] = work[bar_index - 1][lo1Idx];
}
//
shortExit1Buffer[bar_index] = work[bar_index][lo1Idx];
//
if (shortExit1Buffer[bar_index - 1] == EMPTY_VALUE)
{
shortExit1StartBuffer[bar_index] = shortExit1Buffer[bar_index];
}
}
//
// Exit 2 ...
//
// Long ...
if (multiplier2 > 0 && work[bar_index][trend2Idx] == 1)
{
if (work[bar_index][hi2Idx] < work[bar_index - 1][hi2Idx])
{
work[bar_index][hi2Idx] = work[bar_index - 1][hi2Idx];
}
//
longExit2Buffer[bar_index] = work[bar_index][hi2Idx];
//
if (longExit2Buffer[bar_index - 1] == EMPTY_VALUE)
{
longExit2StartBuffer[bar_index] = longExit2Buffer[bar_index];
}
}
//
// Short ...
if (multiplier2 > 0 && work[bar_index][trend2Idx] == -1)
{
//
if (work[bar_index][lo2Idx] > work[bar_index - 1][lo2Idx])
{
work[bar_index][lo2Idx] = work[bar_index - 1][lo2Idx];
}
//
shortExit2Buffer[bar_index] = work[bar_index][lo2Idx];
//
if (shortExit2Buffer[bar_index - 1] == EMPTY_VALUE)
{
shortExit2StartBuffer[bar_index] = shortExit2Buffer[bar_index];
}
}
}
}
//
// END Functions ...
//
+261
View File
@@ -0,0 +1,261 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XCT
// Description: Trend Magic Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XCT Indicator"
#property strict
//
// START Constants ...
//
//
#define ShortName "XCT"
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Constants ...
//
//
// START Inputs ...
//
//
input color clr = clrYellow; // Text Color
input ENUM_BASE_CORNER corner = CORNER_RIGHT_LOWER; // Text Position
//
input group "Presentation";
input bool showCandleTime = true; // Show Candle Time
//
// END Inputs ...
//
//
// START Buffers ...
//
//
#property indicator_chart_window
//
#property indicator_buffers 0
#property indicator_plots 0
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (showCandleTime)
{
CreateIndicatorObject();
}
else
{
ObjectDelete(0, ShortName);
}
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
ulong chID = FindChartID(
_Symbol,
_Period
//
);
//
// Delete Object ...
ObjectDelete(chID, ShortName);
//
Comment("");
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
ArraySetAsSeries(time, true);
//
if (!showCandleTime)
{
return rates_total;
}
//
ulong chID = FindChartID(
_Symbol,
_Period
//
);
//
XBarRemainsTime barRemains;
barRemains.Init(
_Symbol,
_Period
//
);
//
string msg = barRemains
.ToString(
"",
"",
"",
"",
"",
":",
true
//
);
//
long mSpread = SymbolInfoInteger(Symbol(), SYMBOL_SPREAD);
//
string _sp = "";
if (mSpread < 10)
_sp = "..";
else if (mSpread < 100)
_sp = ".";
//
string objText = "Spread: " + IntegerToString(mSpread) + _sp + " Next Bar in: " + msg;
//
ObjectSetInteger(chID, ShortName, OBJPROP_COLOR, clr);
ObjectSetString(chID, ShortName, OBJPROP_TEXT, objText);
ObjectSetInteger(chID, ShortName, OBJPROP_FONTSIZE, 10);
ObjectSetString(chID, ShortName, OBJPROP_FONT, "Courier");
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
void CreateIndicatorObject()
{
//
if (!showCandleTime)
{
return;
}
//
ObjectCreate(0, ShortName, OBJ_LABEL, 0, 0, 0);
ObjectSetInteger(0, ShortName, OBJPROP_CORNER, corner);
ObjectSetInteger(0, ShortName, OBJPROP_XDISTANCE, 10);
ObjectSetInteger(0, ShortName, OBJPROP_YDISTANCE, 2);
//
ENUM_ANCHOR_POINT Anchor = ANCHOR_LEFT_UPPER;
switch (corner)
{
case CORNER_LEFT_UPPER:
Anchor = ANCHOR_LEFT_UPPER;
break;
case CORNER_RIGHT_UPPER:
Anchor = ANCHOR_RIGHT_UPPER;
break;
case CORNER_LEFT_LOWER:
Anchor = ANCHOR_LEFT_LOWER;
break;
case CORNER_RIGHT_LOWER:
Anchor = ANCHOR_RIGHT_LOWER;
break;
}
//
ObjectSetInteger(0, ShortName, OBJPROP_ANCHOR, Anchor);
}
//
// END Functions ...
//
@@ -0,0 +1,366 @@
///////////////////////////////////////////////////////
// SaherElm IT Center MQL5 Indicator
// -------------------------------------------
// Name: XDON
// Description: DONCHAIN Channel ...
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XDON Indicator"
#property strict
//
#define ShortName "XDON"
//
// INPUT ...
//
input group "Market";
input int length = 52; // Market Length
input double offset = 0; // Offset
//
input group "Presentation";
input bool showOpen = true; // Show Open
input bool showHigh = true; // Show High
input bool showClose = true; // Show Close
input bool showLow = true; // Show Low
//
// BUFFERS ...
//
#property indicator_chart_window
//
#property indicator_buffers 8
#property indicator_plots 8
//
#define upperOBufferIndex 0
double upperOBuffer[];
//
#property indicator_label1 "XDON OU"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrCornflowerBlue
#property indicator_width1 2
//
#define lowerOBufferIndex 1
double lowerOBuffer[];
//
#property indicator_label2 "XDON OL"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrCornflowerBlue
#property indicator_width2 2
//
#define upperCBufferIndex 2
double upperCBuffer[];
//
#property indicator_label3 "XDON CU"
#property indicator_type3 DRAW_LINE
#property indicator_color3 clrCoral
#property indicator_width3 2
//
#define lowerCBufferIndex 3
double lowerCBuffer[];
//
#property indicator_label4 "XDON CL"
#property indicator_type4 DRAW_LINE
#property indicator_color4 clrCoral
#property indicator_width4 2
//
#define upperHBufferIndex 4
double upperHBuffer[];
//
#property indicator_label5 "XDON HU"
#property indicator_type5 DRAW_LINE
#property indicator_color5 clrAquamarine
#property indicator_width5 2
//
#define lowerHBufferIndex 5
double lowerHBuffer[];
//
#property indicator_label6 "XDON HL"
#property indicator_type6 DRAW_LINE
#property indicator_color6 clrAquamarine
#property indicator_width6 2
//
#define upperLBufferIndex 6
double upperLBuffer[];
//
#property indicator_label7 "XDON LU"
#property indicator_type7 DRAW_LINE
#property indicator_color7 clrDarkOrchid
#property indicator_width7 2
//
#define lowerLBufferIndex 7
double lowerLBuffer[];
//
#property indicator_label8 "XDON LL"
#property indicator_type8 DRAW_LINE
#property indicator_color8 clrDarkOrchid
#property indicator_width8 2
//
// EVENT Handlers ...
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
if (rates_total < length - 1)
{
return prev_calculated;
}
//
int start = prev_calculated == 0
? length
: prev_calculated - 1;
//
// Main Loop ...
for (int barIndex = start; barIndex < rates_total; barIndex++)
{
//
// OPEN ...
//
double upperOValue = open[ArrayMaximum(open, barIndex - length + 1, length)];
double lowerOValue = open[ArrayMinimum(open, barIndex - length + 1, length)];
//
double oDelta = MathAbs(upperOValue - lowerOValue);
double oOffsetValue = oDelta * (offset) * 0.01;
//
upperOBuffer[barIndex] = upperOValue - oOffsetValue;
lowerOBuffer[barIndex] = lowerOValue + oOffsetValue;
//
// CLOSE ...
//
double upperCValue = close[ArrayMaximum(close, barIndex - length + 1, length)];
double lowerCValue = close[ArrayMinimum(close, barIndex - length + 1, length)];
//
double cDelta = MathAbs(upperCValue - lowerCValue);
double cOffsetValue = cDelta * (offset) * 0.01;
//
upperCBuffer[barIndex] = upperCValue - cOffsetValue;
lowerCBuffer[barIndex] = lowerCValue + cOffsetValue;
//
// HIGH ...
//
double upperHValue = high[ArrayMaximum(high, barIndex - length + 1, length)];
double lowerHValue = high[ArrayMinimum(high, barIndex - length + 1, length)];
//
double hDelta = MathAbs(upperHValue - lowerHValue);
double hOffsetValue = hDelta * (offset) * 0.01;
//
upperHBuffer[barIndex] = upperHValue - hOffsetValue;
lowerHBuffer[barIndex] = lowerHValue + hOffsetValue;
//
// LOW ...
//
double upperLValue = low[ArrayMaximum(low, barIndex - length + 1, length)];
double lowerLValue = low[ArrayMinimum(low, barIndex - length + 1, length)];
//
double lDelta = MathAbs(upperLValue - lowerLValue);
double lOffsetValue = lDelta * (offset) * 0.01;
//
upperLBuffer[barIndex] = upperLValue - lOffsetValue;
lowerLBuffer[barIndex] = lowerLValue + lOffsetValue;
}
//
return rates_total;
}
//
// CUSTOM Functions ...
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
result = length >= 7;
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// Open ...
ENUM_DRAW_TYPE openDrawType = showOpen ? DRAW_LINE : DRAW_NONE;
//
// UPPER ...
SetIndexBuffer(upperOBufferIndex, upperOBuffer, INDICATOR_DATA);
PlotIndexSetInteger(upperOBufferIndex, PLOT_SHOW_DATA, showOpen);
PlotIndexSetDouble(upperOBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(upperOBufferIndex, PLOT_DRAW_TYPE, openDrawType);
//
// LOWER ...
SetIndexBuffer(lowerOBufferIndex, lowerOBuffer, INDICATOR_DATA);
PlotIndexSetInteger(lowerOBufferIndex, PLOT_SHOW_DATA, showOpen);
PlotIndexSetDouble(lowerOBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(lowerOBufferIndex, PLOT_DRAW_TYPE, openDrawType);
//
// Close ...
ENUM_DRAW_TYPE closeDrawType = showClose ? DRAW_LINE : DRAW_NONE;
//
// UPPER ...
SetIndexBuffer(upperCBufferIndex, upperCBuffer, INDICATOR_DATA);
PlotIndexSetInteger(upperCBufferIndex, PLOT_SHOW_DATA, showClose);
PlotIndexSetDouble(upperCBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(upperCBufferIndex, PLOT_DRAW_TYPE, closeDrawType);
//
// LOWER ...
SetIndexBuffer(lowerCBufferIndex, lowerCBuffer, INDICATOR_DATA);
PlotIndexSetInteger(lowerCBufferIndex, PLOT_SHOW_DATA, showClose);
PlotIndexSetDouble(lowerCBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(lowerCBufferIndex, PLOT_DRAW_TYPE, closeDrawType);
//
// High ...
ENUM_DRAW_TYPE highDrawType = showHigh ? DRAW_LINE : DRAW_NONE;
//
// UPPER ...
SetIndexBuffer(upperHBufferIndex, upperHBuffer, INDICATOR_DATA);
PlotIndexSetInteger(upperHBufferIndex, PLOT_SHOW_DATA, showHigh);
PlotIndexSetDouble(upperHBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(upperHBufferIndex, PLOT_DRAW_TYPE, highDrawType);
//
// LOWER ...
SetIndexBuffer(lowerHBufferIndex, lowerHBuffer, INDICATOR_DATA);
PlotIndexSetInteger(lowerHBufferIndex, PLOT_SHOW_DATA, showHigh);
PlotIndexSetDouble(lowerHBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(lowerHBufferIndex, PLOT_DRAW_TYPE, highDrawType);
//
// Low ...
ENUM_DRAW_TYPE lowDrawType = showLow ? DRAW_LINE : DRAW_NONE;
//
// UPPER ...
SetIndexBuffer(upperLBufferIndex, upperLBuffer, INDICATOR_DATA);
PlotIndexSetInteger(upperLBufferIndex, PLOT_SHOW_DATA, showLow);
PlotIndexSetDouble(upperLBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(upperLBufferIndex, PLOT_DRAW_TYPE, lowDrawType);
//
// LOWER ...
SetIndexBuffer(lowerLBufferIndex, lowerLBuffer, INDICATOR_DATA);
PlotIndexSetInteger(lowerLBufferIndex, PLOT_SHOW_DATA, showLow);
PlotIndexSetDouble(lowerLBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(lowerLBufferIndex, PLOT_DRAW_TYPE, lowDrawType);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
+479
View File
@@ -0,0 +1,479 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// --------------------------------------------
// Name: XHK
// Description: Hiken Ashi ...
// Market Analysor ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XHK Indicator"
#property strict
//
// Constants ...
//
// Indicator Short Name ...
#define ShortName "XHK"
//
// Imports ...
#include <MovingAverages.mqh>
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// Inputs ...
//
input group "Market";
input int smoothingLength = 17; // Smoothing Length
//
input group "Presentation";
input bool drawHikenAshi = true; // Draw Hiken Ashi
input bool drawSmoothedHikenAshi = true; // Draw Smoothed Hiken Ashi
//
// Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 10
#property indicator_plots 10
//
// Buffers ...
//
// Open ...
#define openBufferIndex 0
double openBuffer[];
//
// High ...
#define highBufferIndex 1
double highBuffer[];
//
// Low ...
#define lowBufferIndex 2
double lowBuffer[];
//
// Close ...
#define closeBufferIndex 3
double closeBuffer[];
//
// Candle Color ...
#define candleColorBufferIndex 4
double candleColorBuffer[];
//
#define candlesBufferIndex 0
//
#property indicator_label1 "XHK Open;XHK High;XHK Low;XHK Close"
#property indicator_type1 DRAW_COLOR_CANDLES
#property indicator_color1 CLR_NONE, clrAqua, clrMagenta
//
// SM Open ...
#define openSMBufferIndex 5
double openSMBuffer[];
//
// SM High ...
#define highSMBufferIndex 6
double highSMBuffer[];
//
// SM Low ...
#define lowSMBufferIndex 7
double lowSMBuffer[];
//
// SM Close ...
#define closeSMBufferIndex 8
double closeSMBuffer[];
//
// SM Candle Color ...
#define candleColorSMBufferIndex 9
double candleColorSMBuffer[];
//
#define candlesSMBufferIndex 1
//
#property indicator_label2 "XSMHK Open;XSMHK High;XSMHK Low;XSMHK Close"
#property indicator_type2 DRAW_COLOR_CANDLES
#property indicator_color2 CLR_NONE, clrDarkGreen, clrDarkRed
//
// Variables, Properties and etc ...
//
int maxLength;
//
double mHideColorIDX = 0;
//
// Event Handlers ...
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i, prev_calculated, rates_total, open, high, close, low);
}
//
CalculateSM(rates_total, prev_calculated);
//
return rates_total;
}
//
// Functions ...
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = true;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// Candles Color ...
ArraySetAsSeries(candleColorBuffer, true);
SetIndexBuffer(candleColorBufferIndex, candleColorBuffer, INDICATOR_COLOR_INDEX);
//
// Set EMPTY_VALUE on Candles Buffer ...
PlotIndexSetDouble(candlesBufferIndex, PLOT_EMPTY_VALUE, 0.0);
//
PlotIndexSetInteger(candlesBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(candleColorBufferIndex, PLOT_SHOW_DATA, false);
//
// Open ...
ArraySetAsSeries(openBuffer, true);
PlotIndexSetInteger(openBufferIndex, PLOT_SHOW_DATA, false);
SetIndexBuffer(openBufferIndex, openBuffer, INDICATOR_DATA);
//
// High ...
ArraySetAsSeries(highBuffer, true);
SetIndexBuffer(highBufferIndex, highBuffer, INDICATOR_DATA);
PlotIndexSetInteger(highBufferIndex, PLOT_SHOW_DATA, false);
//
// Close ...
ArraySetAsSeries(closeBuffer, true);
SetIndexBuffer(closeBufferIndex, closeBuffer, INDICATOR_DATA);
PlotIndexSetInteger(closeBufferIndex, PLOT_SHOW_DATA, false);
//
// Low ...
ArraySetAsSeries(lowBuffer, true);
SetIndexBuffer(lowBufferIndex, lowBuffer, INDICATOR_DATA);
PlotIndexSetInteger(lowBufferIndex, PLOT_SHOW_DATA, false);
//
// Candles Color ...
ArraySetAsSeries(candleColorSMBuffer, true);
SetIndexBuffer(candleColorSMBufferIndex, candleColorSMBuffer, INDICATOR_COLOR_INDEX);
//
// Set EMPTY_VALUE on Candles Buffer ...
PlotIndexSetDouble(candlesSMBufferIndex, PLOT_EMPTY_VALUE, 0.0);
//
PlotIndexSetInteger(candlesSMBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(candleColorSMBufferIndex, PLOT_SHOW_DATA, false);
//
// Open ...
ArraySetAsSeries(openSMBuffer, true);
PlotIndexSetInteger(openSMBufferIndex, PLOT_SHOW_DATA, false);
SetIndexBuffer(openSMBufferIndex, openSMBuffer, INDICATOR_DATA);
//
// High ...
ArraySetAsSeries(highSMBuffer, true);
SetIndexBuffer(highSMBufferIndex, highSMBuffer, INDICATOR_DATA);
PlotIndexSetInteger(highSMBufferIndex, PLOT_SHOW_DATA, false);
//
// Close ...
ArraySetAsSeries(closeSMBuffer, true);
SetIndexBuffer(closeSMBufferIndex, closeSMBuffer, INDICATOR_DATA);
PlotIndexSetInteger(closeSMBufferIndex, PLOT_SHOW_DATA, false);
//
// Low ...
ArraySetAsSeries(lowSMBuffer, true);
SetIndexBuffer(lowSMBufferIndex, lowSMBuffer, INDICATOR_DATA);
PlotIndexSetInteger(lowSMBufferIndex, PLOT_SHOW_DATA, false);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index, // Selected Bar Index
const int prevCalculated,
const int ratesTotal,
const double &open[],
const double &high[],
const double &close[],
const double &low[] //
)
{
//
double mPrevHKOpenValue;
double mPrevHKCloseValue;
//
if (ArraySize(open) <= bar_index + 1)
{
//
mPrevHKOpenValue = 0;
mPrevHKCloseValue = 0;
}
else
{
//
mPrevHKOpenValue = openBuffer[bar_index + 1];
mPrevHKCloseValue = closeBuffer[bar_index + 1];
}
//
double mHKOpenValue = (mPrevHKOpenValue + mPrevHKCloseValue) / 2;
double mHKCloseValue = (open[bar_index] + high[bar_index] + close[bar_index] + low[bar_index]) / 4;
double mHKHighValue = MathMax(high[bar_index], MathMax(mHKOpenValue, mHKCloseValue));
double mHKLowValue = MathMin(low[bar_index], MathMin(mHKOpenValue, mHKCloseValue));
//
openBuffer[bar_index] = mHKOpenValue;
highBuffer[bar_index] = mHKHighValue;
lowBuffer[bar_index] = mHKLowValue;
closeBuffer[bar_index] = mHKCloseValue;
//
bool isBearish =
//
openBuffer[bar_index] > closeBuffer[bar_index]
//
;
//
candleColorBuffer[bar_index] = !drawHikenAshi
? mHideColorIDX
: isBearish
? 2
: 1;
}
//
// Calculate Smoothed HikenAshi ...
void CalculateSM(
int ratesTotal, // Total Bars
int prevCalculated // Calculated Bars
)
{
//
// Open ...
int calculatedSMHKOpens = ExponentialMAOnBuffer(
ratesTotal,
prevCalculated,
0,
smoothingLength,
openBuffer,
openSMBuffer);
//
// High ...
int calculatedSMHKHighs = ExponentialMAOnBuffer(
ratesTotal,
prevCalculated,
0,
smoothingLength,
highBuffer,
highSMBuffer);
//
// Low ...
int calculatedSMHKLows = ExponentialMAOnBuffer(
ratesTotal,
prevCalculated,
0,
smoothingLength,
lowBuffer,
lowSMBuffer);
//
// Close ...
int calculatedSMHKCloses = ExponentialMAOnBuffer(
ratesTotal,
prevCalculated,
0,
smoothingLength,
closeBuffer,
closeSMBuffer);
//
// Find Calculated Items for Colors ...
int mNumberOfItems = MathMin(calculatedSMHKOpens, calculatedSMHKHighs);
mNumberOfItems = MathMin(mNumberOfItems, calculatedSMHKLows);
mNumberOfItems = MathMin(mNumberOfItems, calculatedSMHKCloses);
//
// Create a Loop for Color of Candles ...
for (int i = 0; i < mNumberOfItems; i++)
{
//
bool isBearish =
//
openSMBuffer[i] > closeSMBuffer[i]
//
;
//
if (drawSmoothedHikenAshi)
{
//
candleColorSMBuffer[i] = isBearish
? 2
: 1;
}
else
{
//
candleColorSMBuffer[i] = mHideColorIDX;
}
}
}
@@ -0,0 +1,583 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XHULL
// Description: Hull Trend Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XHULL Indicator"
#property strict
//
// START Constants ...
//
//
#define ShortName "XHULL"
//
struct XHullData
{
//
double value;
double value3;
//
double wsum1;
double wsum2;
double wsum3;
//
double lsum1;
double lsum2;
double lsum3;
};
//
// END Constants ...
//
//
// START Includes and Imports ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START XSCHULL Class Definition ...
//
//
// a Class For Hull Calculations ...
class XSCHull
{
//
public:
//
// Constructor ...
XSCHull() : mFullPeriod(1), mHalfPeriod(1), mSqrtPeriod(1), mArraySize(-1)
{
//
// These are a way above to assign Private variables at Construct time ...
}
//
// Deconstructor ...
~XSCHull()
{
ArrayFree(mData);
}
//
// Initial Hull ...
bool Init(
int mPeriod,
double mDivisor)
{
//
bool result = false;
//
mFullPeriod = (int)(mPeriod > 1 ? mPeriod : 1);
mHalfPeriod = (int)(mFullPeriod > 1 ? mFullPeriod / (mDivisor > 1 ? mDivisor : 1) : 1);
mSqrtPeriod = (int)MathSqrt(mFullPeriod);
//
mArraySize = -1;
mWeight1 = mWeight2 = mWeight3 = 1;
//
result = true;
//
return result;
}
//
// CalCulate Specific Value ...
double Calculate(
double value,
int i,
int bars)
{
//
double result = 0;
//
if (mArraySize < bars)
{
//
mArraySize = ArrayResize(mData, bars + 500);
if (mArraySize < bars)
return result;
}
//
mData[i].value = value;
if (i > mFullPeriod)
{
//
mData[i].wsum1 = mData[i - 1].wsum1 + value * mHalfPeriod - mData[i - 1].lsum1;
mData[i].lsum1 = mData[i - 1].lsum1 + value - mData[i - mHalfPeriod].value;
mData[i].wsum2 = mData[i - 1].wsum2 + value * mFullPeriod - mData[i - 1].lsum2;
mData[i].lsum2 = mData[i - 1].lsum2 + value - mData[i - mFullPeriod].value;
}
else
{
//
mData[i].wsum1 = mData[i].wsum2 =
mData[i].lsum1 = mData[i].lsum2 = mWeight1 = mWeight2 = 0;
for (int k = 0, w1 = mHalfPeriod, w2 = mFullPeriod; w2 > 0 && i >= k; k++, w1--, w2--)
{
//
if (w1 > 0)
{
//
mData[i].wsum1 += mData[i - k].value * w1;
mData[i].lsum1 += mData[i - k].value;
mWeight1 += w1;
}
//
mData[i].wsum2 += mData[i - k].value * w2;
mData[i].lsum2 += mData[i - k].value;
mWeight2 += w2;
}
}
//
mData[i].value3 = 2.0 * mData[i].wsum1 / mWeight1 - mData[i].wsum2 / mWeight2;
//
if (i > mSqrtPeriod)
{
//
mData[i].wsum3 = mData[i - 1].wsum3 + mData[i].value3 * mSqrtPeriod - mData[i - 1].lsum3;
mData[i].lsum3 = mData[i - 1].lsum3 + mData[i].value3 - mData[i - mSqrtPeriod].value3;
}
else
{
//
mData[i].wsum3 =
mData[i].lsum3 = mWeight3 = 0;
//
for (int k = 0, w3 = mSqrtPeriod; w3 > 0 && i >= k; k++, w3--)
{
//
mData[i].wsum3 += mData[i - k].value3 * w3;
mData[i].lsum3 += mData[i - k].value3;
mWeight3 += w3;
}
}
//
result = mData[i].wsum3 / mWeight3;
//
return result;
}
//
// Protected ...
protected:
//
// Private ...
private:
//
int mFullPeriod;
int mHalfPeriod;
int mSqrtPeriod;
int mArraySize;
double mWeight1;
double mWeight2;
double mWeight3;
//
XHullData mData[];
};
//
// END XSCHULL Class Definition ...
//
//
// START Inputs ...
//
//
input group "Market";
input int length = 72; // Length
input double divisor = 2.0; // Divisor (Speed)
//
input group "Calculation";
input ENUM_APPLIED_PRICE upAppliedTo = PRICE_HIGH; // Up Zone Applied to
input ENUM_APPLIED_PRICE downAppliedTo = PRICE_LOW; // Down Zone Applied to
//
input group "Presentation";
input bool showUpZone = true; // Show Up Zone
input bool showDownZone = true; // Show Down Zone
//
// END Inputs ...
//
//
// START Buffers ...
//
//
#property indicator_chart_window
//
#property indicator_buffers 4
#property indicator_plots 4
//
// UP Zone ...
//
#define upZoneBufferIndex 0
#define upZoneColorBufferIndex 1
//
double upZoneBuffer[];
double upZoneColorBuffer[];
//
#property indicator_label1 "XHULL Up"
#property indicator_type1 DRAW_COLOR_LINE
#property indicator_color1 clrLightGray, clrAqua, clrMagenta
#property indicator_width1 1
//
// DOWN Zone ...
//
#define downZoneBufferIndex 2
#define downZoneColorBufferIndex 3
//
double downZoneBuffer[];
double downZoneColorBuffer[];
//
#property indicator_label2 "XHULL Down"
#property indicator_type2 DRAW_COLOR_LINE
#property indicator_color2 clrLightGray, clrAqua, clrMagenta
#property indicator_width2 1
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
XSCHull *mUpZHull;
XSCHull *mDownZHull;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Make an Instance of Hull Class ...
//
mUpZHull = new XSCHull();
mUpZHull.Init(
length,
divisor);
//
mDownZHull = new XSCHull();
mDownZHull.Init(
length,
divisor);
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart mPeriod is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
delete mUpZHull;
delete mDownZHull;
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
// this counts Available Bars ...
int limit;
//
limit = prev_calculated - 1;
if (limit < 0)
{
limit = 0;
}
//
// Main Loop ...
for (int i = limit; i < rates_total && !IsStopped(); i++)
{
//
double upPrice = getPrice(
upAppliedTo,
open, high, low, close, i);
//
double downPrice = getPrice(
downAppliedTo,
open, high, low, close, i);
//
CalculateBuffers(
i,
rates_total,
upPrice,
downPrice);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = true;
//
result =
length >= 9 &&
divisor >= 0.5;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = length;
//
return result;
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
//
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// UP Zone ...
//
// Draw Type ...
ENUM_DRAW_TYPE upZoneDrawType = showUpZone ? DRAW_COLOR_LINE : DRAW_NONE;
//
// Buffer ...
SetIndexBuffer(upZoneBufferIndex, upZoneBuffer, INDICATOR_DATA);
PlotIndexSetInteger(upZoneBufferIndex, PLOT_SHOW_DATA, showUpZone);
PlotIndexSetInteger(upZoneBufferIndex, PLOT_DRAW_TYPE, upZoneDrawType);
//
// Color Buffer ...
SetIndexBuffer(upZoneColorBufferIndex, upZoneColorBuffer, INDICATOR_COLOR_INDEX);
//
// DOWN Zone ...
//
// Draw Type ...
ENUM_DRAW_TYPE downZoneDrawType = showDownZone ? DRAW_COLOR_LINE : DRAW_NONE;
//
// Buffer ...
SetIndexBuffer(downZoneBufferIndex, downZoneBuffer, INDICATOR_DATA);
PlotIndexSetInteger(downZoneBufferIndex - 1, PLOT_SHOW_DATA, showDownZone);
PlotIndexSetInteger(downZoneBufferIndex - 1, PLOT_DRAW_TYPE, downZoneDrawType);
//
// Color Buffer ...
SetIndexBuffer(downZoneColorBufferIndex, downZoneColorBuffer, INDICATOR_COLOR_INDEX);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index, // Selected Bar Index
int ratesTotal, // Total Rates
double upPrice, // Up Price ...
double downPrice // Down Price ...
)
{
//
double upValue = mUpZHull.Calculate(
upPrice,
bar_index,
ratesTotal);
upZoneBuffer[bar_index] = upValue;
double upColorIDX = (bar_index > 0)
? (upZoneBuffer[bar_index] > upZoneBuffer[bar_index - 1])
? 1
: (upZoneBuffer[bar_index] < upZoneBuffer[bar_index - 1])
? 2
: upZoneColorBuffer[bar_index - 1]
: 0;
upZoneColorBuffer[bar_index] = upColorIDX;
//
double downValue = mDownZHull.Calculate(
downPrice,
bar_index,
ratesTotal);
downZoneBuffer[bar_index] = downValue;
double downColorIDX = (bar_index > 0)
? (downZoneBuffer[bar_index] > downZoneBuffer[bar_index - 1])
? 1
: (downZoneBuffer[bar_index] < downZoneBuffer[bar_index - 1])
? 2
: downZoneColorBuffer[bar_index - 1]
: 0;
downZoneColorBuffer[bar_index] = downColorIDX;
}
//
// END Functions ...
//
//
// TEMPLATE Function ...
template <typename T>
double getPrice(ENUM_APPLIED_PRICE tprice, T &open[], T &high[], T &low[], T &close[], int i)
{
switch (tprice)
{
case PRICE_CLOSE:
return (close[i]);
case PRICE_OPEN:
return (open[i]);
case PRICE_HIGH:
return (high[i]);
case PRICE_LOW:
return (low[i]);
case PRICE_MEDIAN:
return ((high[i] + low[i]) / 2.0);
case PRICE_TYPICAL:
return ((high[i] + low[i] + close[i]) / 3.0);
case PRICE_WEIGHTED:
return ((high[i] + low[i] + close[i] + close[i]) / 4.0);
}
return (0);
}
@@ -0,0 +1,846 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// -------------------------------------------------
// Name: XICH
// Description: Ichimoku Kinko Hyo ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XICH Indicator"
#property strict
//
// START Constants ...
//
//
// Indicator Short Name ...
#define ShortName "XICH"
//
// Ichimoku Golden Numbers ...
enum ENUM_X_ICHIMOKU_GOLDEN_NUMBERS
{
X_ICH_BASE = 9,
X_ICH_GOLDEN = 17,
X_ICH_CYCLE = 26,
X_ICH_PERIOD = 35,
X_ICH_STAR = 45,
X_ICH_MED = 52,
X_ICH_LONG = 63,
X_ICH_FULL = 72
};
//
// Ichimoku Lines Calculator Mode ...
enum ENUM_X_ICHIMOKU_CALCULATION_MODE
{
//
X_XICH_HH_LL_MODE = 1, // Highest High and Lowest Low
X_XICH_HO_LC_MODE = 2, // Highest Open and Lowest Close
};
//
// END Constants ...
//
//
// START Inputs ...
//
//
// ICHIMOKU Kinko Hyo ...
//
// TENKANSEN ...
input group "Tenkan Sen";
input int tenkanSenLength = 9; // Length
input ENUM_X_ICHIMOKU_CALCULATION_MODE tenkanSenMode = X_XICH_HH_LL_MODE; // Calculation Mode
//
// KIJUNSEN ...
input group "Kijun Sen";
input int kijunSenLength = 26; // Length
input ENUM_X_ICHIMOKU_CALCULATION_MODE kijunSenMode = X_XICH_HH_LL_MODE; // Calculation Mode
//
// SENKOUSPANB ...
input group "Senkou Span B";
input int senkouSpanBLength = 52; // Length
input ENUM_X_ICHIMOKU_CALCULATION_MODE senkouSpanBMode = X_XICH_HH_LL_MODE; // Calculation Mode
//
// CHIKOUSPAN ...
input group "Chikou Span";
input ENUM_APPLIED_PRICE chikuoSpanAppliedTo = PRICE_CLOSE; // Price Type
//
input group "Presentation";
input bool showTenkanSen = true; // Show Tenkan Sen
input bool showKijunSen = true; // Show Kijun Sen
input bool showKijunSenPlus = false; // Show Kijun Sen +
input bool showKijunSenNegative = false; // Show Kijun Sen -
input bool showChikouSpan = true; // Show Chikou Span
input bool showSenkouSpanA = true; // Show Senkou Span A
input bool showSenkouSpanB = true; // Show Senkou Span B
input bool showKumo = true; // Show Kumo
input bool shiftKumo = true; // Shift Kumo to Future
//
// END Inputs ...
//
//
// START Includes and Imports ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 15
#property indicator_plots 8
//
// PLOTTED Buffers ...
//
// ICHIMOKU ...
//
// TENKANSEN ...
//
#define tenkanSenBufferIndex 0
double tenkanSenBuffer[];
//
#property indicator_label1 "XICH TK"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrBrown
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
// KIJUNSEN ...
//
#define kijunSenBufferIndex 1
double kijunSenBuffer[];
//
#property indicator_label2 "XICH KJ"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrDodgerBlue
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//
#define kijunSenPlusBufferIndex 2
double kijunSenPlusBuffer[];
//
#property indicator_label3 "XICH KJ+"
#property indicator_type3 DRAW_LINE
#property indicator_color3 clrMediumTurquoise
#property indicator_style3 STYLE_DOT
#property indicator_width3 1
//
#define kijunSenNegativeBufferIndex 3
double kijunSenNegativeBuffer[];
//
#property indicator_label4 "XICH KJ-"
#property indicator_type4 DRAW_LINE
#property indicator_color4 clrDarkSeaGreen
#property indicator_style4 STYLE_DOT
#property indicator_width4 1
//
// CHIKOUSPAN ...
//
#define chikouSpanBufferIndex 4
double chikouSpanBuffer[];
//
#property indicator_label5 "XICH CS"
#property indicator_type5 DRAW_LINE
#property indicator_color5 clrDarkGreen
#property indicator_style5 STYLE_SOLID
#property indicator_width5 1
//
#define senkouABufferIndex 5
double senkouABuffer[];
//
#property indicator_label6 "XICH SSA"
#property indicator_type6 DRAW_LINE
#property indicator_color6 clrLightGray
#property indicator_style6 STYLE_DASHDOTDOT
#property indicator_width6 1
//
#define senkouBBufferIndex 6
double senkouBBuffer[];
//
#property indicator_label7 "XICH SSB"
#property indicator_type7 DRAW_LINE
#property indicator_color7 clrLightGray
#property indicator_style7 STYLE_DASHDOTDOT
#property indicator_width7 1
//
// KUMO ...
//
// SENKOUSPANA ...
//
#define senkouSpanABufferIndex 7
double senkouSpanABuffer[];
//
// SENKOUSPANB ...
//
#define senkouSpanBBufferIndex 8
double senkouSpanBBuffer[];
//
// KUMOCLOUD ...
//
#define kumoBufferIndex 7
//
#property indicator_label8 "XICH Kumo"
#property indicator_type8 DRAW_FILLING
#property indicator_color8 clrAqua, clrMagenta
#property indicator_style8 STYLE_SOLID
#property indicator_width8 1
//
// DATA Buffers ...
//
#define dTenkanBufferIndex 9
double dTenkanBuffer[];
//
#define dKijunBufferIndex 10
double dKijunBuffer[];
//
#define dChikouBufferIndex 11
double dChikouBuffer[];
//
#define dSSABufferIndex 12
double dSSABuffer[];
//
#define dSSBBufferIndex 13
double dSSBBuffer[];
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
int mHandler;
//
ENUM_SERIESMODE mTenkanSenTopMode = NULL;
ENUM_SERIESMODE mTenkanSenBottomMode = NULL;
//
ENUM_SERIESMODE mKijunSenTopMode = NULL;
ENUM_SERIESMODE mKijunSenBottomMode = NULL;
//
ENUM_SERIESMODE mSenkouSpanBTopMode = NULL;
ENUM_SERIESMODE mSenkouSpanBBottomMode = NULL;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Init Handler ...
mHandler = iIchimoku(
_Symbol,
_Period,
tenkanSenLength,
kijunSenLength,
senkouSpanBLength);
if (mHandler == INVALID_HANDLE)
{
return INIT_FAILED;
}
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
IndicatorRelease(mHandler);
}
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// Check Calculated Bars ...
int ichCalculatedBars = BarsCalculated(mHandler);
if (ichCalculatedBars < maxLength)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
int copiedTenkans = CopyBuffer(mHandler, TENKANSEN_LINE, 0, limit, dTenkanBuffer);
int copiedKijuns = CopyBuffer(mHandler, KIJUNSEN_LINE, 0, limit, dKijunBuffer);
int copiedChikous = CopyBuffer(mHandler, CHIKOUSPAN_LINE, 0, limit, dChikouBuffer);
int copiedSSAs = CopyBuffer(mHandler, SENKOUSPANA_LINE, 0, limit, dSSABuffer);
int copiedSSBs = CopyBuffer(mHandler, SENKOUSPANB_LINE, 0, limit, dSSBBuffer);
if (
copiedSSAs < 0 ||
copiedSSBs < 0 ||
copiedKijuns < 0 ||
copiedTenkans < 0 ||
copiedChikous < 0)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result =
//
(tenkanSenLength > 2 &&
kijunSenLength > tenkanSenLength &&
senkouSpanBLength > kijunSenLength)
//
;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
// Ichimoku ...
result = MathMax(result, tenkanSenLength);
result = MathMax(result, kijunSenLength);
result = MathMax(result, senkouSpanBLength);
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// ICHIMOKU ...
//
// TENKANSEN ...
//
ENUM_DRAW_TYPE tenkanSenDrawType = showTenkanSen ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(tenkanSenBuffer, true);
SetIndexBuffer(tenkanSenBufferIndex, tenkanSenBuffer, INDICATOR_DATA);
PlotIndexSetInteger(tenkanSenBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(tenkanSenBufferIndex, PLOT_SHOW_DATA, showTenkanSen);
PlotIndexSetInteger(tenkanSenBufferIndex, PLOT_DRAW_TYPE, tenkanSenDrawType);
//
// KIJUNSEN ...
//
ENUM_DRAW_TYPE kijunSenDrawType = showKijunSen ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(kijunSenBuffer, true);
SetIndexBuffer(kijunSenBufferIndex, kijunSenBuffer, INDICATOR_DATA);
PlotIndexSetInteger(kijunSenBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(kijunSenBufferIndex, PLOT_SHOW_DATA, showKijunSen);
PlotIndexSetInteger(kijunSenBufferIndex, PLOT_DRAW_TYPE, kijunSenDrawType);
//
// KIJUNSEN Plus ...
//
ENUM_DRAW_TYPE kijunSenPlusDrawType = showKijunSenPlus ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(kijunSenPlusBuffer, true);
SetIndexBuffer(kijunSenPlusBufferIndex, kijunSenPlusBuffer, INDICATOR_DATA);
PlotIndexSetInteger(kijunSenPlusBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(kijunSenPlusBufferIndex, PLOT_SHIFT, kijunSenLength);
PlotIndexSetInteger(kijunSenPlusBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(kijunSenPlusBufferIndex, PLOT_DRAW_TYPE, kijunSenPlusDrawType);
//
// KIJUNSEN Negative ...
//
ENUM_DRAW_TYPE kijunSenNegativeDrawType = showKijunSenNegative ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(kijunSenNegativeBuffer, true);
SetIndexBuffer(kijunSenNegativeBufferIndex, kijunSenNegativeBuffer, INDICATOR_DATA);
PlotIndexSetInteger(kijunSenNegativeBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(kijunSenNegativeBufferIndex, PLOT_SHIFT, -kijunSenLength);
PlotIndexSetInteger(kijunSenNegativeBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(kijunSenNegativeBufferIndex, PLOT_DRAW_TYPE, kijunSenNegativeDrawType);
//
// CHIKOUSPAN ...
//
ENUM_DRAW_TYPE chikouSpanDrawType = showChikouSpan ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(chikouSpanBuffer, true);
SetIndexBuffer(chikouSpanBufferIndex, chikouSpanBuffer, INDICATOR_DATA);
PlotIndexSetInteger(chikouSpanBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(chikouSpanBufferIndex, PLOT_SHIFT, -kijunSenLength);
PlotIndexSetInteger(chikouSpanBufferIndex, PLOT_SHOW_DATA, showChikouSpan);
PlotIndexSetInteger(chikouSpanBufferIndex, PLOT_DRAW_TYPE, chikouSpanDrawType);
//
// SENKOUSPAN A and B ...
int shiftSize = shiftKumo ? kijunSenLength : 0;
//
// SENKOUSPANA ...
ENUM_DRAW_TYPE senkouSpanADrawType = showSenkouSpanA ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(senkouABuffer, true);
SetIndexBuffer(senkouABufferIndex, senkouABuffer, INDICATOR_DATA);
PlotIndexSetInteger(senkouABufferIndex, PLOT_SHIFT, shiftSize);
PlotIndexSetInteger(senkouABufferIndex, PLOT_SHOW_DATA, showSenkouSpanA);
PlotIndexSetInteger(senkouABufferIndex, PLOT_DRAW_TYPE, senkouSpanADrawType);
//
// SENKOUSPANB ...
ENUM_DRAW_TYPE senkouSpanBDrawType = showSenkouSpanB ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(senkouBBuffer, true);
SetIndexBuffer(senkouBBufferIndex, senkouBBuffer, INDICATOR_DATA);
PlotIndexSetInteger(senkouBBufferIndex, PLOT_SHIFT, shiftSize);
PlotIndexSetInteger(senkouBBufferIndex, PLOT_SHOW_DATA, showSenkouSpanB);
PlotIndexSetInteger(senkouBBufferIndex, PLOT_DRAW_TYPE, senkouSpanBDrawType);
//
// KUMO ...
//
// SENKOUSPANA ...
ArraySetAsSeries(senkouSpanABuffer, true);
SetIndexBuffer(senkouSpanABufferIndex, senkouSpanABuffer, INDICATOR_DATA);
PlotIndexSetInteger(senkouSpanABufferIndex, PLOT_DRAW_BEGIN, maxLength);
//
// SENKOUSPANB ...
ArraySetAsSeries(senkouSpanBBuffer, true);
SetIndexBuffer(senkouSpanBBufferIndex, senkouSpanBBuffer, INDICATOR_DATA);
PlotIndexSetInteger(senkouSpanBBufferIndex, PLOT_DRAW_BEGIN, maxLength);
//
// KUMO ...
//
ENUM_DRAW_TYPE kumoDrawType = showKumo ? DRAW_FILLING : DRAW_NONE;
//
PlotIndexSetInteger(kumoBufferIndex, PLOT_SHIFT, shiftSize);
PlotIndexSetInteger(kumoBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(kumoBufferIndex, PLOT_DRAW_TYPE, kumoDrawType);
//
// DATA Buffers ...
//
// D Tenkan ...
ArraySetAsSeries(dTenkanBuffer, true);
SetIndexBuffer(dTenkanBufferIndex, dTenkanBuffer, INDICATOR_CALCULATIONS);
//
// D Kijun ...
ArraySetAsSeries(dKijunBuffer, true);
SetIndexBuffer(dKijunBufferIndex, dKijunBuffer, INDICATOR_CALCULATIONS);
//
// D Chikou ...
ArraySetAsSeries(dChikouBuffer, true);
SetIndexBuffer(dChikouBufferIndex, dChikouBuffer, INDICATOR_CALCULATIONS);
//
// D SSA ...
ArraySetAsSeries(dSSABuffer, true);
SetIndexBuffer(dSSABufferIndex, dSSABuffer, INDICATOR_CALCULATIONS);
//
// D SSB ...
ArraySetAsSeries(dSSBBuffer, true);
SetIndexBuffer(dSSBBufferIndex, dSSBBuffer, INDICATOR_CALCULATIONS);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index // Selected Bar Index
)
{
//
// ICHIMOKU ...
//
double topValue;
double bottomValue;
//
// TENKANSEN ...
//
// Extract Tenkan Sen Top/Bottom Calculation Mode based on User Input ...
if (mTenkanSenTopMode == NULL || mTenkanSenBottomMode == NULL)
{
//
switch (tenkanSenMode)
{
//
case X_XICH_HH_LL_MODE:
//
mTenkanSenTopMode = MODE_HIGH;
mTenkanSenBottomMode = MODE_LOW;
break;
//
case X_XICH_HO_LC_MODE:
//
mTenkanSenTopMode = MODE_OPEN;
mTenkanSenBottomMode = MODE_CLOSE;
break;
}
}
//
XOHCL bar;
bar.Init(
_Symbol,
_Period,
bar_index
//
);
//
// Calculate Top ...
topValue = bar
.FindHighest(
tenkanSenLength,
mTenkanSenTopMode
//
);
//
// Calculate Bottom ...
bottomValue = bar
.FindLowest(
tenkanSenLength,
mTenkanSenBottomMode
//
);
//
double tenkanSenValue = (topValue + bottomValue) / 2;
tenkanSenBuffer[bar_index] = tenkanSenValue;
//
// KIJUNSEN ...
//
// Extract Kijun Sen Top/Bottom Calculation Mode based on User Input ...
if (mKijunSenTopMode == NULL || mKijunSenBottomMode == NULL)
{
//
switch (kijunSenMode)
{
//
case X_XICH_HH_LL_MODE:
//
mKijunSenTopMode = MODE_HIGH;
mKijunSenBottomMode = MODE_LOW;
break;
//
case X_XICH_HO_LC_MODE:
//
mKijunSenTopMode = MODE_OPEN;
mKijunSenBottomMode = MODE_CLOSE;
break;
}
}
//
// Calculate Top ...
topValue = bar
.FindHighest(
kijunSenLength,
mKijunSenTopMode
//
);
//
// Calculate Bottom ...
bottomValue = bar
.FindLowest(
kijunSenLength,
mKijunSenBottomMode
//
);
//
double kijunSenValue = (topValue + bottomValue) / 2;
kijunSenBuffer[bar_index] = kijunSenValue;
//
kijunSenPlusBuffer[bar_index] = kijunSenValue;
kijunSenNegativeBuffer[bar_index] = kijunSenValue;
//
// CHIKOUSPAN ...
double chikouSpanValue = bar
.GetPrice(chikuoSpanAppliedTo);
//
chikouSpanBuffer[bar_index] = chikouSpanValue;
//
// KUMO ...
//
// SENKOUSPANA ...
double senkouSpanAValue = (tenkanSenValue + kijunSenValue) / 2;
senkouABuffer[bar_index] = senkouSpanAValue;
senkouSpanABuffer[bar_index] = senkouSpanAValue;
//
// SENKOUSPANB ...
//
// Extract Senkou Span B Top/Bottom Calculation Mode based on User Input ...
if (mSenkouSpanBTopMode == NULL || mSenkouSpanBBottomMode == NULL)
{
//
switch (senkouSpanBMode)
{
//
case X_XICH_HH_LL_MODE:
//
mSenkouSpanBTopMode = MODE_HIGH;
mSenkouSpanBBottomMode = MODE_LOW;
break;
//
case X_XICH_HO_LC_MODE:
//
mSenkouSpanBTopMode = MODE_OPEN;
mSenkouSpanBBottomMode = MODE_CLOSE;
break;
}
}
//
// Calculate Top ...
topValue = bar
.FindHighest(
senkouSpanBLength,
mSenkouSpanBTopMode
//
);
//
// Calculate Bottom ...
bottomValue = bar
.FindLowest(
senkouSpanBLength,
mSenkouSpanBBottomMode
//
);
//
double senkouSpanBValue = (topValue + bottomValue) / 2;
senkouBBuffer[bar_index] = senkouSpanBValue;
senkouSpanBBuffer[bar_index] = senkouSpanBValue;
}
//
// END Functions ...
//
+446
View File
@@ -0,0 +1,446 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 XMC MA Cross Indicator
// ---------------------------------------------------
// Name: XMC
// Description: Moving Average Crosses
// Market Analysor ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XMC Indicator"
#property strict
//
// START Constants ...
//
//
// Indicator Short Name ...
#define ShortName "XMC"
//
// END Constants ...
//
//
// START Inputs ...
//
//
input group "Fast";
input int fastMaLength = 9; // Length
input int fastMaShift = 0; // Shift
input ENUM_MA_METHOD fastMaMethod = MODE_EMA; // Method
input ENUM_APPLIED_PRICE fastMaAppliedTo = PRICE_CLOSE; // Applied To
//
input group "Slow";
input int slowMaLength = 18; // Length
input int slowMaShift = 0; // Shift
input ENUM_MA_METHOD slowMaMethod = MODE_EMA; // Method
input ENUM_APPLIED_PRICE slowMaAppliedTo = PRICE_CLOSE; // Applied To
//
input group "Verifier";
input int verifierMaLength = 50; // Length
input int verifierMaShift = 0; // Shift
input ENUM_MA_METHOD verifierMaMethod = MODE_EMA; // Method
input ENUM_APPLIED_PRICE verifierMaAppliedTo = PRICE_CLOSE; // Applied To
//
input group "Presentation";
input bool showFastMa = true; // Show Fast
input bool showSlowMa = true; // Show Slow
input bool showVerifierMa = true; // Show Verifier
//
// END Inputs ...
//
//
// START Includes and Imports ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 3
#property indicator_plots 3
//
// PLOTTED Buffers ...
//
// MA ...
//
// FAST ...
#define fastMaBufferIndex 0
double fastMaBuffer[];
//
#property indicator_label1 "XMC MA F"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrYellow
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
// SLOW ...
#define slowMaBufferIndex 1
double slowMaBuffer[];
//
#property indicator_label2 "XMC MA S"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrDarkOrange
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//
// VERIFIER ...
#define verifierMaBufferIndex 2
double verifierMaBuffer[];
//
#property indicator_label3 "XMC MA V"
#property indicator_type3 DRAW_LINE
#property indicator_color3 clrDarkBlue
#property indicator_style3 STYLE_SOLID
#property indicator_width3 2
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
int fastMaHandler = INVALID_HANDLE;
int slowMaHandler = INVALID_HANDLE;
int verifierMaHandler = INVALID_HANDLE;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// MA Initialization ...
//
// FAST ...
fastMaHandler = iMA(
_Symbol,
_Period,
fastMaLength,
fastMaShift,
fastMaMethod,
fastMaAppliedTo);
if (fastMaHandler == INVALID_HANDLE)
{
return INIT_FAILED;
}
//
// SLOW ...
slowMaHandler = iMA(
_Symbol,
_Period,
slowMaLength,
slowMaShift,
slowMaMethod,
slowMaAppliedTo);
if (slowMaHandler == INVALID_HANDLE)
{
return INIT_FAILED;
}
//
// VERIFIER ...
verifierMaHandler = iMA(
_Symbol,
_Period,
verifierMaLength,
verifierMaShift,
verifierMaMethod,
verifierMaAppliedTo);
if (verifierMaHandler == INVALID_HANDLE)
{
return INIT_FAILED;
}
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
IndicatorRelease(fastMaHandler);
IndicatorRelease(slowMaHandler);
IndicatorRelease(verifierMaHandler);
}
//
// Calculations ...
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// Check Calculated Bars ...
int fastMaCalculatedBars = BarsCalculated(fastMaHandler);
int slowMaCalculatedBars = BarsCalculated(slowMaHandler);
int verifierMaCalculatedBars = BarsCalculated(verifierMaHandler);
if (fastMaCalculatedBars < maxLength ||
slowMaCalculatedBars < maxLength ||
verifierMaCalculatedBars < maxLength)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
int copiedFastMas = CopyBuffer(fastMaHandler, 0, 0, limit, fastMaBuffer);
int copiedSlowMas = CopyBuffer(slowMaHandler, 0, 0, limit, slowMaBuffer);
int copiedVerifierMas = CopyBuffer(verifierMaHandler, 0, 0, limit, verifierMaBuffer);
if (copiedFastMas <= 0 ||
copiedSlowMas <= 0 ||
copiedVerifierMas <= 0)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result =
//
// Validate Ma ...
(fastMaLength > 2 &&
slowMaLength > fastMaLength &&
verifierMaLength > slowMaLength)
//
;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
// Ma ...
result = MathMax(result, fastMaLength);
result = MathMax(result, slowMaLength);
result = MathMax(result, verifierMaLength);
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// MA ...
//
// FAST ...
ENUM_DRAW_TYPE fastMaDrawType = showFastMa ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(fastMaBuffer, true);
SetIndexBuffer(fastMaBufferIndex, fastMaBuffer, INDICATOR_DATA);
PlotIndexSetInteger(fastMaBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fastMaBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(fastMaBufferIndex, PLOT_DRAW_TYPE, fastMaDrawType);
//
// SLOW ...
ENUM_DRAW_TYPE slowMaDrawType = showSlowMa ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(slowMaBuffer, true);
SetIndexBuffer(slowMaBufferIndex, slowMaBuffer, INDICATOR_DATA);
PlotIndexSetInteger(slowMaBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slowMaBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(slowMaBufferIndex, PLOT_DRAW_TYPE, slowMaDrawType);
//
// VERIFIER ...
ENUM_DRAW_TYPE verifierMaDrawType = showVerifierMa ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(verifierMaBuffer, true);
SetIndexBuffer(verifierMaBufferIndex, verifierMaBuffer, INDICATOR_DATA);
PlotIndexSetInteger(verifierMaBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(verifierMaBufferIndex, PLOT_SHOW_DATA, false);
PlotIndexSetInteger(verifierMaBufferIndex, PLOT_DRAW_TYPE, verifierMaDrawType);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
//
string indicatorShortName = "";
StringConcatenate(indicatorShortName, ShortName, "");
//
IndicatorSetString(INDICATOR_SHORTNAME, indicatorShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index // Selected Bar Index
)
{
}
//
// END Functions ...
//
@@ -0,0 +1,238 @@
///////////////////////////////////////////////////////
// SaherElm IT Center MQL5 Indicator
// -------------------------------------------
// Name: XMidTest
// Description: DONCHAIN Channel ...
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XMidTest Indicator"
#property strict
//
// Imports ...
#include "../Classes/Indicators/x-saherelm.mid.class.mq5"
//
#define ShortName "XMidTest"
//
#property indicator_chart_window
//
#property indicator_buffers 1
#property indicator_plots 1
//
// Variables ...
XSCMid *mMid;
//
#property indicator_type1 DRAW_LINE
double mainBuffer[];
double mainColorBuffer[];
//
// Initialization ...
int OnInit()
{
//
// Initialize Indicator Class ...
bool isInited = InitIndicatorClass();
if (!isInited)
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
mMid.DeInit(reason);
delete mMid;
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
// this counts Available Bars ...
int limit;
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
int maxLength = mMid.GetInputs().Max();
//
int midCalculatedBars = mMid.GetCalculatedBars();
if (midCalculatedBars < 0)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
int midMainCopiedItems = mMid.CopyBufferValue(
GetTitle(XSCMID_MAIN_LINE),
mainBuffer,
0,
limit //
);
if (midMainCopiedItems <= 0)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i);
}
//
return rates_total;
}
//
// CUSTOM Functions ...
//
// Validate Input Args for Initialization ...
bool InitIndicatorClass()
{
//
bool result = false;
//
// Initialize and Prepare
// Inputs of Indicator ...
XSCMidInputs inputs;
result = inputs.Init();
if (!result)
{
return result;
}
//
// Instantiate Class ...
mMid = new XSCMid(
_Symbol,
_Period //
);
//
// Now Initialize Indicator Class using Given Inputs ...
result = mMid.Init(
inputs //
);
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// Start Styling and Indexing Buffers ...
//
string bufferLabel = GetTitle(XSCMID_MAIN_LINE);
int mainIDX = mMid.GetBufferIndexByLine(XSCMID_MAIN_LINE);
XBuffer mainBufferStruct;
mMid.GetBufferByLine(
XSCMID_MAIN_LINE,
mainBufferStruct //
);
//
int bufferIndex = 0;
//
int max = mMid.GetInputs().Max();
//
ArraySetAsSeries(mainBuffer, true);
//
XBufferPlotStyle mainBufferStyle;
mainBufferStyle.clr = clrAqua;
mainBufferStyle.type = DRAW_LINE;
mainBufferStyle.width = 3;
//
SetIndexBuffer(
bufferIndex,
mainBuffer,
mainBufferStyle,
mainColorBuffer,
bufferLabel,
true,
EMPTY_VALUE //
);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
void CalculateBuffers(int barIndex)
{
}
@@ -0,0 +1,855 @@
//////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// --------------------------------------
// Name: XMRB
// Description: Moving Average Ribbon
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XMRB Indicator"
#property strict
//
// START Constants ...
//
//
// Indicator Short Name ...
#define ShortName "XMRB"
//
// END Constants ...
//
//
// START Inputs ...
//
//
input group "Ribbon 1";
input int fast1Length = 20; // Fast
input int slow1Length = 50; // Slow
input ENUM_APPLIED_PRICE r1AppliedTo = PRICE_HIGH; // Applied To
//
input group "Ribbon 2";
input int fast2Length = 20; // Fast
input int slow2Length = 50; // Slow
input ENUM_APPLIED_PRICE r2AppliedTo = PRICE_OPEN; // Applied To
//
input group "Ribbon 3";
input int fast3Length = 20; // Fast
input int slow3Length = 50; // Slow
input ENUM_APPLIED_PRICE r3AppliedTo = PRICE_CLOSE; // Applied To
//
input group "Ribbon 4";
input int fast4Length = 20; // Fast
input int slow4Length = 50; // Slow
input ENUM_APPLIED_PRICE r4AppliedTo = PRICE_MEDIAN; // Applied To
//
input group "Ribbon 5";
input int fast5Length = 20; // Fast
input int slow5Length = 50; // Slow
input ENUM_APPLIED_PRICE r5AppliedTo = PRICE_TYPICAL; // Applied To
//
input group "Ribbon 6";
input int fast6Length = 20; // Fast
input int slow6Length = 50; // Slow
input ENUM_APPLIED_PRICE r6AppliedTo = PRICE_LOW; // Applied To
//
input group "Calculation";
input ENUM_MA_METHOD ribbonMode = MODE_EMA; // Mode
//
input group "Presentation";
input bool showFastMa = true; // Show Fast
input bool showSlowMa = true; // Show Slow
input bool showRibbon = false; // Show Ribbon
//
// END Inputs ...
//
//
// START Includes and Imports ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 14
#property indicator_plots 14
//
// PLOTTED Buffers ...
//
// MA ...
//
// FAST ...
#define fastMaBufferIndex 0
double fastMaBuffer[];
//
#property indicator_label1 "XMRB F"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrLime
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
// SLOW ...
#define slowMaBufferIndex 1
double slowMaBuffer[];
//
#property indicator_label2 "XMRB S"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrRed
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//
// DATA Buffers ...
//
// FAST ...
//
#define fast1BufferIndex 2
double fast1Buffer[];
//
#property indicator_label3 "XMRB 1 F"
#property indicator_type3 DRAW_LINE
#property indicator_color3 clrAquamarine
#property indicator_style3 STYLE_DOT
#property indicator_width3 1
//
#define fast2BufferIndex 3
double fast2Buffer[];
//
#property indicator_label4 "XMRB 2 F"
#property indicator_type4 DRAW_LINE
#property indicator_color4 clrAquamarine
#property indicator_style4 STYLE_DOT
#property indicator_width4 1
//
#define fast3BufferIndex 4
double fast3Buffer[];
//
#property indicator_label5 "XMRB 3 F"
#property indicator_type5 DRAW_LINE
#property indicator_color5 clrAquamarine
#property indicator_style5 STYLE_DOT
#property indicator_width5 1
//
#define fast4BufferIndex 5
double fast4Buffer[];
//
#property indicator_label6 "XMRB 4 F"
#property indicator_type6 DRAW_LINE
#property indicator_color6 clrAquamarine
#property indicator_style6 STYLE_DOT
#property indicator_width6 1
//
#define fast5BufferIndex 6
double fast5Buffer[];
//
#property indicator_label7 "XMRB 5 F"
#property indicator_type7 DRAW_LINE
#property indicator_color7 clrAquamarine
#property indicator_style7 STYLE_DOT
#property indicator_width7 1
//
#define fast6BufferIndex 7
double fast6Buffer[];
//
#property indicator_label8 "XMRB 6 F"
#property indicator_type8 DRAW_LINE
#property indicator_color8 clrAquamarine
#property indicator_style8 STYLE_DOT
#property indicator_width8 1
//
// SLOW ...
//
#define slow1BufferIndex 8
double slow1Buffer[];
//
#property indicator_label9 "XMRB 1 S"
#property indicator_type9 DRAW_LINE
#property indicator_color9 clrPlum
#property indicator_style9 STYLE_DOT
#property indicator_width9 1
//
#define slow2BufferIndex 9
double slow2Buffer[];
//
#property indicator_label10 "XMRB 2 S"
#property indicator_type10 DRAW_LINE
#property indicator_color10 clrPlum
#property indicator_style10 STYLE_DOT
#property indicator_width10 1
//
#define slow3BufferIndex 10
double slow3Buffer[];
//
#property indicator_label11 "XMRB 3 S"
#property indicator_type11 DRAW_LINE
#property indicator_color11 clrPlum
#property indicator_style11 STYLE_DOT
#property indicator_width11 1
//
#define slow4BufferIndex 11
double slow4Buffer[];
//
#property indicator_label12 "XMRB 4 S"
#property indicator_type12 DRAW_LINE
#property indicator_color12 clrPlum
#property indicator_style12 STYLE_DOT
#property indicator_width12 1
//
#define slow5BufferIndex 12
double slow5Buffer[];
//
#property indicator_label13 "XMRB 5 S"
#property indicator_type13 DRAW_LINE
#property indicator_color13 clrPlum
#property indicator_style13 STYLE_DOT
#property indicator_width13 1
//
#define slow6BufferIndex 13
double slow6Buffer[];
//
#property indicator_label14 "XMRB 6 S"
#property indicator_type14 DRAW_LINE
#property indicator_color14 clrPlum
#property indicator_style14 STYLE_DOT
#property indicator_width14 1
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
int fast1MaHandler = INVALID_HANDLE;
int fast2MaHandler = INVALID_HANDLE;
int fast3MaHandler = INVALID_HANDLE;
int fast4MaHandler = INVALID_HANDLE;
int fast5MaHandler = INVALID_HANDLE;
int fast6MaHandler = INVALID_HANDLE;
//
int slow1MaHandler = INVALID_HANDLE;
int slow2MaHandler = INVALID_HANDLE;
int slow3MaHandler = INVALID_HANDLE;
int slow4MaHandler = INVALID_HANDLE;
int slow5MaHandler = INVALID_HANDLE;
int slow6MaHandler = INVALID_HANDLE;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Initialize MAs ...
if (!InitializeMas())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
//
IndicatorRelease(fast1MaHandler);
IndicatorRelease(fast2MaHandler);
IndicatorRelease(fast3MaHandler);
IndicatorRelease(fast4MaHandler);
IndicatorRelease(fast5MaHandler);
IndicatorRelease(fast6MaHandler);
//
IndicatorRelease(slow1MaHandler);
IndicatorRelease(slow2MaHandler);
IndicatorRelease(slow3MaHandler);
IndicatorRelease(slow4MaHandler);
IndicatorRelease(slow5MaHandler);
IndicatorRelease(slow6MaHandler);
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// Check Calculated Bars ...
//
int fast1MaCalculatedBars = BarsCalculated(fast1MaHandler);
int fast2MaCalculatedBars = BarsCalculated(fast2MaHandler);
int fast3MaCalculatedBars = BarsCalculated(fast3MaHandler);
int fast4MaCalculatedBars = BarsCalculated(fast4MaHandler);
int fast5MaCalculatedBars = BarsCalculated(fast5MaHandler);
int fast6MaCalculatedBars = BarsCalculated(fast6MaHandler);
//
int slow1MaCalculatedBars = BarsCalculated(slow1MaHandler);
int slow2MaCalculatedBars = BarsCalculated(slow2MaHandler);
int slow3MaCalculatedBars = BarsCalculated(slow3MaHandler);
int slow4MaCalculatedBars = BarsCalculated(slow4MaHandler);
int slow5MaCalculatedBars = BarsCalculated(slow5MaHandler);
int slow6MaCalculatedBars = BarsCalculated(slow6MaHandler);
if (
fast1MaCalculatedBars < maxLength ||
fast2MaCalculatedBars < maxLength ||
fast3MaCalculatedBars < maxLength ||
fast4MaCalculatedBars < maxLength ||
fast5MaCalculatedBars < maxLength ||
fast6MaCalculatedBars < maxLength ||
slow1MaCalculatedBars < maxLength ||
slow2MaCalculatedBars < maxLength ||
slow3MaCalculatedBars < maxLength ||
slow4MaCalculatedBars < maxLength ||
slow5MaCalculatedBars < maxLength ||
slow6MaCalculatedBars < maxLength //
)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
//
int copiedFast1Mas = CopyBuffer(fast1MaHandler, 0, 0, limit, fast1Buffer);
int copiedFast2Mas = CopyBuffer(fast2MaHandler, 0, 0, limit, fast2Buffer);
int copiedFast3Mas = CopyBuffer(fast3MaHandler, 0, 0, limit, fast3Buffer);
int copiedFast4Mas = CopyBuffer(fast4MaHandler, 0, 0, limit, fast4Buffer);
int copiedFast5Mas = CopyBuffer(fast5MaHandler, 0, 0, limit, fast5Buffer);
int copiedFast6Mas = CopyBuffer(fast6MaHandler, 0, 0, limit, fast6Buffer);
//
int copiedSlow1Mas = CopyBuffer(slow1MaHandler, 0, 0, limit, slow1Buffer);
int copiedSlow2Mas = CopyBuffer(slow2MaHandler, 0, 0, limit, slow2Buffer);
int copiedSlow3Mas = CopyBuffer(slow3MaHandler, 0, 0, limit, slow3Buffer);
int copiedSlow4Mas = CopyBuffer(slow4MaHandler, 0, 0, limit, slow4Buffer);
int copiedSlow5Mas = CopyBuffer(slow5MaHandler, 0, 0, limit, slow5Buffer);
int copiedSlow6Mas = CopyBuffer(slow6MaHandler, 0, 0, limit, slow6Buffer);
if (
copiedFast1Mas <= 0 ||
copiedFast2Mas <= 0 ||
copiedFast3Mas <= 0 ||
copiedFast4Mas <= 0 ||
copiedFast5Mas <= 0 ||
copiedFast6Mas <= 0 ||
copiedSlow1Mas <= 0 ||
copiedSlow2Mas <= 0 ||
copiedSlow3Mas <= 0 ||
copiedSlow4Mas <= 0 ||
copiedSlow5Mas <= 0 ||
copiedSlow6Mas <= 0 //
)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result =
//
(fast1Length > 2 &&
fast2Length > 2 &&
fast3Length > 2 &&
fast4Length > 2 &&
fast5Length > 2 &&
fast6Length > 2 &&
slow1Length > fast1Length &&
slow2Length > fast2Length &&
slow3Length > fast3Length &&
slow4Length > fast4Length &&
slow5Length > fast5Length &&
slow6Length > fast6Length
//
)
//
;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
// Ma ...
//
result = MathMax(fast1Length, fast2Length);
result = MathMax(result, fast3Length);
result = MathMax(result, fast4Length);
result = MathMax(result, fast5Length);
result = MathMax(result, fast6Length);
//
result = MathMax(result, slow1Length);
result = MathMax(result, slow2Length);
result = MathMax(result, slow3Length);
result = MathMax(result, slow4Length);
result = MathMax(result, slow5Length);
result = MathMax(result, slow6Length);
//
return result;
}
//
// Initialize Ma Handlers ...
bool InitializeMas()
{
//
bool result = false;
//
fast1MaHandler = iMA(
_Symbol,
_Period,
fast1Length,
0,
ribbonMode,
r1AppliedTo);
fast2MaHandler = iMA(
_Symbol,
_Period,
fast2Length,
0,
ribbonMode,
r2AppliedTo);
fast3MaHandler = iMA(
_Symbol,
_Period,
fast3Length,
0,
ribbonMode,
r3AppliedTo);
fast4MaHandler = iMA(
_Symbol,
_Period,
fast4Length,
0,
ribbonMode,
r4AppliedTo);
fast5MaHandler = iMA(
_Symbol,
_Period,
fast5Length,
0,
ribbonMode,
r5AppliedTo);
fast6MaHandler = iMA(
_Symbol,
_Period,
fast6Length,
0,
ribbonMode,
r6AppliedTo);
//
slow1MaHandler = iMA(
_Symbol,
_Period,
slow1Length,
0,
ribbonMode,
r1AppliedTo);
slow2MaHandler = iMA(
_Symbol,
_Period,
slow2Length,
0,
ribbonMode,
r2AppliedTo);
slow3MaHandler = iMA(
_Symbol,
_Period,
slow3Length,
0,
ribbonMode,
r3AppliedTo);
slow4MaHandler = iMA(
_Symbol,
_Period,
slow4Length,
0,
ribbonMode,
r4AppliedTo);
slow5MaHandler = iMA(
_Symbol,
_Period,
slow5Length,
0,
ribbonMode,
r5AppliedTo);
slow6MaHandler = iMA(
_Symbol,
_Period,
slow6Length,
0,
ribbonMode,
r6AppliedTo);
//
result =
fast1MaHandler != INVALID_HANDLE &&
fast2MaHandler != INVALID_HANDLE &&
fast3MaHandler != INVALID_HANDLE &&
fast4MaHandler != INVALID_HANDLE &&
fast5MaHandler != INVALID_HANDLE &&
fast6MaHandler != INVALID_HANDLE &&
slow1MaHandler != INVALID_HANDLE &&
slow2MaHandler != INVALID_HANDLE &&
slow3MaHandler != INVALID_HANDLE &&
slow4MaHandler != INVALID_HANDLE &&
slow5MaHandler != INVALID_HANDLE &&
slow6MaHandler != INVALID_HANDLE;
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// FAST ...
ENUM_DRAW_TYPE fastDrawType = showFastMa ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(fastMaBuffer, true);
SetIndexBuffer(fastMaBufferIndex, fastMaBuffer, INDICATOR_DATA);
PlotIndexSetInteger(fastMaBufferIndex, PLOT_SHOW_DATA, showFastMa);
PlotIndexSetInteger(fastMaBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fastMaBufferIndex, PLOT_DRAW_TYPE, fastDrawType);
//
// SLOW ...
ENUM_DRAW_TYPE slowDrawType = showSlowMa ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(slowMaBuffer, true);
SetIndexBuffer(slowMaBufferIndex, slowMaBuffer, INDICATOR_DATA);
PlotIndexSetInteger(slowMaBufferIndex, PLOT_SHOW_DATA, showSlowMa);
PlotIndexSetInteger(slowMaBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slowMaBufferIndex, PLOT_DRAW_TYPE, slowDrawType);
//
// DATA ...
ENUM_DRAW_TYPE ribbonDrawType = showRibbon ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(fast1Buffer, true);
SetIndexBuffer(fast1BufferIndex, fast1Buffer, INDICATOR_DATA);
PlotIndexSetInteger(fast1BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(fast1BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fast1BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(fast2Buffer, true);
SetIndexBuffer(fast2BufferIndex, fast2Buffer, INDICATOR_DATA);
PlotIndexSetInteger(fast2BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(fast2BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fast2BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(fast3Buffer, true);
SetIndexBuffer(fast3BufferIndex, fast3Buffer, INDICATOR_DATA);
PlotIndexSetInteger(fast3BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(fast3BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fast3BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(fast4Buffer, true);
SetIndexBuffer(fast4BufferIndex, fast4Buffer, INDICATOR_DATA);
PlotIndexSetInteger(fast4BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(fast4BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fast4BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(fast5Buffer, true);
SetIndexBuffer(fast5BufferIndex, fast5Buffer, INDICATOR_DATA);
PlotIndexSetInteger(fast5BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(fast5BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fast5BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(fast6Buffer, true);
SetIndexBuffer(fast6BufferIndex, fast6Buffer, INDICATOR_DATA);
PlotIndexSetInteger(fast6BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(fast6BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(fast6BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(slow1Buffer, true);
SetIndexBuffer(slow1BufferIndex, slow1Buffer, INDICATOR_DATA);
PlotIndexSetInteger(slow1BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(slow1BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slow1BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(slow2Buffer, true);
SetIndexBuffer(slow2BufferIndex, slow2Buffer, INDICATOR_DATA);
PlotIndexSetInteger(slow2BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(slow2BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slow2BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(slow3Buffer, true);
SetIndexBuffer(slow3BufferIndex, slow3Buffer, INDICATOR_DATA);
PlotIndexSetInteger(slow3BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(slow3BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slow3BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(slow4Buffer, true);
SetIndexBuffer(slow4BufferIndex, slow4Buffer, INDICATOR_DATA);
PlotIndexSetInteger(slow4BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(slow4BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slow4BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(slow5Buffer, true);
SetIndexBuffer(slow5BufferIndex, slow5Buffer, INDICATOR_DATA);
PlotIndexSetInteger(slow5BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(slow5BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slow5BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
//
ArraySetAsSeries(slow6Buffer, true);
SetIndexBuffer(slow6BufferIndex, slow6Buffer, INDICATOR_DATA);
PlotIndexSetInteger(slow6BufferIndex, PLOT_SHOW_DATA, showRibbon);
PlotIndexSetInteger(slow6BufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(slow6BufferIndex, PLOT_DRAW_TYPE, ribbonDrawType);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index // Selected Bar Index
)
{
//
// Retireve Values ...
//
double fast1Value = fast1Buffer[bar_index];
double fast2Value = fast2Buffer[bar_index];
double fast3Value = fast3Buffer[bar_index];
double fast4Value = fast4Buffer[bar_index];
double fast5Value = fast5Buffer[bar_index];
double fast6Value = fast6Buffer[bar_index];
//
double fasts[] = {
fast1Value,
fast2Value,
fast3Value,
fast4Value,
fast5Value,
fast6Value};
//
double slow1Value = slow1Buffer[bar_index];
double slow2Value = slow2Buffer[bar_index];
double slow3Value = slow3Buffer[bar_index];
double slow4Value = slow4Buffer[bar_index];
double slow5Value = slow5Buffer[bar_index];
double slow6Value = slow6Buffer[bar_index];
//
double slows[] = {
slow1Value,
slow2Value,
slow3Value,
slow4Value,
slow5Value,
slow6Value};
//
double fastValue = GetAverage(fasts);
fastMaBuffer[bar_index] = fastValue;
//
double slowValue = GetAverage(slows);
slowMaBuffer[bar_index] = slowValue;
}
//
// END Functions ...
//
@@ -0,0 +1,721 @@
//////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XOSC
// Description: provides some oscillator values
// as empty Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm X121_XAMA Indicator"
#property strict
//
// START Constants ...
//
#define ShortName "XOSC"
//
// END Constants ...
//
//
// START Inputs ...
//
//
// ATR ...
input group "ATR";
input int atrLength = 14; // Length
//
// RVI ...
// The buffer numbers are the following: 0 - MAIN_LINE, 1 - SIGNAL_LINE.
input group "RVI";
input int rviLength = 10; // Length
//
// BULLPOWER ...
input group "Bulls Power";
input int bullpLength = 13; // Length
//
// BEARPOWER ...
input group "Bears Power";
input int bearpLength = 13; // Length
//
// VOLUME ...
input group "Volumes";
input ENUM_APPLIED_VOLUME volumeAppliedTo = VOLUME_TICK; // Applied To
//
// RSI ...
input group "RSI";
input int rsiLength = 14; // Length
input ENUM_APPLIED_PRICE rsiAppliedTo = PRICE_CLOSE; // Applied To
//
// CCI ...
input group "CCI";
input int cciLength = 14; // Length
input ENUM_APPLIED_PRICE cciAppliedTo = PRICE_TYPICAL; // Applied To
//
// STDDEV ...
input group "Standard Deviation";
input int stddevLength = 20; // Length
input int stddevShift = 0; // Shift
input ENUM_MA_METHOD stddevMethod = MODE_SMA; // Mode
input ENUM_APPLIED_PRICE stddevAppliedTo = PRICE_CLOSE; // AppliedTo
//
// MOMENTUM ...
input group "Momentum";
input int momentumLength = 14; // Length
input ENUM_APPLIED_PRICE momentumAppliedTo = PRICE_CLOSE; // Applied To
//
// SAR ...
input group "SAR";
input double sarStep = 0.02; // Step
input double sarMaximum = 0.2; // Maximum
//
// MACD ...
// The buffer numbers are the following: 0 - MAIN_LINE, 1 - SIGNAL_LINE.
input group "MACD";
input int macdFastLength = 12; // Fast Length
input int macdSlowLength = 26; // Slow Length
input int macdSignaLength = 9; // Signal Length
input ENUM_APPLIED_PRICE macdAppliedTo = PRICE_CLOSE; // Applied To
//
// STOCHASTIC ...
// The buffer numbers: 0 - MAIN_LINE, 1 - SIGNAL_LINE.
input group "Stochastic";
input int stochKLength = 5; // K Length
input int stochDLength = 3; // D Length
input int stochSlowing = 3; // Slowing
input ENUM_MA_METHOD stochMaMethod = MODE_SMA; // Ma Method
input ENUM_STO_PRICE stochMode = STO_LOWHIGH; // Calculation Mode
//
// END Inputs ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// START Buffers ...
//
//
#property indicator_chart_window
//
#property indicator_buffers 15
#property indicator_plots 0
//
// ATR ...
#define atrBufferIndex 0
double atrBuffer[];
//
// RVI ...
#define rviMainBufferIndex 1
#define rviSignalBufferIndex 2
double rviMainBuffer[];
double rviSignalBuffer[];
//
// BULLPOWER ...
#define bullPBufferIndex 3
double bullPBuffer[];
//
// BEARPOWER ...
#define bearPBufferIndex 4
double bearPBuffer[];
//
// VOLUME ...
#define volumeBufferIndex 5
double volumeBuffer[];
//
// RSI ...
#define rsiBufferIndex 6
double rsiBuffer[];
//
// CCI ...
#define cciBufferIndex 7
double cciBuffer[];
//
// MOMENTUM ...
#define momentumBufferIndex 8
double momentumBuffer[];
//
// SAR ...
#define sarBufferIndex 9
double sarBuffer[];
//
// MACD ...
#define macdMainBufferIndex 10
#define macdSignalBufferIndex 11
double macdMainBuffer[];
double macdSignalBuffer[];
//
// STOCHASTIC ...
#define stochMainBufferIndex 12
#define stochSignalBufferIndex 13
double stochMainBuffer[];
double stochSignalBuffer[];
//
// STANDARDDEVIATION ...
#define stddevBufferIndex 14
double stddevBuffer[];
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
int atrHandler = INVALID_HANDLE;
int rviHandler = INVALID_HANDLE;
int bullPHandler = INVALID_HANDLE;
int bearPHandler = INVALID_HANDLE;
int volumeHandler = INVALID_HANDLE;
int rsiHandler = INVALID_HANDLE;
int cciHandler = INVALID_HANDLE;
int momentumHandler = INVALID_HANDLE;
int sarHandler = INVALID_HANDLE;
int macdHandler = INVALID_HANDLE;
int stochHandler = INVALID_HANDLE;
int stddevHandler = INVALID_HANDLE;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Initializing Handlers ...
//
// ATR ...
atrHandler = iATR(
_Symbol,
_Period,
atrLength);
//
// RVI ...
rviHandler = iRVI(
_Symbol,
_Period,
rviLength);
//
// BULLSPOWER ...
bullPHandler = iBullsPower(
_Symbol,
_Period,
bullpLength);
//
// BEARSPOWER ...
bearPHandler = iBearsPower(
_Symbol,
_Period,
bullpLength);
//
// VOLUMES ...
volumeHandler = iVolumes(
_Symbol,
_Period,
volumeAppliedTo);
//
// RSI ...
rsiHandler = iRSI(
_Symbol,
_Period,
rsiLength,
rsiAppliedTo);
//
// CCI ...
cciHandler = iCCI(
_Symbol,
_Period,
cciLength,
cciAppliedTo);
//
// MOMENTUM ...
momentumHandler = iMomentum(
_Symbol,
_Period,
momentumLength,
momentumAppliedTo);
//
// SAR ...
sarHandler = iSAR(
_Symbol,
_Period,
sarStep,
sarMaximum);
//
// MACD ...
macdHandler = iMACD(
_Symbol,
_Period,
macdFastLength,
macdSlowLength,
macdSignaLength,
macdAppliedTo);
//
// STOCHASTIC ...
stochHandler = iStochastic(
_Symbol,
_Period,
stochKLength,
stochDLength,
stochSlowing,
stochMaMethod,
stochMode);
//
// STANDARDDEVIATION ...
stddevHandler = iStdDev(
_Symbol,
_Period,
stddevLength,
stddevShift,
stddevMethod,
stddevAppliedTo);
//
bool isAllHandlersInit =
//
atrHandler != INVALID_HANDLE &&
rviHandler != INVALID_HANDLE &&
bullPHandler != INVALID_HANDLE &&
bearPHandler != INVALID_HANDLE &&
volumeHandler != INVALID_HANDLE &&
rsiHandler != INVALID_HANDLE &&
cciHandler != INVALID_HANDLE &&
momentumHandler != INVALID_HANDLE &&
sarHandler != INVALID_HANDLE &&
macdHandler != INVALID_HANDLE &&
stochHandler != INVALID_HANDLE &&
stddevHandler != INVALID_HANDLE
//
;
if (!isAllHandlersInit)
{
return INIT_FAILED;
}
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
IndicatorRelease(atrHandler);
IndicatorRelease(rviHandler);
IndicatorRelease(bullPHandler);
IndicatorRelease(bearPHandler);
IndicatorRelease(volumeHandler);
IndicatorRelease(rsiHandler);
IndicatorRelease(cciHandler);
IndicatorRelease(momentumHandler);
IndicatorRelease(sarHandler);
IndicatorRelease(macdHandler);
IndicatorRelease(stochHandler);
IndicatorRelease(stddevHandler);
}
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// Check Calculated Bars ...
int atrCalculatedBars = BarsCalculated(atrHandler);
int rviCalculatedBars = BarsCalculated(rviHandler);
int bullPCalculatedBars = BarsCalculated(bullPHandler);
int bearPCalculatedBars = BarsCalculated(bearPHandler);
int volumeCalculatedBars = BarsCalculated(volumeHandler);
int rsiCalculatedBars = BarsCalculated(rsiHandler);
int cciCalculatedBars = BarsCalculated(cciHandler);
int momentumCalculatedBars = BarsCalculated(momentumHandler);
int sarCalculatedBars = BarsCalculated(sarHandler);
int macdCalculatedBars = BarsCalculated(macdHandler);
int stochCalculatedBars = BarsCalculated(stochHandler);
int stddevCalculatedBars = BarsCalculated(stddevHandler);
//
bool isCalculatedBarsPassed =
//
atrCalculatedBars >= maxLength &&
rviCalculatedBars >= maxLength &&
bullPCalculatedBars >= maxLength &&
bearPCalculatedBars >= maxLength &&
volumeCalculatedBars >= maxLength &&
rsiCalculatedBars >= maxLength &&
cciCalculatedBars >= maxLength &&
momentumCalculatedBars >= maxLength &&
sarCalculatedBars >= maxLength &&
macdCalculatedBars >= maxLength &&
stochCalculatedBars >= maxLength &&
stddevCalculatedBars >= maxLength
//
;
if (!isCalculatedBarsPassed)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
int atrCopiedItems = CopyBuffer(atrHandler, 0, 0, limit, atrBuffer);
int rviMainCopiedItems = CopyBuffer(rviHandler, MAIN_LINE, 0, limit, rviMainBuffer);
int rviSignalCopiedItems = CopyBuffer(rviHandler, SIGNAL_LINE, 0, limit, rviSignalBuffer);
int bullPCopiedItems = CopyBuffer(bullPHandler, 0, 0, limit, bullPBuffer);
int bearPCopiedItems = CopyBuffer(bearPHandler, 0, 0, limit, bearPBuffer);
int volumeCopiedItems = CopyBuffer(volumeHandler, 0, 0, limit, volumeBuffer);
int rsiCopiedItems = CopyBuffer(rsiHandler, 0, 0, limit, rsiBuffer);
int cciCopiedItems = CopyBuffer(cciHandler, 0, 0, limit, cciBuffer);
int momentumCopiedItems = CopyBuffer(momentumHandler, 0, 0, limit, momentumBuffer);
int sarCopiedItems = CopyBuffer(sarHandler, 0, 0, limit, sarBuffer);
int macdMainCopiedItems = CopyBuffer(macdHandler, MAIN_LINE, 0, limit, macdMainBuffer);
int macdSignalCopiedItems = CopyBuffer(macdHandler, SIGNAL_LINE, 0, limit, macdSignalBuffer);
int stochMainCopiedItems = CopyBuffer(stochHandler, MAIN_LINE, 0, limit, stochMainBuffer);
int stocSignalhCopiedItems = CopyBuffer(stochHandler, SIGNAL_LINE, 0, limit, stochSignalBuffer);
int stddevCopiedItems = CopyBuffer(stddevHandler, 0, 0, limit, stddevBuffer);
//
bool isCopiedBarsPassed =
//
atrCopiedItems > 0 &&
rviMainCopiedItems > 0 &&
rviSignalCopiedItems > 0 &&
bullPCopiedItems > 0 &&
bearPCopiedItems > 0 &&
volumeCopiedItems > 0 &&
rsiCopiedItems > 0 &&
cciCopiedItems > 0 &&
momentumCopiedItems > 0 &&
sarCopiedItems > 0 &&
macdMainCopiedItems > 0 &&
macdSignalCopiedItems > 0 &&
stochMainCopiedItems > 0 &&
stocSignalhCopiedItems > 0 &&
stddevCopiedItems > 0
//
;
if (!isCopiedBarsPassed)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
//
// Do Buffers Calculation ...
// HERE We Do Not anything ...
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
// Validate Args ...
result =
//
atrLength >= 2 &&
rviLength >= 2 &&
bullpLength >= 2 &&
bearpLength >= 2 &&
rsiLength >= 2 &&
cciLength >= 2 &&
momentumLength >= 2 &&
sarStep > 0 &&
sarStep < sarMaximum &&
macdFastLength >= 2 &&
macdSlowLength > macdFastLength &&
macdSignaLength >= 2 &&
stochKLength >= 2 &&
stochDLength >= 2 &&
stochSlowing >= 2 &&
stddevLength >= 2 &&
stddevShift >= 0
//
;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = MathMax(atrLength, rviLength);
result = MathMax(result, bullpLength);
result = MathMax(result, bearpLength);
result = MathMax(result, rsiLength);
result = MathMax(result, cciLength);
result = MathMax(result, momentumLength);
result = MathMax(result, macdFastLength);
result = MathMax(result, macdSlowLength);
result = MathMax(result, macdSignaLength);
result = MathMax(result, stochKLength);
result = MathMax(result, stochDLength);
result = MathMax(result, stochSlowing);
result = MathMax(result, stddevLength);
//
return result;
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// DATA Buffers ...
//
// ATR ...
ArraySetAsSeries(atrBuffer, true);
SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS);
//
// RVI ...
//
// Main ...
ArraySetAsSeries(rviMainBuffer, true);
SetIndexBuffer(rviMainBufferIndex, rviMainBuffer, INDICATOR_CALCULATIONS);
//
// Signal ...
ArraySetAsSeries(rviSignalBuffer, true);
SetIndexBuffer(rviSignalBufferIndex, rviSignalBuffer, INDICATOR_CALCULATIONS);
//
// BULLPOWER ...
ArraySetAsSeries(bullPBuffer, true);
SetIndexBuffer(bullPBufferIndex, bullPBuffer, INDICATOR_CALCULATIONS);
//
// BEARPOWER ...
ArraySetAsSeries(bearPBuffer, true);
SetIndexBuffer(bearPBufferIndex, bearPBuffer, INDICATOR_CALCULATIONS);
//
// VOLUME ...
ArraySetAsSeries(volumeBuffer, true);
SetIndexBuffer(volumeBufferIndex, volumeBuffer, INDICATOR_CALCULATIONS);
//
// RSI ...
ArraySetAsSeries(rsiBuffer, true);
SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_CALCULATIONS);
//
// CCI ...
ArraySetAsSeries(cciBuffer, true);
SetIndexBuffer(cciBufferIndex, cciBuffer, INDICATOR_CALCULATIONS);
//
// MOMENTUM ...
ArraySetAsSeries(momentumBuffer, true);
SetIndexBuffer(momentumBufferIndex, momentumBuffer, INDICATOR_CALCULATIONS);
//
// SAR ...
ArraySetAsSeries(sarBuffer, true);
SetIndexBuffer(sarBufferIndex, sarBuffer, INDICATOR_CALCULATIONS);
//
// STANDARDDEVIATION ...
ArraySetAsSeries(stddevBuffer, true);
SetIndexBuffer(stddevBufferIndex, stddevBuffer, INDICATOR_CALCULATIONS);
//
// MACD ...
//
// Main ...
ArraySetAsSeries(macdMainBuffer, true);
SetIndexBuffer(macdMainBufferIndex, macdMainBuffer, INDICATOR_CALCULATIONS);
//
// Signal ...
ArraySetAsSeries(macdSignalBuffer, true);
SetIndexBuffer(macdSignalBufferIndex, macdSignalBuffer, INDICATOR_CALCULATIONS);
}
//
// END Functions ...
//
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,440 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ----------------------------------------------------
// Name: XSSLC
// Description: SSL Channel Indicator
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XSSLC Indicator"
#property strict
//
// START Constants ...
//
//
// Indicator Short Name ...
#define ShortName "XSSLC"
//
// END Constants ...
//
//
// START Inputs ...
//
//
input group "Market";
input int length = 36; // Length
//
input group "Calculation";
input ENUM_MA_METHOD method = MODE_SMA; // Method
input ENUM_APPLIED_PRICE upAppliedTo = PRICE_HIGH; // Up Applied To
input ENUM_APPLIED_PRICE downAppliedTo = PRICE_LOW; // Down Applied To
//
input group "Presentation";
input bool showUp = true; // Show Up
input bool showDown = true; // Show Down
//
// END Inputs ...
//
//
// START Includes and Imports ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// END Includes and Imports ...
//
//
// START Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 5
#property indicator_plots 2
//
// PLOTTED Buffers ...
//
#define upBufferIndex 0
double upBuffer[];
//
#property indicator_label1 "XSSLC Up"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrLime
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
#define downBufferIndex 1
double downBuffer[];
//
#property indicator_label2 "XSSLC Down"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrRed
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//
// DATA Buffers ...
//
#define upMaBufferIndex 2
double upMaBuffer[];
//
#define downMaBufferIndex 3
double downMaBuffer[];
//
#define kpiBufferIndex 4
double kpiBuffer[];
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
int upHandler = INVALID_HANDLE;
int downHandler = INVALID_HANDLE;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Initialize Requierd Handlers ...
upHandler = iMA(
_Symbol,
_Period,
length,
0,
method,
upAppliedTo);
downHandler = iMA(
_Symbol,
_Period,
length,
0,
method,
downAppliedTo);
if (upHandler == INVALID_HANDLE || downHandler == INVALID_HANDLE)
{
//
string msg = "Error in Initilizing Indicator ...";
Print(msg);
//
return INIT_FAILED;
}
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Release Indicators ...
IndicatorRelease(upHandler);
IndicatorRelease(downHandler);
}
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// Check Calculated Bars ...
int upCalculatedBars = BarsCalculated(upHandler);
int downCalculatedBars = BarsCalculated(downHandler);
if (upCalculatedBars < maxLength ||
downCalculatedBars < maxLength)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
int copiedUps = CopyBuffer(upHandler, 0, 0, limit, upMaBuffer);
int copiedDowns = CopyBuffer(downHandler, 0, 0, limit, downMaBuffer);
if (copiedUps <= 0 ||
copiedDowns <= 0)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
CalculateBuffers(i, limit, rates_total, prev_calculated, close);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result =
//
(length > 2)
//
;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = MathMax(result, length);
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// UP ...
//
ENUM_DRAW_TYPE upDrawType = showUp ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(upBuffer, true);
SetIndexBuffer(upBufferIndex, upBuffer, INDICATOR_DATA);
PlotIndexSetInteger(upBufferIndex, PLOT_SHOW_DATA, showUp);
PlotIndexSetInteger(upBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(upBufferIndex, PLOT_DRAW_TYPE, upDrawType);
//
// DOWN ...
//
ENUM_DRAW_TYPE downDrawType = showDown ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(downBuffer, true);
SetIndexBuffer(downBufferIndex, downBuffer, INDICATOR_DATA);
PlotIndexSetInteger(downBufferIndex, PLOT_SHOW_DATA, showDown);
PlotIndexSetInteger(downBufferIndex, PLOT_DRAW_BEGIN, maxLength);
PlotIndexSetInteger(downBufferIndex, PLOT_DRAW_TYPE, downDrawType);
//
// DATA Buffers ...
//
// UP MA ...
ArraySetAsSeries(upMaBuffer, true);
SetIndexBuffer(upMaBufferIndex, upMaBuffer, INDICATOR_CALCULATIONS);
//
// DOWN MA ...
ArraySetAsSeries(downMaBuffer, true);
SetIndexBuffer(downMaBufferIndex, downMaBuffer, INDICATOR_CALCULATIONS);
//
// KPI ...
ArraySetAsSeries(kpiBuffer, true);
SetIndexBuffer(kpiBufferIndex, kpiBuffer, INDICATOR_CALCULATIONS);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index, // Selected Bar Index
int limit,
int ratesTotal,
int prevCalculated,
const double &close[])
{
//
double upMaValue = upMaBuffer[bar_index];
double downMaValue = downMaBuffer[bar_index];
//
double closeValue = close[bar_index];
//
double kpiValue;
if (closeValue > upMaValue)
{
kpiValue = 1;
}
else if (closeValue < downMaValue)
{
kpiValue = -1;
}
else
{
kpiValue = kpiBuffer[bar_index + 1];
}
//
kpiBuffer[bar_index] = kpiValue;
//
double upValue = kpiValue < 0 ? downMaValue : upMaValue;
upBuffer[bar_index] = upValue;
//
double downValue = kpiValue < 0 ? upMaValue : downMaValue;
downBuffer[bar_index] = downValue;
}
//
// END Functions ...
//
@@ -0,0 +1,580 @@
//////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XSTR
// Description: Super Trend Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm X121_XAMA Indicator"
#property strict
//
// START Constants ...
//
#define ShortName "XSTR"
//
// END Constants ...
//
//
// START Inputs ...
//
//
// Market ...
input group "ATR";
input int atrLength = 14; // Length
input double atrMultiplier = 3.0; // Multiplier
input ENUM_APPLIED_PRICE atrAppliedTo = PRICE_MEDIAN; // Applied To
//
// Presentation ...
input group "Presentation";
input bool showTrends = true; // Show Trends
input bool fillTrends = true; // Fill Trends
//
// END Inputs ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// START Buffers ...
//
//
#property indicator_chart_window
//
#property indicator_buffers 9
#property indicator_plots 2
//
#define fillUpBufferIndex 0
double fillUpBuffer[];
#define fillDownBufferIndex 1
double fillDownBuffer[];
//
#define fillingPlotBufferIndex 0
//
#property indicator_label1 "XSTR Filling"
#property indicator_type1 DRAW_FILLING
#property indicator_color1 clrBisque, clrPaleGreen
//
#define mainBufferIndex 2
#define mainPlotBufferIndex 1
double mainBuffer[];
//
#define mainColorBufferIndex 3
double mainColorBuffer[];
//
#property indicator_label2 "XSTR"
#property indicator_type2 DRAW_COLOR_LINE
#property indicator_color2 CLR_NONE, clrGreen, clrDarkRed
#property indicator_style2 STYLE_DOT
//
// DATA Buffers ...
//
#define atrBufferIndex 4
double atrBuffer[];
//
#define trendBufferIndex 5
double trendBuffer[];
//
#define upBufferIndex 6
double upBuffer[];
//
#define downBufferIndex 7
double downBuffer[];
//
#define priceBufferIndex 8
double priceBuffer[];
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int maxLength;
//
int atrHandler = INVALID_HANDLE;
//
int changeOfTrend;
int startBearishTrend;
int startBullishTrend;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
atrHandler = iATR(
_Symbol,
_Period,
atrLength);
if (atrHandler == INVALID_HANDLE)
{
return INIT_FAILED;
}
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
IndicatorRelease(atrHandler);
}
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
int numOfRequiredAtrs;
if (prev_calculated > rates_total || prev_calculated < 0)
{
numOfRequiredAtrs = rates_total;
}
else
{
//
numOfRequiredAtrs = rates_total - prev_calculated;
if (prev_calculated > 0)
{
numOfRequiredAtrs++;
}
}
//
// Checking for stop ...
if (IsStopped())
{
return 0;
}
//
// Check Number of items Copy or not ...
int copiedATRs = CopyBuffer(atrHandler, 0, 0, numOfRequiredAtrs, atrBuffer);
if (copiedATRs <= 0)
{
return 0;
}
//
int limit;
//
// checking for the limit start of calculation of an indicator ...
if (prev_calculated > rates_total || prev_calculated <= 0)
{
//
// starting index for calculation of all bars ...
limit = maxLength;
}
else
{
//
// starting number for calculation of new bars
limit = prev_calculated - 1;
}
//
// Main Loop ...
for (int i = limit; i < rates_total && !IsStopped(); i++)
{
//
// Calculated Price ...
double price = getPrice(
atrAppliedTo,
open,
high,
low,
close,
i);
// price = (high[i] + low[i]) / 2;
priceBuffer[i] = price;
//
double atr = atrBuffer[i];
//
// Up ...
upBuffer[i] = price + (atrMultiplier * atr);
//
// Down ...
downBuffer[i] = price - (atrMultiplier * atr);
//
if (close[i] > upBuffer[i - 1])
{
//
trendBuffer[i] = 1;
if (trendBuffer[i - 1] == -1)
{
changeOfTrend = 1;
}
}
else if (close[i] < downBuffer[i - 1])
{
//
trendBuffer[i] = -1;
if (trendBuffer[i - 1] == 1)
{
changeOfTrend = 1;
}
}
else if (trendBuffer[i - 1] == 1)
{
//
trendBuffer[i] = 1;
changeOfTrend = 0;
}
else if (trendBuffer[i - 1] == -1)
{
//
trendBuffer[i] = -1;
changeOfTrend = 0;
}
//
// Down Trend Starting ...
if (trendBuffer[i] < 0 && trendBuffer[i - 1] > 0)
{
startBearishTrend = 1;
}
else
{
startBearishTrend = 0;
}
//
// Up Trend Starting ...
if (trendBuffer[i] > 0 && trendBuffer[i - 1] < 0)
{
startBullishTrend = 1;
}
else
{
startBullishTrend = 0;
}
//
if (trendBuffer[i] > 0 && downBuffer[i] < downBuffer[i - 1])
{
downBuffer[i] = downBuffer[i - 1];
}
//
if (trendBuffer[i] < 0 && upBuffer[i] > upBuffer[i - 1])
{
upBuffer[i] = upBuffer[i - 1];
}
//
if (startBearishTrend == 1)
{
upBuffer[i] = priceBuffer[i] + (atrMultiplier * atr);
}
//
if (startBullishTrend == 1)
{
downBuffer[i] = priceBuffer[i] - (atrMultiplier * atr);
}
//
// Draw the indicator ...
//
double colorIDX = 0;
mainColorBuffer[i] = colorIDX;
//
if (trendBuffer[i] == 1)
{
//
mainBuffer[i] = downBuffer[i];
if (changeOfTrend == 1)
{
mainBuffer[i - 1] = mainBuffer[i - 2];
changeOfTrend = 0;
}
//
colorIDX = 1;
}
else if (trendBuffer[i] == -1)
{
//
mainBuffer[i] = upBuffer[i];
if (changeOfTrend == 1)
{
//
mainBuffer[i - 1] = mainBuffer[i - 2];
changeOfTrend = 0;
}
//
colorIDX = 2;
}
//
if (showTrends)
{
mainColorBuffer[i] = colorIDX;
}
//
// Filling ...
if (fillTrends)
{
//
fillUpBuffer[i] = mainBuffer[i];
fillDownBuffer[i] = close[i];
}
else
{
//
fillUpBuffer[i] = EMPTY_VALUE;
fillDownBuffer[i] = EMPTY_VALUE;
}
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
// Validate Args ...
result =
//
atrLength >= 2
//
;
//
return result;
}
//
// Retrieve all Exists Input Max Length ...
// use for Start Of Drawing ...
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = atrLength;
//
return result;
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// PLOT Buffers ...
//
// FILLINGS ...
SetIndexBuffer(fillUpBufferIndex, fillUpBuffer, INDICATOR_DATA);
SetIndexBuffer(fillDownBufferIndex, fillDownBuffer, INDICATOR_DATA);
PlotIndexSetInteger(fillingPlotBufferIndex, PLOT_SHOW_DATA, false);
//
// MAIN ...
SetIndexBuffer(mainBufferIndex, mainBuffer, INDICATOR_DATA);
PlotIndexSetInteger(mainPlotBufferIndex, PLOT_SHOW_DATA, showTrends);
SetIndexBuffer(mainColorBufferIndex, mainColorBuffer, INDICATOR_COLOR_INDEX);
//
// DATA Buffers ...
//
// ATR ...
SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS);
//
// TREND ...
SetIndexBuffer(trendBufferIndex, trendBuffer, INDICATOR_CALCULATIONS);
//
// UP ...
SetIndexBuffer(upBufferIndex, upBuffer, INDICATOR_CALCULATIONS);
//
// DOWN ...
SetIndexBuffer(downBufferIndex, downBuffer, INDICATOR_CALCULATIONS);
//
// PRICE ...
SetIndexBuffer(priceBufferIndex, priceBuffer, INDICATOR_CALCULATIONS);
}
//
// END Functions ...
//
//
// TEMPLATE Function ...
template <typename T>
double getPrice(ENUM_APPLIED_PRICE tprice, T &open[], T &high[], T &low[], T &close[], int i)
{
switch (tprice)
{
case PRICE_CLOSE:
return (close[i]);
case PRICE_OPEN:
return (open[i]);
case PRICE_HIGH:
return (high[i]);
case PRICE_LOW:
return (low[i]);
case PRICE_MEDIAN:
return ((high[i] + low[i]) / 2.0);
case PRICE_TYPICAL:
return ((high[i] + low[i] + close[i]) / 3.0);
case PRICE_WEIGHTED:
return ((high[i] + low[i] + close[i] + close[i]) / 4.0);
}
return (0);
}
+457
View File
@@ -0,0 +1,457 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Trend Detector Oscillator
// --------------------------------------------------
// Name: XTD
// Description: trend detecting in both sides ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XTD Oscillator"
#property strict
//
// START Constants ...
//
#define ShortName "XTD"
//
// XTD Oscillator States ...
enum ENUM_X_XTD_STATES
{
X_XTD_BULLISH_CROSSED_OVER_BEARISH = 2,
X_XTD_BULLISH_OVER_BEARISH = 1,
X_XTD_NEUTURAL = 0,
X_XTD_BULLISH_UNDER_BEARISH = -1,
X_XTD_BULLISH_CROSSED_UNDER_BEARISH = -2
};
//
// END Constants ...
//
//
// START Inputs ...
//
input int length = 14; // Market Length
input bool drawCrosses = true; // Draw Cross Arrows
//
// Bullish ...
input uchar bullishArrowCode = 228; // Cross Over Arrow Code
input color bullishArrowColor = clrAqua; // Cross Over Arrow Color
//
// Bearish ...
input uchar bearishArrowCode = 230; // Cross Under Arrow Code
input color bearishArrowColor = clrMagenta; // Cross Under Arrow Color
//
// END Inputs ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5";
//
// Includes Draw Library ...
#include "../Libraries/x-saherelm.draw.lib.mq5";
//
// START Buffers ...
//
// #property indicator_separate_window
#property indicator_chart_window
//
#property indicator_buffers 3
// #property indicator_plots 3
#property indicator_plots 0
//
#define bullishBufferIndex 0
#define bearishBufferIndex 1
#define signalBufferIndex 2
//
double bullishBuffer[];
double bearishBuffer[];
double signalBuffer[];
//
// #property indicator_label1 "XBullPower"
// #property indicator_type1 DRAW_LINE
// #property indicator_color1 clrLime
// #property indicator_style1 STYLE_SOLID
// #property indicator_width1 1
//
// #property indicator_label2 "XBearPower"
// #property indicator_type2 DRAW_LINE
// #property indicator_color2 clrRed
// #property indicator_style2 STYLE_SOLID
// #property indicator_width2 1
//
// #property indicator_label3 "XSignal"
// #property indicator_type3 DRAW_LINE
// #property indicator_color3 clrGold
// #property indicator_style3 STYLE_DOT
// #property indicator_width3 1
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int xtdBullishCandleCount = 0;
int xtdBearishCandleCount = 0;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
drawPrefix = ShortName;
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
}
//
// Calculations ...
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
int maxLength = MathMax(0, length);
//
limit = prev_calculated < maxLength ? rates_total - (maxLength + 1) : rates_total - prev_calculated;
//
// Main Loop ...
for (int i = limit; i >= 0 && !IsStopped(); i--)
{
//
CalculateBuffers(i, close);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
// Validate Args ...
if (length >= 5)
{
result = true;
}
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// Bullish Buffer ...
string bullishBufferLabel = ShortName + "BullPow " + "(" + (string)length + ")";
ArraySetAsSeries(bullishBuffer, true);
SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_CALCULATIONS);
// SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_DATA);
// PlotIndexSetInteger(bullishBufferIndex, PLOT_DRAW_BEGIN, length);
// PlotIndexSetString(bullishBufferIndex, PLOT_LABEL, bullishBufferLabel);
//
// Bearish Buffer ...
string bearishBufferLabel = ShortName + "BearPow " + "(" + (string)length + ")";
ArraySetAsSeries(bearishBuffer, true);
SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_CALCULATIONS);
// SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_DATA);
// PlotIndexSetInteger(bearishBufferIndex, PLOT_DRAW_BEGIN, length);
// PlotIndexSetString(bearishBufferIndex, PLOT_LABEL, bearishBufferLabel);
//
// Signal Buffer ...
string signalBufferLabel = ShortName + "Signal " + "(" + (string)length + ")";
ArraySetAsSeries(signalBuffer, true);
SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_CALCULATIONS);
// SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_DATA);
// PlotIndexSetInteger(signalBufferIndex, PLOT_DRAW_BEGIN, length);
// PlotIndexSetString(signalBufferIndex, PLOT_LABEL, signalBufferLabel);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
//
string indicatorShortName = "";
StringConcatenate(indicatorShortName, ShortName, " ", "( ", length, " )");
//
IndicatorSetString(INDICATOR_SHORTNAME, indicatorShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index,
const double &close[])
{
//
// Reset Global Counters ...
xtdBullishCandleCount = 0;
xtdBearishCandleCount = 0;
//
// Loop through Closes ...
for (int i = bar_index; i <= bar_index + length; i++)
{
for (int j = i + 1; j <= bar_index + length; j++)
{
//
if (close[i] > close[j])
{
xtdBullishCandleCount++;
}
//
if (close[i] < close[j])
{
xtdBearishCandleCount++;
}
}
}
//
// Bullish Power Buffer ...
bullishBuffer[bar_index] = MathAbs(xtdBullishCandleCount);
//
// Bearish Power Buffer ...
bearishBuffer[bar_index] = MathAbs(xtdBearishCandleCount);
//
// Signal Buffer ...
signalBuffer[bar_index] = bullishBuffer[bar_index] - bearishBuffer[bar_index];
//
// Check and Draw Crosses if it's Specified ...
if (drawCrosses)
{
DrawCrosses(bar_index);
}
}
//
//
double GetState(
int bar_index // Specified Bar Index
)
{
//
// Check Cross Points ...
// bullishCrossedOverBearish = 2;
// bullishOverBearish = 1;
// bullishCrossedUnderBearish = -2;
// bullishUnderBearish = -1;
// OtherWise = 0;
bool isBullishCrossedOverBearish = IsCrossedOver(
bullishBuffer,
bearishBuffer,
bar_index);
bool isBullishCrossedUnderBearish = IsCrossedUnder(
bullishBuffer,
bearishBuffer,
bar_index);
bool isBullishOverBearish = IsOver(
bullishBuffer,
bearishBuffer,
bar_index);
bool isBullishUnderBearish = IsUnder(
bullishBuffer,
bearishBuffer,
bar_index);
//
double result = X_XTD_NEUTURAL;
if (isBullishCrossedOverBearish)
{
result = X_XTD_BULLISH_CROSSED_OVER_BEARISH;
}
else if (isBullishCrossedUnderBearish)
{
result = X_XTD_BULLISH_CROSSED_UNDER_BEARISH;
}
else if (isBullishOverBearish)
{
result = X_XTD_BULLISH_OVER_BEARISH;
}
else if (isBullishUnderBearish)
{
result = X_XTD_BULLISH_UNDER_BEARISH;
}
else
{
result = X_XTD_NEUTURAL;
}
//
return result;
}
//
// Draw Crosses ...
void DrawCrosses(
int bar_index // the bars which required to draw cross arrow on it ...
)
{
//
double stateValue = GetState(bar_index);
//
bool isOver = stateValue == 2;
double low = iLow(_Symbol, _Period, bar_index);
double high = iHigh(_Symbol, _Period, bar_index);
//
double price = isOver ? low : high;
datetime time = iTime(_Symbol, _Period, bar_index);
ENUM_ARROW_ANCHOR anchor = isOver ? ANCHOR_TOP : ANCHOR_BOTTOM;
uchar arrowCode = isOver ? bullishArrowCode : bearishArrowCode;
color arrowColor = isOver ? bullishArrowColor : bearishArrowColor;
string crossName = "Trend " + (isOver ? "Up" : "Down") + "_" + (string)time + "_" + (string)price;
//
DrawArrow(
0,
crossName,
0,
time,
price,
arrowCode,
anchor,
arrowColor);
}
//
// END Functions ...
//
@@ -0,0 +1,457 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Trend Detector Oscillator
// --------------------------------------------------
// Name: XTD
// Description: trend detecting in both sides ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XTD Oscillator"
#property strict
//
// START Constants ...
//
#define ShortName "XTD"
//
// XTD Oscillator States ...
enum ENUM_X_XTD_STATES
{
X_XTD_BULLISH_CROSSED_OVER_BEARISH = 2,
X_XTD_BULLISH_OVER_BEARISH = 1,
X_XTD_NEUTURAL = 0,
X_XTD_BULLISH_UNDER_BEARISH = -1,
X_XTD_BULLISH_CROSSED_UNDER_BEARISH = -2
};
//
// END Constants ...
//
//
// START Inputs ...
//
input int length = 14; // Market Length
input bool drawCrosses = true; // Draw Cross Arrows
//
// Bullish ...
input uchar bullishArrowCode = 228; // Cross Over Arrow Code
input color bullishArrowColor = clrAqua; // Cross Over Arrow Color
//
// Bearish ...
input uchar bearishArrowCode = 230; // Cross Under Arrow Code
input color bearishArrowColor = clrMagenta; // Cross Under Arrow Color
//
// END Inputs ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5";
//
// Includes Draw Library ...
#include "../Libraries/x-saherelm.draw.lib.mq5";
//
// START Buffers ...
//
#property indicator_separate_window
// #property indicator_chart_window
//
#property indicator_buffers 3
#property indicator_plots 2
// #property indicator_plots 0
//
#define bullishBufferIndex 0
#define bearishBufferIndex 1
#define signalBufferIndex 2
//
double bullishBuffer[];
double bearishBuffer[];
double signalBuffer[];
//
#property indicator_label1 "XBullPower"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrLime
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
#property indicator_label2 "XBearPower"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrRed
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//
// #property indicator_label3 "XSignal"
// #property indicator_type3 DRAW_LINE
// #property indicator_color3 clrGold
// #property indicator_style3 STYLE_DOT
// #property indicator_width3 1
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
//
int xtdBullishCandleCount = 0;
int xtdBearishCandleCount = 0;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
drawPrefix = ShortName;
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
}
//
// Calculations ...
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
int maxLength = MathMax(0, length);
//
limit = prev_calculated < maxLength ? rates_total - (maxLength + 1) : rates_total - prev_calculated;
//
// Main Loop ...
for (int i = limit; i >= 0 && !IsStopped(); i--)
{
//
CalculateBuffers(i, close);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
// Validate Args ...
if (length >= 5)
{
result = true;
}
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// Bullish Buffer ...
string bullishBufferLabel = ShortName + "BullPow " + "(" + (string)length + ")";
ArraySetAsSeries(bullishBuffer, true);
// SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_CALCULATIONS);
SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_DATA);
PlotIndexSetInteger(bullishBufferIndex, PLOT_DRAW_BEGIN, length);
PlotIndexSetString(bullishBufferIndex, PLOT_LABEL, bullishBufferLabel);
//
// Bearish Buffer ...
string bearishBufferLabel = ShortName + "BearPow " + "(" + (string)length + ")";
ArraySetAsSeries(bearishBuffer, true);
// SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_CALCULATIONS);
SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_DATA);
PlotIndexSetInteger(bearishBufferIndex, PLOT_DRAW_BEGIN, length);
PlotIndexSetString(bearishBufferIndex, PLOT_LABEL, bearishBufferLabel);
//
// Signal Buffer ...
string signalBufferLabel = ShortName + "Signal " + "(" + (string)length + ")";
ArraySetAsSeries(signalBuffer, true);
SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_CALCULATIONS);
// SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_DATA);
// PlotIndexSetInteger(signalBufferIndex, PLOT_DRAW_BEGIN, length);
// PlotIndexSetString(signalBufferIndex, PLOT_LABEL, signalBufferLabel);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
//
string indicatorShortName = "";
StringConcatenate(indicatorShortName, ShortName, " ", "( ", length, " )");
//
IndicatorSetString(INDICATOR_SHORTNAME, indicatorShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(
int bar_index,
const double &close[])
{
//
// Reset Global Counters ...
xtdBullishCandleCount = 0;
xtdBearishCandleCount = 0;
//
// Loop through Closes ...
for (int i = bar_index; i <= bar_index + length; i++)
{
for (int j = i + 1; j <= bar_index + length; j++)
{
//
if (close[i] > close[j])
{
xtdBullishCandleCount++;
}
//
if (close[i] < close[j])
{
xtdBearishCandleCount++;
}
}
}
//
// Bullish Power Buffer ...
bullishBuffer[bar_index] = MathAbs(xtdBullishCandleCount);
//
// Bearish Power Buffer ...
bearishBuffer[bar_index] = MathAbs(xtdBearishCandleCount);
//
// Signal Buffer ...
signalBuffer[bar_index] = bullishBuffer[bar_index] - bearishBuffer[bar_index];
//
// Check and Draw Crosses if it's Specified ...
if (drawCrosses)
{
DrawCrosses(bar_index);
}
}
//
//
double GetState(
int bar_index // Specified Bar Index
)
{
//
// Check Cross Points ...
// bullishCrossedOverBearish = 2;
// bullishOverBearish = 1;
// bullishCrossedUnderBearish = -2;
// bullishUnderBearish = -1;
// OtherWise = 0;
bool isBullishCrossedOverBearish = IsCrossedOver(
bullishBuffer,
bearishBuffer,
bar_index);
bool isBullishCrossedUnderBearish = IsCrossedUnder(
bullishBuffer,
bearishBuffer,
bar_index);
bool isBullishOverBearish = IsOver(
bullishBuffer,
bearishBuffer,
bar_index);
bool isBullishUnderBearish = IsUnder(
bullishBuffer,
bearishBuffer,
bar_index);
//
double result = X_XTD_NEUTURAL;
if (isBullishCrossedOverBearish)
{
result = X_XTD_BULLISH_CROSSED_OVER_BEARISH;
}
else if (isBullishCrossedUnderBearish)
{
result = X_XTD_BULLISH_CROSSED_UNDER_BEARISH;
}
else if (isBullishOverBearish)
{
result = X_XTD_BULLISH_OVER_BEARISH;
}
else if (isBullishUnderBearish)
{
result = X_XTD_BULLISH_UNDER_BEARISH;
}
else
{
result = X_XTD_NEUTURAL;
}
//
return result;
}
//
// Draw Crosses ...
void DrawCrosses(
int bar_index // the bars which required to draw cross arrow on it ...
)
{
//
double stateValue = GetState(bar_index);
//
bool isOver = stateValue == 2;
double low = iLow(_Symbol, _Period, bar_index);
double high = iHigh(_Symbol, _Period, bar_index);
//
double price = isOver ? low : high;
datetime time = iTime(_Symbol, _Period, bar_index);
ENUM_ARROW_ANCHOR anchor = isOver ? ANCHOR_TOP : ANCHOR_BOTTOM;
uchar arrowCode = isOver ? bullishArrowCode : bearishArrowCode;
color arrowColor = isOver ? bullishArrowColor : bearishArrowColor;
string crossName = "Trend " + (isOver ? "Up" : "Down") + "_" + (string)time + "_" + (string)price;
//
DrawArrow(
0,
crossName,
0,
time,
price,
arrowCode,
anchor,
arrowColor);
}
//
// END Functions ...
//
+351
View File
@@ -0,0 +1,351 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Candle Indicator
// ---------------------------------------------
// Name: XTM
// Description: Trend Magic Indicator ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XTM Indicator"
#property strict
//
// START Constants ...
//
#define ShortName "XTM"
//
// XTM Indicator States ...
enum ENUM_X_XTM_STATES
{
X_XTM_BULLISH = 1,
X_XTM_BEARISH = -1,
X_XTM_NEUTURAL = 0,
};
//
// END Constants ...
//
//
// START Inputs ...
//
//
input group "Market";
input int maPeriod = 14; // Period
input int maShift = 0; // Shift
input ENUM_MA_METHOD maMethod = MODE_SMA; // Method
input ENUM_APPLIED_PRICE maAppliedTo = PRICE_CLOSE; // Applied To
//
input group "Presentation";
input bool showLine = true; // Show Line
//
// END Inputs ...
//
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// START Buffers ...
//
#property indicator_chart_window
//
#property indicator_buffers 3
#property indicator_plots 1
//
// maBuffer ...
#define maBufferIndex 0
#define maColorBufferIndex 1
#define stateBufferIndex 2
double maBuffer[];
double maColorBuffer[];
double stateBuffer[];
#property indicator_label1 "XTM"
#property indicator_type1 DRAW_COLOR_LINE
#property indicator_color1 clrLime, clrGray, clrRed, CLR_NONE
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
// END Buffers ...
//
//
// START Global Definitions: Variables, Properties and etc ...
//
int maHandler = INVALID_HANDLE;
//
// END Global Definitions: Variables, Properties and etc ...
//
//
// START Event Handlers ...
//
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Initializing MA Handler ...
maHandler = iMA(
_Symbol,
_Period,
maPeriod,
maShift,
maMethod,
maAppliedTo);
if (maHandler == INVALID_HANDLE)
{
return INIT_FAILED;
}
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
// Here we can handle De Initialization Reasons ...
}
//
// Calculations ...
//
// Calculating what we want ...
int OnCalculate(
//
// total Candles on chart ...
const int rates_total,
//
// total calculated Candles on charts ...
const int prev_calculated,
//
// history of Candles Open Time ...
const datetime &time[],
//
// history of Candles Open Price ...
const double &open[],
//
// history of Candles High Price ...
const double &high[],
//
// history of Candles Low Price ...
const double &low[],
//
// history of Candles Close Price ...
const double &close[],
//
// history of Tick Volumes on Candle ...
const long &tick_volume[],
//
// history of Trade Volumes ...
const long &volume[],
//
// history of Candles Spread Price ...
const int &spread[])
{
//
// Prepare Buffers ...
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(volume, true);
ArraySetAsSeries(spread, true);
//
// this counts Available Bars ...
int limit;
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
int maxLength = MathMax(0, maPeriod);
//
// Check Calculated Bars ...
int maCalculatedBars = BarsCalculated(maHandler);
if (maCalculatedBars < maxLength)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
int copiedMas = CopyBuffer(maHandler, 0, 0, limit, maBuffer);
if (copiedMas <= 0)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
//
// Do Buffers Calculation ...
CalculateBuffers(i);
}
//
return rates_total;
}
//
// END Event Handlers ...
//
//
// START Functions ...
//
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
// Validate Args ...
if (maPeriod >= 2)
{
result = true;
}
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
string maBufferLabel = "XTM " + "(" + (string)maPeriod + ")";
//
// Ma Buffer ...
ArraySetAsSeries(maBuffer, true);
SetIndexBuffer(maBufferIndex, maBuffer, INDICATOR_DATA);
PlotIndexSetString(maBufferIndex, PLOT_LABEL, maBufferLabel);
//
// Ma Color Buffer ...
ArraySetAsSeries(maColorBuffer, true);
SetIndexBuffer(maColorBufferIndex, maColorBuffer, INDICATOR_COLOR_INDEX);
//
// State Buffer ...
ArraySetAsSeries(stateBuffer, true);
SetIndexBuffer(stateBufferIndex, stateBuffer, INDICATOR_CALCULATIONS);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
//
string indicatorShortName = "";
StringConcatenate(indicatorShortName, ShortName, " ", "(", maPeriod, ")");
//
IndicatorSetString(INDICATOR_SHORTNAME, indicatorShortName);
}
//
// Calculate Buffers ...
void CalculateBuffers(int bar_index)
{
//
// Requirements ...
XOHCL candle;
candle.Init(
_Symbol,
_Period,
bar_index
//
);
//
double maValue = maBuffer[bar_index];
//
double lineColorIndex =
maValue < candle.low ? 0 : maValue > candle.high ? 2
: 1;
//
// Define State Value ...
// lineColorIndex == 0 => Bullish => 1;
// lineColorIndex == 1 => Neutural => 0;
// lineColorIndex == 2 => Bearish => -1;
double stateValue =
lineColorIndex == 0 ? X_XTM_BULLISH : lineColorIndex == 2 ? X_XTM_BEARISH
: X_XTM_NEUTURAL;
//
// Set Ma Buffer Color Index ...
maColorBuffer[bar_index] = showLine ? lineColorIndex : 3;
//
// Set State Buffer Value ...
stateBuffer[bar_index] = stateValue;
}
//
// END Functions ...
//
+750
View File
@@ -0,0 +1,750 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// ---------------------------------------------
// Name: XZG
// Description: Zogzag Implementation ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://saherelm.ir"
#property version "1.00"
#property description "SaherElm XZG Indicator"
#property strict
//
#define ShortName "XZG"
//
// DEFINITIONS ...
enum ENUM_X_ZG_SEARCH_MODE
{
X_ZG_SEARCH_EXTREMUM = 0, // searching for the first extremum
X_ZG_SEARCH_PEAK = 1, // searching for the next ZigZag peak
X_ZG_SEARCH_VALE = -1 // searching for the next ZigZag vale
};
//
// How to Calculate Up and Down Price ...
enum ENUM_X_ZG_PRICE_MODE
{
//
X_ZG_PRICE_HIGH_LOW_MODE = 1,
X_ZG_PRICE_OPEN_CLOSE_MODE = 2,
};
//
// INPUT ...
//
input group "Market";
input int depth = 12; // Depth
input int deviation = 5; // Deviation
input int backStep = 3; // Back Step
input ENUM_X_ZG_PRICE_MODE mode = X_ZG_PRICE_HIGH_LOW_MODE; // Mode
//
input group "Presentation";
input bool showZigZag = true; // Show ZigZag
input bool showPeaksAndVales = true; // Show Peaks and Vales
//
// BUFFERS ...
//
#property indicator_chart_window
//
#property indicator_buffers 6
#property indicator_plots 4
//
// ZigZag ...
//
#define mainBufferIndex 0
#define mainBufferPlotIndex 0
double mainBuffer[];
#define mainColorBufferIndex 1
double mainColorBuffer[];
//
#property indicator_label1 "XZG Main"
#property indicator_type1 DRAW_COLOR_SECTION
#property indicator_color1 CLR_NONE, clrRoyalBlue, clrSaddleBrown
#property indicator_width1 2
//
// Highs ...
//
// ZigZag Pointer or Line Indicator ...
#define arrowBufferIndex 2
#define arrowBufferPlotIndex 1
double arrowBuffer[];
//
#define arrowColorBufferIndex 3
double arrowColorBuffer[];
//
#property indicator_label2 "XZG PV"
#property indicator_type2 DRAW_COLOR_ARROW
#property indicator_color2 CLR_NONE, clrAqua, clrMagenta
#property indicator_width2 1
//
#define highsBufferIndex 4
double highsBuffer[];
//
// Lows ...
//
#define lowsBufferIndex 5
double lowsBuffer[];
//
// VARIABLES ...
//
int mRecalc = 3; // Number of last extremes for recalculation
//
// EVENT Handlers ...
//
// Initialization ...
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// logTag = ShortName;
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
//
// DeInitialization ...
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
}
//
// Calculating what we want ...
int OnCalculate(
const int rates_total, // Total Bars on Chart ...
const int prev_calculated, // Total Calculated Bars on Charts ...
const datetime &time[], // History of Open Time ...
const double &open[], // History of Open Price ...
const double &high[], // History of High Price ...
const double &low[], // History of Low Price ...
const double &close[], // History of Close Price ...
const long &tick_volume[], // History of Tick Volumes on Bar ...
const long &volume[], // History of Trade Volumes ...
const int &spread[] // History of Spread Price ...
)
{
//
double mZGHigh[];
double mZGLow[];
if (mode == X_ZG_PRICE_OPEN_CLOSE_MODE)
{
//
ArrayCopy(
mZGHigh,
open
//
);
//
ArrayCopy(
mZGLow,
close
//
);
}
else
{
//
ArrayCopy(
mZGHigh,
high
//
);
//
ArrayCopy(
mZGLow,
low
//
);
}
//
int zigZagResult = CalcukateZigZag(
prev_calculated,
rates_total,
mZGHigh,
mZGLow
//
);
//
if (zigZagResult != rates_total)
{
return zigZagResult;
}
//
return rates_total;
}
//
// CUSTOM Functions ...
//
// Validate Input Args for Initialization ...
bool ValidateInputs()
{
//
bool result = false;
//
result =
//
depth > 0 &&
deviation > 0 &&
backStep > 0
//
;
//
return result;
}
//
// Define Indexes and Styles ...
void DefineBuffers()
{
//
// Main ...
//
SetIndexBuffer(mainBufferIndex, mainBuffer, INDICATOR_DATA);
SetIndexBuffer(mainColorBufferIndex, mainColorBuffer, INDICATOR_COLOR_INDEX);
//
PlotIndexSetInteger(mainBufferPlotIndex, PLOT_SHOW_DATA, showZigZag);
PlotIndexSetInteger(mainBufferPlotIndex, PLOT_DRAW_BEGIN, 0);
PlotIndexSetDouble(mainBufferPlotIndex, PLOT_EMPTY_VALUE, 0);
//
// Arrow ...
//
SetIndexBuffer(arrowBufferIndex, arrowBuffer, INDICATOR_DATA);
//
PlotIndexSetInteger(arrowBufferPlotIndex, PLOT_SHOW_DATA, showPeaksAndVales);
PlotIndexSetInteger(arrowBufferPlotIndex, PLOT_DRAW_BEGIN, 0);
PlotIndexSetInteger(arrowBufferPlotIndex, PLOT_ARROW, 159);
PlotIndexSetInteger(arrowBufferPlotIndex, PLOT_ARROW_SHIFT, 0);
PlotIndexSetDouble(arrowBufferPlotIndex, PLOT_EMPTY_VALUE, 0);
//
// Arrow Color ...
SetIndexBuffer(arrowColorBufferIndex, arrowColorBuffer, INDICATOR_COLOR_INDEX);
//
// Highs ...
SetIndexBuffer(highsBufferIndex, highsBuffer, INDICATOR_CALCULATIONS);
//
// Lows ...
SetIndexBuffer(lowsBufferIndex, lowsBuffer, INDICATOR_CALCULATIONS);
}
//
// Set Indicator Short Name and also we can define Buffers Labels ...
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
//
// Calculating Zig Zag ...
int CalcukateZigZag(
const int prev_calculated,
const int rates_total,
double &high[],
double &low[]
//
)
{
//
if (rates_total < 100)
{
return 0;
}
//
// Define Variables ...
int i = 0;
//
int start = 0;
int extreme_counter = 0;
int extreme_search = X_ZG_SEARCH_EXTREMUM;
int shift = 0;
int back = 0;
int last_high_pos = 0;
int last_low_pos = 0;
//
double val = 0;
double res = 0;
double curlow = 0;
double curhigh = 0;
double last_high = 0;
double last_low = 0;
//
double colorIDX = 0;
double lastZigZagValue = 0;
//
// Initializing ...
if (prev_calculated == 0)
{
//
ArrayInitialize(mainBuffer, 0);
ArrayInitialize(highsBuffer, 0);
ArrayInitialize(lowsBuffer, 0);
//
start = depth;
}
//
// Already Calculated Before ...
if (prev_calculated > 0)
{
//
i = rates_total - 1;
//
// Searching for the third X_ZG_SEARCH_EXTREMUM from the last UnComplete Bar ...
while (extreme_counter < mRecalc && i > rates_total - 100)
{
//
res = mainBuffer[i];
if (res != 0)
{
extreme_counter++;
}
//
i--;
}
//
i++;
start = i;
//
// What type of X_ZG_SEARCH_EXTREMUM we Search for ...
if (lowsBuffer[i] != 0)
{
//
curlow = lowsBuffer[i];
extreme_search = X_ZG_SEARCH_PEAK;
}
else
{
//
curhigh = highsBuffer[i];
extreme_search = X_ZG_SEARCH_VALE;
}
//
// Clear Values ...
for (i = start + 1; i < rates_total && !IsStopped(); i++)
{
//
mainBuffer[i] = 0;
lowsBuffer[i] = 0;
highsBuffer[i] = 0;
}
}
//
// Search for High and Low Extremes ...
for (shift = start; shift < rates_total && !IsStopped(); shift++)
{
//
// Low ...
val = low[Lowest(low, depth, shift)];
if (val == last_low)
{
val = 0;
}
else
{
//
last_low = val;
//
if ((low[shift] - val) > deviation * _Point)
{
val = 0;
}
else
{
//
for (back = 1; back <= backStep; back++)
{
//
res = lowsBuffer[shift - back];
if ((res != 0) && (res > val))
{
lowsBuffer[shift - back] = 0;
}
}
}
}
//
if (low[shift] == val)
{
lowsBuffer[shift] = val;
}
else
{
lowsBuffer[shift] = 0;
}
//
// High ...
val = high[Highest(high, depth, shift)];
if (val == last_high)
{
val = 0;
}
else
{
//
last_high = val;
//
if ((val - high[shift]) > deviation * _Point)
{
val = 0;
}
else
{
//
for (back = 1; back <= backStep; back++)
{
//
res = highsBuffer[shift - back];
if ((res != 0) && (res < val))
{
highsBuffer[shift - back] = 0;
}
}
}
}
//
if (high[shift] == val)
{
highsBuffer[shift] = val;
}
else
{
highsBuffer[shift] = 0;
}
}
//
// Set Last Value ...
if (extreme_search == 0) // Undefined Values ...
{
//
last_low = 0;
last_high = 0;
}
else
{
//
last_low = curlow;
last_high = curhigh;
}
//
// Final Selection of Extreme Points for ZigZag ...
for (shift = start; shift < rates_total && !IsStopped(); shift++)
{
//
res = 0;
//
switch (extreme_search)
{
//
case X_ZG_SEARCH_EXTREMUM:
//
if (last_low == 0 && last_high == 0)
{
//
if (highsBuffer[shift] != 0)
{
//
last_high_pos = shift;
last_high = high[shift];
//
extreme_search = X_ZG_SEARCH_VALE;
//
mainBuffer[shift] = last_high;
//
res = 1;
}
//
if (lowsBuffer[shift] != 0)
{
//
last_low_pos = shift;
last_low = low[shift];
//
extreme_search = X_ZG_SEARCH_PEAK;
//
mainBuffer[shift] = last_low;
//
res = 1;
}
}
break;
//
case X_ZG_SEARCH_PEAK:
//
if (lowsBuffer[shift] != 0 && lowsBuffer[shift] < last_low && highsBuffer[shift] == 0)
{
//
mainBuffer[last_low_pos] = 0;
//
last_low_pos = shift;
last_low = lowsBuffer[shift];
//
mainBuffer[shift] = last_low;
//
res = 1;
}
//
if (highsBuffer[shift] != 0 && lowsBuffer[shift] == 0)
{
//
last_high_pos = shift;
last_high = highsBuffer[shift];
//
mainBuffer[shift] = last_high;
//
extreme_search = X_ZG_SEARCH_VALE;
//
res = 1;
}
break;
//
case X_ZG_SEARCH_VALE:
//
if (highsBuffer[shift] != 0 && highsBuffer[shift] > last_high && lowsBuffer[shift] == 0)
{
//
mainBuffer[last_high_pos] = 0;
//
last_high_pos = shift;
last_high = highsBuffer[shift];
//
mainBuffer[shift] = last_high;
}
//
if (lowsBuffer[shift] != 0 && highsBuffer[shift] == 0)
{
//
last_low_pos = shift;
last_low = lowsBuffer[shift];
//
mainBuffer[shift] = last_low;
//
extreme_search = X_ZG_SEARCH_PEAK;
}
break;
}
//
double iZigZagForColor = lastZigZagValue;
double iZigZag = mainBuffer[shift];
if (iZigZag == 0 && lastZigZagValue != 0)
{
arrowBuffer[shift] = lastZigZagValue;
}
else if (iZigZag != 0)
{
//
lastZigZagValue = iZigZag;
arrowBuffer[shift] = lastZigZagValue;
}
//
colorIDX =
lastZigZagValue > iZigZagForColor
? 1
: lastZigZagValue < iZigZagForColor
? 2
: colorIDX;
//
mainColorBuffer[shift] = showZigZag ? colorIDX : 0;
arrowColorBuffer[shift] = showPeaksAndVales ? colorIDX : 0;
}
//
return rates_total;
}
//
// TOOLS ...
//
// Search for the index of the highest bar ...
int Highest(
const double &mArray[],
const int mDepth,
const int mStart //
)
{
//
int result = 0;
//
if (mStart < 0)
{
return result;
}
//
double max = mArray[mStart];
result = mStart;
//
// Start searching ...
for (int i = mStart - 1; i > mStart - mDepth && i >= 0; i--)
{
//
if (mArray[i] > max)
{
//
result = i;
max = mArray[i];
}
}
//
// Return index of the highest bar
return result;
}
//
// Search for the index of the lowest bar ...
int Lowest(
const double &mArray[],
const int mDepth,
const int mStart //
)
{
//
int result = 0;
//
if (mStart < 0)
{
return result;
}
//
double min = mArray[mStart];
result = mStart;
//
// Start searching ...
for (int i = mStart - 1; i > mStart - mDepth && i >= 0; i--)
{
//
if (mArray[i] < min)
{
//
result = i;
min = mArray[i];
}
}
//
// Return index of the lowest bar
return result;
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,314 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: X110Signaller
// Description: Signalling using X121 rules ...
//
//
// 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 ...
#include "../Libraries/x-saherelm.xtrade.lib.mq5"
#include "../Classes/x-saherelm.x121.xmcycle.class.mq5"
//
// Definitions ...
//
// Class ...
class X110Signaller : public XSignallerDescriptor
{
//
// Public ...
public:
//
// Props ...
//
// Constructor(s) ...
void X110Signaller()
{
name = X110;
Default();
}
//
// Deconstructor ...
void ~X110Signaller() {}
//
// Override(s) ...
//
bool HasLongConditions(
const X121MCycleConditions &conditions, // Market Conditions
double &sl, // Hold SL ...
double &tp // Hold TP ...
) override
{
//
bool result = false;
//
sl = 0;
tp = 0;
//
result = allowLong;
if (!result)
{
return result;
}
//
bool isCloseOverSenkouSpanA = conditions.bars[1].close > conditions.ichSenkouSpanAs[1];
//
bool isBaseBullish = isCloseOverSenkouSpanA &&
conditions.isSenkouSpanAOverB &&
conditions.isSenkouSpanAOverLast;
//
bool isKijunSenOverSenkouSpanA = conditions.ichKijunSens[1] > conditions.ichSenkouSpanAs[1];
//
bool isCloseOverTenkanSen = conditions.bars[1].close > conditions.ichTenkanSens[1];
//
bool isPriceCloseCrossedUpTenkanSen = conditions.bars[2].close <= conditions.ichTenkanSens[2] &&
conditions.bars[1].close > conditions.ichTenkanSens[1];
//
double cKumoUpper = MathMax(conditions.ichSenkouSpanAs[1], conditions.ichSenkouSpanBs[1]);
double pKumoUpper = MathMax(conditions.ichSenkouSpanAs[2], conditions.ichSenkouSpanBs[2]);
//
double cKumoLower = MathMin(conditions.ichSenkouSpanAs[1], conditions.ichSenkouSpanBs[1]);
double pKumoLower = MathMin(conditions.ichSenkouSpanAs[2], conditions.ichSenkouSpanBs[2]);
//
bool isTenkanSenOverKumo = conditions.ichTenkanSens[1] > cKumoUpper;
bool isTenkanSenOverKumoPrev = conditions.ichTenkanSens[2] > pKumoUpper;
//
bool isTenkanSenUnderKumo = conditions.ichTenkanSens[1] < cKumoLower;
bool isTenkanSenUnderKumoPrev = conditions.ichTenkanSens[2] < pKumoLower;
//
bool isTenkanSenCrossedOverKumo = isTenkanSenOverKumo &&
!isTenkanSenOverKumoPrev;
//
bool isTenkanSenCrossedUnderKumo = isTenkanSenUnderKumo &&
!isTenkanSenUnderKumoPrev;
//
bool condition1 =
isBaseBullish &&
isCloseOverTenkanSen &&
isKijunSenOverSenkouSpanA &&
conditions.isTenkanSenCrossedOverKijunSen;
//
bool condition2 =
isBaseBullish &&
isCloseOverTenkanSen &&
isKijunSenOverSenkouSpanA &&
conditions.isTenkanSenOverKijunSen &&
conditions.isSenkouSpanACrossedOverB;
//
bool condition3 =
isBaseBullish &&
isKijunSenOverSenkouSpanA &&
isPriceCloseCrossedUpTenkanSen &&
conditions.isTenkanSenOverKijunSen;
//
bool condition4 =
isCloseOverTenkanSen &&
isTenkanSenCrossedOverKumo &&
conditions.isTenkanSenOverKijunSen &&
conditions.isFutureSenkouSpanAOverB &&
conditions.isFutureSenkouSpanAOverLast;
//
result =
//
condition1
//
||
//
condition2
//
||
//
condition3
//
||
//
condition4
//
;
//
if (result)
{
sl = conditions.ichSenkouSpanBs[1];
}
//
return result;
}
//
bool HasShortConditions(
const X121MCycleConditions &conditions, // Market Conditions
double &sl, // Hold SL ...
double &tp // Hold TP ...
) override
{
//
bool result = false;
//
sl = 0;
tp = 0;
//
result = allowLong;
if (!result)
{
return result;
}
//
bool isCloseUnderSenkouSpanB = conditions.bars[1].close < conditions.ichSenkouSpanBs[1];
//
bool isBaseBearish = isCloseUnderSenkouSpanB &&
conditions.isSenkouSpanAUnderB &&
conditions.isSenkouSpanAUnderLast;
//
bool isKijunSenUnderSenkouSpanB = conditions.ichKijunSens[1] < conditions.ichSenkouSpanBs[1];
//
bool isCloseUnderTenkanSen = conditions.bars[1].close < conditions.ichTenkanSens[1];
//
bool isPriceCloseCrossedDownTenkanSen = conditions.bars[2].close >= conditions.ichTenkanSens[2] &&
conditions.bars[1].close < conditions.ichTenkanSens[1];
//
double cKumoUpper = MathMax(conditions.ichSenkouSpanAs[1], conditions.ichSenkouSpanBs[1]);
double pKumoUpper = MathMax(conditions.ichSenkouSpanAs[2], conditions.ichSenkouSpanBs[2]);
//
double cKumoLower = MathMin(conditions.ichSenkouSpanAs[1], conditions.ichSenkouSpanBs[1]);
double pKumoLower = MathMin(conditions.ichSenkouSpanAs[2], conditions.ichSenkouSpanBs[2]);
//
bool isTenkanSenOverKumo = conditions.ichTenkanSens[1] > cKumoUpper;
bool isTenkanSenOverKumoPrev = conditions.ichTenkanSens[2] > pKumoUpper;
//
bool isTenkanSenUnderKumo = conditions.ichTenkanSens[1] < cKumoLower;
bool isTenkanSenUnderKumoPrev = conditions.ichTenkanSens[2] < pKumoLower;
//
bool isTenkanSenCrossedOverKumo = isTenkanSenOverKumo &&
!isTenkanSenOverKumoPrev;
//
bool isTenkanSenCrossedUnderKumo = isTenkanSenUnderKumo &&
!isTenkanSenUnderKumoPrev;
//
bool condition1 =
isBaseBearish &&
isCloseUnderTenkanSen &&
isKijunSenUnderSenkouSpanB &&
conditions.isTenkanSenCrossedUnderKijunSen;
//
bool condition2 =
isBaseBearish &&
isCloseUnderTenkanSen &&
isKijunSenUnderSenkouSpanB &&
conditions.isTenkanSenUnderKijunSen &&
conditions.isSenkouSpanACrossedUnderB;
//
bool condition3 =
isBaseBearish &&
isKijunSenUnderSenkouSpanB &&
isPriceCloseCrossedDownTenkanSen &&
conditions.isTenkanSenUnderKijunSen;
//
bool condition4 =
isCloseUnderTenkanSen &&
isTenkanSenCrossedUnderKumo &&
conditions.isTenkanSenUnderKijunSen &&
conditions.isFutureSenkouSpanAUnderB &&
conditions.isFutureSenkouSpanAUnderLast;
//
result =
//
condition1
//
||
//
condition2
//
||
//
condition3
//
||
//
condition4
//
;
//
if (result)
{
sl = conditions.ichSenkouSpanAs[1];
}
//
return result;
}
//
// Tools ...
void Default()
{
//
allowLong = true;
allowShort = true;
//
r2r = 1;
//
staticVolumeLong = 0.01;
staticVolumeShort = 0.01;
}
};
@@ -0,0 +1,188 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: X121Signaller
// Description: Signalling using X121 rules ...
//
//
// 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 ...
#include "../Libraries/x-saherelm.xtrade.lib.mq5"
#include "../Classes/x-saherelm.x121.xmcycle.class.mq5"
//
// Definitions ...
//
// Class ...
class X121Signaller : public XSignallerDescriptor
{
//
// Public ...
public:
//
// Props ...
//
// Constructor(s) ...
void X121Signaller()
{
name = X121;
Default();
}
//
// Deconstructor ...
void ~X121Signaller() {}
//
// Override(s) ...
//
bool HasLongConditions(
const X121MCycleConditions &conditions, // Market Conditions
double &sl, // Hold SL ...
double &tp // Hold TP ...
) override
{
//
bool result = false;
//
sl = 0;
tp = 0;
//
result = allowLong;
if (!result)
{
return result;
}
//
result =
//
(conditions.isMRBFastCrossedOverSlow &&
(conditions.isCHEBullish &&
conditions.isTrendBullish &&
conditions.isMCFastOverSlow))
//
||
//
(conditions.isMRBSlowCrossedtOverVerifier &&
(conditions.isCHEBullish &&
conditions.isTrendBullish &&
conditions.isMCFastOverSlow &&
conditions.isMRBFastOverSlow))
//
||
//
(conditions.isCHESwitchedToBullish &&
(conditions.isTrendBullish &&
conditions.isMCFastOverSlow &&
conditions.isMRBFastOverSlow))
//
;
//
if (result)
{
sl = conditions.mrbSlows[1];
}
//
return result;
}
//
bool HasShortConditions(
const X121MCycleConditions &conditions, // Market Conditions
double &sl, // Hold SL ...
double &tp // Hold TP ...
) override
{
//
bool result = false;
//
sl = 0;
tp = 0;
//
result = allowShort;
if (!result)
{
return result;
}
//
result =
//
(conditions.isSMHKSwitchedToBearish &&
(conditions.isTDBearish &&
conditions.isCHEBearish &&
conditions.isTrendBearish))
//
||
//
(conditions.isTDSwitchedToBearish &&
(conditions.isSMHKBearish &&
conditions.isCHEBearish &&
conditions.isTrendBearish))
//
||
//
(conditions.isCHESwitchedToBearish &&
(conditions.isTDBearish &&
conditions.isSMHKBearish &&
conditions.isTrendBearish))
//
||
//
(conditions.isTrendSwitchedToBearish &&
(conditions.isTDBearish &&
conditions.isCHEBearish &&
conditions.isSMHKBearish))
//
;
//
if (result)
{
sl = conditions.mrbFasts[1];
}
//
return result;
}
//
// Tools ...
void Default()
{
//
allowLong = true;
allowShort = true;
//
r2r = 1;
//
staticVolumeLong = 0.01;
staticVolumeShort = 0.01;
}
};
@@ -0,0 +1,193 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Class Library
// ----------------------------------------------
// Name: X786Signaller
// Description: Signalling using X786 rules ...
//
//
// 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 ...
#include "../Libraries/x-saherelm.xtrade.lib.mq5"
#include "../Classes/x-saherelm.x121.xmcycle.class.mq5"
//
// Definitions ...
//
// Class ...
class X786Signaller : public XSignallerDescriptor
{
//
// Public ...
public:
//
// Props ...
//
// Constructor(s) ...
void X786Signaller()
{
//
name = X786;
Default();
}
//
// Deconstructor ...
void ~X786Signaller() {}
//
// Override(s) ...
//
virtual bool HasLongConditions(
const X121MCycleConditions &conditions, // Market Conditions
double &sl, // Hold SL ...
double &tp // Hold TP ...
)
{
//
bool result = false;
//
sl = 0;
tp = 0;
//
result = allowLong;
if (!result)
{
return result;
}
//
result =
//
(conditions.isSMHKSwitchedToBullish &&
(conditions.isTDBullish &&
conditions.isCHEBullish &&
conditions.isTrendBullish))
//
||
//
(conditions.isTDSwitchedToBullish &&
(conditions.isSMHKBullish &&
conditions.isCHEBullish &&
conditions.isTrendBullish))
//
||
//
(conditions.isCHESwitchedToBullish &&
(conditions.isTDBullish &&
conditions.isSMHKBullish &&
conditions.isTrendBullish))
//
||
//
(conditions.isTrendSwitchedToBullish &&
(conditions.isTDBullish &&
conditions.isCHEBullish &&
conditions.isSMHKBullish))
//
;
//
if (result) {
sl = conditions.donLowerHs[1];
}
//
return result;
}
//
virtual bool HasShortConditions(
const X121MCycleConditions &conditions, // Market Conditions
double &sl, // Hold SL ...
double &tp // Hold TP ...
)
{
//
bool result = false;
//
result = allowShort;
if (!result)
{
return result;
}
//
tp = 0;
sl = 0;
//
result =
//
(conditions.isSMHKSwitchedToBearish &&
(conditions.isTDBearish &&
conditions.isCHEBearish &&
conditions.isTrendBearish))
//
||
//
(conditions.isTDSwitchedToBearish &&
(conditions.isSMHKBearish &&
conditions.isCHEBearish &&
conditions.isTrendBearish))
//
||
//
(conditions.isCHESwitchedToBearish &&
(conditions.isTDBearish &&
conditions.isSMHKBearish &&
conditions.isTrendBearish))
//
||
//
(conditions.isTrendSwitchedToBearish &&
(conditions.isTDBearish &&
conditions.isCHEBearish &&
conditions.isSMHKBearish))
//
;
//
if (result) {
sl = conditions.donUpperLs[1];
}
//
return result;
}
//
// Tools ...
void Default()
{
//
allowLong = true;
allowShort = true;
//
r2r = 1;
//
staticVolumeLong = 0.01;
staticVolumeShort = 0.01;
}
};