Creating Metatrader DLLs with Lazarus / Free Pascal

Quoting 7bit

Disliked

As soon as you got rid of all global variables inside the dll and as a consequence your functions don't have any side effects anymore (side effect = change things or be dependent on things outside the scope of the function) your DLL will be thread save and the problem is gone.

In the above mentioned posting i describe a way to hold all needed global variables inside the mql4 where they cannot influence other EA instances and an easy way to pass them all to a dll function call with just one array (and being able to read/write them) instead of having...

Ignored

Quoting dinhero

Disliked

Can it be possible to insert an GUI inside a DLL, so the GUI would start when the DLL is call by Metatrader ?

Ignored

Quoting rangebound

Disliked

GUI windows within DLLs are fine (I.E. Your EAs and Indicators can open windows defined / compiled within your DLL) However there are subtle issues that need to be known .... namely :
..................

Ignored

library Test_Dll_1_0;

 uses SysUtils, Classes, Dialogs;

 //Variable and type are global so they can be call by other process
  type
    TTabTest = array[1..100] of integer;
    PTabTest = ^TTabTest;

  var
    References: PTabTest;
    indx: integer;


 //Test function for producing a token number
 function Produce_Token(var Token_done : integer): pointer ; stdcall;  //input not really used

  begin
    New(References);
    References^[1] := 0;

      for indx := 1 to 100 do
      References^[indx] := Trunc(Random(10000));

    ShowMessage('Référence n°24 : '+IntToStr(References^[24]));
    //Dispose(References);
    result := References ;
  end;


  //This function have as objectif to verify the that the pointer give what we want
  [color=Red][b]function Verif_Token(var Pointer_Token : PTabTest): integer  ;stdcall;
  begin
      ShowMessage('Back to the table'+IntToStr(Pointer_Token^[24]))

  end;[/b][/color]

 procedure DllMessage; export;
 begin
   ShowMessage('Hello world from a Delphi DLL') ;
 end;





 exports
 Produce_Token,
 Verif_Token,
 DllMessage;

 begin
 end.

//List of function to import
#import "Test_Dll_1_0.dll"
   
   int Produce_Token(int Token_done);
   int Verif_Token(int verif_token);
   void DllMessage(); 

#import

int init()
  {
//----
   DllMessage();
//----
   return(0);
  }

int deinit()
  {
//----
   
//----
   return(0);
  }

int start()
  {
//----
   static int Pointer_value ; 
   
   Pointer_value = Produce_Token(1); //we produce the token
   
   Print(Pointer_value);
   
   Verif_Token(Pointer_value); // then we verify if it is correct
//----
   return(0);
  }
//+------------------------------------------------------------------+

[color=SeaGreen]/** 
* This serves as an example how to make an indicator that has its 
* values calculated by a DLL. The code below is only a thin wrapper 
* around the DLL, there are no loops, no calculations in mql4, 
* it is simply initially setting up the indicator buffer and then 
* simply passing every incoming tick to the DLL which will then 
* do all the rest and calculate and write the values to the buffer. 
*/ [/color]
#property copyright "Copyright © 2010, Bernd Kreuss" 
#property link      "[url]http://sites.google.com/site/prof7bit/[/url]" 
 
#property indicator_chart_window 
#property indicator_buffers 1 
#property indicator_color1 Red 
 
#import "sma.dll" 
[color=SeaGreen]   // history and buffer are passed by reference, this means the dll will receive pointers to the arrays  [/color]
   void updateBuffer(double &history[][6], double &buffer[], int bars, int indicator_counted, int period); 
#import 
 
extern int ma_period=13; 
extern int ma_shift=0; 
 
double buffer[]; [color=SeaGreen]// the indicator buffer [/color]
double history[][6]; [color=SeaGreen]// this will later point to the complete chart history [/color]
 
int init(){ 
   [color=SeaGreen]// set up the indicator buffer [/color]
   SetIndexStyle(0, DRAW_LINE); 
   SetIndexShift(0, ma_shift); 
   SetIndexBuffer(0, buffer); 
   SetIndexLabel(0, "simple moving average"); 
   IndicatorDigits(Digits);

[color=SeaGreen]   // the following will initiate some magic from MT4: After  
   // this call the array will automatically be updated by MT4 on 
   // every tick. It will from now on behave like the Close[]  
   // or Open[] arrays, only here we have all OHLCV data  
   // conveniently in one big 2-dimensional array. 
   //  
   // ArrayCopyRates() does not really copy something, intead it 
   // will simply internally change a pointer to make it point 
   // to the automatically updating data. Maybe a better name 
   // for what really happens here would be GetRatesDataPointer() 
   // to retrieve the address where MT4 holds the history but this  
   // would probably only confuse n00bs, since there is no concept 
   // of pointers in mql4, although they of course do exist behind 
   // the scenes.   [/color]
   ArrayCopyRates(history, NULL, 0); 
} 
  

