MQL5 Events

1. MQL5 Events: A Beginner's Guide

MQL5 Events are a powerful and essential component of the MetaQuotes Language 5 (MQL5) programming environment used in MetaTrader 5. They allow Expert Advisors (EAs), scripts, and indicators to respond to a wide range of occurrences within the trading platform and even external events, enabling dynamic and automated trading strategies. This article will provide a comprehensive, beginner-friendly overview of MQL5 Events, covering their types, handling, and practical applications.

1. 1. What are MQL5 Events?

In essence, an MQL5 Event is a notification that something has happened. These occurrences can be as simple as a new tick arriving on a chart, a timer expiring, or a chart event like a change in chart properties. MQL5 programs don’t constantly *poll* for changes; instead, they *react* to events when they are triggered. This event-driven architecture is crucial for efficiency and responsiveness. Without events, an EA would need to continuously check for changes, consuming significant system resources and potentially missing important opportunities.

1. 1. Types of MQL5 Events

MQL5 categorizes events into several groups, each handling different types of notifications. Understanding these categories is fundamental to using events effectively.

1. 1. 1. 1. Chart Events

These events relate directly to the chart the MQL5 program is attached to. They are arguably the most commonly used events for trading applications.

• **`CHARTEVENT_OBJECT_CREATE`:** Triggered when a graphical object (trend line, rectangle, Fibonacci retracement, etc.) is created on the chart. Useful for strategies that adapt to user-defined objects. See Technical Analysis for more on graphical objects.
• **`CHARTEVENT_OBJECT_DELETE`:** Triggered when a graphical object is deleted from the chart.
• **`CHARTEVENT_OBJECT_SELECT`:** Triggered when a graphical object is selected.
• **`CHARTEVENT_OBJECT_DOUBLE_CLICK`:** Triggered when a graphical object is double-clicked.
• **`CHARTEVENT_OBJECT_RIGHT_CLICK`:** Triggered when a graphical object is right-clicked.
• **`CHARTEVENT_CHART_CHANGE`:** Triggered when the chart’s symbol or timeframe is changed. This is vital for adapting an EA to different trading conditions. Consider Timeframe Analysis.
• **`CHARTEVENT_ACCOUNT`:** Triggered when there is a change in the account information (balance, equity, profit, etc.).
• **`CHARTEVENT_TIMER`:** Triggered when a timer set by `EventSetTimer()` expires. Used for periodic tasks, such as checking news events or recalculating indicators. Indicator Development often uses timers.
• **`CHARTEVENT_SCRIPT_BUILD`:** Triggered when a script is completed.

1. 1. 1. 2. Trade Events

These events are related to trading operations.

• **`TRADE_TRANSACTION`:** Triggered after a trade transaction is completed (order sent, filled, modified, canceled). This is the core event for tracking trade execution and managing positions. Understanding Order Types is crucial when handling this event.
• **`TRADE_REQUEST`:** Triggered before a trade request is sent to the server. Allows for pre-trade validation or modification.
• **`TRADE_EXECUTION`:** Triggered after a trade request has been executed by the server.

1. 1. 1. 3. Market Data Events

These events deal with incoming market data.

• **`MARKET_EVENT_NEW_TICK`:** Triggered when a new tick (price update) arrives for the symbol. This is the foundation for many real-time trading strategies. Tick Data Analysis is relevant here.
• **`MARKET_EVENT_ORDER_BOOK_UPDATE`:** Triggered when the order book (depth of market) is updated.
• **`MARKET_EVENT_MARKET_CLOSED`:** Triggered when the market is closed.
• **`MARKET_EVENT_MARKET_OPEN`:** Triggered when the market is opened.

1. 1. 1. 4. Account Events

These events pertain to account-level changes.

• **`ACCOUNT_EVENT_MARGIN_LEVEL`:** Triggered when the margin level changes. Important for risk management. Learn about Margin Calls to understand this event.
• **`ACCOUNT_EVENT_TRADE_DISABLED`:** Triggered when trading is disabled on the account.
• **`ACCOUNT_EVENT_TRADE_ENABLED`:** Triggered when trading is enabled on the account.

1. 1. 1. 5. Custom Events

MQL5 allows you to define and trigger your own custom events. This provides maximum flexibility for complex applications. You use the `EventPost()` function to trigger a custom event and `EventSelect()` to handle it.

1. 1. Handling MQL5 Events

To respond to an event, you need to implement an event handler function. This function is automatically called by the MetaTrader 5 platform when the corresponding event is triggered.

1. 1. 1. The `OnEvent()` Function

The primary function used to handle events is `OnEvent()`. It has the following signature:

```mql5 void OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam) ```

• **`id`:** The event ID (e.g., `CHARTEVENT_NEW_TICK`, `TRADE_TRANSACTION`).
• **`lparam`:** A long integer parameter, often used to pass additional information about the event (e.g., deal number for `TRADE_TRANSACTION`).
• **`dparam`:** A double parameter, used for passing floating-point values.
• **`sparam`:** A string parameter, used for passing text information.

1. 1. 1. Event Selection with `EventSelect()`

Before you can handle an event, you need to tell MQL5 which events your `OnEvent()` function should respond to. This is done using the `EventSelect()` function.

```mql5 EventSelect(event_id, handler_function); ```

• **`event_id`:** The ID of the event you want to handle.
• **`handler_function`:** The name of your `OnEvent()` function.

• • Example:**

```mql5 void OnStart()

 {
  // Select the CHARTEVENT_NEW_TICK event and associate it with the OnEvent() function
  EventSelect(CHARTEVENT_NEW_TICK, OnEvent);
  EventSelect(TRADE_TRANSACTION, OnEvent);
 }

void OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam)

 {
  if(id == CHARTEVENT_NEW_TICK)
    {
     // Code to execute when a new tick arrives
     Print("New tick received!");
    }
  else if(id == TRADE_TRANSACTION)
    {
     // Code to execute when a trade transaction occurs
     Print("Trade transaction completed!");
    }
 }

```

1. 1. 1. Event Deselection with `EventDeselect()`

If you no longer want to handle a specific event, you can use `EventDeselect()`:

```mql5 EventDeselect(event_id); ```

1. 1. 1. Event Filtering

For some events, you can further refine which events your handler function responds to using event filters. For example, with `TRADE_TRANSACTION`, you can filter by trade type (e.g., only handle order fill events).

1. 1. Practical Applications of MQL5 Events

Here are some examples of how MQL5 Events can be used in trading applications:

• **Trailing Stop Loss:** Use `MARKET_EVENT_NEW_TICK` to continuously monitor price movements and adjust the stop-loss level of an open position. This is a common Risk Management technique.
• **News Trading:** Use `CHARTEVENT_TIMER` to periodically check for news releases and execute trades based on news events. Fundamental Analysis is key here.
• **Automated Trading Based on Graphical Objects:** Use `CHARTEVENT_OBJECT_CREATE` and other chart object events to react to user-defined indicators on the chart. For instance, an EA could open a position when a trend line is broken. See Trend Following Strategies.
• **Position Sizing Based on Margin Level:** Use `ACCOUNT_EVENT_MARGIN_LEVEL` to dynamically adjust position sizes based on the current margin level, preventing margin calls.
• **Alerting:** Use `TRADE_TRANSACTION` to send alerts (e.g., email, push notifications) when a trade is filled, closed, or encounters an error.
• **Backtesting Enhancements:** Use events to simulate real-world trading conditions more accurately during backtesting, such as delays in order execution. Backtesting Strategies can benefit from event simulation.
• **Custom Indicators with Real-time Updates:** Use `MARKET_EVENT_NEW_TICK` to update indicator values in real-time, providing a more responsive trading experience. Moving Average Convergence Divergence (MACD) is a good example of an indicator that benefits from real-time updates.
• **Order Book Analysis:** Use `MARKET_EVENT_ORDER_BOOK_UPDATE` to analyze the order book and identify potential support and resistance levels. Depth of Market Analysis involves this event.
• **Detecting Slippage:** Compare the requested price with the filled price in a `TRADE_TRANSACTION` event to detect and log slippage. Slippage is a key concept in Trading Psychology.
• **Implementing Breakout Strategies:** Using `MARKET_EVENT_NEW_TICK` combined with price level monitoring, you can implement breakout strategies that trigger trades when prices break through predefined levels. Breakout Trading relies heavily on accurate tick data.
• **Detecting and Reacting to Gaps:** Using `MARKET_EVENT_NEW_TICK` and comparing the current open price to the previous close price, you can detect gaps in the market and execute strategies accordingly. Gap Trading is a specialized technique.
• **Trading with Fibonacci Retracements:** Monitor the creation and deletion of Fibonacci retracement objects using `CHARTEVENT_OBJECT_CREATE` and `CHARTEVENT_OBJECT_DELETE` to automatically trade based on Fibonacci levels. Fibonacci Trading is a popular method.
• **Trading with Elliott Wave Patterns:** Utilize chart object events to detect the drawing of Elliott Wave patterns and initiate trades based on wave theory. Elliott Wave Theory often involves graphical analysis.
• **Using Bollinger Bands for Trading:** React to price movements crossing Bollinger Band boundaries with `MARKET_EVENT_NEW_TICK` to generate trading signals. Bollinger Bands are a widely used indicator.
• **Employing Ichimoku Cloud Strategies:** Monitor the interaction between price and the Ichimoku Cloud using `MARKET_EVENT_NEW_TICK` to identify potential trading opportunities. Ichimoku Cloud is a versatile indicator.
• **Utilizing Relative Strength Index (RSI):** Generate buy and sell signals based on RSI levels crossing overbought and oversold thresholds using `MARKET_EVENT_NEW_TICK`. Relative Strength Index (RSI) is a momentum indicator.
• **Trading with Moving Averages:** Implement crossover strategies with moving averages based on `MARKET_EVENT_NEW_TICK` to identify trend changes. Moving Averages are fundamental tools.
• **Using Parabolic SAR for Trading:** Identify potential trend reversals using the Parabolic SAR indicator and `MARKET_EVENT_NEW_TICK`. Parabolic SAR is a trend-following indicator.
• **Implementing Donchian Channel Strategies:** Generate trading signals based on price breaking through Donchian Channel boundaries using `MARKET_EVENT_NEW_TICK`. Donchian Channels are volatility indicators.

1. 1. Conclusion

MQL5 Events are a powerful mechanism for creating responsive and automated trading applications. By understanding the different event types, how to handle them with the `OnEvent()` function and `EventSelect()`, and exploring the practical applications outlined above, you can significantly enhance your trading strategies and build sophisticated EAs, scripts, and indicators. Remember to consult the official MQL5 documentation ([1](https://www.mql5.com/en/docs)) for the most up-to-date information and detailed explanations. MQL5 Reference is an invaluable resource.

Expert Advisor Development greatly relies on effective event handling. Learning to master events is a critical step toward becoming a proficient MQL5 programmer. Scripting in MQL5 also uses events for interactive functionality.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners