Interfaces in C++

[mirage228]

Hallo,

ich habe vor die Deklaration meines Interfaces für eine Pluginschnitstelle nach C++ zu portieren, damit man damit auch Plugins schreiben kann.

Nun habe ich vom Delphi Compiler eine Header Datei für C++ generieren lassen. (siehe Anhang)

Ich weiss jetzt aber nicht, in wie fern diese Header-Datei sich unter Visual C++ oder Ähnlichem kompilieren lässt, da es ja eine Borland C++ Builder Header Datei ist und diese eventuell bestimmte, in anderen Sprachen nicht verfügbare Typen etc. benutzt.. Kennt sich da jemand aus und kann mir sagen, in wie weit sich die angehängte Unit in anderen C++'s kompilieren lässt?
Wieviel muss modifiziert werden?

Danke schonma im Vorraus

mfG
mirage228

[Stevie]

Wenn du mir mal die uEventTypes.hpp gibst, dann kompilier ich's mal mit C++Builder durch.

Visual C++ kannst du erstmal ohne erheblichen Aufwand vergessen, meinst du, der kennst Borland-Klamotten?

P.S.: Ich hab sie einfach mal auskommentiert und die Zeile 249 auch, klappt wunderbar!
P.P.S.: Vergiss es, ich hab nicht richtig gelesen!

[mirage228]

Hi,

Ich habe eigentlich darauf geachtet, dass ich keine Delphi spezifischen Sachen verwende. Also die meisten Sachen sollte es unter C++ geben (WideString gehört auch dazu, soweit ich weiss).

Aber wenns unter dem C++ Builder funktionieren würde, dann wäre das schonmal super.

Also im Anhang ist die uEventTypes.hpp. Wäre nett, wenn du es mal probieren würdest.

mfG
mirage228

[Stevie]

Zitat von mirage228:

Ich habe eigentlich darauf geachtet, dass ich keine Delphi spezifischen Sachen verwende.

Von Delphi-spezifisch hab ich auch nix gesagt, sondern Borland-spezifisch.
Die Header gibts bei Visual C++ nicht, wenn du sie trotzdem benutzt hagelts Fehler, weil da so Klamotten wie

Code:

#if __BORLANDC__ < 0x500
#error BCW 5.0 or greater required
#endif

drinstehen.
Ok, das geht bestimmt irgendwie, aber da müsste man alles umschreiben usw.

Mit dem C++Builder geht's übrigens...

[shmia]

Ich würde dir eine andere Vorgehensweise raten.
Du erzeugst mit dem TLB-Editor von Delphi eine eigene TLB-Datei und erzeugst darin dein Interface. Aber es werden keine CoClasses deklariert. Wichtig ist, dass das Flag OLE-Automation gesetzt ist.
Die TLB-Datei wird mit dem Borland Tool TRegSrv.exe registriert.

In deiner eigenen Anwendung gibt es ebenfalls eine TLB. Auf der Seite Verwendet wird obige TLB "includiert".
Und schon kannst du das Interface benutzen.

Jeder, der ein Plugin für deine Anwendung schreiben möchte geht den gleichen Weg und includiert
deine TLB. Danach kann er eine CoClass erstellen, die dein Interface inmplementiert.
Es spielt dann keine Rolle, ob das Plugin mit Delphi, C++-Builder, MS VC++ oder einer
sonstigen Programmiersprache erzeugt wird.

Möglicherweise kannst du die TLB-Datei zusätzlich als Resource in deine Anwendung aufnehmen
und beim Starten mit dem Parameter /REGSERVER gleich mit registieren. (Aber so etwas habe ich auch noch nie probiert )

[mirage228]

Zitat von Stevie:

Mit dem C++Builder geht's übrigens...

Das ist doch schonmal was ^^ - Danke fürs Testen

Zitat von shmia:

Ich würde dir eine andere Vorgehensweise raten.
Du erzeugst mit dem TLB-Editor von Delphi eine eigene TLB-Datei und erzeugst darin dein Interface. Aber es werden keine CoClasses deklariert. Wichtig ist, dass das Flag OLE-Automation gesetzt ist.
Die TLB-Datei wird mit dem Borland Tool TRegSrv.exe registriert.

In deiner eigenen Anwendung gibt es ebenfalls eine TLB. Auf der Seite Verwendet wird obige TLB "includiert".
Und schon kannst du das Interface benutzen.

Jeder, der ein Plugin für deine Anwendung schreiben möchte geht den gleichen Weg und includiert
deine TLB. Danach kann er eine CoClass erstellen, die dein Interface inmplementiert.
Es spielt dann keine Rolle, ob das Plugin mit Delphi, C++-Builder, MS VC++ oder einer
sonstigen Programmiersprache erzeugt wird.

Möglicherweise kannst du die TLB-Datei zusätzlich als Resource in deine Anwendung aufnehmen
und beim Starten mit dem Parameter /REGSERVER gleich mit registieren. (Aber so etwas habe ich auch noch nie probiert )

