Dynamisches Menü erstellt/gesteuert von DLL's

[Cyberaxx]

Hallo,

ursprünglich galt das als PM an Sakura aufgrund seines Tutorials "Plugins in eigenen Anwendungen"
Danke für das Tutorial, war eine gute Grundlage.

Meine Anwendung möchte ich gerne komplett variable erstellen.
Beim starten des Programmes werden alle Plugins geladen. Ich möchte aber gerne in den Plugins die Menüpunkte selber verwalten.

Am Anfang soll das MainMenu keinen Inhalt besitzen.

Nehmen wir mal ein Beispiel.

Plugin 1 soll als Hauptmenüpunkt "Lager" haben und als eigentliches Menüpunkt "Verladeplanung"
Plugin 2 soll ebenfalls unter "Lager" stehen und seinen eigenen Menüpunkt haben.

Wie wäre es möglich so etwas zu realisieren?

Es kann sein das der Menüpunkt "lager" bereits existiert oder aber auch nicht.
Damit das ganze aber richtig perfekt wird, dazu sollen noch weitere Untermenüs.
Nur die DLL gibt vor wo sie sitzt.

Ich hab es mal versucht, das MainMenu zu übergeben an die DLL und dann da zu suchen ob die betreffenden menüpunkte
bereits existieren und dann anzufügen, aber da hagelte es nur zugriffsverletzungen und ich konnte von da auch das
OnClick nicht nicht zuweisen.

Wenn das Hauptformular das Menü erstellen muss, müsste ich ja alle Punkte übergeben, da weiß ich nicht wie ich das machen,
Hauptmenü und Menüeintrag wären ja kein Problem.

Vllt. hat hier ja jemand eine Ahnung, wie man sowas steuern kann.

[DGL-luke]

Hallo, warum nicht so:

Delphi-Quellcode:

function NumOptions: Integer;
function GetOption(NOption: Integer; out OnClickEvent: TNotifyEvent): PChar;

function NumSubOptions(NOption: Integer): Integer; 
function GetSubOption(NOption, NSubOption: Integer; out OnClickEvent: TNotifyEvent): PChar;

Die relativ triviale Implementierung verschweige ich da jetzt mal. wie du das ganze in deine hauptanwendung dann importierst, sollte klar sein.

[Cyberaxx]

Also da stehe ich doch gerade auf dem Schlauch...

NumOptions sollte mit in dem Fall die Anzahl der Hauptmenüpunkte?
GetOption(den nten menüpunkt): Name des Punktes?

NumSubOptions Anzahl der Untermenüs?
GetSubOption(nter Hautpmenüpunkt, nter Submenüpunkt): Name?

Das mit dem OnClick ist mir auch noch nicht so wirklich klar , sry.

[DGL-luke]

hallo,

wenn du auf einen menüpunkt klickst, soll ja was passieren, oder? und was genau (den event, der ausgelöst werden soll), das gibts du im OnClick an.

btw:

Delphi-Quellcode:

procedure BuildMenu(menu: HMENU);
var
  mmen: TMainMenu;
begin
  mmen := TMainMenu.Create;
  mmen.hmenu := menu;

  //und jetzt befehle in mmen einfügen
end;

So in der art könnts auch funktionieren... schau dir mal TMainMenu / Main menu in der OH bzw. im PSDK an.

[Cyberaxx]

Das heißt der Obere Teil kommt hin bzw. habe ich richtig interpretiert?

Wie ich das Menü baue selbst ist soweit klar aber nicht

Delphi-Quellcode:

out OnClickEvent: TNotifyEvent

[DGL-luke]

Hallo,

alle Events in Delphi sind von der form "TSomeEvent = procedure(param: TXYZ) of object;".
TNotifyEvent ist das, womit alle OnClick-Ereignisse verarbeitet werden. der ist als "procedure(sender: TObject) of object;" definiert.

Indem du nun den out-Parameter (out heißt, er wird vom Callee zugewiesen) "OnCLickEvent" zuweist, gibst du dem caller diese referenz, die er dann aufrufen kann. z.B. so:

Delphi-Quellcode:

//implementation der funktion in der dll
function GetOption(NOption: Integer; out OnClickEvent: TNotifyEvent): PChar; 
begin
  Result := PChar(TEventDispatcherSingleton.GetInstance.MenuCaptions[NOption]);
  OnClickEvent := TEventDispatcherSingleton.GetInstance.MenuEvents[NOption]);