[color=SeaGreen]/** 
* You probably know the standard example from MetaQuotes where  
* they use the value of IndicatorCounted() and the value of Bars  
* and set up a loop that is intended to loop over all new bars  
* (bars that have been newly appeared since start() was called the  
* last time) and then inside this loop they will calculate the  
* indicator value for these bars and write them into the buffer. 
* 
* All this is now done inside the DLL, and it is done more or  
* less the very same way. 
* 
* We supply the updateBuffer() function with all data that it  
* needs to do this. It will know the number of bars in the chart, 
* the number of already calculated bars and it has a pointer  
* to the buffer array to directly write the values to the buffer.  
* We don't need to touch the buffer from mql4. 
*/ [/color]
int start(){ 
   updateBuffer(history, buffer, Bars, IndicatorCounted(), ma_period); 
}

[b]library[/b] sma; 
 
[color=SeaGreen]{$mode objfpc}{$H+} [/color]
 
[b]type [/b]
[color=SeaGreen]  {MT4 stores the data of each candle in such a structure. 
  MT4 will then give us a pointer to an array of such candles} [/color]
  TCandle = [b]packed record [/b]
    time:   LongInt; [color=SeaGreen]// POSIX timestamp [/color]
    open, 
    high, 
    low, 
    close, 
    volume: Double; 
[b]  end; [/b]
  
[color=SeaGreen]  {the following would be a pretty large array but we actually never create 
  an instance of it, we only need a typed pointer to such an array. 
  We will later receive a pointer from MT4 to the chart history 
  stored in such an array} [/color]
  THistory = [b]array[/b][0..MaxLongInt div SizeOf(TCandle) - 1] [b]of[/b] TCandle; 
  PHistory = ^THistory; 
 
[color=SeaGreen]  {This is the structure of an indicator buffer. We will be given a 
  pointer to an indicator buffer to fill it with the calculated values} [/color]
  TBuffer = [b]array[/b][0..MaxLongInt div SizeOf(Double) - 1] [b]of[/b] Double; 
  PBuffer = ^TBuffer; 
 
[b]const [/b]
  EMPTY_VALUE = $7FFFFFFF; 
 
 
[color=SeaGreen]{calculate the moving average for the bar at index. Index is the absolute index 
in the history array of the bar for which we want to calculate this value. The 
function will return the value or it will return EMPTY_VALUE if there are not 
enough bars before index to calculate a moving average of the requested period} [/color]
[b]function[/b] movingAverage(history: PHistory; period: LongInt; index: LongInt): Double; 
[b]var[/b] 
  sum: Double; 
  i:   LongInt; 
 
[b]begin [/b]
  if index < period then exit(EMPTY_VALUE); 
  if period < 1 then exit(history^[index].Close); 
 
  sum := 0; 
  [b]for[/b] i := 0 [b]to[/b] period - 1 [b]do[/b] 
  [b]begin[/b] 
[color=SeaGreen]    // index is the absolute index of the bar in the history array 
    // for which to calculate the moving average. The UpdateBuffer 
    // function has already transformed it for our convenience. [/color]
    sum += history^[index - i].Close; 
  [b]end;[/b] 
  Result := sum / period; 
[b]end; [/b]
 
[color=SeaGreen]
{Calculate for all (new) bars the indicator values and update the 
indicator buffer. This is more or less the same thing that is found 
in the example indicators from MetaQuotes. On every tick we look at 
the numbers from Bars and IndicatorCounted() to determine over which 
bars we have to loop and (re-)calculate the indicator value, only 
here we do it in Pascal and it is nicely documented and the code 
looks much cleaner} [/color]
[b]procedure[/b] updateBuffer(history: PHistory; buffer: PBuffer; bars: LongInt; indicator_counted: LongInt; period: LongInt); stdcall; 
[b]var [/b]
  i:  LongInt; 
  iC: LongInt; 
  iB: LongInt; 
[b]begin [/b]
[color=SeaGreen]  // unlike in metatrader which silently tranforms the 
  // indices of the buffers so that in mql4 the 0 is always 
  // the last bar in the buffer, the real underlying arrays 
  // with which we are dealing here directly start with 0 
  // as the oldest bar and bars - 1 as the current bar. 
 
  // We tranform bars and indicator_counted from MT4 into 
  // abolute indices in our buffer arrays so that 
  // iB will be the index of the current bar and 
  // iC will be the index of the last seen bar 
  // in most cases they will be identical and 
  // we loop only one iteration: the current bar. 
  // When a new bar has just appeared we will loop 
  // over the last two bars. [/color]
  iC := indicator_counted - 1; 
  iB := bars - 1; 
 
  [b]if[/b] indicator_counted = 0 [b]then[/b] 
  [b]begin [/b]
[color=SeaGreen]    // this is a special case and happens only when it is called 
    // for the very first time. We cannot start at index -1, 
    // instead we start at 0 in this case. [/color]
    iC := 0; 
  [b]end; [/b]
 
