Creating Forms that are stored in DLLs

There are lots of resources and solutions out there on the internet that are specific to this problem, however, in using the BusinessSkinForm components, that are tightly integrated with the VCL and messaging, I came across a few problems with the standard approaches.

The final solution came with the assistance of Steve Woods (aka Reconics).

The main problem with storing Forms in dlls and being able to create instances of them from within a host exe is that when Delphi compiles up a dll, it has its own TApplication and TScreen instances (as well as other info as to be discovered).

 

This means that the DLL and the EXE message loops are different, the RTTI information is different, and causes lots of problems like the well know "cannot assign a TFont to a TFont" message.

 

So how do we Coax the form in the DLL to think it is part of the EXE, we replace the Application and Screen Object in the DLL with the reference to the EXE's Application and Screen.

 

This is a standard approach that you will find on the net. However there is one additional element that needs to be passed from EXE to DLL and this is the tricky one.

 

From Steve Woods -

“The problem is caused by the ControlAtom local variable in the Controls.pas units. When the controls unit initializes it creates a global atom based on the string 'ControlOfs' + the HInstance and thread ID of the application and stores the atom in the ControlAtom local variable.

All well and good. Then when new wincontrols are added to the application a pointer to the control is stored under the window handle using the SetProp API function. This allows Delphi to get the TWinControl of a Handle.

The CM_MouseEnter etc. events are generated from the TApplication.DoMouseIdle method. In order to get the current wincontrol under the mouse, and thus pass the required messages, its searches for a property with a Atom equal to the local ControlAtom variable stored in the Controls units.

This all works fine for standalone apps but when you start putting forms in DLL's the following happens:

The controls unit is initialized again for the DLL. This creates a new global atom and stores it in the Controls unit local variable, so you now have TWO control global atoms, one for the main app and one for the DLL.

And thus, when the Application.DoMouseIdle method tries to find a property stored with the same name (atom) as the application on a DLL form, it fails. To solve this I had to hack the controls.pas units a little. I added a routine : Function GetControlAtom : Pointer that returns @ControlAtom from the controls units.

Then in your DLL's you initialize by passing the ControlAtom from the application Controls units and set this value in the Controls unit of the DLL:

eg

Library ADLL; 
Uses 
  ... 
  forms, 
  Controls, //Add this here so it initializes unit before we try and change GetControlAtom; 
  ... 

procedure CreateForm(App : TApplication;Scr : TScreen;RealControlAtom : 
Integer); 
Var 
  P : ^Word; 
Begin 
  If (OldApp = Nil) Then 
  Begin 
    OldApp := Application; 
    OldScr := Screen; 
    P := GetControlAtom; 
    OldAtom := P^; 
    Application := App; 
    Screen := Scr; 
    P^ := RealControlAtom; 
  end; 
  TForm1.Create(Application.MainForm); 
end; 

and make sure you clean-up before you unload the dll."

Stage 1) The ControlAtom variable is private to the controls.pas unit so we need to change Controls.pas for the EXE and DLL projects

 

Take a copy of controls.pas from the delphisourcevcl directory and save it into a directory that the EXE project and DLL project can access.

In the Interface Section add the function declaration for the function that will return the address of the current ControlAtom variable.

 

  function GetControlAtom : pointer; 

 

In the implementation section add the GetControlAtom function.

 

  function GetControlAtom : pointer; begin result := @ControlAtom; end;

 

We now have an exposed function that will return the address of the Control Atom Variable.

Stage 2) Setting up the DLL exported functions

 

Add the modified Controls.pas to the project so it appears in the Project manager. Delphi will then use this source in preference to the standard controls.dcu.

We now need to provide a DLLInitialization procedure and a DLLFinalization Procedure. The DLLInitialization must be called before trying to use any forms from the DLL, usually this is

called just after loading the dll into memory. The DLLFinalization procedure should be called before the DLL is unloaded from memory.

Below is an example of the code needed to be exposed in the DLL. Notice the dll exports 3 functions/procedures DLLInitiailize, DLLFinalize and GetInstance

GetInstance is the call that actually returns an instance of a the dlls Form.

 

library plugin; 
uses 
  ShareMem, 
  SysUtils, 
  Classes, 
  Windows, 
  Forms, 
  Controls in 'Controls.pas',  
  pluginform in 'pluginform.pas' {MyPlugin}; 