end;

//aufruf
with TMenuItem.Create(Mainmenu1) do
begin
  Parent := TopItem;
  Caption := GetOption(5, OnClickEvent);  //onclickevent muss als variable deklariert worden sein
  OnClick := OnClickEvent;
end;

Wie ich mit meinem "TEventDispatcherSingleton" oben schon angedeutet habe, müssen diese Events dann auch auf einen richtigen Event , also die Implementation des Events als Klassenmethode, zugewiesen werden. (Man kann das auch auf freie prozeduren zuweisen, aber das wird dann tricky)

Das TEventDispatcherSingleton sieht dann vielleicht so aus:

Delphi-Quellcode:

type
  TEventDispatcherSingleton = class
  private
    Instance: TEventDispatcherSingleton;
    constructor Create;
  public
    MenuCaptions: array of string;
    MenuEvents: array of TNotifyEvent;

    procedure OnMenuItemXClick(Sender: TObject); //das muss man dann implementieren

    class function GetInstance: TEventDispatcherSingleton; // dort wird geschaut, ob instance belegt ist, wenn ja zurückgegeben, wenn nicht zuerst erzeugt

[fLaSh11]

Korrigiere doch bitte den Schreibfehler in der Überschrift, sonst kann man den Thread mit der Suchfunktion evtl. nicht finden :thumb:

[Cyberaxx]

Hallo,

ich muss zugeben(auch wenn man mich für dumm hällt) ich steige da nicht durch, vllt. bin ich auch noch nicht so weit in dem eingestiegen, sowas hab ich bisher auch noch nie gemacht.

Es ging mir hauptsächlich nur um das anlegen des Menüs, die Zuweisungen hätte ich in etwa so geregelt wie in Sakuras Tutorial.

Solange ich das hier nicht verstehe, tendiere ich natürlich auch zur einfacheren Lösung.
Ich würde das aber gerne verstehen.

[Apollonius]

Wenn du einen Menüpunkt ermitteln willst, dann möchtest du vielleicht außer dem Namen auch das onClick-Ereignis wissen. Eine Funktion kann aber nunmal nur ein "direktes" Ergebnis haben, deshalb der ou-Parameter. In der Variablen (!), die du hier angibst, wird das onClick gespeichert. Schau doch mal in der Hilfe unter Parameterübergabe!
Hoffe geholfen zu haben
Apollonius

[Cyberaxx]

das mit der Variable ist klar. es geht eher um das von DGL-Luke.

Ich komme mit seinem Beispiel nicht klar.

[DGL-luke]

na womit denn nicht? Das Singleton-Pattern musst du natürlich nicht umsetzen. Wäre aber am sinnvollsten hier denke ich.

[Cyberaxx]

Der erste Teil klappt ja schon. also das erstellen des Menüs, dazu erstmal danke und im nachhinein hätte ich auf so eine Funktion selber kommen müssen.

Dann hatte ich anfangs versucht, wie bei meinen sonstigen Anwendungen einfach in der Deklaration

Delphi-Quellcode:

procedure ClickEvent(Sender: TObject);

und dann beim inizialisieren der DLL einfach

Delphi-Quellcode:

function InitPlugin(var PluginData: TPluginData): Boolean;
  var
    Item: TMenuItem;
begin
  [...]
  Item.Caption := 'test';
  Item.OnClick := ClickEvent;
  [...]
end;

Wenn ich das in normalen Anwedungen mache klappt das auch immer nur bei der DLL nicht.

Bin dann auf Sakuras Tutorial gestossen und dort macht er es einfach über eine Liste in der er die Plugins setzt und im Menuitem den Tag benutz. Beim drücken eines Items wird der Tag abgefragt und einfach die DLL aufgerufen.

Da war mir das aber noch nicht klar wie ich eben das Menü so hinbekomme wie ich es haben wollte und oben beschrieben.

Ich programmiere zwar nicht seit gestern und hab meiner Meinung nach auch schon einges gemacht aber mit deinem Post(#6) komme ich einfach nicht klar. Ich bin bei sowas auch hartnäckig und möchte auch wenn ich nachher dumm da steh das gerne komplett erklährt haben :)
Aus einfacheit halber hätte ich anfangs eben Sakuras Methode genutzt und eben zum MenuItem Item noch eine Property hinzugefügt um den Tag nicht nutzen zu müssen.
Da es aber hier noch einen anderen Lösungsvorschlag gab würde ich ihn eben gerne verstehen.

Ich glaub ich hab mich zu oft wiederholt, ich setz das erstmal ab. ;)

