902 lines
35 KiB
MQL5
902 lines
35 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| FdSymbolInfo.mqh |
|
|
//| Copyright Jan 2021, Alexey Vochanskiy |
|
|
//| https://www.mql5.com/ru/users/vdev |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright Jan 2021, Alexey Vochanskiy"
|
|
#property link "https://www.mql5.com/ru/users/vdev"
|
|
#property version "1.01"
|
|
|
|
#include <Object.mqh>
|
|
|
|
// Code for MQL5
|
|
#ifdef __MQL5__
|
|
#include <Trade/SymbolInfo.mqh>
|
|
|
|
class CFdSymbolInfo : public CSymbolInfo {
|
|
public:
|
|
CFdSymbolInfo()
|
|
{
|
|
//CSymbolInfo::CSymbolInfo();
|
|
}
|
|
~CFdSymbolInfo() { }
|
|
};
|
|
#endif
|
|
|
|
// Code for MQL4
|
|
#ifdef __MQL4__
|
|
class CFdSymbolInfo : public CObject {
|
|
protected:
|
|
string m_name; // symbol name
|
|
MqlTick m_tick; // structure of tick;
|
|
double m_point; // symbol point
|
|
double m_tick_value; // symbol tick value
|
|
double m_tick_value_profit; // symbol tick value profit
|
|
double m_tick_value_loss; // symbol tick value loss
|
|
double m_tick_size; // symbol tick size
|
|
double m_contract_size; // symbol contract size
|
|
double m_lots_min; // symbol lots min
|
|
double m_lots_max; // symbol lots max
|
|
double m_lots_step; // symbol lots step
|
|
double m_lots_limit; // symbol lots limit
|
|
double m_swap_long; // symbol swap long
|
|
double m_swap_short; // symbol swap short
|
|
int m_digits; // symbol digits
|
|
int m_order_mode; // symbol valid orders
|
|
ENUM_SYMBOL_TRADE_EXECUTION m_trade_execution; // symbol trade execution
|
|
//ENUM_SYMBOL_CALC_MODE m_trade_calcmode; // symbol trade calcmode
|
|
ENUM_SYMBOL_TRADE_MODE m_trade_mode; // symbol trade mode
|
|
//ENUM_SYMBOL_SWAP_MODE m_swap_mode; // symbol swap mode
|
|
ENUM_DAY_OF_WEEK m_swap3; // symbol swap3
|
|
double m_margin_initial; // symbol margin initial
|
|
double m_margin_maintenance; // symbol margin maintenance
|
|
bool m_margin_hedged_use_leg; // calculate hedged margin using larger leg
|
|
double m_margin_hedged; // symbol margin hedged
|
|
int m_trade_time_flags; // symbol trade time flags
|
|
int m_trade_fill_flags; // symbol trade fill flags
|
|
|
|
public:
|
|
CFdSymbolInfo();
|
|
~CFdSymbolInfo();
|
|
//--- methods of access to protected data
|
|
string Name(void) const
|
|
{
|
|
return(m_name);
|
|
}
|
|
bool Name(const string name);
|
|
bool Refresh(void);
|
|
bool RefreshRates(void);
|
|
//--- fast access methods to the integer symbol propertyes
|
|
bool Select(void) const;
|
|
bool Select(const bool select);
|
|
bool IsSynchronized(void) const;
|
|
//--- volumes
|
|
ulong Volume(void) const
|
|
{
|
|
return(m_tick.volume);
|
|
}
|
|
ulong VolumeHigh(void) const;
|
|
ulong VolumeLow(void) const;
|
|
//--- miscellaneous
|
|
datetime Time(void) const
|
|
{
|
|
return(m_tick.time);
|
|
}
|
|
int Spread(void) const;
|
|
bool SpreadFloat(void) const;
|
|
int TicksBookDepth(void) const;
|
|
//--- trade levels
|
|
int StopsLevel(void) const;
|
|
int FreezeLevel(void) const;
|
|
//--- fast access methods to the double symbol propertyes
|
|
//--- bid parameters
|
|
double Bid(void) const
|
|
{
|
|
return(m_tick.bid);
|
|
}
|
|
double BidHigh(void) const;
|
|
double BidLow(void) const;
|
|
//--- ask parameters
|
|
double Ask(void) const
|
|
{
|
|
return(m_tick.ask);
|
|
}
|
|
double AskHigh(void) const;
|
|
double AskLow(void) const;
|
|
//--- last parameters
|
|
double Last(void) const
|
|
{
|
|
return(m_tick.last);
|
|
}
|
|
double LastHigh(void) const;
|
|
double LastLow(void) const;
|
|
//--- fast access methods to the mix symbol propertyes
|
|
int OrderMode(void) const
|
|
{
|
|
return(m_order_mode);
|
|
}
|
|
//--- terms of trade
|
|
//ENUM_SYMBOL_CALC_MODE TradeCalcMode(void) const { return(m_trade_calcmode); }
|
|
string TradeCalcModeDescription(void) const;
|
|
ENUM_SYMBOL_TRADE_MODE TradeMode(void) const
|
|
{
|
|
return(m_trade_mode);
|
|
}
|
|
string TradeModeDescription(void) const;
|
|
//--- execution terms of trade
|
|
ENUM_SYMBOL_TRADE_EXECUTION TradeExecution(void) const
|
|
{
|
|
return(m_trade_execution);
|
|
}
|
|
string TradeExecutionDescription(void) const;
|
|
//--- swap terms of trade
|
|
//ENUM_SYMBOL_SWAP_MODE SwapMode(void) const { return(m_swap_mode); }
|
|
string SwapModeDescription(void) const;
|
|
ENUM_DAY_OF_WEEK SwapRollover3days(void) const
|
|
{
|
|
return(m_swap3);
|
|
}
|
|
string SwapRollover3daysDescription(void) const;
|
|
//--- dates for futures
|
|
datetime StartTime(void) const;
|
|
datetime ExpirationTime(void) const;
|
|
//--- margin parameters
|
|
double MarginInitial(void) const
|
|
{
|
|
return(m_margin_initial);
|
|
}
|
|
double MarginMaintenance(void) const
|
|
{
|
|
return(m_margin_maintenance);
|
|
}
|
|
bool MarginHedgedUseLeg(void) const
|
|
{
|
|
return(m_margin_hedged_use_leg);
|
|
}
|
|
double MarginHedged(void) const
|
|
{
|
|
return(m_margin_hedged);
|
|
}
|
|
//--- left for backward compatibility
|
|
double MarginLong(void) const
|
|
{
|
|
return(0.0);
|
|
}
|
|
double MarginShort(void) const
|
|
{
|
|
return(0.0);
|
|
}
|
|
double MarginLimit(void) const
|
|
{
|
|
return(0.0);
|
|
}
|
|
double MarginStop(void) const
|
|
{
|
|
return(0.0);
|
|
}
|
|
double MarginStopLimit(void) const
|
|
{
|
|
return(0.0);
|
|
}
|
|
//--- trade flags parameters
|
|
int TradeTimeFlags(void) const
|
|
{
|
|
return(m_trade_time_flags);
|
|
}
|
|
int TradeFillFlags(void) const
|
|
{
|
|
return(m_trade_fill_flags);
|
|
}
|
|
//--- tick parameters
|
|
int Digits(void) const
|
|
{
|
|
return(m_digits);
|
|
}
|
|
double Point(void) const
|
|
{
|
|
return(m_point);
|
|
}
|
|
double TickValue(void) const
|
|
{
|
|
return(m_tick_value);
|
|
}
|
|
double TickValueProfit(void) const
|
|
{
|
|
return(m_tick_value_profit);
|
|
}
|
|
double TickValueLoss(void) const
|
|
{
|
|
return(m_tick_value_loss);
|
|
}
|
|
double TickSize(void) const
|
|
{
|
|
return(m_tick_size);
|
|
}
|
|
//--- lots parameters
|
|
double ContractSize(void) const
|
|
{
|
|
return(m_contract_size);
|
|
}
|
|
double LotsMin(void) const
|
|
{
|
|
return(m_lots_min);
|
|
}
|
|
double LotsMax(void) const
|
|
{
|
|
return(m_lots_max);
|
|
}
|
|
double LotsStep(void) const
|
|
{
|
|
return(m_lots_step);
|
|
}
|
|
double LotsLimit(void) const
|
|
{
|
|
return(m_lots_limit);
|
|
}
|
|
//--- swaps
|
|
double SwapLong(void) const
|
|
{
|
|
return(m_swap_long);
|
|
}
|
|
double SwapShort(void) const
|
|
{
|
|
return(m_swap_short);
|
|
}
|
|
//--- fast access methods to the string symbol propertyes
|
|
string CurrencyBase(void) const;
|
|
string CurrencyProfit(void) const;
|
|
string CurrencyMargin(void) const;
|
|
string Bank(void) const;
|
|
string Description(void) const;
|
|
string Path(void) const;
|
|
//--- session information
|
|
long SessionDeals(void) const;
|
|
long SessionBuyOrders(void) const;
|
|
long SessionSellOrders(void) const;
|
|
double SessionTurnover(void) const;
|
|
double SessionInterest(void) const;
|
|
double SessionBuyOrdersVolume(void) const;
|
|
double SessionSellOrdersVolume(void) const;
|
|
double SessionOpen(void) const;
|
|
double SessionClose(void) const;
|
|
double SessionAW(void) const;
|
|
double SessionPriceSettlement(void) const;
|
|
double SessionPriceLimitMin(void) const;
|
|
double SessionPriceLimitMax(void) const;
|
|
//--- access methods to the API MQL5 functions
|
|
bool InfoInteger(const ENUM_SYMBOL_INFO_INTEGER prop_id, long& var) const;
|
|
bool InfoDouble(const ENUM_SYMBOL_INFO_DOUBLE prop_id, double& var) const;
|
|
bool InfoString(const ENUM_SYMBOL_INFO_STRING prop_id, string& var) const;
|
|
bool InfoMarginRate(const ENUM_ORDER_TYPE order_type, double& initial_margin_rate, double& maintenance_margin_rate) const;
|
|
//--- service methods
|
|
double NormalizePrice(const double price) const;
|
|
bool CheckMarketWatch(void);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CFdSymbolInfo::CFdSymbolInfo(void) : m_name(NULL),
|
|
m_point(0.0),
|
|
m_tick_value(0.0),
|
|
m_tick_value_profit(0.0),
|
|
m_tick_value_loss(0.0),
|
|
m_tick_size(0.0),
|
|
m_contract_size(0.0),
|
|
m_lots_min(0.0),
|
|
m_lots_max(0.0),
|
|
m_lots_step(0.0),
|
|
m_swap_long(0.0),
|
|
m_swap_short(0.0),
|
|
m_digits(0),
|
|
m_order_mode(0),
|
|
m_trade_execution(0),
|
|
//m_trade_calcmode(0),
|
|
//m_trade_mode(0),
|
|
//m_swap_mode(0),
|
|
m_swap3(0),
|
|
m_margin_initial(0.0),
|
|
m_margin_maintenance(0.0),
|
|
m_margin_hedged_use_leg(false),
|
|
m_margin_hedged(0.0),
|
|
m_trade_time_flags(0),
|
|
m_trade_fill_flags(0)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CFdSymbolInfo::~CFdSymbolInfo(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Set name |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::Name(const string name)
|
|
{
|
|
string symbol_name=StringLen(name)>0 ? name : _Symbol;
|
|
//--- check previous set name
|
|
if(m_name!=symbol_name) {
|
|
m_name=symbol_name;
|
|
//---
|
|
if(!CheckMarketWatch())
|
|
return(false);
|
|
//---
|
|
if(!Refresh()) {
|
|
m_name="";
|
|
Print(__FUNCTION__+": invalid data of symbol '"+symbol_name+"'");
|
|
return(false);
|
|
}
|
|
}
|
|
//--- succeed
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Refresh cached data |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::Refresh(void)
|
|
{
|
|
long tmp_long=0;
|
|
//---
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_POINT, m_point))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_VALUE, m_tick_value))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_VALUE_PROFIT, m_tick_value_profit))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_VALUE_LOSS, m_tick_value_loss))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_SIZE, m_tick_size))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_CONTRACT_SIZE, m_contract_size))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_MIN, m_lots_min))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_MAX, m_lots_max))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_STEP, m_lots_step))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_LIMIT, m_lots_limit))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_SWAP_LONG, m_swap_long))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_SWAP_SHORT, m_swap_short))
|
|
return(false);
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_DIGITS, tmp_long))
|
|
return(false);
|
|
m_digits=(int)tmp_long;
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_ORDER_MODE, tmp_long))
|
|
return(false);
|
|
m_order_mode=(int)tmp_long;
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_TRADE_EXEMODE, tmp_long))
|
|
return(false);
|
|
m_trade_execution=(ENUM_SYMBOL_TRADE_EXECUTION)tmp_long;
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_TRADE_CALC_MODE, tmp_long))
|
|
return(false);
|
|
/* m_trade_calcmode=(ENUM_SYMBOL_CALC_MODE)tmp_long;
|
|
if(!SymbolInfoInteger(m_name,SYMBOL_TRADE_MODE,tmp_long))
|
|
return(false);*/
|
|
m_trade_mode=(ENUM_SYMBOL_TRADE_MODE)tmp_long;
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_SWAP_MODE, tmp_long))
|
|
return(false);
|
|
/* m_swap_mode=(ENUM_SYMBOL_SWAP_MODE)tmp_long;
|
|
if(!SymbolInfoInteger(m_name,SYMBOL_SWAP_ROLLOVER3DAYS,tmp_long))
|
|
return(false);*/
|
|
m_swap3=(ENUM_DAY_OF_WEEK)tmp_long;
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_MARGIN_INITIAL, m_margin_initial))
|
|
return(false);
|
|
if(!SymbolInfoDouble(m_name, SYMBOL_MARGIN_MAINTENANCE, m_margin_maintenance))
|
|
return(false);
|
|
/* if(!SymbolInfoDouble(m_name,SYMBOL_MARGIN_HEDGED,m_margin_hedged))
|
|
return(false);
|
|
if(!SymbolInfoInteger(m_name,SYMBOL_MARGIN_HEDGED_USE_LEG,tmp_long))
|
|
return(false);*/
|
|
m_margin_hedged_use_leg=(bool)tmp_long;
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_EXPIRATION_MODE, tmp_long))
|
|
return(false);
|
|
m_trade_time_flags=(int)tmp_long;
|
|
if(!SymbolInfoInteger(m_name, SYMBOL_FILLING_MODE, tmp_long))
|
|
return(false);
|
|
m_trade_fill_flags=(int)tmp_long;
|
|
//--- succeed
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Refresh cached data |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::RefreshRates(void)
|
|
{
|
|
return(SymbolInfoTick(m_name, m_tick));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SELECT" |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::Select(void) const
|
|
{
|
|
return((bool)SymbolInfoInteger(m_name, SYMBOL_SELECT));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Set the property value "SYMBOL_SELECT" |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::Select(const bool select)
|
|
{
|
|
return(SymbolSelect(m_name, select));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Check synchronize symbol |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::IsSynchronized(void) const
|
|
{
|
|
return(SymbolIsSynchronized(m_name));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_VOLUMEHIGH" |
|
|
//+------------------------------------------------------------------+
|
|
ulong CFdSymbolInfo::VolumeHigh(void) const
|
|
{
|
|
return(SymbolInfoInteger(m_name, SYMBOL_VOLUMEHIGH));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_VOLUMELOW" |
|
|
//+------------------------------------------------------------------+
|
|
ulong CFdSymbolInfo::VolumeLow(void) const
|
|
{
|
|
return(SymbolInfoInteger(m_name, SYMBOL_VOLUMELOW));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SPREAD" |
|
|
//+------------------------------------------------------------------+
|
|
int CFdSymbolInfo::Spread(void) const
|
|
{
|
|
return((int)SymbolInfoInteger(m_name, SYMBOL_SPREAD));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SPREAD_FLOAT" |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::SpreadFloat(void) const
|
|
{
|
|
return((bool)SymbolInfoInteger(m_name, SYMBOL_SPREAD_FLOAT));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_TICKS_BOOKDEPTH" |
|
|
//+------------------------------------------------------------------+
|
|
int CFdSymbolInfo::TicksBookDepth(void) const
|
|
{
|
|
return((int)SymbolInfoInteger(m_name, SYMBOL_TICKS_BOOKDEPTH));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_TRADE_STOPS_LEVEL" |
|
|
//+------------------------------------------------------------------+
|
|
int CFdSymbolInfo::StopsLevel(void) const
|
|
{
|
|
return((int)SymbolInfoInteger(m_name, SYMBOL_TRADE_STOPS_LEVEL));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_TRADE_FREEZE_LEVEL" |
|
|
//+------------------------------------------------------------------+
|
|
int CFdSymbolInfo::FreezeLevel(void) const
|
|
{
|
|
return((int)SymbolInfoInteger(m_name, SYMBOL_TRADE_FREEZE_LEVEL));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_BIDHIGH" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::BidHigh(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_BIDHIGH));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_BIDLOW" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::BidLow(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_BIDLOW));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_ASKHIGH" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::AskHigh(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_ASKHIGH));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_ASKLOW" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::AskLow(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_ASKLOW));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_LASTHIGH" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::LastHigh(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_LASTHIGH));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_LASTLOW" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::LastLow(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_LASTLOW));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_TRADE_CALC_MODE" as string |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::TradeCalcModeDescription(void) const
|
|
{
|
|
string str;
|
|
/*
|
|
switch(m_trade_calcmode) {
|
|
case SYMBOL_CALC_MODE_FOREX:
|
|
str="Calculation of profit and margin for Forex";
|
|
break;
|
|
case SYMBOL_CALC_MODE_CFD:
|
|
str="Calculation of collateral and earnings for CFD";
|
|
break;
|
|
case SYMBOL_CALC_MODE_FUTURES:
|
|
str="Calculation of collateral and profits for futures";
|
|
break;
|
|
case SYMBOL_CALC_MODE_CFDINDEX:
|
|
str="Calculation of collateral and earnings for CFD on indices";
|
|
break;
|
|
case SYMBOL_CALC_MODE_CFDLEVERAGE:
|
|
str="Calculation of collateral and earnings for the CFD when trading with leverage";
|
|
break;
|
|
case SYMBOL_CALC_MODE_EXCH_STOCKS:
|
|
str="Calculation for exchange stocks";
|
|
break;
|
|
case SYMBOL_CALC_MODE_EXCH_FUTURES:
|
|
str="Calculation for exchange futures";
|
|
break;
|
|
case SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS:
|
|
str="Calculation for FORTS futures";
|
|
break;
|
|
default:
|
|
str="Unknown calculation mode";
|
|
}
|
|
*/
|
|
return(str);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_TRADE_MODE" as string |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::TradeModeDescription(void) const
|
|
{
|
|
string str;
|
|
//---
|
|
switch(m_trade_mode) {
|
|
case SYMBOL_TRADE_MODE_DISABLED:
|
|
str="Disabled";
|
|
break;
|
|
case SYMBOL_TRADE_MODE_LONGONLY:
|
|
str="Long only";
|
|
break;
|
|
case SYMBOL_TRADE_MODE_SHORTONLY:
|
|
str="Short only";
|
|
break;
|
|
case SYMBOL_TRADE_MODE_CLOSEONLY:
|
|
str="Close only";
|
|
break;
|
|
case SYMBOL_TRADE_MODE_FULL:
|
|
str="Full access";
|
|
break;
|
|
default:
|
|
str="Unknown trade mode";
|
|
}
|
|
//--- result
|
|
return(str);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_TRADE_EXEMODE" as string |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::TradeExecutionDescription(void) const
|
|
{
|
|
string str;
|
|
//---
|
|
switch(m_trade_execution) {
|
|
case SYMBOL_TRADE_EXECUTION_REQUEST:
|
|
str="Trading on request";
|
|
break;
|
|
case SYMBOL_TRADE_EXECUTION_INSTANT:
|
|
str="Trading on live streaming prices";
|
|
break;
|
|
case SYMBOL_TRADE_EXECUTION_MARKET:
|
|
str="Execution of orders on the market";
|
|
break;
|
|
case SYMBOL_TRADE_EXECUTION_EXCHANGE:
|
|
str="Exchange execution";
|
|
break;
|
|
default:
|
|
str="Unknown trade execution";
|
|
}
|
|
//--- result
|
|
return(str);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SWAP_MODE" as string |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::SwapModeDescription(void) const
|
|
{
|
|
string str;
|
|
/*
|
|
switch(m_swap_mode) {
|
|
case SYMBOL_SWAP_MODE_DISABLED:
|
|
str="No swaps";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_POINTS:
|
|
str="Swaps are calculated in points";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_CURRENCY_SYMBOL:
|
|
str="Swaps are calculated in base currency";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_CURRENCY_MARGIN:
|
|
str="Swaps are calculated in margin currency";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT:
|
|
str="Swaps are calculated in deposit currency";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_INTEREST_CURRENT:
|
|
str="Swaps are calculated as annual interest using the current price";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_INTEREST_OPEN:
|
|
str="Swaps are calculated as annual interest using the open price";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_REOPEN_CURRENT:
|
|
str="Swaps are charged by reopening positions at the close price";
|
|
break;
|
|
case SYMBOL_SWAP_MODE_REOPEN_BID:
|
|
str="Swaps are charged by reopening positions at the Bid price";
|
|
break;
|
|
default:
|
|
str="Unknown swap mode";
|
|
}
|
|
*/
|
|
return(str);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SWAP_ROLLOVER3DAYS" as string |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::SwapRollover3daysDescription(void) const
|
|
{
|
|
string str;
|
|
//---
|
|
switch(m_swap3) {
|
|
case SUNDAY:
|
|
str="Sunday";
|
|
break;
|
|
case MONDAY:
|
|
str="Monday";
|
|
break;
|
|
case TUESDAY:
|
|
str="Tuesday";
|
|
break;
|
|
case WEDNESDAY:
|
|
str="Wednesday";
|
|
break;
|
|
case THURSDAY:
|
|
str="Thursday";
|
|
break;
|
|
case FRIDAY:
|
|
str="Friday";
|
|
break;
|
|
case SATURDAY:
|
|
str="Saturday";
|
|
break;
|
|
default:
|
|
str="Unknown";
|
|
}
|
|
//--- result
|
|
return(str);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_START_TIME" |
|
|
//+------------------------------------------------------------------+
|
|
datetime CFdSymbolInfo::StartTime(void) const
|
|
{
|
|
return((datetime)SymbolInfoInteger(m_name, SYMBOL_START_TIME));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_EXPIRATION_TIME" |
|
|
//+------------------------------------------------------------------+
|
|
datetime CFdSymbolInfo::ExpirationTime(void) const
|
|
{
|
|
return((datetime)SymbolInfoInteger(m_name, SYMBOL_EXPIRATION_TIME));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_CURRENCY_BASE" |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::CurrencyBase(void) const
|
|
{
|
|
return(SymbolInfoString(m_name, SYMBOL_CURRENCY_BASE));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_CURRENCY_PROFIT" |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::CurrencyProfit(void) const
|
|
{
|
|
return(SymbolInfoString(m_name, SYMBOL_CURRENCY_PROFIT));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_CURRENCY_MARGIN" |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::CurrencyMargin(void) const
|
|
{
|
|
return(SymbolInfoString(m_name, SYMBOL_CURRENCY_MARGIN));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_BANK" |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::Bank(void) const
|
|
{
|
|
return(SymbolInfoString(m_name, SYMBOL_BANK));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_DESCRIPTION" |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::Description(void) const
|
|
{
|
|
return(SymbolInfoString(m_name, SYMBOL_DESCRIPTION));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_PATH" |
|
|
//+------------------------------------------------------------------+
|
|
string CFdSymbolInfo::Path(void) const
|
|
{
|
|
return(SymbolInfoString(m_name, SYMBOL_PATH));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_DEALS" |
|
|
//+------------------------------------------------------------------+
|
|
long CFdSymbolInfo::SessionDeals(void) const
|
|
{
|
|
return(SymbolInfoInteger(m_name, SYMBOL_SESSION_DEALS));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_BUY_ORDERS" |
|
|
//+------------------------------------------------------------------+
|
|
long CFdSymbolInfo::SessionBuyOrders(void) const
|
|
{
|
|
return(SymbolInfoInteger(m_name, SYMBOL_SESSION_BUY_ORDERS));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_SELL_ORDERS" |
|
|
//+------------------------------------------------------------------+
|
|
long CFdSymbolInfo::SessionSellOrders(void) const
|
|
{
|
|
return(SymbolInfoInteger(m_name, SYMBOL_SESSION_SELL_ORDERS));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_TURNOVER" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionTurnover(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_TURNOVER));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_INTEREST" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionInterest(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_INTEREST));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_BUY_ORDERS_VOLUME" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionBuyOrdersVolume(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_BUY_ORDERS_VOLUME));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_SELL_ORDERS_VOLUME" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionSellOrdersVolume(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_SELL_ORDERS_VOLUME));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_OPEN" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionOpen(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_OPEN));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_CLOSE" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionClose(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_CLOSE));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_AW" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionAW(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_AW));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_PRICE_SETTLEMENT" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionPriceSettlement(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_PRICE_SETTLEMENT));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_PRICE_LIMIT_MIN" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionPriceLimitMin(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_PRICE_LIMIT_MIN));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get the property value "SYMBOL_SESSION_PRICE_LIMIT_MAX" |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::SessionPriceLimitMax(void) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, SYMBOL_SESSION_PRICE_LIMIT_MAX));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access functions SymbolInfoInteger(...) |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::InfoInteger(const ENUM_SYMBOL_INFO_INTEGER prop_id, long &var) const
|
|
{
|
|
return(SymbolInfoInteger(m_name, prop_id, var));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access functions SymbolInfoDouble(...) |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::InfoDouble(const ENUM_SYMBOL_INFO_DOUBLE prop_id, double &var) const
|
|
{
|
|
return(SymbolInfoDouble(m_name, prop_id, var));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access functions SymbolInfoString(...) |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::InfoString(const ENUM_SYMBOL_INFO_STRING prop_id, string &var) const
|
|
{
|
|
return(SymbolInfoString(m_name, prop_id, var));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access functions SymbolInfoMarginRate(...) |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::InfoMarginRate(const ENUM_ORDER_TYPE order_type, double& initial_margin_rate, double& maintenance_margin_rate) const
|
|
{
|
|
//return(SymbolInfoMarginRate(m_name, order_type, initial_margin_rate, maintenance_margin_rate));
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Normalize price |
|
|
//+------------------------------------------------------------------+
|
|
double CFdSymbolInfo::NormalizePrice(const double price) const
|
|
{
|
|
if(m_tick_size!=0)
|
|
return(NormalizeDouble(MathRound(price/m_tick_size)*m_tick_size, m_digits));
|
|
//---
|
|
return(NormalizeDouble(price, m_digits));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Checks if symbol is selected in the MarketWatch |
|
|
//| and adds symbol to the MarketWatch, if necessary |
|
|
//+------------------------------------------------------------------+
|
|
bool CFdSymbolInfo::CheckMarketWatch(void)
|
|
{
|
|
//--- check if symbol is selected in the MarketWatch
|
|
/*if(!Select()) {
|
|
if(GetLastError()==ERR_MARKET_UNKNOWN_SYMBOL) {
|
|
printf(__FUNCTION__+": Unknown symbol '%s'", m_name);
|
|
return(false);
|
|
}
|
|
if(!Select(true)) {
|
|
printf(__FUNCTION__+": Error adding symbol %d", GetLastError());
|
|
return(false);
|
|
}
|
|
}
|
|
//--- succeed
|
|
return(true);*/
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
#endif
|
|
//+------------------------------------------------------------------+
|