Hallo.

Ich habe ein Phänomen was ich mir nicht ganz erklären kann.

Ich habe eine Form (XE4) mit einer ActionList und die Actions ToolButtons zugewiesen.
Das funktioniert wenn ich das Fenster normal in einem Projekt einbinde.

Füge das ich das Fenster in eine DLL ein, lade die DLL in einem Programm und starte das Fenster werden die Actions nicht mehr ausgelöst.
Muss ich beim create der Form in der DLL irgendwas berücksichtigen?

Code:

markieren

Code:

var isFormCreated:boolean;

procedure createForm(absenderAktiv:boolean);stdcall;
begin

    FEMail                 := TFemail.create(application);

    isFormCreated          := TRUE;

    FEMail.Icon.LoadFromResourceName(HInstance,'logo');
end;


procedure showForm;stdcall;
begin
    if not isFormCreated then createForm(false);
    if isFormCreated then begin
        FEMail.showmodal;
    end;
end;

Edit:
Scheinbar bin ich nicht allein. Ok der ist von 2003 und leider keine Antwort.
http://www.delphigroups.info/2/8b/352235.html

Edit2 :
Ok ein paar andere Threads schreiben das scheinbar die application.idle Methode dafür zuständig ist und d.h das mein aufrufendes Programm dann für die Action zuständig ist?

Du nutzt wahrscheinlich keine dynamisch geladenen BPLs, somit hat die DLL eine eiegene VCL-Kopie und kriegt wohl ncihts mit...

Ich nutze keine BPL, sondern DLL und diese wird aber dynamisch geladen.

Ja, ich weiss, das meine ich aber nicht.
Wenn Du in Delphi DLLs baust, baut der Compiler standardmäßig alles rein, RTL, VCL etc. Somit hast du alles da, was die DLL braucht um dein Zeug zu machen, man weiss ja nicht, von wem man geladen wird.
Das gleiche passiert bei einer exe in Delphi. Muss man ja keine Bibliotheken mitliefern, wie zum Bsp. BPLs. Die sind dann statisch reingelinkt.

Wenn Du allerdings eine Delphi anwendung mit DLLs bauen willst, die Oberfläche haben, dann solltest Du das alles dynamisch linken so dass Du dann zwar RTLXXX.bpl etc mitliefern musst, aber exe und DLL sich diese teilen, kleiner werden und vor allem gleiche Klassen-Beschreibungen, globale Objekte etc haben.

Einfaches Beispiel :

Nimm mal das Application Objekt von der Exe und der DLL mit statischen runtime Bibliotheken und wirst sehen, dass es unterschiedliche sind. Bei dynamisch gelinkten sind diese gleich.
Im Ersten Fall hast Du auch das problem, dass TAction <> TAction ist, weil das für das programm 2 verschiedenen Klassen sind, eine Kopie in der exe, die andere in der DLL. Bei dynamisch gelinkten ist es in der BPL und somit gleich.

Habe gerade kein Delphi zur Hand sollte aber funktionieren wenn das Application.Handle der Exe an die Dll übergeben wird.
Bau eine InitFunktion für die Dll die Das Handle bekommt.

So in etwa:

markieren

Delphi-Quellcode:

Procedure InitDll(const aHandle : THandle) ; stdcall;
begin
 Applicaton.Handle := aHandle;
end;

Wichtig direkt nach dem Laden der Dll aufrufen.
Eventuell auch ein Gegenstücke wenn die Dll wieder entladen wird.

Wir benutzen hier so ein Konstrukt um auch Dll's die mit verschiedenen Versionen kompiliert sind zu benutzen.

Gruss Fritz

Zitat von stalkingwolf:

Edit2 :
Ok ein paar andere Threads schreiben das scheinbar die application.idle Methode dafür zuständig ist und d.h das mein aufrufendes Programm dann für die Action zuständig ist?

Genau. Eine Dll ist ja auch eine Anwendung. Nur dass dort Application eben nicht viel macht.
Sobald das Formular in deiner Dll fertig geladen und angezeigt ist hat es ein gültiges Fensterhandle.
Das teilst Du dem Hauptprogramm mit. Dann kannst Du dir via PostMessage Nachrichten schicken. Genauso gibst Du der Dll Instanz nach dem erstellen das Handle deines Hauptfensters an und dann geht es in beide Richtungen.
Vorteil ist, das diese Lösung auch funktioniert wenn das Fenster direkt im Hauptprogramm eingebunden wird.

Probiere es mal so, dass du den OnIdle-Aufruf deiner Delphi-Applikation zu deiner DLL durchreichst, damit dort CheckSynchronize aufgerufen wird:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    procedure MyIdle(Sender: TObject; var Done: Boolean);
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  Application.OnIdle := MyIdle;
end;

procedure TForm1.MyIdle(Sender: TObject; var Done: Boolean);
begin
  ExampleDllFunctionNameForCheckSynchronize;
end;

// - - - - - - - - -
// in deiner DLL:

procedure ExampleDllFunctionNameForCheckSynchronize; stdcall;
begin
  CheckSynchronize;
end;

exports
  ExampleDllFunctionNameForCheckSynchronize;

Zitat von Fritzew:

Habe gerade kein Delphi zur Hand sollte aber funktionieren wenn das Application.Handle der Exe an die Dll übergeben wird.
Bau eine InitFunktion für die Dll die Das Handle bekommt.

Wenn ich das mache, dann hagelt es bei den Actions die Meldung "Externe Exception C000001D."

Zitat von TiGü:

Probiere es mal so, dass du den OnIdle-Aufruf deiner Delphi-Applikation zu deiner DLL durchreichst, damit dort CheckSynchronize aufgerufen wird:

Das hat leider nichts gebracht.