| //+------------------------------------------------------------------+
|
| //| PaperTrading.mqh |
|
| //| Copyright 2025, EscapeEA |
|
| //| https://www.escapeea.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, EscapeEA"
|
| #property link "https://www.escapeea.com"
|
| #property version "2.00"
|
| #property strict
|
|
|
| #include <Trade\PositionInfo.mqh>
|
| #include <Trade\DealInfo.mqh>
|
| #include <Trade\AccountInfo.mqh>
|
| #include <Trade\SymbolInfo.mqh>
|
| #include <Arrays\ArrayObj.mqh>
|
|
|
| // Forward declarations
|
| class CRiskManager; // Forward declaration of RiskManager
|
|
|
| // Include the actual header files after forward declarations
|
| #include "RiskManager.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Paper Trade Settings |
|
| //+------------------------------------------------------------------+
|
| input group "=== Paper Trading Settings ==="
|
| input bool InpEnablePaperTrading = true; // Enable Paper Trading
|
| input int InpPaperTradesRequired = 5; // Total Paper Trades
|
| input int InpPaperWinsRequired = 3; // Required Wins for Live Trading
|
| input double InpPaperInitialBalance = 10000.0; // Initial Paper Balance
|
| input bool InpSimulateSlippage = true; // Simulate Slippage
|
| input bool InpSimulatePartialFills = true; // Simulate Partial Fills
|
| input double InpMaxSlippagePips = 1.0; // Max Slippage (pips)
|
| input int InpFillProbability = 90; // Fill Probability (%)
|
|
|
| //+------------------------------------------------------------------+
|
| //| Paper Trade Structure |
|
| //+------------------------------------------------------------------+
|
| struct SPaperTrade {
|
| ulong ticket; // Trade ticket
|
| string symbol; // Symbol
|
| ENUM_ORDER_TYPE type; // Order type
|
| double volume; // Trade volume
|
| double openPrice; // Open price
|
| double stopLoss; // Stop loss
|
| double takeProfit; // Take profit
|
| datetime openTime; // Open time
|
| datetime closeTime; // Close time
|
| double closePrice; // Close price
|
| double commission; // Commission
|
| double swap; // Swap
|
| double profit; // Profit/loss
|
| bool isClosed; // Is trade closed
|
| bool isWinner; // Is winning trade
|
|
|
| // Constructor
|
| SPaperTrade() {
|
| ticket = 0;
|
| volume = 0.0;
|
| openPrice = 0.0;
|
| stopLoss = 0.0;
|
| takeProfit = 0.0;
|
| closePrice = 0.0;
|
| commission = 0.0;
|
| swap = 0.0;
|
| profit = 0.0;
|
| isClosed = false;
|
| isWinner = false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| CPaperTrading class |
|
| //+------------------------------------------------------------------+
|
| class CPaperTrading
|
| {
|
| private:
|
| // Trade management
|
| CArrayObj m_trades; // Array of paper trades
|
| double m_balance; // Current paper balance
|
| double m_equity; // Current paper equity
|
| int m_totalTrades; // Total paper trades
|
| int m_winningTrades; // Number of winning trades
|
| int m_losingTrades; // Number of losing trades
|
| bool m_liveTrading; // Live trading enabled
|
|
|
| // Simulation parameters
|
| double m_slippage; // Current slippage
|
| double m_spread; // Current spread
|
|
|
| // External components
|
| CSymbolInfo m_symbol; // Symbol info
|
| CAccountInfo m_account; // Account info
|
| CRiskManager *m_riskManager; // Risk manager (forward declared)
|
|
|
| // Private methods
|
| double CalculateCommission(double volume, double price);
|
| double CalculateSwap(double volume, double price, ENUM_ORDER_TYPE type);
|
| double CalculateSlippage();
|
| bool SimulateFill();
|
| void UpdateEquity();
|
|
|
| public:
|
| // Constructor/Destructor
|
| CPaperTrading(CRiskManager *riskManager = NULL);
|
| ~CPaperTrading();
|
|
|
| // Initialization
|
| bool Initialize(CSymbolInfo *symbol, CAccountInfo *account,
|
| CEnhancedRiskManager *riskManager);
|
| void Deinitialize();
|
|
|
| // Trading operations
|
| bool OpenPosition(ENUM_ORDER_TYPE type, double volume,
|
| double price, double sl, double tp,
|
| string comment = "");
|
| bool ClosePosition(ulong ticket, double price);
|
| void CheckForExits();
|
|
|
| // Getters
|
| double GetBalance() const { return m_balance; }
|
| double GetEquity() const { return m_equity; }
|
| int GetTotalTrades() const { return m_totalTrades; }
|
| int GetWinningTrades() const { return m_winningTrades; }
|
| int GetLosingTrades() const { return m_losingTrades; }
|
| double GetWinRate() const {
|
| return (m_totalTrades > 0) ? (double)m_winningTrades / m_totalTrades * 100.0 : 0.0;
|
| }
|
| bool IsLiveTradingAllowed() const {
|
| return m_liveTrading || (!InpEnablePaperTrading);
|
| }
|
|
|
| // State management
|
| void Reset();
|
| void Update();
|
|
|
| // Chart display
|
| void UpdateChart();
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CPaperTrading::CPaperTrading() : m_balance(InpPaperInitialBalance),
|
| m_equity(InpPaperInitialBalance),
|
| m_totalTrades(0),
|
| m_winningTrades(0),
|
| m_losingTrades(0),
|
| m_liveTrading(false),
|
| m_slippage(0.0),
|
| m_spread(0.0),
|
| m_symbol(NULL),
|
| m_account(NULL),
|
| m_riskManager(NULL)
|
| {
|
| m_trades.Clear();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CPaperTrading::~CPaperTrading()
|
| {
|
| Deinitialize();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize paper trading system |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::Initialize(CSymbolInfo *symbol, CAccountInfo *account,
|
| CEnhancedRiskManager *riskManager)
|
| {
|
| // Validate inputs
|
| if(symbol == NULL || account == NULL || riskManager == NULL) {
|
| Print("PaperTrading: Invalid initialization parameters");
|
| return false;
|
| }
|
|
|
| // Store references
|
| m_symbol = symbol;
|
| m_account = account;
|
| m_riskManager = riskManager;
|
|
|
| // Reset state
|
| Reset();
|
|
|
| // Initialize chart objects
|
| UpdateChart();
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Clean up resources |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::Deinitialize()
|
| {
|
| // Clean up resources
|
| m_trades.Clear();
|
|
|
| // Remove chart objects
|
| string prefix = "PaperTrade_";
|
| ObjectsDeleteAll(0, prefix);
|
| ChartRedraw();
|
|
|
| // Reset references
|
| m_symbol = NULL;
|
| m_account = NULL;
|
| m_riskManager = NULL;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Open a new paper position |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::OpenPosition(ENUM_ORDER_TYPE type, double volume,
|
| double price, double sl, double tp,
|
| string comment = "")
|
| {
|
| // Check if paper trading is enabled
|
| if(!InpEnablePaperTrading) {
|
| m_liveTrading = true;
|
| return true; // Allow live trading
|
| }
|
|
|
| // Check if we have enough wins to trade live
|
| if(m_winningTrades >= InpPaperWinsRequired && m_totalTrades >= InpPaperTradesRequired) {
|
| m_liveTrading = true;
|
| return true; // Allow live trading
|
| }
|
|
|
| // Check if we've reached the maximum number of paper trades
|
| if(m_totalTrades >= InpPaperTradesRequired) {
|
| Print("PaperTrading: Maximum number of paper trades reached (", InpPaperTradesRequired, "). ",
|
| m_winningTrades, " wins out of ", InpPaperWinsRequired, " required for live trading.");
|
| return false;
|
| }
|
|
|
| // Check risk management
|
| if(m_riskManager != NULL && !m_riskManager.IsTradingAllowed()) {
|
| Print("PaperTrading: Risk management restricts trading");
|
| return false;
|
| }
|
|
|
| // Check if we can simulate a fill
|
| if(!SimulateFill()) {
|
| Print("PaperTrading: Order fill simulation failed");
|
| return false;
|
| }
|
|
|
| // Calculate slippage if enabled
|
| double actualPrice = price;
|
| if(InpSimulateSlippage) {
|
| double slippage = CalculateSlippage();
|
| if(type == ORDER_TYPE_BUY || type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_BUY_STOP) {
|
| actualPrice += slippage;
|
| } else {
|
| actualPrice -= slippage;
|
| }
|
| }
|
|
|
| // Create new trade
|
| SPaperTrade *trade = new SPaperTrade();
|
| if(trade == NULL) {
|
| Print("PaperTrading: Failed to create new trade");
|
| return false;
|
| }
|
|
|
| // Initialize trade
|
| trade.ticket = (ulong)(TimeCurrent() % 1000000 + m_trades.Total());
|
| trade.symbol = m_symbol.Name();
|
| trade.type = type;
|
| trade.volume = volume;
|
| trade.openPrice = actualPrice;
|
| trade.stopLoss = sl;
|
| trade.takeProfit = tp;
|
| trade.openTime = TimeCurrent();
|
| trade.commission = CalculateCommission(volume, actualPrice);
|
| trade.swap = 0.0; // Will be updated on bar close
|
| trade.isClosed = false;
|
| trade.isWinner = false;
|
|
|
| // Add to trades array
|
| if(!m_trades.Add(trade)) {
|
| delete trade;
|
| Print("PaperTrading: Failed to add trade to array");
|
| return false;
|
| }
|
|
|
| // Update statistics
|
| m_totalTrades++;
|
|
|
| // Update balance (subtract margin, will be added back on close)
|
| double margin = m_riskManager != NULL ?
|
| m_riskManager.CalculateMargin(trade.symbol, trade.volume, trade.type) :
|
| (trade.volume * m_symbol.TickValue() * m_symbol.TickSize());
|
| m_balance -= margin;
|
|
|
| PrintFormat("PaperTrading: Opened %s position %.2f lots at %.5f (SL: %.5f, TP: %.5f)",
|
| EnumToString(type), volume, actualPrice, sl, tp);
|
|
|
| // Update chart
|
| UpdateChart();
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Close a paper position |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::ClosePosition(ulong ticket, double price)
|
| {
|
| for(int i = 0; i < m_trades.Total(); i++) {
|
| SPaperTrade *trade = m_trades.At(i);
|
| if(trade == NULL || trade.isClosed || trade.ticket != ticket) continue;
|
|
|
| // Calculate P/L
|
| double priceDiff = price - trade.openPrice;
|
| if(trade.type == ORDER_TYPE_SELL || trade.type == ORDER_TYPE_SELL_LIMIT || trade.type == ORDER_TYPE_SELL_STOP) {
|
| priceDiff = -priceDiff;
|
| }
|
|
|
| double pips = priceDiff / m_symbol.Point();
|
| double profit = pips * m_symbol.TickValue() * trade.volume / (m_symbol.Point() / m_symbol.TickSize());
|
|
|
| // Update trade info
|
| trade.closePrice = price;
|
| trade.closeTime = TimeCurrent();
|
| trade.profit = profit;
|
| trade.isClosed = true;
|
|
|
| // Update balance
|
| m_balance += profit - trade.commission - trade.swap;
|
|
|
| // Update statistics
|
| if(profit > 0) {
|
| m_winningTrades++;
|
| } else {
|
| m_losingTrades++;
|
| }
|
|
|
| // Update equity
|
| UpdateEquity();
|
|
|
| PrintFormat("PaperTrading: Closed position %d at %.5f, P/L: $%.2f",
|
| ticket, price, profit - trade.commission - trade.swap);
|
|
|
| // Update chart
|
| UpdateChart();
|
|
|
| return true;
|
| }
|
|
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check for exit conditions |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::CheckForExits()
|
| {
|
| double bid = m_symbol.Bid();
|
| double ask = m_symbol.Ask();
|
|
|
| for(int i = m_trades.Total() - 1; i >= 0; i--) {
|
| SPaperTrade *trade = m_trades.At(i);
|
| if(trade == NULL || trade.isClosed) continue;
|
|
|
| // Check if position should be closed by stop loss or take profit
|
| double currentPrice = (trade.type == ORDER_TYPE_BUY || trade.type == ORDER_TYPE_BUY_LIMIT || trade.type == ORDER_TYPE_BUY_STOP) ? bid : ask;
|
|
|
| // Check stop loss
|
| if((trade.type == ORDER_TYPE_BUY || trade.type == ORDER_TYPE_BUY_LIMIT || trade.type == ORDER_TYPE_BUY_STOP) &&
|
| trade.stopLoss > 0 && currentPrice <= trade.stopLoss) {
|
| ClosePosition(trade.ticket, trade.stopLoss);
|
| trade.isWinner = false;
|
| continue;
|
| }
|
|
|
| if((trade.type == ORDER_TYPE_SELL || trade.type == ORDER_TYPE_SELL_LIMIT || trade.type == ORDER_TYPE_SELL_STOP) &&
|
| trade.stopLoss > 0 && currentPrice >= trade.stopLoss) {
|
| ClosePosition(trade.ticket, trade.stopLoss);
|
| trade.isWinner = false;
|
| continue;
|
| }
|
|
|
| // Check take profit
|
| if((trade.type == ORDER_TYPE_BUY || trade.type == ORDER_TYPE_BUY_LIMIT || trade.type == ORDER_TYPE_BUY_STOP) &&
|
| trade.takeProfit > 0 && currentPrice >= trade.takeProfit) {
|
| ClosePosition(trade.ticket, trade.takeProfit);
|
| trade.isWinner = true;
|
| continue;
|
| }
|
|
|
| if((trade.type == ORDER_TYPE_SELL || trade.type == ORDER_TYPE_SELL_LIMIT || trade.type == ORDER_TYPE_SELL_STOP) &&
|
| trade.takeProfit > 0 && currentPrice <= trade.takeProfit) {
|
| ClosePosition(trade.ticket, trade.takeProfit);
|
| trade.isWinner = true;
|
| continue;
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate commission for a trade |
|
| //+------------------------------------------------------------------+
|
| double CPaperTrading::CalculateCommission(double volume, double price)
|
| {
|
| // Default commission: $5 per lot
|
| return 5.0 * volume;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate swap for an open position |
|
| //+------------------------------------------------------------------+
|
| double CPaperTrading::CalculateSwap(double volume, double price, ENUM_ORDER_TYPE type)
|
| {
|
| // Simulate swap based on position type and size
|
| double swapRate = (type == ORDER_TYPE_BUY) ? -0.5 : 0.2; // pips per lot per day
|
| return volume * swapRate * m_symbol.Point() * 10000.0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate slippage for order execution |
|
| //+------------------------------------------------------------------
|
| double CPaperTrading::CalculateSlippage()
|
| {
|
| if(!InpSimulateSlippage) return 0.0;
|
|
|
| // Random slippage up to max slippage
|
| return MathRand() / 32767.0 * InpMaxSlippagePips * m_symbol.Point();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Simulate order fill probability |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::SimulateFill()
|
| {
|
| if(!InpSimulatePartialFills) return true;
|
|
|
| // Random chance of fill based on fill probability
|
| return (MathRand() % 100) < InpFillProbability;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update equity based on open positions |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::UpdateEquity()
|
| {
|
| double floatingPL = 0.0;
|
| double bid = m_symbol.Bid();
|
| double ask = m_symbol.Ask();
|
| double pointValue = m_symbol.Point() * m_symbol.TradeTickValue() / m_symbol.TradeTickSize();
|
|
|
| for(int i = 0; i < m_trades.Total(); i++) {
|
| SPaperTrade *trade = m_trades.At(i);
|
| if(trade == NULL || trade.isClosed) continue;
|
|
|
| if(trade.type == ORDER_TYPE_BUY) {
|
| floatingPL += (bid - trade.openPrice) * trade.volume * pointValue;
|
| } else {
|
| floatingPL += (trade.openPrice - ask) * trade.volume * pointValue;
|
| }
|
| }
|
|
|
| m_equity = m_balance + floatingPL;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Reset paper trading account |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::Reset()
|
| {
|
| // Clear existing trades
|
| m_trades.Clear();
|
|
|
| // Reset metrics
|
| m_balance = InpPaperInitialBalance;
|
| m_equity = InpPaperInitialBalance;
|
| m_totalTrades = 0;
|
| m_winningTrades = 0;
|
| m_losingTrades = 0;
|
| m_liveTrading = false;
|
|
|
| // Reset chart
|
| UpdateChart();
|
|
|
| Print("PaperTrading: Account reset");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update paper trading system |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::Update()
|
| {
|
| // Update market data
|
| m_symbol.RefreshRates();
|
|
|
| // Check for exits
|
| CheckForExits();
|
|
|
| // Update equity
|
| UpdateEquity();
|
|
|
| // Update chart periodically
|
| static datetime lastUpdate = 0;
|
| if(TimeCurrent() - lastUpdate >= 1) {
|
| UpdateChart();
|
| lastUpdate = TimeCurrent();
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update chart with paper trading information |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::UpdateChart()
|
| {
|
| string prefix = "PaperTrade_";
|
|
|
| // Create or update info panel
|
| string objName = prefix + "Info";
|
|
|
| // Create or update info text
|
| string infoText = StringFormat("=== Paper Trading ===\n" +
|
| "Balance: $%.2f\n" +
|
| "Equity: $%.2f\n" +
|
| "Trades: %d (%d wins, %d losses)\n" +
|
| "Win Rate: %.1f%%\n" +
|
| "Live Trading: %s",
|
| m_balance, m_equity,
|
| m_totalTrades, m_winningTrades, m_losingTrades,
|
| GetWinRate(),
|
| m_liveTrading ? "Enabled" : "Disabled");
|
|
|
| // Create or update the info label
|
| if(ObjectFind(0, objName) < 0) {
|
| ObjectCreate(0, objName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
| ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, 20);
|
| ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, 20);
|
| ObjectSetInteger(0, objName, OBJPROP_COLOR, clrWhite);
|
| ObjectSetInteger(0, objName, OBJPROP_BGCOLOR, clrNavy);
|
| ObjectSetInteger(0, objName, OBJPROP_BACK, false);
|
| ObjectSetInteger(0, objName, OBJPROP_HIDDEN, true);
|
| ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
|
| ObjectSetInteger(0, objName, OBJPROP_SELECTED, false);
|
| ObjectSetInteger(0, objName, OBJPROP_ZORDER, 0);
|
| }
|
|
|
| ObjectSetString(0, objName, OBJPROP_TEXT, infoText);
|
| ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 8);
|
|
|
| // Update trade markers on chart
|
| for(int i = 0; i < m_trades.Total(); i++) {
|
| SPaperTrade *trade = m_trades.At(i);
|
| if(trade == NULL) continue;
|
|
|
| string tradePrefix = prefix + IntegerToString(trade.ticket) + "_";
|
|
|
| // Create or update entry marker
|
| string entryName = tradePrefix + "Entry";
|
| if(ObjectFind(0, entryName) < 0) {
|
| ObjectCreate(0, entryName, OBJ_ARROW, 0, trade.openTime,
|
| trade.type <= 1 ? trade.openPrice + 10 * m_symbol.Point() : trade.openPrice - 10 * m_symbol.Point());
|
| ObjectSetInteger(0, entryName, OBJPROP_ARROWCODE, trade.type <= 1 ? 233 : 234);
|
| ObjectSetInteger(0, entryName, OBJPROP_COLOR, trade.type <= 1 ? clrLime : clrRed);
|
| ObjectSetInteger(0, entryName, OBJPROP_WIDTH, 2);
|
| }
|
|
|
| // Create or update exit marker if closed
|
| if(trade.isClosed) {
|
| string exitName = tradePrefix + "Exit";
|
| if(ObjectFind(0, exitName) < 0) {
|
| ObjectCreate(0, exitName, OBJ_ARROW, 0, trade.closeTime,
|
| trade.type <= 1 ? trade.closePrice - 10 * m_symbol.Point() : trade.closePrice + 10 * m_symbol.Point());
|
| ObjectSetInteger(0, exitName, OBJPROP_ARROWCODE, 251);
|
| ObjectSetInteger(0, exitName, OBJPROP_COLOR, trade.isWinner ? clrLime : clrRed);
|
| ObjectSetInteger(0, exitName, OBJPROP_WIDTH, 2);
|
| }
|
| }
|
| }
|
|
|
| // Redraw the chart
|
| ChartRedraw();
|
| if(ObjectFind(0, objName) < 0) {
|
| ObjectCreate(0, objName, OBJ_RECTANGLE_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, 10);
|
| ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, 10);
|
| ObjectSetInteger(0, objName, OBJPROP_XSIZE, 200);
|
| ObjectSetInteger(0, objName, OBJPROP_YSIZE, 120);
|
| ObjectSetInteger(0, objName, OBJPROP_BGCOLOR, clrWhiteSmoke);
|
| ObjectSetInteger(0, objName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
|
| ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
| ObjectSetInteger(0, objName, OBJPROP_BACK, false);
|
| }
|
|
|
| // Update info text
|
| string infoText = "=== Paper Trading ===\n";
|
| infoText += StringFormat("Balance: %.2f %s\n", m_balance, m_account.Currency());
|
| infoText += StringFormat("Equity: %.2f %s\n", m_equity, m_account.Currency());
|
| infoText += StringFormat("Trades: %d (%dW/%dL)\n",
|
| m_totalTrades, m_winningTrades, m_losingTrades);
|
| infoText += StringFormat("Win Rate: %.1f%%\n", GetWinRate());
|
| infoText += StringFormat("Status: %s",
|
| m_liveTrading ? "LIVE TRADING" : "PAPER TRADING");
|
|
|
| objName = prefix + "InfoText";
|
| if(ObjectFind(0, objName) < 0) {
|
| ObjectCreate(0, objName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, 15);
|
| ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, 15);
|
| ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
| ObjectSetInteger(0, objName, OBJPROP_COLOR, clrBlack);
|
| ObjectSetString(0, objName, OBJPROP_FONT, "Arial");
|
| ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 8);
|
| }
|
| ObjectSetString(0, objName, OBJPROP_TEXT, infoText);
|
|
|
| // Redraw chart
|
| ChartRedraw();
|
| }
|
| //+------------------------------------------------------------------+
|
