AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Tutorials Delphi PlugIns in eigenen Anwendungen

PlugIns in eigenen Anwendungen

Ein Tutorial von sakura · begonnen am 14. Mai 2003 · letzter Beitrag vom 26. Feb 2010
Antwort Antwort
Seite 4 von 4   « Erste     234
Benutzerbild von sakura
sakura
Registriert seit: 10. Jun 2002
Nachdem ich gezeigt habe, wie man Erweiterungen (PlugIns) für die Delphi-IDE erstellen kann, möchte ich dieses Mal zeigen, wie man dieses Konzept in eigenen Anwendungen nutzen kann. Dazu werde ich das Tutorial in mehrere Abschnitte aufteilen.

Der erste Abschnitt zeigt die denkbar einfachste Form ein PlugIn zu erstellen. Diese Methode ist nicht unbedingt sehr flexibel, erlaubt es jedoch, schnell einfache Erweiterungen zu erstellen. Vorteil ist, daß das Thema auch für "Neulinge" auf diesem Bereich recht einfach betrachtet werden kann.

Um dieses zu erreichen, werde ich die erste Variante als "Delphi-Only-Lösung" vorstellen, daß heißt, daß auch die PlugIns mit Delphi erstellt werden müssen.

Code:
[color=#000080][i]HINWEIS:[/i]
Diese Variante benötigt die Unit ShareMem, welche wiederum voraussetzt, daß die Library [i]BORLNDMM.DLL[/i]
zusammen mit der Anwendung ausgeliefert wid. Diese DLL befindet sich im Delphi\Bin Verzeichnis und darf
zusammen mit der Anwendung weitergegeben werden. In älteren Delphi-Versionen (3...) ist es möglich, daß die
Borland DLL einen anderen Namen hat.

Die Unit ShareMem muß als erstes in der Uses-Klausel des Projektes und aller PlugIns stehen![/color]
PlugIns, wie kommen die eigentlich in die Anwendung

Es gibt verschiedene Möglichkeiten, woran eine Anwendung erkennt, das diese PlugIns zu laden hat. Alle Möglichkeiten setzen eines jedoch voraus: Die Anwendung muß so konzipiert sein, daß diese PlugIns überhaupt unterstützt.

In diesem Beispiel sucht die Anwendung nach der Datei PlugIns.ini, welche im gleichen Verzeichnis wie die Anwendung liegen muß. Die Ini-Datei sieht wie folgt aus.
Code:
[info]
info1=This file contains a list of all plugins.
info2=each plugin has its own section
info3=each plugin section has to contain a string "type=plugin"
info4=each plugin section has to contain a string "dllname" pointing to the plugin file

[sample01]
type=Plugin[color=#800000](off)[/color]
dllname=plugin01.dll

[sample02]
type=Plugin[color=#800000](off)[/color]
dllname=plugin02.dll
Die rot dargestellten Bereiche müssen gelöscht werden, damit die PlugIns geladen werden. In den ZIP-Files sind die Plug-Ins so eingestellt, daß diese (per Default) erst einmal nicht geladen werden, damit die Anwendung ohne Plug-Ins getestet werden kann. Wenn die Strings (off) gelöscht sind, werden die Plug-Ins beim nächsten Start automatisch geladen, dann kann das "neue" Verhalten der Anwendung getestet werden.

Andere Möglichkeiten nach Plug-Ins zu suchen

Oft werden zwei weitere Methoden genutzt, um Plug-Ins zu suchen.
  • Die Plug-Ins müssen in der Registry unter einem bestimmten Schlüssel eingetragen werden (z.B. Borland Delphi)
  • Die Plug-Ins müssen in einem bestimmten Verzeichnis liegen.
Letztere Methode ist nur bedingt empfehlenswert, da diese voraussetzt, das in dem Verzeichnis ausschließlich Plug-Ins liegen, andere Dateien können zu Problemen führen.

Plug-Ins zulassen

In diesem Beispiel werden wir ausschließlich Plug-Ins zulassen, welche als DLLs geladen werden können. Diese Plug-Ins müssen eine Funktion mit dem Namen LoadPlugIn exportieren, welche folgende Paramter hat:function LoadPlugin(Parent: THandle; var PlugIn: TPlugIn): Boolean; export; Der erste Parameter Parent erhält den Handle der Anwendung, welche das Plug-In lädt. Der zweite Paramter PlugIn kann vom Plug-In genutzt werden, um ein Object zurückzuliefern. Wird keines zurückgeliefert, so wird da Plug-In nicht im Menü angezeigt.

Die Applikation lädt die Plug-Ins mit Hilfe der Win-API Funtion LoadLibrary. LoadLibrary liefert einen Handle auf die geladene Library zurück. Wenn die Library erfolgreich geladen wurde, versucht Applikation die Methode LoadPlugIn mit Hilfe der Win-API Funtion GetProcAddress zu laden.
Code:
[color=#000080][i]HINWEIS:[/i]
Bei dem Export von Funktionen aus DLLs muß Groß- und Kleinschreibung beachtet werden (C++-Standard)!!![/color]
Nach erfolgreichem Ladevorgang der Prozedur wird diese aufgerufen und das Plug-In initialisiert.
Code:
[color=#000080][i]HINWEIS:[/i]
In diesem Beispiel muß sich das PlugIn um die Initialisierung des zurückgelieferten Objektes kümmern.
Die Applikation übernimmt die Zerstörung des Objektes, wenn dieses nicht mehr gebraucht wird.[/color]
Das exportierte Plug-In Objekt

Damit die Applikation nach Bedarf auf das Plug-In zurgreifen kann, muß dieses ein Objekt zurückliefern, welches durch die Applikation erkannt wird. Damit sowohl die Applikation, als auch jedes Plug-In vom gleichen Objekttyp "sprechen", wird dieser in einer gemeinsamen Unit definiert. Diese Unit ist dem Download beigefügt (\Shared Units\uPlugInDefinition.pas).
Delphi-Quellcode:
//Auszug aus der Unit
type
  TPlugIn = class
  public
    constructor Create(aParent: THandle);
    // information strings
    function GetName: string; virtual; stdcall; abstract;
    function GetAuthor: string; virtual; stdcall; abstract;
    function GetComment: string; virtual; stdcall; abstract;
    // menu data
    function GetMenuText: string; virtual; stdcall; abstract;
    function GetEnabled: Boolean; virtual; stdcall; abstract;
    // launch the Expert
    procedure Execute; virtual; stdcall; abstract;
    // event handler
    function EventHandler(EventNotification: TEventNotification): TEventAction;
        virtual; stdcall; abstract;
  end;

  TLoadPlugIn = function(Parent: THandle; var PlugIn: TPlugIn): Boolean;
Einerseits ist hier die abstrakte Definition, welche daß durch jedes Plug-In zu exportierende Objekt zeigt. Dieses Objekt liefert verschiedene Informationen zurück. Unter anderem wird gesteuert, wie sich das Plug-In im Menü darstellt und auf welche Ereigenisse reagiert wird. Desweiteren ist auch das Format der zu exportierenden Funktion TLoadPlugIn definiert.

Das Plug-In I

Jedes Plug-In, welches interaktiv angesteuert werden kann, muss ein Objekt vom Typ TPlugIn exportieren. Dieses Objekt muß alle abstrakten Methoden implementieren, welche durch die abstrakte Klasse TPlugIn definiert sind.

Im ersten Plug-In sieht die Klassendefinition wie folgt aus
Delphi-Quellcode:
type
  TPlugIn01 = class(TPlugIn)
  public
    // information strings
    function GetName: string; override; stdcall;
    function GetAuthor: string; override; stdcall;
    function GetComment: string; override; stdcall;
    // menu data
    function GetMenuText: string; override; stdcall;
    function GetEnabled: Boolean; override; stdcall;
    // launch the Expert
    procedure Execute; override; stdcall;
    // event handler
    function EventHandler(EventNotification: TEventNotification): TEventAction;
        override; stdcall;
  end;

{ TPlugIn01 }

function TPlugIn01.EventHandler(EventNotification: TEventNotification):
    TEventAction;
begin
  // nothing to do
  Result := evnContinue;
end;

...
Alle Methoden werden implementiert. Das erste Plug-In führt keine weiteren Aktionen aus. Wird sein Menüpunkt durch den Nutzer aktiviert, so wird lediglich eine Messagebox angezeigt.

Das Plug-In II

Das zweite Plug-In ist ein wenig komplexer. Es reagiert auf mehrere Ereignisse (File->New, File->Open, File->Save). Dazu wird in der Methode EventHandler auf entsprechende Ereignisse reagiert.
Delphi-Quellcode:
function TPlugIn02.EventHandler(
  EventNotification: TEventNotification): TEventAction;
begin
  case EventNotification of
    evnFileNew:
      if MessageBox(Parent, 'Änderungen verwerfen?', 'Öhm', MB_ICONWARNING or
          MB_YESNO) = IDYES then
        Result := evnContinue
      else
        Result := evnAbort;
    evnFileOpen:
      if MessageBox(Parent, 'Änderungen verwerfen?', 'Öhm', MB_ICONWARNING or
          MB_YESNO) = IDYES then
        Result := evnContinue
      else
        Result := evnAbort;
    evnFileSave:
    begin
      MessageBox(Parent, 'Bitte "Speichern als..." wählen', 'Öhm',
          MB_ICONINFORMATION or MB_OK);
      Result := evnAbort;
    end;
  else
    Result := evnContinue;
  end;
end;
Damit das Plug-In auf diese Ereignisse reagieren kann, muß die Applikation das Plug-In informieren, wenn solche Ereignisse auftreten. Dazu stelle ich Ihnen die Methode RunEvent aus der Applikation vor.
Delphi-Quellcode:
function TForm1.RunEvent(EventNotification: TEventNotification): Boolean;
var
  I: Integer;
begin
  for I := 0 to High(FPlugIns) do
    if FPlugIns[I].PlugIn <> nil then
    begin
      if FPlugIns[I].PlugIn.EventHandler(EventNotification) = evnAbort then
      begin
        Result := False;
        Exit;
      end;
    end;
    Result := True;
end;
Diese Methode sendet ein Ereignis an alle Plug-Ins. Wenn alle Plug-Ins den Status evnContinue zurückliefern, dann liefert die Methode True zurück, ansonsten False. Diese Methode wird zum Beispiel aufgerufen, wenn der User im Menü File auf New klickt.
Delphi-Quellcode:
procedure TForm1.New1Click(Sender: TObject);
begin
  if RunEvent(evnFileNew) then
  begin
    mmoFileContent.Clear;
    FFileName := '';
  end;
end;
Wenn kein Plug-In geladen ist, wird der aktuelle Inhalt des Memos einfach gelöscht. Wenn das zweite Plug-In geladen ist, fragt dieses den User, ob er die Inhalte des Memos wirklich verwerfen will. Antwortet der mit "nein", liefert das Plug-In II evnAbort zurück und das Memo wird nicht gelöscht.

Der komplette Code

Der komplette Code für dieses einfache Beispiel kann von Mitgliedern der Delphi-PRAXiS frei runtergeladen werden. Wenn Fragen bestehen, einfach ins Forum posten. Mal schauen...

Der nächste Schritt

Im nächsten Schritt werde ich ein etwas komplexeres Beispiel zeigen. Voraussetzung dafür wird ein Verständnis von Delphi-Interfaces sein. Wann es kommt, steht noch nicht fest

......
Angehängte Dateien
Dateityp: zip extandable_application__i___incl._bins_.zip (313,3 KB, 638x aufgerufen)
Dateityp: zip extandable_application__i___excl._bins_.zip (15,5 KB, 282x aufgerufen)
Ich bin nicht zurück, ich tue nur so
 
Benutzerbild von Die Muhkuh
Die Muhkuh

 
Delphi 2009 Professional
 
#31
  Alt 6. Sep 2007, 17:17
Ich würde sagen, dass einfach das IF weggehört. Vielleicht ein Tippfehler?
Manuel
  Mit Zitat antworten Zitat
Benutzerbild von Luckie
Luckie

 
Delphi 2006 Professional
 
#32
  Alt 6. Sep 2007, 22:20
Das habe ich mir auch so edacht. Aber ih dachte, dass sakura das zu mindest testweise noch mal kompiliert hätte.
Michael
  Mit Zitat antworten Zitat
viakt133

 
Lazarus
 
#33
  Alt 26. Feb 2010, 22:14
Hallo,

ich beschäftige mich grad mit Modularisierung per Interface und da hab ich diesen Thread hier gefunden, der das was ich mit interfaces erreichen will, mit Plugins macht.

Habe die Quelltexte auf meinen Rechner geladen. Aber irgendwas mach ich noch falsch. Die Plugins der Beispielprogramme werden nicht geladen.

Ich habe folgendes probiert:

im Ordner ../ExtendibleApplication (I)/Bins/plugins.ini

[sample01]
;type=Plugin(off) auskommentiert
dllname=plugin01.dll

[sample01]
type=Plugin(off) ganz gelöscht
dllname=plugin01.dll

und

[sample01]
type=Plugin() nur das Wort "off" entfernt
dllname=plugin01.dll

[sample01]
type=Plugin(on) das Wort "off" entfernt und durch "on" ersetzt.
dllname=plugin01.dll


Trotzdem wird kein Plugin geladen.

Ich erhalte bei Anklicken des Menüs Plug-ins->Show Plug-in Information die Meldung

"NO OF PLUG-INS LOADED: 0"

Was muss ich ändern. Eventuell muss ja der Quellcode korrigiert werden.
Bisher habe ich nur die .exe getestet.

Wo muss ich evtl. im Ouelltext nachsehen?

Wo gibt es weitere Dokus zum Thema?
  Mit Zitat antworten Zitat
viakt133

 
Lazarus
 
#34
  Alt 26. Feb 2010, 22:36
Zitat von sakura:
Genau habe ich es jetzt nicht im Kopf, aber sofern ich mich erinnere, müssen die DLLs in der Registry angegeben werden - genaueres steht auf jeden Fall im obigen Text.

......
Up's, das hab ich vorhin leider überlesen: Sorry! Wie war gleich das Kommando, um ne Dll in der Registry anzumelden?
  Mit Zitat antworten Zitat
Benutzerbild von RWarnecke
RWarnecke

 
Delphi XE8 Enterprise
 
#35
  Alt 26. Feb 2010, 23:01
Hallo,

Du brauchst die DLL's nicht in der Registry anmelden um Sie als Plugin nutzen zu können. Das geht aus so.

Aber den Befehl den Du wahrscheinlich suchst heißt regsvr32.exe
Rolf Warnecke
  Mit Zitat antworten Zitat
Benutzerbild von Luckie
Luckie

 
Delphi 2006 Professional
 
#36
  Alt 26. Feb 2010, 23:05
COM DLLs muss man im System registrieren, aber keine DLL Plugins für Anwendungen.
Michael
  Mit Zitat antworten Zitat
viakt133

 
Lazarus
 
#37
  Alt 26. Feb 2010, 23:12
Zitat von RWarnecke:
Hallo,

Du brauchst die DLL's nicht in der Registry anmelden um Sie als Plugin nutzen zu können. Das geht aus so.

Aber den Befehl den Du wahrscheinlich suchst heißt regsvr32.exe
Danke, wie verrückt. Das war der Befehl, den ich gesucht habe.

Jetzt hab ich auch rausgekriegt wie die entscheidende Zeile in der Ini Datei heißen muss:

[sample0X]
type=plugin
dllname=<Name der zu ladenden DLL>

Ich hatte ja die Zeile mit der Plugin Angabe ganz gelöscht oder plugin(on) geschrieben. Damit klappte es nicht. Nur so, wie hier mit Sample0X angegeben funktioniert es.


.
  Mit Zitat antworten Zitat
Themen-Optionen Tutorial durchsuchen
Tutorial durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 11:28 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz