mql4-lib

In mql4-lib, an Indicator can exist in two modes:

1. Runtime Controlled (Standalone): The indicator is controlled by the MetaTrader terminal. In this mode, isRuntimeControlled() returns true. You must configure visual styles (e.g., SetIndexStyle, IndicatorShortName) inside the constructor.
2. Driven (Programmatic): The indicator is driven by your own code (e.g., an EA or Script) using a HistoryData derived class like Renko or TimeSeriesData. In this mode, isRuntimeControlled() returns false, and you are responsible for resizing buffers (e.g., using ArrayResize) within the main() method.

Using an Indicator in an EA with a Renko Driver

To use an indicator programmatically, instantiate its parameter class, create the indicator instance, and subscribe to the driver's OnUpdate event.

//--- OnInit
DeMarkerParam *param=new DeMarkerParam;
param.setAvgPeriod(14);
deMarker=new DeMarker(param);

//--- Subscribe to Renko driver
renko = new Renko(_Symbol,300);
renko.OnUpdate+=deMarker;

//--- OnTick
renko.update(Close[0]);

//--- Access value
double value = deMarker[0];

//--- OnDeinit
delete renko;

The library provides two primary operations for price calculation that allow you to express order logic symmetrically, regardless of whether the order is a BUY or a SELL. This approach reduces code complexity by focusing on the direction of profit rather than checking order types manually.

Profit Calculation: p(s, e)

Calculates the profit as the absolute price difference from a start price s to an end price e.

• To calculate loss, use -p(s, e) or p(e, s). Using -p(s, e) is preferred for clarity.

Target Price Calculation: pp(p, pr)

Calculates the target price if you start from price p and want to achieve a profit of pr.

• To target a specific loss, use pp(p, -pr).
• Convenience Overload: The pr parameter can also accept a value in points directly.

Expressing Breakeven

You can express the breakeven condition symmetrically for both BUY and SELL orders using: order.p(order.getOpenPrice(), order.getStopLoss()) >= 0.

• For a BUY order, this evaluates to openPrice <= stopLoss.
• For a SELL order, this evaluates to openPrice >= stopLoss.
• Conceptually: "If we move from the open price to the stop loss price, we still profit."

// Example of symmetric breakeven check
if(o.p(o.getOpenPrice(), o.getStopLoss()) >= 0) {
    // Order is at or past breakeven
}

The library provides sophisticated collection types using MQL class templates.

List Types

• LinkedList<T>: A linked list implementation. Faster for frequent insertions and deletions.
• Vector<T>: An array-based implementation (similar to Java's ArrayList). Faster for random access.

Set Types

• ArraySet<T>: Array-based set implementation.
• HashSet<T>: Hash-based set implementation.

Iteration

To iterate through collections, use the Iter<T> RAII class or the provided macros. The macros handle resource cleanup automatically.

• foreach(Type, collection): Uses an internal iterator variable named it.
• foreachv(Type, var, collection): Declares a specific variable var for the element.
• foreachorder(pool): Specialized macro for iterating through an order pool.

LinkedList<Order*> orderList; // linked list based implementation, faster insert/remove
LinkedList<int> intList; // supports primary types
Vector<Order*> orderVector; // array based implementation, faster random access
Vector<int> intVector;

// Using Iter RAII class
for(Iter<Order*> it(list); !it.end(); it.next())
  {
    Order* o = it.current();
    Print(o.toString());
  }

// Using foreach macro
foreach(Order*, list)
  {
    Order* o = it.current();
    Print(o.toString());
  }

// Using foreachv macro
foreachv(Order*, o, list)
  {
    Print(o.toString());
  }

You can bypass MetaTrader's limitations by sending custom events from an external C/C++ application using the PostMessage or PostThreadMessage Win32 API. This mechanism uses a custom WM_KEYDOWN message to trigger OnChartEvent in MQL.

To ensure the MQL program (specifically those deriving from EventApp) processes the message via its onAppEvent handler, you must encode the event and param using the EncodeKeydownMessage algorithm.

Limitations:

• The parameter is limited to a 32-bit integer.
• This solution may not work in 64-bit MetaTrader 5.
• It is considered a temporary workaround; the official way to handle asynchronous events is via ChartEventCustom (which is difficult to implement in C++ due to anti-debugging measures).

#include <Windows.h>
#include <stdint.h>
#include <limits.h>

static const int WORD_BIT = sizeof(int16_t)*CHAR_BIT;

void EncodeKeydownMessage(const WORD event,const DWORD param,WPARAM &wparam,LPARAM &lparam)
{
    DWORD t=(DWORD)event;
    t<<= WORD_BIT;
    t |= 0x80000000;
    DWORD highPart= param & 0xFFFF0000;
    DWORD lowPart = param & 0x0000FFFF;
    wparam = (WPARAM)(t|(highPart>>WORD_BIT));
    lparam = (LPARAM)lowPart;
}

BOOL MqlSendAppMessage(HWND hwnd, WORD event, DWORD param)
{
    WPARAM wparam;
    LPARAM lparam;
    EncodeKeydownMessage(event, param, wparam, lparam);
    return PostMessageW(hwnd,WM_KEYDOWN,wparam, lparam);
}

To create an Expert Advisor with inputs, follow these steps:

1. Define a parameter class inheriting from AppParam.
2. Use the ObjectAttr macro to declare fields. This automatically generates getter/setter methods following Java Beans conventions.
3. Define your EA class inheriting from ExpertAdvisor, passing the parameter class to its constructor.
4. Use BEGIN_INPUT and END_INPUT blocks to define the inputs for the MetaTrader terminal.
5. Use DECLARE_EA to register the EA. Set the second parameter to true to indicate it uses input parameters.

Note: Use the constructor for initialization (instead of OnInit) and the destructor for deinitialization (instead of OnDeinit). Use fail(message, returnCode) within the constructor if initialization fails.

#include <Mql/Lang/ExpertAdvisor.mqh>

class MyEaParam: public AppParam
{
  ObjectAttr(string,eaName,EaName);
  ObjectAttr(double,baseLot,BaseLot);
public:
};

class MyEa: public ExpertAdvisor
{
private:
  MyEaParam *m_param;
public:
       MyEa(MyEaParam *param)
       :m_param(param)
      {
      }
      ~MyEa()
      {
      }
  void main() {Print("Hello from " + m_param.getEaName());}
};

BEGIN_INPUT(MyEaParam)
  INPUT(string,EaName,"My EA");
  INPUT(double,BaseLot,0.1);
END_INPUT

DECLARE_EA(MyEa,true)