MQL5 Cookbook: Sound Notifications for MetaTrader 5 Trade Events

23 October 2013, 11:38
Anatoli Kazharski
5 190


In this article, we will consider such issues as including sound files in the file of the Expert Advisor, and thus adding sound notifications to trade events. The fact that the files will be included means that the sound files will be located inside the Expert Advisor. So when giving the compiled version of the Expert Advisor (*.ex5) to another user, you will not have to also provide the sound files and explain where they need to be saved.



For test purposes, we will take the Expert Advisor from the previous article "MQL5 Cookbook: Saving Optimization Results of an Expert Advisor Based on Specified Criteria". To make it simpler, I have removed everything that is not relevant to the current subject.

To add sound notification to a trade event using the MQL5 resources, we can use the Alert() and PlaySound() functions. If you opt for the Alert() function, it will always play the same sound notification and open a window with the relevant message. You can see it in action in the article entitled "MQL5 Cookbook: Using Different Print Modes".

The alert sound can be set in the terminal settings: Tools -> Options or Ctrl+O. Further, in the Events tab, we need to check the "Enable" option to enable sound notifications for events and select the appropriate sound file in the drop-down list of alerts.

Fig. 1. The "Events" tab in the terminal settings

However, you also have the opportunity to set a unique sound notification for any custom program event. For this purpose, we use the PlaySound() function.

Before we add sound notifications to the Expert Advisor, let's create an Expert Advisor for test purposes. Let's implement an idea of opening a sound panel when loading an Expert Advisor on the chart. The sound panel will be made of graphical objects, such as button (OBJ_BUTTON). Each button will have its own unique sound assigned to it that will be played when the button is clicked.

I went online and found 25 different sound files in the *.wav format (they are available for download at the end of the article). They must be placed in the MetaTrader 5\MQL5\Files\Sounds folder. To get the hang of working with sound files, we will now create a new Expert Advisor using the MQL5 Wizard. At the very beginning, we specify the array size based on the number of buttons on the sound panel (there will be 26 buttons in total).

//--- Array size
#define ARRAY_SIZE 26

Then, we need to specify the folders and file names that will provide resources to the Expert Advisor. This can be done using the #resource directive. After the directive, we specify the file location in double quotes:

//--- Sound files
#resource "\\Files\\Sounds\\alert.wav"
#resource "\\Files\\Sounds\\AHOOGA.wav"
#resource "\\Files\\Sounds\\APPLAUSE.wav"
#resource "\\Files\\Sounds\\BONK.wav"
#resource "\\Files\\Sounds\\CARBRAKE.wav"
#resource "\\Files\\Sounds\\CASHREG.wav"
#resource "\\Files\\Sounds\\CLAP.wav"
#resource "\\Files\\Sounds\\CORKPOP.wav"
#resource "\\Files\\Sounds\\DOG.wav"
#resource "\\Files\\Sounds\\DRIVEBY.wav"
#resource "\\Files\\Sounds\\DRUMROLL.wav"
#resource "\\Files\\Sounds\\EXPLODE.wav"
#resource "\\Files\\Sounds\\FINALBEL.wav"
#resource "\\Files\\Sounds\\FROG.wav"
#resource "\\Files\\Sounds\\GLASS.wav"
#resource "\\Files\\Sounds\\GUNSHOT.wav"
#resource "\\Files\\Sounds\\LASER.wav"
#resource "\\Files\\Sounds\\LATNWHIS.wav"
#resource "\\Files\\Sounds\\PIG.wav"
#resource "\\Files\\Sounds\\RICOCHET.wav"
#resource "\\Files\\Sounds\\RINGIN.wav"
#resource "\\Files\\Sounds\\SIREN.wav"
#resource "\\Files\\Sounds\\TRAIN.wav"
#resource "\\Files\\Sounds\\UH_OH.wav"
#resource "\\Files\\Sounds\\VERYGOOD.wav"
#resource "\\Files\\Sounds\\WHOOSH.wav"

Now, we need to create three string arrays that will contain locations of the resource files, names of the graphical objects and the text displayed on the graphical objects. Please note the use of double colon when specifying the file locations - it is a special indication for calling the resource by name.

//--- Sound file location
string sound_paths[ARRAY_SIZE]=
//--- Names of graphical objects
string sound_names[ARRAY_SIZE]=
//--- Text displayed on graphical objects
string sound_texts[ARRAY_SIZE]=

