Most MQL5 coders construct their buying and selling robots round a core trio of features: OnInit() , OnDeinit() , and OnTick() . Whereas this basis is important, it is like attempting to prepare dinner a gourmand meal with solely a pot, a pan, and a single burner. The MQL5 setting affords a wealthy occasion mannequin with specialised handlers that may make your Skilled Advisors (EAs) and indicators extra environment friendly, interactive, and highly effective.

By venturing past the fundamentals, you may construct EAs that do not depend on each single tick, create dynamic person interfaces instantly on the chart, and even monitor and react to buying and selling exercise from different sources. Let’s discover three of essentially the most highly effective—and underutilized—occasion handlers: OnTimer() , OnChartEvent() , and OnTradeTransaction() .

#property copyright "Copyright 2025, EAHQ"
#property hyperlink      "https://www.mql5.com/en/customers/michael4308"
#property model   "1.00"


datetime lastBarTime = 0;




int OnInit()
{
   
   EventSetTimer(60);
   Print("Timer EA Initialized. Checking for brand new H1 bar each minute.");
   
   return(INIT_SUCCEEDED);
}



void OnDeinit(const int cause)
{
   
   EventKillTimer();
   Print("Timer EA Eliminated. Timer stopped.");
}



void OnTimer()
{
   
   datetime newBarTime = (datetime)SeriesInfoInteger(_Symbol, PERIOD_H1, SERIES_LASTBAR_DATE);
   
   
   if(newBarTime > lastBarTime)
   {
      
      lastBarTime = newBarTime;
      
      Print("New H1 Bar Detected at: ", TimeToString(newBarTime));
      
      
      
   }
}



void OnTick()
{
  
}

By utilizing OnTimer() , this EA is way more environment friendly. It solely consumes CPU assets as soon as a minute, leaving your terminal extra responsive and lowering the processing load, which is particularly necessary when operating a number of EAs.

Making Charts Interactive with OnChartEvent()

Have you ever ever wished to let a person draw a line on a chart to set a take-profit stage or drag a rectangle to outline a buying and selling zone? The OnChartEvent() handler is your gateway to creating wealthy, interactive chart instruments. 🎨

This perform is a grasp listener that captures a variety of person interactions with the chart, reminiscent of mouse clicks, key presses, and—most powerfully—interactions with graphical objects.

How It Works

The OnChartEvent() perform receives a number of parameters, however an important are:

• id : The kind of occasion that occurred (e.g., a key was pressed, an object was created).

• lparam , dparam , sparam : Parameters containing detailed details about the occasion. Their which means is determined by the id .

For object interactions, you will usually examine for these occasion IDs:

• CHARTEVENT_OBJECT_CREATE : Fired when a person finishes drawing a brand new object.

• CHARTEVENT_OBJECT_DRAG : Fired when a person drags an object throughout the chart.

• CHARTEVENT_OBJECT_CLICK : Fired when a person clicks on an object.

Instance: Setting a Take-Revenue Degree with a Line

Let’s create an indicator that permits the person to attract a horizontal line. The indicator will then learn the worth stage of that line and print it to the Consultants log, simulating how an EA may use it to set a Take-Revenue.

#property copyright "Copyright 2025, EAHQ"
#property indicator_chart_window




void OnChartEvent(const int id,
                  const lengthy &lparam,
                  const double &dparam,
                  const string &sparam)
{
   
   if(id == CHARTEVENT_OBJECT_CREATE)
   {
      
      Print("Object Created: ", sparam);
      
      
      if(ObjectType(sparam) == OBJ_HLINE)
      {
         
         double priceLevel = ObjectGetDouble(0, sparam, OBJPROP_PRICE, 0);
         Print("Take-Revenue stage set by HLine '", sparam, "' at worth: ", DoubleToString(priceLevel, _Digits));
         
         
      }
   }
   
   
   if(id == CHARTEVENT_OBJECT_DRAG)
   {
       
       if(ObjectType(sparam) == OBJ_HLINE)
       {
         double priceLevel = ObjectGetDouble(0, sparam, OBJPROP_PRICE, 0);
         Remark("Present TP Degree: ", DoubleToString(priceLevel, _Digits));
       }
   }
}

This straightforward instance opens up a world of potentialities for creating intuitive, user-friendly buying and selling instruments that bridge the hole between handbook evaluation and automatic execution.

The Final Watchdog: OnTradeTransaction()

What in case your EA must learn about every little thing taking place in your buying and selling account? This contains handbook trades you place, trades executed by different EAs, and even actions taken by your dealer. The OnTradeTransaction() occasion handler is the last word watchdog, providing you with real-time perception into all buying and selling exercise. 🕵️

This handler is triggered at any time when a commerce transaction happens on the account, reminiscent of inserting an order, modifying a stop-loss, closing a place, or a deal being executed.

How It Works

The OnTradeTransaction() perform receives three arguments:

• trans : An MqlTradeTransaction construction containing detailed details about the transaction (kind, order ticket, worth, quantity, and many others.).

• request : The unique MqlTradeRequest that initiated this transaction.

• end result : The MqlTradeResult of executing the request.

You may examine the trans.kind subject to grasp what sort of transaction simply occurred. A typical and really helpful kind is TRADE_TRANSACTION_DEAL_ADD , which indicators {that a} new deal has been added to the account historical past (i.e., a commerce was executed).

Instance: Monitoring and Logging All New Trades

Here is an EA that does nothing however monitor the account. When any new commerce (deal) is executed—whether or not by this EA, one other EA, or manually—it logs the main points.

#property copyright "Copyright 2025, EAHQ"
#property model   "1.00"




void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &end result)
{
   
   if(trans.kind == TRADE_TRANSACTION_DEAL_ADD)
   {
      
      ulong deal_ticket = trans.deal;
      
      
      if(HistoryDealSelect(deal_ticket))
      {
         lengthy deal_type = HistoryDealGetInteger(deal_ticket, DEAL_TYPE);
         lengthy deal_magic = HistoryDealGetInteger(deal_ticket, DEAL_MAGIC);
         double deal_volume = HistoryDealGetDouble(deal_ticket, DEAL_VOLUME);
         string deal_symbol = HistoryDealGetString(deal_ticket, DEAL_SYMBOL);
         
         
         PrintFormat("New Deal Executed: Ticket #%d, Image: %s, Kind: %s, Quantity: %.2f, Magic: %d",
                     deal_ticket,
                     deal_symbol,
                     (deal_type == DEAL_TYPE_BUY ? "Purchase" : "Promote"),
                     deal_volume,
                     deal_magic);
                     
         
         
         
      }
   }
}


void OnInit() {}
void OnDeinit(const int cause) {}
void OnTick() {}

This handler is extremely highly effective. You may construct:

• A Commerce Supervisor: An EA that routinely applies stop-loss and take-profit ranges to any commerce opened on the account, no matter its supply.

• An Fairness Protector: An EA that screens for brand new offers and closes all open positions if the account drawdown exceeds a sure threshold.

• A Synchronization Instrument: An EA that copies trades from one account to a different in real-time.

By mastering these superior occasion handlers, you elevate your MQL5 coding from easy automation to creating actually clever, environment friendly, and interactive buying and selling techniques. Go forward and experiment—your buying and selling instruments won’t ever be the identical once more.