3.2.1DLL imports for MT4, and for 32-bit MT5

#import "FXBlueQuickChannel.dll"
  int QC_StartSenderW(string);
  int QC_ReleaseSender(int);
  int QC_SendMessageW(int, string, int);
  int QC_StartReceiverW(string, int);
  int QC_ReleaseReceiver(int);
  int QC_GetMessages5W(int, uchar&[], int);
  int QC_CheckChannelW(string);
  int QC_ChannelHasReceiverW(string);
#import

3.2.2DLL imports for 64-bit MT5

#import "FXBlueQuickChannel64.dll"
  long QC_StartSenderW(string);
  int QC_ReleaseSender(long);
  int QC_SendMessageW(long, string, int);
  long QC_StartReceiverW(string, long);
  int QC_ReleaseReceiver(long);
  int QC_GetMessages5W(long, uchar&[], int);
  int QC_CheckChannelW(string);
  int QC_ChannelHasReceiverW(string);
#import

3.3QC_StartSender()

int QC_StartSenderW(string ChannelName);

QC_StartSender() opens a channel for sending. It returns a handle (i.e. an identifier) for the channel which should be used in subsequent calls to QC_ReleaseSender() and QC_SendMessage(). You should always release channels when you have finished with them, typically during OnDeinit().

A return value of zero indicates that the channel could not be opened. This usually means that system resources are critically low.

An EA/script will typically call QC_StartSender() in its OnInit() function, and store the handle in a global variable for later use.

3.4QC_ReleaseSender()

int QC_ReleaseSender(int ChannelHandle);

QC_ReleaseSender() frees up a channel which was previously opened using QC_StartSender(). The parameter is the handle returned by QC_StartSender().

The function returns 1 if the channel was successfully released.

3.5QC_SendMessage()

int QC_SendMessageW(int ChannelHandle, string & Message, int Flags);

QC_SendMessage() sends a message down a channel. The first two parameters are simply the handle returned by QC_StartSender() and the text of the message to be sent.

The third parameter is a flag bit-mask, i.e. a combination of options as follows:

Therefore, a flag value of 3 means "clear any pending messages, and also ignore the message if no receiver is running".

A flag value of 0 means "add this message to any existing messages which are already waiting for collection, and store the message for future collection even if no receiver is running yet".

A return value of 1 from QC_SendMessage() means that the message was successfully added to the channel. A return value of -1 means that the message was ignored because flag 2 was used and no receiver is currently connected to the channel.

A return value of 0 indicates failure to add the message. There are a number of possible reasons for this:

• The handle parameter for the channel is not valid.
• The system is critically low on resources.
• The channel is full. It already has 65532 bytes of pending messages waiting for collection by the receiver.

3.6QC_StartReceiver()

int QC_StartReceiverW(string ChannelName, int WindowHandle);

QC_StartReceiver() opens a channel for receiving messages. It returns a handle (i.e. an identifier) for the channel which should be used in subsequent calls to QC_ReleaseReceiver() and QC_GetMessages(). You should always release channels when you have finished with them, typically in OnDeinit().

There should only be one receiver running on a channel. If necessary, you can check whether another EA has already called QC_StartReceiver() by using the QC_ChannelHasReceiver() function.

The first parameter for QC_StartReceiver() is the channel name to open. The second parameter is the window handle of the MT4 chart on which the EA/script is running. This can be obtained in MQ4 using WindowHandle(Symbol(), Period()). For example:

glbHandle = QC_StartReceiver("MyChannel", WindowHandle(Symbol(), Period()))

Please note that WindowHandle() may return zero during OnInit() if MT4 is starting up with the EA already running on chart. Therefore, you should call QC_StartReceiver() during OnTick(), not during OnInit() - and obviously make sure that you only call it once during OnTick(), rather than on every tick.

A return value of zero indicates that the channel could not be opened. This typically means that system resources are critically low.

An EA/script will usually store the handle from QC_StartReceiver() in a global variable for later use by QC_GetMessages() and QC_ReleaseReceiver().

3.7QC_ReleaseReceiver()

int QC_ReleaseReceiver(int ChannelHandle);

QC_ReleaseReceiver() frees up a channel which was previously opened using QC_StartReceiver(). The parameter is the handle returned by QC_StartReceiver().

The function returns 1 if the channel was successfully released.

3.8Retrieving messages

3.8.1Retrieving messages to a string buffer

int QC_GetMessages5W(int, uchar&[], int);

In order to retrieve messages you need to create a uchar[] array; pass that array to the QC_GetMessages5W() function; and then use MT4's CharArrayToString() function to convert the uchar[] array to a string.

QC_GetMessages5W() returns an integer which is 0 if there are no pending messages; -1 if the buffer is too small; and otherwise returns the length of the data which has been put into the uchar[] buffer.

You can get the size, in bytes, of the pending messages using QC_CheckChannel(), and then allocate a receiver buffer on a dynamic basis using ArrayResize(). However, it will normally be more efficient to allocate a static buffer when your EA/script starts up.