[Cyberaxx]

Auch wenn es schon was her ist...

Hab es nun etwas anders gelöst, naja zumindest teilweise.

Zitat:

Zitat von DGL-luke

Hallo, warum nicht so:

Delphi-Quellcode:

function NumOptions: Integer;
function GetOption(NOption: Integer; out OnClickEvent: TNotifyEvent): PChar;

function NumSubOptions(NOption: Integer): Integer; 
function GetSubOption(NOption, NSubOption: Integer; out OnClickEvent: TNotifyEvent): PChar;

Die relativ triviale Implementierung verschweige ich da jetzt mal. wie du das ganze in deine hauptanwendung dann importierst, sollte klar sein.

Jede DLL soll genau nur einen wirklichen Menüeintrag haben. Also auch nur einen Menüclick.
Ist hier noch nicht in einer DLL, ist ja nur zum test.

Delphi-Quellcode:

type
  TPlugin = class(TObject)
  private
    procedure Click(Sender: TObject);
  public
    function NumOptions: Integer;
    function NumSubMainOptions: Integer;
    function GetOption(out OnClickEvent: TNotifyEvent): PChar;
  end;

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
  var
    OnClickEvent: TNotifyEvent;
    MainItems: Integer;
    MainSubItems: Integer;
    MainItemCount: Integer;
    I: Integer;
    TmpItem: TMenuItem;
    TmpSubItem: TMenuItem;
    MenuItem: TMenuItem;
begin
  Plugin := TPlugin.Create; // Plugin Erstellen

  MainItems := Plugin.NumOptions; // Anzahl der Hauptelemente holen
  MainSubItems := Plugin.NumSubMainOptions; // Anzahl der Elemente unter dem Hauptelement

  while JvMainMenu1.Items.Count <= MainItems do // Weniger Hauptelemente vorhanden, Elemente hinzufüge
    begin
    TmpItem := TMenuItem.Create(JvMainMenu1);
    TmpItem.Caption := 'Main';
    Tmpitem.Enabled := False;

    JvMainMenu1.Items.Insert(JvMainMenu1.Items.Count, TmpItem);
    end;

  TmpItem := JvMainMenu1.Items[MainItems];
  TmpItem.Enabled := True;

  while TmpItem.Count <= MainSubItems do
    begin
    TmpSubItem := TMenuItem.Create(Self);
    TmpSubitem.Caption := 'MainSub';
    TmpSubItem.Enabled := False;

    Tmpitem.Insert(TmpItem.Count, TmpSubItem);
    end;

  TmpSubItem := TmpItem.Items[MainSubItems];
  TmpSubItem.Enabled := True;

  MenuItem := TMenuitem.Create(Self);
  MenuItem.Caption := Plugin.GetOption(OnClickEvent);
  MenuItem.OnClick := OnClickEvent;

  TmpSubItem.Insert(TmpSubitem.Count, MenuItem);
end;

Damit bekomme ich die Anzahl der Menüeinträge und das dazugehörige Untermenü aber wie könnte man das ganze denn noch variabler gestallten, wenn ich dazu noch ein Untermenü habe oder gar noch einge Untermenüs. Sprich ich kenne die Anzahl der Untermenüs und deren Untermenüs nicht.

Delphi-Quellcode:

Frachtenverwaltung
 - Lager
   - Planung
     - Listen
       - Beladelist

[Cyberaxx]

Ein menüitem zu übergeben, das im Plugin erstellt worden ist, ist nicht sehr sinnig oder?

[DGL-luke]

Hm. Ich hatte bereits HMENU erwähnt. Du solltest auf jeden Fall nicht VCL-Klassen zwischen den Modulen hin und her reichen.

Aber du kannst - vielleicht, ich hab mich damit noch nicht beschäftigt - in der DLL dein eigenes TMainMenu instanziieren und darauf das HMENU deines TMainMenu zuweisen. Siehe auch ein Post weiter oben von mir.

[Cyberaxx]

Ich habe es gerade testweise mit TMainMenu versucht aber dann müsste ich im Hauptprogramm das Menü auseinander nehmen, das nicht Einträge doppelt sind oder vllt dann eben nicht mehr da sind.

Irgendwie kompliziert. Will ja auch nicht xmal ne Funktion schreiben um diverse Untermenüs zu erstellen und prüfen.