Let's write a function, CreateButton(), that will create the graphical object "Button" on a chart with the specified properties:

//| Creating the Button object                                       |
void CreateButton(long              chart_id,         // chart id
                  int               sub_window,       // window number
                  string            name,             // object name
                  string            text,             // displayed name
                  ENUM_ANCHOR_POINT anchor,           // anchor point
                  ENUM_BASE_CORNER  corner,           // chart corner
                  string            font_name,        // font
                  int               font_size,        // font size
                  color             font_color,       // font color
                  color             background_color, // background color
                  color             border_color,     // border color
                  int               x_size,           // width
                  int               y_size,           // height
                  int               x_distance,       // X-coordinate
                  int               y_distance,       // Y-coordinate
                  long              z_order)          // Z-order
//--- Creating an object
      ObjectSetString(chart_id,name,OBJPROP_TEXT,text);                  // setting name
      ObjectSetString(chart_id,name,OBJPROP_FONT,font_name);             // setting font
      ObjectSetInteger(chart_id,name,OBJPROP_COLOR,font_color);          // setting font color
      ObjectSetInteger(chart_id,name,OBJPROP_BGCOLOR,background_color);  // setting background color
      ObjectSetInteger(chart_id,name,OBJPROP_BORDER_COLOR,border_color); // setting border color
      ObjectSetInteger(chart_id,name,OBJPROP_ANCHOR,anchor);             // setting anchor point
      ObjectSetInteger(chart_id,name,OBJPROP_CORNER,corner);             // setting chart corner
      ObjectSetInteger(chart_id,name,OBJPROP_FONTSIZE,font_size);        // setting font size
      ObjectSetInteger(chart_id,name,OBJPROP_XSIZE,x_size);              // setting width X
      ObjectSetInteger(chart_id,name,OBJPROP_YSIZE,y_size);              // setting height Y
      ObjectSetInteger(chart_id,name,OBJPROP_XDISTANCE,x_distance);      // setting X-coordinate
      ObjectSetInteger(chart_id,name,OBJPROP_YDISTANCE,y_distance);      // setting Y-coordinate
      ObjectSetInteger(chart_id,name,OBJPROP_SELECTABLE,false);          // cannot select the object if FALSE
      ObjectSetInteger(chart_id,name,OBJPROP_STATE,false);               // button state (clicked/unclicked)
      ObjectSetInteger(chart_id,name,OBJPROP_ZORDER,z_order);            // higher/lower Z-order
      ObjectSetString(chart_id,name,OBJPROP_TOOLTIP,"\n");               // no tooltip if "\n"

To make it more playful, the color of each button will be selected at random. To implement this, we will write a simple function - GetRandomColor():

//| Returning a random color                                         |
color GetRandomColor()
//--- Select a random color from 0 to 25
      case 0  : return(clrOrange);           break;
      case 1  : return(clrGold);             break;
      case 2  : return(clrChocolate);        break;
      case 3  : return(clrChartreuse);       break;
      case 4  : return(clrLime);             break;
      case 5  : return(clrSpringGreen);      break;
      case 6  : return(clrMediumBlue);       break;
      case 7  : return(clrDeepSkyBlue);      break;
      case 8  : return(clrBlue);             break;
      case 9  : return(clrSeaGreen);         break;
      case 10 : return(clrRed);              break;
      case 11 : return(clrSlateGray);        break;
      case 12 : return(clrPeru);             break;
      case 13 : return(clrBlueViolet);       break;
      case 14 : return(clrIndianRed);        break;
      case 15 : return(clrMediumOrchid);     break;
      case 16 : return(clrCrimson);          break;
      case 17 : return(clrMediumAquamarine); break;
      case 18 : return(clrDarkGray);         break;
      case 19 : return(clrSandyBrown);       break;
      case 20 : return(clrMediumSlateBlue);  break;
      case 21 : return(clrTan);              break;
      case 22 : return(clrDarkSalmon);       break;
      case 23 : return(clrBurlyWood);        break;
      case 24 : return(clrHotPink);          break;
      case 25 : return(clrLightSteelBlue);   break;
      default : return(clrGold);

Let's now write the function that will add the sound panel to the chart - SetSoundPanel():