For example, using a buffer size defined by a constant:

uchar buffer[];
ArrayResize(buffer, QC_BUFFER_SIZE);
int res = QC_GetMessages5W(glbHandle, buffer, QC_BUFFER_SIZE);
if (res > 0) {
  string strMsg = CharArrayToString(buffer, 0, res);
  Print(strMsg);
}

3.8.2Copying messages to a file

int QC_GetMessages2W(int ChannelHandle, string Filename);

QC_GetMessages2W() writes the list of pending messages, if any, to the specified filename. The file can be anywhere on disk (subject to file permissions), and you need to pass the full filename rather than the sort of bare relative filename used for MT4's own file functions. For example, to write to a file called mymessages in the MQL4\Files directory of MT4, you would use the following:

int result = QC_GetMessages2W(glbHandle, StringConcatenate(TerminalInfoString(TERMINAL_DATA_PATH), "\\MQL4\\files\\mymessages.txt"));

QC_Messages2W() overwrites the specified file if it already exists, and can return the following integer values describing success/failure:

• 0: Successfully written non-blank list of messages
• 1: No pending messages

2: Unable to create the specified file. The name may be invalid, or the file may already be open and locked for writing.

• 3: Opened the file, but unable to write to it.

3.9QC_CheckChannel()

int QC_CheckChannelW(string ChannelName);

QC_CheckChannel() returns information about a channel. The possible return values are as follows:

3.10QC_ChannelHasReceiver()

int QC_ChannelHasReceiverW(string ChannelName);

QC_ChannelHasReceiver() checks whether a receiver is currently running on a channel, i.e. whether there is an EA/script which has called QC_StartReceiver(). The possible return values are as follows:

4Use of QuickChannel in non-MQL code

Although QuickChannel is principally designed for use with MT4 and MT5, it can also be used in any other programming environment which allows DLL calls. For example, you can use it to send from MT4 to a receiver application written in C#, or vice versa.

4.1Collecting messages in non-MT4 code

In most programming environments, e.g. C#, it should be possible to use functions such as QC_GetMessages5W(), but there is also a QC_GetMessages4() function which returns a Windows BSTR (a managed Unicode string) and it will be simpler to use in many environments including .NET.

BSTR QC_GetMessages4(IntPtr ChannelHandle);

Please see below for an example import of QC_GetMessages4() in C#.

4.1.1Collecting messages in VBA/VB6

The QC_GetMessages5W() function can also be used in VBA code in Microsoft Excel (or in VB6). You call it in the same way as a Win32 function such as GetWindowText() which copies a string value into a buffer. For example:

Dim Buffer As String, szBuffer As Long, res As Long
szBuffer = 100000
Buffer = Space$(szBuffer + 1)
res = QC_GetMessages5W(qchandle, Buffer, szBuffer)
If res > 0 Then
  Dim strResult As String
  strResult = Left(Buffer, res)
  MsgBox strResult
ElseIf res = 0 Then
  ' No messages
Else
  ' Error, e.g. buffer too short
End If

4.2Function imports in non-MQL programming environments

You will need to translate the function definitions for MT4/5 into the corresponding definitions for your programming environment such as C# or VB.NET. Please note the following points:

In the 64-bit version of QuickChannel, channel handles are 8 bytes long. For example, in .NET you should declare these as IntPtr rather than Integer.

In 64-bit code, the window handle expected by QC_StartReceiver() is also 8 bytes long rather than 4 bytes long.

If you are using VBA in Microsoft Excel, then please note that the standard installation of Microsoft Office is 32-bit even on a 64-bit version of Windows. Unless you have overridden the default installation, Office will be 32-bit and you should use the 32-bit version of QuickChannel.

4.2.1Example imports for C#

The following imports are for 64-bit C# code. For 32-bit code, you simply change the DLL references from FXBlueQuickChannel64.dll to FXBlueQuickChannel.dll.

[DllImport("FXBlueQuickChannel64.dll",CharSet=CharSet.Unicode)]
public static extern IntPtr QC_StartSenderW(string ChannelName);

[DllImport("FXBlueQuickChannel64.dll",CharSet=CharSet.Unicode)]
public static extern int QC_SendMessageW(IntPtr ChannelHandle, string Msg, int Flags);

[DllImport("FXBlueQuickChannel64.dll")]
public static extern int QC_ReleaseSender(IntPtr ChannelHandle);

[DllImport("FXBlueQuickChannel64.dll", CharSet = CharSet.Unicode)]
public static extern IntPtr QC_StartReceiverW(string ChannelName, IntPtr WindowHandle);

[DllImport("FXBlueQuickChannel64.dll", CharSet = CharSet.Unicode)]
[return : MarshalAs(UnmanagedType.BStr)]
public static extern string QC_GetMessages4(IntPtr ChannelHandle);