[color=SeaGreen]  // loop over the new bars and calculate and update the 
  // indicator buffer at these positions. [/color]
  [b]for[/b] i := iC [b]to[/b] iB [b]do[/b] 
  [b]begin [/b]
    buffer^[i] := movingAverage(history, period, i); 
  [b]end; [/b]
[b]end; [/b]
 
[b]exports [/b]
  updateBuffer; 
 
[b]begin 
end. [/b]

Quoting HLloyd

Disliked

What is the format Pascal uses internally to compare dates?

Ignored

function PosixToDateTime(posix: LongInt): TDateTime;
begin
  Result := (posix / 86400) + 25569;
end;

function DateTimeToPosix(dt: TDateTime): LongInt;
begin
  Result := Round((dt - 25569) * 86400);
end;

program project1;

{$mode objfpc}{$H+}

uses
  sysutils;

var
  foo: TDateTime;
  bar: TDateTime;
  year, month, day, hour, minute, second, milli: word;
  timestamp: LongInt;
  x : LongInt;

function PosixToDateTime(posix: LongInt): TDateTime;
begin
  Result := (posix / 86400) + 25569;
end;

function DateTimeToPosix(dt: TDateTime): LongInt;
begin
  Result := Round((dt - 25569) * 86400);
end;

begin
  foo := PosixToDateTime(587675785);  // this is 15. August 1988, 19:16:25
  bar := now();                        // this is the current time

  writeln('foo was converted from some POSIX timestamp ');
  writeln('foo: ',DateTimeToStr(foo));  // this will print 15-8-88 19:16:25
  writeln('bar: ',DateTimeToStr(bar));  // this will print the current date and time

  // compare times
  if foo < bar then
  begin
    writeln('foo was before bar');
  end;

  // format it to a string (see the documentation of FormatDateTime)
  writeln(FormatDateTime('yyyy.mm.dd hh:mm:ss', bar));

  // day of week
  writeln('it is day ', DayOfWeek(bar), ' of the week');

  // decode
  DecodeDate(bar, year, month, day);
  writeln('DecodeDate: ', year, '-', month, '-', day);

  DecodeTime(bar, hour, minute, second, milli);
  writeln('DecodeTime: ', hour, '-', minute, '-', second, '-', milli);

  // encode
  foo := EncodeDate(2012, 12, 21);
  writeln('encoded and formatted ', FormatDateTime('dddd, dd. mmm yyyy', foo));

  // timestamps
  timestamp := DateTimeToPosix(foo);
  writeln('converted to POSIX timestamp ', timestamp);
  foo := PosixToDateTime(timestamp);
  writeln('and back: ', FormatDateTime('dddd, dd. mmm yyyy', foo));
end.

bernd@t40:~/Desktop/pascaltest $ ./project1
foo was converted from some POSIX timestamp
foo: 15-8-88 19:16:25
bar: 11-7-10 19:00:04
foo was before bar
2010.07.11 19:00:04
it is day 1 of the week
DecodeDate: 2010-7-11
DecodeTime: 19-0-4-117
encoded and formatted Friday, 21. Dec 2012
converted to POSIX timestamp 1356048000
and back: Friday, 21. Dec 2012
bernd@t40:~/Desktop/pascaltest $

Quoting rangebound

Disliked

The windows function CreateWindow() associates the new window's message queue with the thread that was active when CreateWindow() was called. It is not possible to tell windows to use a different thread. You can however hack this association later but it is not advised.


MT4 creates the following issues :
1) Indicators
These run in the main application thread. And therefore if you create a (non modal) window in a call to your DLL from your indicator then all will be fine as the new window will attach to the main applications message queue...

Ignored

 
library ScreenCapture;
 
{$mode objfpc}{$H+}
 
uses
  interfaces, Windows, Graphics;
 
function printScreen(fileName: LPCSTR): longint; stdcall;
var
  MyJPEG:   TJPEGImage;
  ScreenDC:   HDC;
 
begin
  MyJPEG := TJPEGImage.Create;
 
  try
    ScreenDC := GetDC(0);
    MyJPEG.LoadFromDevice(ScreenDC);
    ReleaseDC(0,ScreenDC);
    MyJPEG.SaveToFile( fileName );
  finally
    MyJPEG.Free;
  end;
 
  result := 0;
end;
 
exports
  printScreen;
 
  {$IFDEF WINDOWS}{$R ScreenCapture.rc}{$ENDIF}
 
begin
end.

Quoting zznbrm

Disliked

I threw together a quick dll to capture a screenshot of the MT4 window and save in JPEG format to a file. The DLL is 11.6 MB in size. Anyone know how to reduce the size of the DLL?

Ignored

Quoting 7bit

Disliked

Go to project options -> compiler options and disable debugging info and enable "strip symbols from executable". You can also try to enable smart linking, this might also squeeze out a few bytes.

The executable size will then go down to ~150k. If you remove the line with the $R directive in the source code you will have an additional decrease in size but then it can't contain version info, icons, and other resources, you should then be able to reduce it to ~70kb (these numbers are for a really minimal dll that does not have huge...

Ignored