//| Adding the sound panel to the chart                              |
void SetSoundPanel()
   int   column_count =0;       // Column counter
   int   x_dist       =10;      // Indent from the left side of the chart
   int   y_dist       =15;      // Indent from the top of the chart
   int   x_size       =100;     // Button width
   int   y_size       =20;      // Button height
   color button_color =clrNONE; // Button color
//--- Set the objects
   for(int i=0; i<ARRAY_SIZE; i++)
      //--- Increase the column counter
      //--- Get the button color
      //--- Draw a button
      //--- If two buttons have already been set in the same row
         x_dist=10;        // Move the X-coordinate to the initial position
         y_dist+=20;       // Set the Y-coordinate for the next row
         column_count=0;   // Zero out the counter
      //--- Set the X-coordinate for the next button 
//--- Refresh the chart

To remove the panel from the chart, we will use the functions provided below:

//| Deleting the info panel                                          |
void DeleteSoundPanel()
//--- Delete position properties and their values
   for(int i=0; i<ARRAY_SIZE; i++)
//--- Redraw the chart
//| Deleting objects by name                                         |
void DeleteObjectByName(string name)
//--- If the object is found
      //--- If an error occurred when deleting, print the relevant message
         Print("Error ("+IntegerToString(GetLastError())+") when deleting the object!");

So, when loading the Expert Advisor, the panel will be set on the chart from the OnInit() function and deleted from the chart when removing the Expert Advisor by the OnDeinit() function.

//| Custom indicator initialization function                         |
void OnInit()
//--- Set the sound panel
//| Deinitialization function of the expert advisor                  |
void OnDeinit(const int reason)
//--- Delete the sound panel

Now we only need to implement interaction with the panel so that the appropriate sound is played when a certain button is clicked. To make it even more cheerful, we will change button colors when one of the sound panel buttons is pressed. To implement this, we will need the ChangeColorsOnSoundPanel() function whose code is given below:

//| Changing colors on the sound panel                               |
void ChangeColorsOnSoundPanel()
   color clr=clrNONE; // Button color
//--- Iterate over all buttons in a loop and change their color
   for(int i=0; i<ARRAY_SIZE; i++)
      //--- Get the new color
      //--- Set the border color
      //--- Set the background color
      //--- Unclicked button
      //--- Refresh the chart
      //--- Wait for 20 ms (lag)

And finally, the following code should be added to the OnChartEvent() function:

//| Event handler                                                    |
void OnChartEvent(const int     id,     // Event identifier  
                  const long&   lparam, // Parameter of the event of type long
                  const double& dparam, // Parameter of the event of type double
                  const string& sparam) // Parameter of the event of type string
//--- If there was an event of left-clicking on the object
      //--- If the object name contains "sound_button"
         //--- Play the sound based on the object name
         //    5019 - ERR_FILE_NOT_EXIST - The file does not exist
            Print("Error: ",GetLastError());
         //--- Change colors of all buttons

The highlighted string in the above code suggests that the location of the sound file is passed to the PlaySound() function using the custom GetSoundPath() function. The code of the GetSoundPath() function is provided below:

//| Returning sound file location by the object name                 |
string GetSoundPath(string object_name)
//--- Iterate over all sound panel objects in a loop
   for(int i=0; i<ARRAY_SIZE; i++)
      //--- If the name of the object clicked in the chart
      //    matches one of those available on the panel, return the file location

Now, everything is ready. The sound panel (the program can be downloaded from the attachments to the article) will be set as soon as the Expert Advisor is attached to the chart:

The sound panel on the chart

Fig. 2. The sound panel on the chart

So, the principle of working with sound files is now clear. We get back to our Expert Advisor from the previous article entitled "MQL5 Cookbook: Saving Optimization Results of an Expert Advisor Based on Specified Criteria" and decide what sounds we will use in the Expert Advisor. Let's create Resources.mqh and include it in the main file of the Expert Advisor.

//--- Include custom libraries
#include "Include/Errors.mqh"
#include "Include/Enums.mqh"
#include "Include/Resources.mqh"
#include "Include/TradeSignals.mqh"
#include "Include/TradeFunctions.mqh"
#include "Include/ToString.mqh"
#include "Include/Auxiliary.mqh"

We now select files for the main trade events.

//--- Sound files
#resource "\\Files\\Sounds\\AHOOGA.WAV"   // Error
#resource "\\Files\\Sounds\\CASHREG.WAV"  // Position opening/position volume increase/pending order triggering
#resource "\\Files\\Sounds\\WHOOSH.WAV"   // Pending order/Stop Loss/Take Profit setting/modification
#resource "\\Files\\Sounds\\VERYGOOD.WAV" // Position closing at profit
#resource "\\Files\\Sounds\\DRIVEBY.WAV"  // Position closing at loss
//--- Sound file location
string SoundError          = "::Files\\Sounds\\AHOOGA.WAV";
string SoundOpenPosition   = "::Files\\Sounds\\CASHREG.WAV";
string SoundAdjustOrder    = "::Files\\Sounds\\WHOOSH.WAV";
string SoundCloseWithProfit= "::Files\\Sounds\\VERYGOOD.WAV";
string SoundCloseWithLoss  = "::Files\\Sounds\\DRIVEBY.WAV";

I would also like to mention that apart from sound files used as resources, in the Expert Advisor you can also store *.bmp images for interface purposes, text files and even indicators. EAs for MetaTrader 5 are now considered to be fully-functional applications - this is very convenient as instead of several files you only need to pass one.

Let's continue. In the external parameters, we need to add the UseSound parameter to have the opportunity to disable sounds:

//--- External parameters of the Expert Advisor
input  int        NumberOfBars =2;    // Number of one-direction bars
sinput double     Lot          =0.1;  // Lot
input  double     TakeProfit   =100;  // Take Profit
input  double     StopLoss     =50;   // Stop Loss
input  double     TrailingStop =10;   // Trailing Stop
input  bool       Reverse      =true; // Position reversal
sinput bool       UseSound     =true; // Sound notifications

In Include\Enums.mqh, we create the ENUM_SOUNDS enumeration for sounds.

//--- Sounds
   SOUND_ERROR             =0,   // Error
   SOUND_OPEN_POSITION     = 1,  // Position opening/position volume increase/pending order triggering
   SOUND_ADJUST_ORDER      = 2,  // Stop Loss/Take Profit/pending order setting
   SOUND_CLOSE_WITH_PROFIT = 3,  // Position closing at profit
   SOUND_CLOSE_WITH_LOSS   = 4   // Position closing at loss

These identifiers will be required for the custom function PlaySoundByID().

//| Playing sounds                                                   |
void PlaySoundByID(ENUM_SOUNDS id)
//--- If it is the real-time mode and sounds are enabled
   if(IsRealtime() && UseSound)
      //--- Play the sound based on the identifier passed
         case SOUND_ERROR              : PlaySound(SoundError);            break;
         case SOUND_OPEN_POSITION      : PlaySound(SoundOpenPosition);     break;
         case SOUND_ADJUST_ORDER       : PlaySound(SoundAdjustOrder);      break;
         case SOUND_CLOSE_WITH_PROFIT  : PlaySound(SoundCloseWithProfit);  break;
         case SOUND_CLOSE_WITH_LOSS    : PlaySound(SoundCloseWithLoss);    break;

During trading operations performed by the Expert Advisor, sound effects can be played by calling PlaySoundByID() from the appropriate trade functions. Let's see how this is implemented in the OpenPosition() function:

//| Opening a position                                               |
void OpenPosition(double lot,
                  ENUM_ORDER_TYPE order_type,
                  double price,
                  double sl,
                  double tp,
                  string comment)
