Consolidate Python ignore rules into root gitignore
This commit is contained in:
Hiroaki86
@@ -0,0 +1,516 @@
|
||||
//+------------------------------------------------------------------+
|
||||
//| Indicator.mqh |
|
||||
//| Copyright 2000-2026, MetaQuotes Ltd. |
|
||||
//| www.mql5.com |
|
||||
//+------------------------------------------------------------------+
|
||||
#include "Series.mqh"
|
||||
//+------------------------------------------------------------------+
|
||||
//| Class CIndicatorBuffer. |
|
||||
//| Purpose: Class for access to data of buffers of |
|
||||
//| technical indicators. |
|
||||
//| Derives from class CDoubleBuffer. |
|
||||
//+------------------------------------------------------------------+
|
||||
class CIndicatorBuffer : public CDoubleBuffer
|
||||
{
|
||||
protected:
|
||||
int m_offset; // shift along the time axis (in bars)
|
||||
string m_name; // name of buffer
|
||||
|
||||
public:
|
||||
CIndicatorBuffer(void);
|
||||
~CIndicatorBuffer(void);
|
||||
//--- methods of access to protected data
|
||||
int Offset(void) const { return(m_offset); }
|
||||
void Offset(const int offset) { m_offset=offset; }
|
||||
string Name(void) const { return(m_name); }
|
||||
void Name(const string name) { m_name=name; }
|
||||
//--- methods of access to data
|
||||
double At(const int index) const;
|
||||
//--- method of refreshing of data in buffer
|
||||
bool Refresh(const int handle,const int num);
|
||||
bool RefreshCurrent(const int handle,const int num);
|
||||
|
||||
private:
|
||||
virtual bool Refresh(void) { return(CDoubleBuffer::Refresh()); }
|
||||
virtual bool RefreshCurrent(void) { return(CDoubleBuffer::RefreshCurrent()); }
|
||||
};
|
||||
//+------------------------------------------------------------------+
|
||||
//| Constructor |
|
||||
//+------------------------------------------------------------------+
|
||||
CIndicatorBuffer::CIndicatorBuffer(void) : m_offset(0),
|
||||
m_name("")
|
||||
{
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Destructor |
|
||||
//+------------------------------------------------------------------+
|
||||
CIndicatorBuffer::~CIndicatorBuffer(void)
|
||||
{
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Access to data in a specified position |
|
||||
//+------------------------------------------------------------------+
|
||||
double CIndicatorBuffer::At(const int index) const
|
||||
{
|
||||
return(CDoubleBuffer::At(index+m_offset));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Refreshing of data in buffer |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicatorBuffer::Refresh(const int handle,const int num)
|
||||
{
|
||||
//--- check
|
||||
if(handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(false);
|
||||
}
|
||||
//---
|
||||
m_data_total=CopyBuffer(handle,num,-m_offset,m_size,m_data);
|
||||
//---
|
||||
return(m_data_total>0);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Refreshing of the data in buffer |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicatorBuffer::RefreshCurrent(const int handle,const int num)
|
||||
{
|
||||
double array[1];
|
||||
//--- check
|
||||
if(handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(false);
|
||||
}
|
||||
//---
|
||||
if(CopyBuffer(handle,num,-m_offset,1,array)>0 && m_data_total>0)
|
||||
{
|
||||
m_data[0]=array[0];
|
||||
return(true);
|
||||
}
|
||||
//--- error
|
||||
return(false);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Class CIndicator. |
|
||||
//| Purpose: Base class of technical indicators. |
|
||||
//| Derives from class CSeries. |
|
||||
//+------------------------------------------------------------------+
|
||||
class CIndicator : public CSeries
|
||||
{
|
||||
protected:
|
||||
int m_handle; // indicator handle
|
||||
string m_status; // status of creation
|
||||
bool m_full_release; // flag
|
||||
bool m_redrawer; // flag
|
||||
|
||||
public:
|
||||
CIndicator(void);
|
||||
~CIndicator(void);
|
||||
//--- methods of access to protected data
|
||||
int Handle(void) const { return(m_handle); }
|
||||
string Status(void) const { return(m_status); }
|
||||
void FullRelease(const bool flag=true) { m_full_release=flag; }
|
||||
void Redrawer(const bool flag=true) { m_redrawer=flag; }
|
||||
//--- method for creating
|
||||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
|
||||
const ENUM_INDICATOR type,const int num_params,const MqlParam ¶ms[]);
|
||||
virtual bool BufferResize(const int size);
|
||||
//--- methods of access to data
|
||||
int BarsCalculated(void) const;
|
||||
double GetData(const int buffer_num,const int index) const;
|
||||
int GetData(const int start_pos,const int count,const int buffer_num,double &buffer[]) const;
|
||||
int GetData(const datetime start_time,const int count,const int buffer_num,double &buffer[]) const;
|
||||
int GetData(const datetime start_time,const datetime stop_time,const int buffer_num,double &buffer[]) const;
|
||||
//--- methods for find extremum
|
||||
int Minimum(const int buffer_num,const int start,const int count) const;
|
||||
double MinValue(const int buffer_num,const int start,const int count,int &index) const;
|
||||
int Maximum(const int buffer_num,const int start,const int count) const;
|
||||
double MaxValue(const int buffer_num,const int start,const int count,int &index) const;
|
||||
//--- method of "freshening" of the data
|
||||
virtual void Refresh(const int flags=OBJ_ALL_PERIODS);
|
||||
//--- methods for working with chart
|
||||
bool AddToChart(const long chart,const int subwin);
|
||||
bool DeleteFromChart(const long chart,const int subwin);
|
||||
//--- methods of conversion of constants to strings
|
||||
static string MethodDescription(const int val);
|
||||
static string PriceDescription(const int val);
|
||||
static string VolumeDescription(const int val);
|
||||
|
||||
protected:
|
||||
//--- methods of tuning
|
||||
bool CreateBuffers(const string symbol,const ENUM_TIMEFRAMES period,const int buffers);
|
||||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
|
||||
const int num_params,const MqlParam ¶ms[]) {return(false);}
|
||||
};
|
||||
//+------------------------------------------------------------------+
|
||||
//| Constructor |
|
||||
//+------------------------------------------------------------------+
|
||||
void CIndicator::CIndicator(void) : m_handle(INVALID_HANDLE),
|
||||
m_status(""),
|
||||
m_full_release(false),
|
||||
m_redrawer(false)
|
||||
{
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Destructor |
|
||||
//+------------------------------------------------------------------+
|
||||
void CIndicator::~CIndicator(void)
|
||||
{
|
||||
//--- indicator handle release
|
||||
if(m_full_release && m_handle!=INVALID_HANDLE)
|
||||
{
|
||||
IndicatorRelease(m_handle);
|
||||
m_handle=INVALID_HANDLE;
|
||||
}
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Creation of the indicator with universal parameters |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicator::Create(const string symbol,const ENUM_TIMEFRAMES period,
|
||||
const ENUM_INDICATOR type,const int num_params,const MqlParam ¶ms[])
|
||||
{
|
||||
//--- check history
|
||||
if(!SetSymbolPeriod(symbol,period))
|
||||
return(false);
|
||||
//--- create
|
||||
m_handle=IndicatorCreate(symbol,period,type,num_params,params);
|
||||
//--- check result
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
return(false);
|
||||
//--- idicator successfully created
|
||||
if(!Initialize(symbol,period,num_params,params))
|
||||
{
|
||||
//--- initialization failed
|
||||
IndicatorRelease(m_handle);
|
||||
m_handle=INVALID_HANDLE;
|
||||
return(false);
|
||||
}
|
||||
//--- ok
|
||||
return(true);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Returns the amount of calculated indicator data |
|
||||
//+------------------------------------------------------------------+
|
||||
int CIndicator::BarsCalculated(void) const
|
||||
{
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
return(-1);
|
||||
//---
|
||||
return(::BarsCalculated(m_handle));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| API access method "Copying an element of indicator buffer |
|
||||
//| by specifying number of buffer and position of element" |
|
||||
//+------------------------------------------------------------------+
|
||||
double CIndicator::GetData(const int buffer_num,const int index) const
|
||||
{
|
||||
CIndicatorBuffer *buffer=At(buffer_num);
|
||||
//--- check
|
||||
if(buffer==NULL)
|
||||
{
|
||||
Print(__FUNCTION__,": invalid buffer");
|
||||
return(EMPTY_VALUE);
|
||||
}
|
||||
//---
|
||||
return(buffer.At(index));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| API access method "Copying the buffer of indicator by specifying |
|
||||
//| a start position and number of elements" |
|
||||
//+------------------------------------------------------------------+
|
||||
int CIndicator::GetData(const int start_pos,const int count,const int buffer_num,double &buffer[]) const
|
||||
{
|
||||
//--- check
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(-1);
|
||||
}
|
||||
if(buffer_num>=m_buffers_total)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_BUFF_NUM);
|
||||
return(-1);
|
||||
}
|
||||
//---
|
||||
return(CopyBuffer(m_handle,buffer_num,start_pos,count,buffer));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| API access method "Copying the buffer of indicator by specifying |
|
||||
//| start time and number of elements" |
|
||||
//+------------------------------------------------------------------+
|
||||
int CIndicator::GetData(const datetime start_time,const int count,const int buffer_num,double &buffer[]) const
|
||||
{
|
||||
//--- check
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(-1);
|
||||
}
|
||||
if(buffer_num>=m_buffers_total)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_BUFF_NUM);
|
||||
return(-1);
|
||||
}
|
||||
//---
|
||||
return(CopyBuffer(m_handle,buffer_num,start_time,count,buffer));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| API access method "Copying the buffer of indicator by specifying |
|
||||
//| start and final time |
|
||||
//+------------------------------------------------------------------+
|
||||
int CIndicator::GetData(const datetime start_time,const datetime stop_time,const int buffer_num,double &buffer[]) const
|
||||
{
|
||||
//--- check
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(-1);
|
||||
}
|
||||
if(buffer_num>=m_buffers_total)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_BUFF_NUM);
|
||||
return(-1);
|
||||
}
|
||||
//---
|
||||
return(CopyBuffer(m_handle,buffer_num,start_time,stop_time,buffer));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Find minimum of a specified buffer |
|
||||
//+------------------------------------------------------------------+
|
||||
int CIndicator::Minimum(const int buffer_num,const int start,const int count) const
|
||||
{
|
||||
//--- check
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(-1);
|
||||
}
|
||||
if(buffer_num>=m_buffers_total)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_BUFF_NUM);
|
||||
return(-1);
|
||||
}
|
||||
//---
|
||||
CIndicatorBuffer *buffer=At(buffer_num);
|
||||
if(buffer==NULL)
|
||||
return(-1);
|
||||
//---
|
||||
return(buffer.Minimum(start,count));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Find minimum of a specified buffer |
|
||||
//+------------------------------------------------------------------+
|
||||
double CIndicator::MinValue(const int buffer_num,const int start,const int count,int &index) const
|
||||
{
|
||||
int idx=Minimum(buffer_num,start,count);
|
||||
double res=EMPTY_VALUE;
|
||||
//--- check
|
||||
if(idx!=-1)
|
||||
{
|
||||
CIndicatorBuffer *buffer=At(buffer_num);
|
||||
res=buffer.At(idx);
|
||||
index=idx;
|
||||
}
|
||||
//---
|
||||
return(res);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Find maximum of a specified buffer |
|
||||
//+------------------------------------------------------------------+
|
||||
int CIndicator::Maximum(const int buffer_num,const int start,const int count) const
|
||||
{
|
||||
//--- check
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(-1);
|
||||
}
|
||||
if(buffer_num>=m_buffers_total)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_BUFF_NUM);
|
||||
return(-1);
|
||||
}
|
||||
//---
|
||||
CIndicatorBuffer *buffer=At(buffer_num);
|
||||
if(buffer==NULL)
|
||||
return(-1);
|
||||
//---
|
||||
return(buffer.Maximum(start,count));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Find maximum of specified buffer |
|
||||
//+------------------------------------------------------------------+
|
||||
double CIndicator::MaxValue(const int buffer_num,const int start,const int count,int &index) const
|
||||
{
|
||||
int idx=Maximum(buffer_num,start,count);
|
||||
double res=EMPTY_VALUE;
|
||||
//--- check
|
||||
if(idx!=-1)
|
||||
{
|
||||
CIndicatorBuffer *buffer=At(buffer_num);
|
||||
res=buffer.At(idx);
|
||||
index=idx;
|
||||
}
|
||||
//---
|
||||
return(res);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Creating data buffers of indicator |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicator::CreateBuffers(const string symbol,const ENUM_TIMEFRAMES period,const int buffers)
|
||||
{
|
||||
bool result=true;
|
||||
//--- check
|
||||
if(m_handle==INVALID_HANDLE)
|
||||
{
|
||||
SetUserError(ERR_USER_INVALID_HANDLE);
|
||||
return(false);
|
||||
}
|
||||
if(buffers==0)
|
||||
return(false);
|
||||
if(!Reserve(buffers))
|
||||
return(false);
|
||||
//---
|
||||
for(int i=0;i<buffers;i++)
|
||||
result&=Add(new CIndicatorBuffer);
|
||||
//---
|
||||
if(result)
|
||||
m_buffers_total=buffers;
|
||||
//---
|
||||
return(result);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Set size of buffers of indicator |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicator::BufferResize(const int size)
|
||||
{
|
||||
if(size>m_buffer_size && !CSeries::BufferResize(size))
|
||||
return(false);
|
||||
//-- history is avalible
|
||||
int total=Total();
|
||||
for(int i=0;i<total;i++)
|
||||
{
|
||||
CIndicatorBuffer *buff=At(i);
|
||||
//--- check pointer
|
||||
if(buff==NULL)
|
||||
return(false);
|
||||
buff.Size(size);
|
||||
}
|
||||
//--- ok
|
||||
return(true);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Refreshing data of indicator |
|
||||
//+------------------------------------------------------------------+
|
||||
void CIndicator::Refresh(const int flags)
|
||||
{
|
||||
int i;
|
||||
CIndicatorBuffer *buff;
|
||||
//--- refreshing buffers
|
||||
for(i=0;i<Total();i++)
|
||||
{
|
||||
buff=At(i);
|
||||
if(m_redrawer)
|
||||
{
|
||||
buff.Refresh(m_handle,i);
|
||||
continue;
|
||||
}
|
||||
if(!(flags&m_timeframe_flags))
|
||||
{
|
||||
if(m_refresh_current)
|
||||
buff.RefreshCurrent(m_handle,i);
|
||||
}
|
||||
else
|
||||
buff.Refresh(m_handle,i);
|
||||
}
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Adds indicator to chart |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicator::AddToChart(const long chart,const int subwin)
|
||||
{
|
||||
if(ChartIndicatorAdd(chart,subwin,m_handle))
|
||||
{
|
||||
m_name=ChartIndicatorName(chart,subwin,ChartIndicatorsTotal(chart,subwin)-1);
|
||||
return(true);
|
||||
}
|
||||
//--- failed
|
||||
return(false);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Deletes indicator from chart |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CIndicator::DeleteFromChart(const long chart,const int subwin)
|
||||
{
|
||||
return(ChartIndicatorDelete(chart,subwin,m_name));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting value of ENUM_MA_METHOD into string |
|
||||
//+------------------------------------------------------------------+
|
||||
string CIndicator::MethodDescription(const int val)
|
||||
{
|
||||
//--- select by value
|
||||
switch(val)
|
||||
{
|
||||
case ENUM_MA_METHOD::MODE_SMA:
|
||||
return("SMA");
|
||||
case ENUM_MA_METHOD::MODE_EMA:
|
||||
return("EMA");
|
||||
case ENUM_MA_METHOD::MODE_SMMA:
|
||||
return("SMMA");
|
||||
case ENUM_MA_METHOD::MODE_LWMA:
|
||||
return("LWMA");
|
||||
}
|
||||
//--- wrong value
|
||||
return("MethodUnknown="+IntegerToString(val));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting value of ENUM_APPLIED_PRICE into string |
|
||||
//+------------------------------------------------------------------+
|
||||
string CIndicator::PriceDescription(const int val)
|
||||
{
|
||||
//--- select by value
|
||||
switch(val)
|
||||
{
|
||||
case ENUM_APPLIED_PRICE::PRICE_CLOSE:
|
||||
return("Close");
|
||||
case ENUM_APPLIED_PRICE::PRICE_OPEN:
|
||||
return("Open");
|
||||
case ENUM_APPLIED_PRICE::PRICE_HIGH:
|
||||
return("High");
|
||||
case ENUM_APPLIED_PRICE::PRICE_LOW:
|
||||
return("Low");
|
||||
case ENUM_APPLIED_PRICE::PRICE_MEDIAN:
|
||||
return("Median");
|
||||
case ENUM_APPLIED_PRICE::PRICE_TYPICAL:
|
||||
return("Typical");
|
||||
case ENUM_APPLIED_PRICE::PRICE_WEIGHTED:
|
||||
return("Weighted");
|
||||
default:
|
||||
//--- is an indicator handle
|
||||
if(val>=10)
|
||||
return("AppliedHandle="+IntegerToString(val));
|
||||
//---
|
||||
break;
|
||||
}
|
||||
//--- wrong value
|
||||
return("PriceUnknown="+IntegerToString(val));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting value of ENUM_APPLIED_VOLUME into string |
|
||||
//+------------------------------------------------------------------+
|
||||
string CIndicator::VolumeDescription(const int val)
|
||||
{
|
||||
//--- select by value
|
||||
switch(val)
|
||||
{
|
||||
case ENUM_APPLIED_VOLUME::VOLUME_TICK:
|
||||
return("Tick");
|
||||
case ENUM_APPLIED_VOLUME::VOLUME_REAL:
|
||||
return("Real");
|
||||
}
|
||||
//--- wrong value
|
||||
return("VolumeUnknown="+IntegerToString(val));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
Reference in New Issue
Block a user