{$R *.res} 

var  
  OldApp : TApplication; 
  OldScreen : TScreen; 
  OldControlAtom : TAtom; 

procedure DLLInitialize(App : TApplication; Scr : TScreen; RealControlAtom :Integer); 
var 
  x : pointer; 
  p : ^Word; 
begin 
  If (OldApp = Nil) Then 
  Begin 
    // store away the current application, screen and control atom 
    OldApp := Application; 
    OldScreen := Screen; 
    p := GetControlAtom; 
    OldControlAtom := p^; 
    // Assign the EXE's application, screen and control atom 
    Application := App; 
    Screen := Scr; 
    p^ := RealControlAtom; 
  end; 
  ASkin := Skin; 
end; 

function GetInstance(AOwner : TComponent) : TForm; 
begin 
  // create an instance of the form 
  result := TMyPlugin.create(Application.MainForm); 
end; 

procedure DLLFinalize; 
var 
  p : ^Word; 
begin 
  // restore the DLL's application, screen and control atom 
  p := GetControlAtom; 
  p^ := OldControlAtom; 
  Screen := OldScreen; 
  Application := OldApp; 
end; 

exports 
  GetInstance, DLLInitialize, DLLFinalize; 

begin 
  OldApp := nil; 
  OldScreen := nil; 
  OldControlAtom := 0; 
end. 

Stage 3) Setting up the EXE.

Add the modified Controls.pas to the project so it appears in the Project manager. Delphi will then use this source in preference to the standard controls.dcu.

Declare some procedure / function types to be used to reference the exported procs in the dll.

 

type 
  TDLLInitialize = procedure (App : TApplication; Scr : TScreen; RealControlAtom : Integer); 
  TDLLFinalize = procedure; 
  TGetInstance = function (AOwner : TComponent) : TForm; 

Add a variable to store the DLL HInstance in

 

var
  FInst : HINST; 

Add a procedure to Load the DLL and initialize it

 

procedure LoadDLL 
var 
AInit : TMyInitialize; 
p : ^WORD; 
begin 
  // get the address of the Exe's control atom 
  p := GetControlAtom; 
  FInst := LoadLibrary('plugin.dll'); 
  AInit := GetProcAddress(FInst,'DLLInitialize'); 
  if assigned(AInit) then 
  begin 
    // pass the TApplication, TScreen and value of the Control Atom 
    AInit(Application,Screen,p^, bsCompressedStoredSkin1); 
  end; 
end; 

Add a procedure to Finalize the DLL and Unload it

 

procedure UnloadDLL 
var 
  AProc : TMyFinalize; 
begin 
  // unload the dll after asking the dll to restore it's original application, screen and ControlAtom 
  AProc := GetProcAddress(FInst,'DLLFinalize'); 
  if assigned(AProc) then 
  begin 
    AProc; 
  end; 
  if FInst <> 0 then FreeLibrary(FInst); 
end; 

Add a procedure to create an instance procedure CreateAForm;

 

 

var 
  AProc : TGetInstance; 
  AForm : TMyPlugin; 
begin 
  // get an instance of the form in the dll - not that the dll creates it... not the exe. 
  AProc := GetProcAddress(FInst,'GetInstance'); 
  if assigned(APRoc) then 
  begin 
    AForm := TMyPlugin(AProc(self)); 
    AForm.Name := 'Form' + Formatdatetime('hhnnss',now); // give it a unique name
  end; 
end; 

So you now have an EXE and DLL that both use the modified controls.pas, that correctly passes the EXE's application object, screen object and ControlAtom to the DLL to trick the DLL into thinking it is part of the EXE application.

 

 

Procedure CreateForm(App : TApplication;Scr : TScreen;RealControlAtom : Integer); 
Var
  P : ^Word; 
Begin 
  If (OldApp = Nil) Then
  Begin 
    OldApp := Application; 
    OldScr := Screen; 
    P := GetControlAtom; 
    OldAtom := P^; 
    Application := App; 
    Screen := Scr; 
    P^ := RealControlAtom; 
  end;
end;

So you now have an EXE and DLL that both use the modified controls.pas, that correctly passes the EXE's application object, screen object and ControlAtom to the DLL to trick the DLL into thinking it is part of the EXE application.