Hi,

also ich habe nun eine TLB, in der die Interfaces definiert sind.

So nun habe ich eine TLB für mein Projekt, die die obige TLB verwendet.

Nun habe ich ja eine Implementierung der Interfaces bereits geschrieben, die ich dem Plugin durch das Interface übergebe.

Wie kann ich auf diesem Weg meine Implementierung anderen zugänglich machen? Ich muss die Interfaces ja irgendwie mit meiner Implementierung verbinden...

mfG
mirage228

[mirage228]

[push]

Hi,

ich bins nochmal. Ich wollte den Beitrag mal pushen, da mich eine Lösung schon interessieren würde...

Vielleicht weiss ja jemand (shmia? ) was ^^

mfG
mirage228

[shmia]

Also gut......
Du hast 2 Interfaces: IPlugIn und IPlugManager.
IPlugin muss von einer Active-X Bibliothek implementiert werden.
IPlugManager wird von deiner Hauptanwendung implementiert.
Die PlugIn-Schnittstelle könne so aussehen:

Delphi-Quellcode:

IPlugIn = interface
  procedure SetExplorer(v:IPlugManager);  // damit bekommt dein PlugIn ein Interfacezeiger
                                          // auf die Hauptanwendung mit.
  function GetDescription : Widestring; 
  function GetFeatureFlags: Integer;
  ....
end;

Beide Interfaces (IPlugIn und IPlugManager) werden nun in einer TLB abgelegt.
Diese TLB nenne ich hier mal Charlie.
Das Interface IPlugManager gibt es (unter einem anderen Namen) ja schon in deiner Hauptanwendung. Du musst das Interface aus der TLB der Hauptanwendung rausschneiden und in Charlie einfügen.
Sowohl deine Hauptanwendung, als auch jede PlugIn-DLL müssen Charlie einbinden.
Die TLB Charlie übernimmt sozusagen die Aufgabe eines universellen Includefiles, dass von vielen Programmiersprachen (Delphi, C++-Builder, Visual C++, ...) verstanden wird.

[mirage228]

Zitat von shmia:

Also gut......
Du hast 2 Interfaces: IPlugIn und IPlugManager.
IPlugin muss von einer Active-X Bibliothek implementiert werden.
IPlugManager wird von deiner Hauptanwendung implementiert.
Die PlugIn-Schnittstelle könne so aussehen:

Delphi-Quellcode:

IPlugIn = interface
  procedure SetExplorer(v:IPlugManager);  // damit bekommt dein PlugIn ein Interfacezeiger
                                          // auf die Hauptanwendung mit.
  function GetDescription : Widestring; 
  function GetFeatureFlags: Integer;
  ....
end;

Beide Interfaces (IPlugIn und IPlugManager) werden nun in einer TLB abgelegt.
Diese TLB nenne ich hier mal Charlie.
Das Interface IPlugManager gibt es (unter einem anderen Namen) ja schon in deiner Hauptanwendung. Du musst das Interface aus der TLB der Hauptanwendung rausschneiden und in Charlie einfügen.
Sowohl deine Hauptanwendung, als auch jede PlugIn-DLL müssen Charlie einbinden.
Die TLB Charlie übernimmt sozusagen die Aufgabe eines universellen Includefiles, dass von vielen Programmiersprachen (Delphi, C++-Builder, Visual C++, ...) verstanden wird.

Hi shmia,

Danke für deine Antwort.

Ich habe jedoch nicht ganz verstanden, wie das ganze System abläuft.

Nun, in der ActiveX Bibliothek (also in dessen TLB "Charlie") liegt das Interface IPlugin, sowie die Interfaces meiner Anwendung (In deinem Beispiel auch noch der IPlugManager). In meiner Anwendung befindet sich die Implementierung der Interfaces meiner Anwendung.
Die von IPlugin, wie von dir gesagt, in der ActiveX Bibliothek.

Jetzt verstehe ich aber die Aufgaben von IPlugin und IPlugManager nicht ganz, bzw. ich verstehe nicht, wie die Plugin DLL an die Implementierung aus meiner EXE-Datei kommt (bzw. an das korrekte Interface der Implementierung).

Du hast in IPlugin die Möglichkeit das Interface IPlugManager (das, soweit ich verstanden habe, in der Anwendung implementiert wird) zu übergeben. Aber welchen Sinn hat das? Wenn ich in meiner Anwendung dort dem Interface IPlugin (, das ich mit der CoClass aus der ActiveX Bibl. erstellt habe) den Zeiger (hier IPlugManager via SetExplorer) übergebe, ist es doch für die Plugin-DLLs (etc.) nicht verfügbar?!

Ich blicke in dem System noch (leider) nicht ganz durch.

Kannst du mir vielleicht ein weiteres mal helfen?

mfG
mirage228