[DllImport("FXBlueQuickChannel64.dll")]
public static extern int QC_ReleaseReceiver(IntPtr ChannelHandle);

4.2.2Example imports for VBA in Microsoft Excel

Please note that installations of Microsoft Office are usually 32-bit even on a 64-bit version of Windows, and therefore you should use the 32-bit version of QuickChannel.

Declare Function QC_StartSender lib "FXBlueQuickChannel.dll" (ByVal ChannelName As String) As Long
Declare Function QC_ReleaseSender lib "FXBlueQuickChannel.dll" (ByVal ChannelHandle As Long) As Long
Declare Function QC_SendMessage lib "FXBlueQuickChannel.dll" (ByVal ChannelHandle As Long, ByVal Message As String, ByVal Flags As Long) As Long
Declare Function QC_StartReceiver lib "FXBlueQuickChannel.dll" (ByVal ChannelName As String, ByVal WindowHandle As Long) As Long
Declare Function QC_ReleaseReceiver lib "FXBlueQuickChannel.dll" (ByVal ChannelHandle As Long) As Long
Declare Function QC_GetMessages5W Lib "FXBlueQuickChannel.dll" (ByVal ChannelHandle As Long, ByVal Buffer As String, ByVal BufferSize As Long) As Long
Declare Function QC_CheckChannel Lib "FXBlueQuickChannel.dll" (ByVal ChannelName As String) As Long
Declare Function QC_ChannelHasReceiver Lib "FXBlueQuickChannel.dll" (ByVal ChannelName As String) As Long

4.3Event-driven message handling

In MT4 and MT5, QuickChannel forces a call to OnTick whenever a new message is available for collection by the receiver.

You can have similar event-driven processing in other environments by watching for Windows messages. When new data is available, QuickChannel posts an event to the window handle which you supply in QC_StartReceiver(). The Windows message details are as follows: msg = WM_USER (1024, 0x400), wparam = 1234, lparam = 5678.

For example, in C# you can trap these messages using the following code for the form or control whose handle you pass to QC_StartReceiver():

protected override void WndProc(ref Message m)
{

  if (m.Msg == 1024 && m.WParam.ToInt32() == 1234 && m.LParam.ToInt32() == 5678) {
  	// A new message is available for collection using QC_GetMessages4()
  } else {
    // Call standard handling for this Windows message
    base.WndProc(ref m);
  }
}

Such processing of Windows messages is not available in MT5, and therefore you will simply have to watch for messages on a timed basis, e.g. using EventSetMillisecondTimer() and the OnTimer() event.

4.4Window handles

You do not have to pass a valid window handle to QC_StartReceiver(). Therefore, you can still create a QuickChannel receiver in programming environments where a window handle is not available.

If you cannot pass a valid handle, you should instead pass the dummy value 1. The only side-effect of doing this is that QC_ChannelHasReceiver() will return 0 (because it checks the validity of the window handle associated with a channel).

5Example MQL4/5 code

Please note: this code is for MT4 or 32-bit MT5. For 64-bit MT5, some of the DLL imports and corresponding variables need to be changed to use long rather than int

Example sender:

#import "FXBlueQuickChannel.dll"
   int QC_StartSenderW(string);
   int QC_ReleaseSender(int);
   int QC_SendMessageW(int, string&, int);
#import

int glbHandle = 0;

void OnInit()
{
   glbHandle = QC_StartSenderW("TestChannel");
}

void OnDeinit(const int reason)
{
   QC_ReleaseSender(glbHandle);
   glbHandle = 0;
}

void OnTick()
{
   string strMsg = "Hello @ " + TimeToStr(TimeCurrent());
   if (!QC_SendMessageW(glbHandle, strMsg , 3)) {
      Print("Message failed");
   }
}

Example receiver:

#import "FXBlueQuickChannel.dll"
   int QC_StartReceiverW(string, int);
   int QC_ReleaseReceiver(int);
   int QC_GetMessages5W(int, uchar&[], int);
#import

#define QC_BUFFER_SIZE     10000

int glbHandle = 0;
uchar glbBuffer[]; // Allocated on initialisation

void OnInit()
{
   // Do initialisation in OnTick (or OnStart), not in OnInit()
}

void OnDeinit(const int reason)
{
   if (glbHandle) QC_ReleaseReceiver(glbHandle);
   glbHandle = 0;
}

void OnTick()
{
   // Create handle and buffer if not already done (i.e. on first tick)
   if (!glbHandle) {
      glbHandle = QC_StartReceiverW("TestChannel", WindowHandle(Symbol(), Period()));
      ArrayResize(glbBuffer, QC_BUFFER_SIZE);
   }

   if (glbHandle) {
      int res = QC_GetMessages5W(glbHandle, glbBuffer, QC_BUFFER_SIZE);
      if (res > 0) {
         string strMsg = CharArrayToString(glbBuffer, 0, res);
         Print(strMsg);
      }
   } else {
      Print("No handle");
   }
}