588 lines
21 KiB
MQL5
588 lines
21 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| PaperTrading.mqh |
|
||
|
|
//| Copyright 2023, MetaQuotes Software Corp. |
|
||
|
|
//| https://www.mql5.com |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#property copyright "Copyright 2023, MetaQuotes Software Corp."
|
||
|
|
#property link "https://www.mql5.com"
|
||
|
|
#property version "1.00"
|
||
|
|
#property strict
|
||
|
|
|
||
|
|
#include <Arrays\ArrayObj.mqh>
|
||
|
|
#include <Trade\PositionInfo.mqh>
|
||
|
|
#include "TradeExecutor.mqh"
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Paper Trade Position Class |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CPosition : public CObject
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
ulong ticket; // Position ticket
|
||
|
|
string symbol; // Symbol
|
||
|
|
ENUM_POSITION_TYPE type; // Position type
|
||
|
|
double volume; // Position volume
|
||
|
|
double openPrice; // Open price
|
||
|
|
double stopLoss; // Stop loss level
|
||
|
|
double takeProfit; // Take profit level
|
||
|
|
datetime openTime; // Open time
|
||
|
|
|
||
|
|
// Constructor
|
||
|
|
CPosition(ulong t, string s, ENUM_POSITION_TYPE pt, double v, double op,
|
||
|
|
double sl, double tp, datetime ot) :
|
||
|
|
ticket(t), symbol(s), type(pt), volume(v), openPrice(op),
|
||
|
|
stopLoss(sl), takeProfit(tp), openTime(ot) {}
|
||
|
|
|
||
|
|
// Check if position is closed
|
||
|
|
bool IsClosed() const { return volume <= 0; }
|
||
|
|
|
||
|
|
// Calculate current profit
|
||
|
|
double CalculateProfit(double currentBid, double currentAsk) const
|
||
|
|
{
|
||
|
|
if(IsClosed()) return 0.0;
|
||
|
|
|
||
|
|
double profit = 0.0;
|
||
|
|
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
||
|
|
|
||
|
|
if(type == POSITION_TYPE_BUY)
|
||
|
|
{
|
||
|
|
profit = (currentBid - openPrice) * volume * SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE) / point;
|
||
|
|
}
|
||
|
|
else if(type == POSITION_TYPE_SELL)
|
||
|
|
{
|
||
|
|
profit = (openPrice - currentAsk) * volume * SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE) / point;
|
||
|
|
}
|
||
|
|
|
||
|
|
return profit;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Paper Trading Class |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CPaperTrading
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
CArrayObj m_positions; // Array of open positions
|
||
|
|
double m_balance; // Paper trading balance
|
||
|
|
double m_equity; // Current equity
|
||
|
|
double m_margin; // Used margin
|
||
|
|
double m_freeMargin; // Free margin
|
||
|
|
|
||
|
|
// Simulation parameters
|
||
|
|
bool m_simulateSlippage; // Simulate slippage
|
||
|
|
bool m_simulatePartialFills; // Simulate partial fills
|
||
|
|
double m_maxSlippagePips; // Maximum slippage in pips
|
||
|
|
double m_fillProbability; // Probability of fill (0-1)
|
||
|
|
|
||
|
|
// Statistics
|
||
|
|
int m_totalTrades; // Total number of trades
|
||
|
|
int m_winningTrades; // Number of winning trades
|
||
|
|
int m_losingTrades; // Number of losing trades
|
||
|
|
double m_totalProfit; // Total profit
|
||
|
|
double m_totalLoss; // Total loss
|
||
|
|
|
||
|
|
// Objects
|
||
|
|
CSymbolInfo *m_symbol; // Pointer to symbol info
|
||
|
|
|
||
|
|
// Private methods
|
||
|
|
double ApplySlippage(double price, ENUM_ORDER_TYPE type);
|
||
|
|
double ApplyPartialFill(double requestedVolume);
|
||
|
|
void UpdateMetrics();
|
||
|
|
|
||
|
|
public:
|
||
|
|
CPaperTrading();
|
||
|
|
~CPaperTrading();
|
||
|
|
|
||
|
|
// Initialization
|
||
|
|
bool Initialize(CSymbolInfo *symbol, double initialBalance = 10000.0,
|
||
|
|
bool simulateSlippage = true, bool simulatePartialFills = true,
|
||
|
|
double maxSlippagePips = 1.0, double fillProbability = 0.95);
|
||
|
|
|
||
|
|
// Trading operations
|
||
|
|
bool OpenPosition(ENUM_ORDER_TYPE type, double lots, double price,
|
||
|
|
double sl = 0, double tp = 0);
|
||
|
|
bool ClosePosition(ulong ticket, double lots = 0);
|
||
|
|
bool ModifyPosition(ulong ticket, double sl, double tp);
|
||
|
|
|
||
|
|
// Position management
|
||
|
|
bool SelectPosition(ulong ticket, CPosition *&position);
|
||
|
|
int TotalPositions() const { return m_positions.Total(); }
|
||
|
|
|
||
|
|
// Account information
|
||
|
|
double GetBalance() const { return m_balance; }
|
||
|
|
double GetEquity() const { return m_equity; }
|
||
|
|
double GetMargin() const { return m_margin; }
|
||
|
|
double GetFreeMargin() const { return m_freeMargin; }
|
||
|
|
|
||
|
|
// Statistics
|
||
|
|
int GetTotalTrades() const { return m_totalTrades; }
|
||
|
|
int GetWinningTrades() const { return m_winningTrades; }
|
||
|
|
int GetLosingTrades() const { return m_losingTrades; }
|
||
|
|
double GetTotalProfit() const { return m_totalProfit; }
|
||
|
|
double GetTotalLoss() const { return m_totalLoss; }
|
||
|
|
double GetWinRate() const
|
||
|
|
{
|
||
|
|
return (m_totalTrades > 0) ? (double)m_winningTrades / m_totalTrades * 100.0 : 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Visualization
|
||
|
|
void UpdateVisualization();
|
||
|
|
|
||
|
|
// Update method called on each tick
|
||
|
|
void Update();
|
||
|
|
|
||
|
|
// Check if live trading is allowed based on paper trading results
|
||
|
|
bool IsLiveTradingAllowed();
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Constructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CPaperTrading::CPaperTrading() : m_balance(10000.0),
|
||
|
|
m_equity(10000.0),
|
||
|
|
m_margin(0.0),
|
||
|
|
m_freeMargin(10000.0),
|
||
|
|
m_simulateSlippage(true),
|
||
|
|
m_simulatePartialFills(true),
|
||
|
|
m_maxSlippagePips(1.0),
|
||
|
|
m_fillProbability(0.95),
|
||
|
|
m_totalTrades(0),
|
||
|
|
m_winningTrades(0),
|
||
|
|
m_losingTrades(0),
|
||
|
|
m_totalProfit(0.0),
|
||
|
|
m_totalLoss(0.0),
|
||
|
|
m_symbol(NULL)
|
||
|
|
{
|
||
|
|
m_positions.Clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Destructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CPaperTrading::~CPaperTrading()
|
||
|
|
{
|
||
|
|
m_positions.Clear();
|
||
|
|
m_symbol = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Initialize paper trading |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPaperTrading::Initialize(CSymbolInfo *symbol, double initialBalance,
|
||
|
|
bool simulateSlippage, bool simulatePartialFills,
|
||
|
|
double maxSlippagePips, double fillProbability)
|
||
|
|
{
|
||
|
|
if(symbol == NULL || initialBalance <= 0)
|
||
|
|
{
|
||
|
|
Print("Error: Invalid parameters in PaperTrading initialization");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_symbol = symbol;
|
||
|
|
m_balance = initialBalance;
|
||
|
|
m_equity = initialBalance;
|
||
|
|
m_freeMargin = initialBalance;
|
||
|
|
|
||
|
|
// Set simulation parameters
|
||
|
|
m_simulateSlippage = simulateSlippage;
|
||
|
|
m_simulatePartialFills = simulatePartialFills;
|
||
|
|
m_maxSlippagePips = maxSlippagePips;
|
||
|
|
m_fillProbability = MathMax(0.0, MathMin(1.0, fillProbability));
|
||
|
|
|
||
|
|
// Initialize statistics
|
||
|
|
m_totalTrades = 0;
|
||
|
|
m_winningTrades = 0;
|
||
|
|
m_losingTrades = 0;
|
||
|
|
m_totalProfit = 0.0;
|
||
|
|
m_totalLoss = 0.0;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Open a new position |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPaperTrading::OpenPosition(ENUM_ORDER_TYPE type, double lots, double price,
|
||
|
|
double sl, double tp)
|
||
|
|
{
|
||
|
|
if(m_symbol == NULL || lots <= 0 || price <= 0)
|
||
|
|
{
|
||
|
|
Print("Error: Invalid parameters in OpenPosition");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Apply slippage if enabled
|
||
|
|
double executionPrice = ApplySlippage(price, type);
|
||
|
|
|
||
|
|
// Apply partial fill if enabled
|
||
|
|
double filledLots = m_simulatePartialFills ?
|
||
|
|
ApplyPartialFill(lots) : lots;
|
||
|
|
|
||
|
|
if(filledLots <= 0)
|
||
|
|
{
|
||
|
|
Print("Order not filled (partial fill simulation)");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Generate a unique ticket
|
||
|
|
static ulong lastTicket = 1000;
|
||
|
|
ulong ticket = ++lastTicket;
|
||
|
|
|
||
|
|
// Create and add the position
|
||
|
|
CPosition *position = new CPosition(ticket, m_symbol.Name(),
|
||
|
|
(type == ORDER_TYPE_BUY) ? POSITION_TYPE_BUY : POSITION_TYPE_SELL,
|
||
|
|
filledLots, executionPrice, sl, tp, TimeCurrent());
|
||
|
|
|
||
|
|
if(position == NULL)
|
||
|
|
{
|
||
|
|
Print("Error: Failed to create position object");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_positions.Add(position);
|
||
|
|
|
||
|
|
// Update metrics
|
||
|
|
UpdateMetrics();
|
||
|
|
|
||
|
|
// Update statistics
|
||
|
|
m_totalTrades++;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Close a position |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPaperTrading::ClosePosition(ulong ticket, double lots = 0)
|
||
|
|
{
|
||
|
|
CPosition *position = NULL;
|
||
|
|
|
||
|
|
// Find the position
|
||
|
|
for(int i = 0; i < m_positions.Total(); i++)
|
||
|
|
{
|
||
|
|
CPosition *pos = m_positions.At(i);
|
||
|
|
if(pos != NULL && pos.ticket == ticket && !pos.IsClosed())
|
||
|
|
{
|
||
|
|
position = pos;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(position == NULL)
|
||
|
|
{
|
||
|
|
Print("Error: Position not found or already closed");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate close price with slippage
|
||
|
|
double closePrice = ApplySlippage(
|
||
|
|
(position.type == POSITION_TYPE_BUY) ? m_symbol.Bid() : m_symbol.Ask(),
|
||
|
|
(position.type == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY
|
||
|
|
);
|
||
|
|
|
||
|
|
// Calculate profit/loss
|
||
|
|
double profit = 0.0;
|
||
|
|
double point = m_symbol.Point();
|
||
|
|
double tickValue = m_symbol.TickValue();
|
||
|
|
|
||
|
|
if(position.type == POSITION_TYPE_BUY)
|
||
|
|
{
|
||
|
|
profit = (closePrice - position.openPrice) * position.volume * tickValue / point;
|
||
|
|
}
|
||
|
|
else // POSITION_TYPE_SELL
|
||
|
|
{
|
||
|
|
profit = (position.openPrice - closePrice) * position.volume * tickValue / point;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update balance and statistics
|
||
|
|
m_balance += profit;
|
||
|
|
|
||
|
|
if(profit >= 0)
|
||
|
|
{
|
||
|
|
m_winningTrades++;
|
||
|
|
m_totalProfit += profit;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_losingTrades++;
|
||
|
|
m_totalLoss -= profit; // Loss is stored as positive value
|
||
|
|
}
|
||
|
|
|
||
|
|
// Close the position or reduce its volume
|
||
|
|
if(lots <= 0 || lots >= position.volume)
|
||
|
|
{
|
||
|
|
// Close the entire position
|
||
|
|
position.volume = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Partial close
|
||
|
|
position.volume -= lots;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update metrics
|
||
|
|
UpdateMetrics();
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Modify position's stop loss and take profit |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPaperTrading::ModifyPosition(ulong ticket, double sl, double tp)
|
||
|
|
{
|
||
|
|
CPosition *position = NULL;
|
||
|
|
|
||
|
|
// Find the position
|
||
|
|
for(int i = 0; i < m_positions.Total(); i++)
|
||
|
|
{
|
||
|
|
CPosition *pos = m_positions.At(i);
|
||
|
|
if(pos != NULL && pos.ticket == ticket && !pos.IsClosed())
|
||
|
|
{
|
||
|
|
position = pos;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(position == NULL)
|
||
|
|
{
|
||
|
|
Print("Error: Position not found or already closed");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update stop loss and take profit
|
||
|
|
position.stopLoss = sl;
|
||
|
|
position.takeProfit = tp;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Select position by ticket |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPaperTrading::SelectPosition(ulong ticket, CPosition *&position)
|
||
|
|
{
|
||
|
|
for(int i = 0; i < m_positions.Total(); i++)
|
||
|
|
{
|
||
|
|
CPosition *pos = m_positions.At(i);
|
||
|
|
if(pos != NULL && pos.ticket == ticket && !pos.IsClosed())
|
||
|
|
{
|
||
|
|
position = pos;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
position = NULL;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Apply slippage to price |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CPaperTrading::ApplySlippage(double price, ENUM_ORDER_TYPE type)
|
||
|
|
{
|
||
|
|
if(!m_simulateSlippage || m_maxSlippagePips <= 0)
|
||
|
|
return price;
|
||
|
|
|
||
|
|
// Generate random slippage (can be positive or negative)
|
||
|
|
double slippagePips = ((double)MathRand() / 32767.0 - 0.5) * 2.0 * m_maxSlippagePips;
|
||
|
|
double point = m_symbol.Point();
|
||
|
|
|
||
|
|
// For buy orders, slippage is added to the price (worse execution)
|
||
|
|
// For sell orders, slippage is subtracted from the price (worse execution)
|
||
|
|
if(type == ORDER_TYPE_BUY)
|
||
|
|
return price + slippagePips * point;
|
||
|
|
else
|
||
|
|
return price - slippagePips * point;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Apply partial fill to order |
|
||
|
|
//+------------------------------------------------------------------
|
||
|
|
double CPaperTrading::ApplyPartialFill(double requestedVolume)
|
||
|
|
{
|
||
|
|
if(!m_simulatePartialFills || m_fillProbability >= 1.0)
|
||
|
|
return requestedVolume;
|
||
|
|
|
||
|
|
// Check if order is filled based on probability
|
||
|
|
if(((double)MathRand() / 32767.0) > m_fillProbability)
|
||
|
|
return 0.0; // Order not filled
|
||
|
|
|
||
|
|
// For simplicity, we either fill the entire order or nothing
|
||
|
|
// In a more advanced simulation, you could implement partial fills
|
||
|
|
return requestedVolume;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update account metrics |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPaperTrading::UpdateMetrics()
|
||
|
|
{
|
||
|
|
if(m_symbol == NULL)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Update current prices
|
||
|
|
m_symbol.RefreshRates();
|
||
|
|
|
||
|
|
// Calculate equity and margin
|
||
|
|
double floatingProfit = 0.0;
|
||
|
|
m_margin = 0.0;
|
||
|
|
|
||
|
|
// Calculate floating P/L and used margin for all open positions
|
||
|
|
for(int i = 0; i < m_positions.Total(); i++)
|
||
|
|
{
|
||
|
|
CPosition *pos = m_positions.At(i);
|
||
|
|
if(pos != NULL && !pos.IsClosed())
|
||
|
|
{
|
||
|
|
// Calculate floating profit/loss
|
||
|
|
if(pos.type == POSITION_TYPE_BUY)
|
||
|
|
{
|
||
|
|
floatingProfit += (m_symbol.Bid() - pos.openPrice) * pos.volume *
|
||
|
|
m_symbol.TickValue() / m_symbol.Point();
|
||
|
|
}
|
||
|
|
else // POSITION_TYPE_SELL
|
||
|
|
{
|
||
|
|
floatingProfit += (pos.openPrice - m_symbol.Ask()) * pos.volume *
|
||
|
|
m_symbol.TickValue() / m_symbol.Point();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate margin (simplified)
|
||
|
|
m_margin += pos.volume * pos.openPrice / 100.0; // 1:100 leverage
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update equity and free margin
|
||
|
|
m_equity = m_balance + floatingProfit;
|
||
|
|
m_freeMargin = m_equity - m_margin;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update method called on each tick |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPaperTrading::Update()
|
||
|
|
{
|
||
|
|
// Update metrics and visualization
|
||
|
|
UpdateMetrics();
|
||
|
|
UpdateVisualization();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Check if live trading is allowed based on paper trading results |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPaperTrading::IsLiveTradingAllowed()
|
||
|
|
{
|
||
|
|
// Check if we have enough trades
|
||
|
|
if(m_totalTrades < 5) // Minimum number of trades required
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// Check win rate (e.g., at least 60% win rate)
|
||
|
|
double winRate = GetWinRate();
|
||
|
|
if(winRate < 60.0)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// Check profit factor (e.g., at least 1.5)
|
||
|
|
double profitFactor = (m_totalLoss != 0) ? m_totalProfit / m_totalLoss : m_totalProfit;
|
||
|
|
if(profitFactor < 1.5)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// All conditions met, allow live trading
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update visualization |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPaperTrading::UpdateVisualization()
|
||
|
|
{
|
||
|
|
// Update metrics first
|
||
|
|
UpdateMetrics();
|
||
|
|
|
||
|
|
// Create or update panel
|
||
|
|
string panelName = "PaperTrading_Panel";
|
||
|
|
|
||
|
|
// Create panel background
|
||
|
|
if(ObjectFind(0, panelName) < 0)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, panelName, OBJ_RECTANGLE_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_XDISTANCE, 10);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_YDISTANCE, 150);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_XSIZE, 200);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_YSIZE, 120);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_BGCOLOR, clrWhiteSmoke);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_COLOR, clrDimGray);
|
||
|
|
ObjectSetInteger(0, panelName, OBJPROP_BACK, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create or update title
|
||
|
|
string titleName = panelName + "_Title";
|
||
|
|
if(ObjectFind(0, titleName) < 0)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, titleName, OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, titleName, OBJPROP_COLOR, clrBlack);
|
||
|
|
ObjectSetInteger(0, titleName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
||
|
|
ObjectSetInteger(0, titleName, OBJPROP_XDISTANCE, 20);
|
||
|
|
ObjectSetInteger(0, titleName, OBJPROP_YDISTANCE, 160);
|
||
|
|
ObjectSetInteger(0, titleName, OBJPROP_FONTSIZE, 10);
|
||
|
|
}
|
||
|
|
ObjectSetString(0, titleName, OBJPROP_TEXT, "PAPER TRADING");
|
||
|
|
|
||
|
|
// Create or update balance label
|
||
|
|
string balanceName = panelName + "_Balance";
|
||
|
|
if(ObjectFind(0, balanceName) < 0)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, balanceName, OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, balanceName, OBJPROP_COLOR, clrBlack);
|
||
|
|
ObjectSetInteger(0, balanceName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
||
|
|
ObjectSetInteger(0, balanceName, OBJPROP_XDISTANCE, 20);
|
||
|
|
ObjectSetInteger(0, balanceName, OBJPROP_YDISTANCE, 180);
|
||
|
|
ObjectSetInteger(0, balanceName, OBJPROP_FONTSIZE, 9);
|
||
|
|
}
|
||
|
|
ObjectSetString(0, balanceName, OBJPROP_TEXT, "Balance: " + DoubleToString(m_balance, 2));
|
||
|
|
|
||
|
|
// Create or update equity label
|
||
|
|
string equityName = panelName + "_Equity";
|
||
|
|
if(ObjectFind(0, equityName) < 0)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, equityName, OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, equityName, OBJPROP_COLOR, clrBlack);
|
||
|
|
ObjectSetInteger(0, equityName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
||
|
|
ObjectSetInteger(0, equityName, OBJPROP_XDISTANCE, 20);
|
||
|
|
ObjectSetInteger(0, equityName, OBJPROP_YDISTANCE, 200);
|
||
|
|
ObjectSetInteger(0, equityName, OBJPROP_FONTSIZE, 9);
|
||
|
|
}
|
||
|
|
ObjectSetString(0, equityName, OBJPROP_TEXT, "Equity: " + DoubleToString(m_equity, 2));
|
||
|
|
|
||
|
|
// Create or update margin label
|
||
|
|
string marginName = panelName + "_Margin";
|
||
|
|
if(ObjectFind(0, marginName) < 0)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, marginName, OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, marginName, OBJPROP_COLOR, clrBlack);
|
||
|
|
ObjectSetInteger(0, marginName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
||
|
|
ObjectSetInteger(0, marginName, OBJPROP_XDISTANCE, 20);
|
||
|
|
ObjectSetInteger(0, marginName, OBJPROP_YDISTANCE, 220);
|
||
|
|
ObjectSetInteger(0, marginName, OBJPROP_FONTSIZE, 9);
|
||
|
|
}
|
||
|
|
ObjectSetString(0, marginName, OBJPROP_TEXT, "Margin: " + DoubleToString(m_margin, 2));
|
||
|
|
|
||
|
|
// Create or update free margin label
|
||
|
|
string freeMarginName = panelName + "_FreeMargin";
|
||
|
|
if(ObjectFind(0, freeMarginName) < 0)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, freeMarginName, OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, freeMarginName, OBJPROP_COLOR, clrBlack);
|
||
|
|
ObjectSetInteger(0, freeMarginName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
||
|
|
ObjectSetInteger(0, freeMarginName, OBJPROP_XDISTANCE, 20);
|
||
|
|
ObjectSetInteger(0, freeMarginName, OBJPROP_YDISTANCE, 240);
|
||
|
|
ObjectSetInteger(0, freeMarginName, OBJPROP_FONTSIZE, 9);
|
||
|
|
}
|
||
|
|
ObjectSetString(0, freeMarginName, OBJPROP_TEXT, "Free Margin: " + DoubleToString(m_freeMargin, 2));
|
||
|
|
|
||
|
|
// Update the chart
|
||
|
|
ChartRedraw();
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|