//--- Set the magic number in the trading structure
//--- Set the slippage in points
//--- The Instant Execution and Market Execution modes
//    *** Starting with build 803, Stop Loss and Take Profit                             ***
//    *** can be set upon opening a position in the SYMBOL_TRADE_EXECUTION_MARKET mode ***
   if(symb.execution_mode==SYMBOL_TRADE_EXECUTION_INSTANT ||
      //--- If the position failed to open
         //--- Play the error sound and print the relevant message
         Print("Error opening the position: ",GetLastError()," - ",ErrorDescription(GetLastError()));
      //--- Otherwise play the position opening sound

If however, a position is closed at Stop Loss, Take Profit, manually or otherwise, this event must be monitored in the OnTrade() function. To implement this, we will write one more function, SoundNotification(), that will be responsible for the necessary checks: if the history of deals shows a new deal with the DEAL_ENTRY_OUT or DEAL_ENTRY_INOUT identifier (full/partial closing of the position or a reversal) for the current symbol, the program will check if that deal closed at profit or loss and will play the appropriate sound.

//| Sound notification                                               |
void SoundNotification()
//--- If it is the real-time mode and sounds are enabled
   if(IsRealtime() && UseSound)
      ulong        ticket      =0; // Deal ticket
      int          total       =0; // Total deals
      static ulong last_ticket =0; // Last ticket prior to this check
      //--- Get the complete history
      //--- Get the number of deals in the obtained list
      //--- In the obtained list, iterate over all deals from the last one to the first one
      for(int i=total-1; i>=0; i--)
         //--- If the deal ticket by its position in the list has been obtained
            //--- get the symbol of the deal
            //--- If the symbol of the deal and the current symbol are the same
               //--- get the direction of the deal
               //--- If it is position closing, volume decrease or reversal
               if(deal.entry==DEAL_ENTRY_OUT || deal.entry==DEAL_ENTRY_INOUT)
                  //--- If the ticket of the current deal from the list (the last deal for the symbol) is equal to the previous ticket
                  //    or this is the initialization of the ticket of the last deal
                  if(ticket==last_ticket || last_ticket==0)
                     //--- Save the ticket and exit
                  //--- Get the result of the deal
                  //--- In case of profit
                     //--- Profit sound
                     //--- Save the ticket number
                  //--- In case of loss
                     //--- Loss sound
                     //--- Save the ticket number

The SoundNotification() function should be placed in the OnInit() and OnTrade() functions:

//| Initialization                                                   |
int OnInit()
//--- Initialize the new bar
//--- Initialize tickets of the last deals for the symbol
//--- Initialization completed successfully
//| Monitoring trade events                                          |
void OnTrade()
//--- Sound notification

The sound notification has also been added at the end of the ModifyTrailingStop() function when modifying the Trailing Stop level.



That's about it. All the files for test purposes are available for download in the attachments to the article. Speaking of sounds in the terminal, I would like to draw your attention to an interesting solution available in Code Base under the name CMIDI (by Integer): it allows you to play MIDI files in MetaTrader 5. Good luck!

Translated from Russian by MetaQuotes Software Corp.
Original article:

Attached files | (321.8 KB)
soundpanel.mq5 (14.07 KB)
Technical Indicators and Digital Filters Technical Indicators and Digital Filters

In this article, technical indicators are treated as digital filters. Operation principles and basic characteristics of digital filters are explained. Also, some practical ways of receiving the filter kernel in MetaTrader 5 terminal and integration with a ready-made spectrum analyzer proposed in the article "Building a Spectrum Analyzer" are considered. Pulse and spectrum characteristics of the typical digital filters are used as examples.

Marvel Your MQL5 Customers with a Usable Cocktail of Technologies! Marvel Your MQL5 Customers with a Usable Cocktail of Technologies!

MQL5 provides programmers with a very complete set of functions and object-oriented API thanks to which they can do everything they want within the MetaTrader environment. However, Web Technology is an extremely versatile tool nowadays that may come to the rescue in some situations when you need to do something very specific, want to marvel your customers with something different or simply you do not have enough time to master a specific part of MT5 Standard Library. Today's exercise walks you through a practical example about how you can manage your development time at the same time as you also create an amazing tech cocktail.

MQL5 Cookbook: Monitoring Multiple Time Frames in a Single Window MQL5 Cookbook: Monitoring Multiple Time Frames in a Single Window

There are 21 time frames available in MetaTrader 5 for analysis. You can take advantage of special chart objects that you can place on the existing chart and set the symbol, time frame and some other properties right there. This article will provide detailed information on such chart graphical objects: we will create an indicator with controls (buttons) that will allow us to set multiple chart objects in a subwindow at the same time. Furthermore, chart objects will accurately fit in the subwindow and will be automatically adjusted when the main chart or terminal window is resized.

MQL5 Cookbook: Indicator Subwindow Controls - Buttons MQL5 Cookbook: Indicator Subwindow Controls - Buttons

In this article, we will consider an example of developing a user interface with button controls. To convey the idea of interactivity to the user, buttons will change their colors when the cursor hovers over them. With the cursor being over a button, the button color will be slightly darkened, getting significantly darker when the button is clicked. Furthermore, we will add tooltips to each button, thus creating an intuitive interface.