Onclick und rechte Maustaste!

[TriphunEM]

Hallo,

wie kann ich bei einem OnClick-Event prüfen ob die rechte oder linke maustaste geklickt wurde.
denn ein onmousedown oder so steht mir bei der komponente nicht zur verfügung!

Es geht darum, ich will einem MainMenu-Eintrag der zur Laufzeit erstellt wurde ein bestimmtes Popup hinzufügen!
Wenn jemand eine andere Lösung kennt, wäre ich auch zu frieden!!!

????



Danke

[Der_Unwissende]

Hi,
mir würde jetzt am ehesten einfallen, dass du einfach die Komponente ableitest. In der abgeleiteten Komponente erstellst du dann eine Methode, die auf Windows-Botschaften reagiert. Hier kannst du dann einfach auf das klicken der Linken oder Rechten Maustaste reagieren.

Delphi-Quellcode:

type
  TExtendedMainMenue = class(TMainMenue)
    private
      procedure LeftMouseButtonDown(var Msg : TMouseInput); message WM_LBUTTONDOWN;
      procedure RightMouseButtonDown(var Msg : TMouseInput); message WM_RBUTTONDOWN;
  end;

Gut, was soll ich da noch erklären? Sollte funktionieren, bin mir aber bei Typ der auftretenden Nachricht nicht sicher, müsstest du mal gucken ob die funktioniert.

Gruß Der Unwissende

[TriphunEM]

danke, aber da ich mit komponenten-programmierung net so gut auskenne bin ihc nur soweit gekommen

Delphi-Quellcode:

unit AdvMainMenu;

interface

uses
  Windows, Menus, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TAdvMainMenu = class(TMainMenu)
  private
    { Private-Deklarationen }
    procedure LeftMouseButtonDown(var Msg : TMouseInput); message WM_LBUTTONDOWN;
    procedure RightMouseButtonDown(var Msg : TMouseInput); message WM_RBUTTONDOWN;
  protected
    { Protected-Deklarationen }
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
   published
    { Published-Deklarationen }
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Standard', [TAdvMainMenu]);
end;

constructor TAdvMainMenu.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
end;

destructor TAdvMainMenu.Destroy;
begin
  inherited Destroy;
end;

Wie muss denn der Code für die Prozeduren aussehen! Wichtig ist auch das ein Sender vorhanden ist, damit ich auch weiß auf welchen item geklickt wurde!
kannst mir da noch weiter helfen???

[faux]

Hallo!

Also ich bin mir nicht sicher, aber gehören die zwei Prozeduren LeftMouseButtonDown und RightMouseButtonDown nicht nach published?

Grüße
Faux

[xaromz]

Hallo,

Zitat:

Zitat von faux

Also ich bin mir nicht sicher, aber gehören die zwei Prozeduren LeftMouseButtonDown und RightMouseButtonDown nicht nach published?

Nein, die fangen ja nur Windows-Botschaften ab und sind keine Ereignisse. In diesen Prozeduren sollten aber dann Ereignisprozeduren aufgerufen werden.

Gruß
xaromz

[faux]

Zitat:

Zitat von xaromz

Nein, die fangen ja nur Windows-Botschaften ab und sind keine Ereignisse. In diesen Prozeduren sollten aber dann Ereignisprozeduren aufgerufen werden.

Ah! Gut zu wissen. ;)

Wie würde dann diese Prozedur aussehen?

[Die Muhkuh]

Delphi-Quellcode:

published
  property OnLeftMouseButtonClicked: TNotifyEvent read FOnLeftMouseButtonClicked write FOnLeftMouseButtonClicked; 
 // Kann auch was anderes als TNotifyEvent sein ;)
end;

[...]

procedure LeftMouseButtonDown(var Msg : TMouseInput);
begin
  if Assigned(FOnLeftMouseButtonClicked) then
    FOnLeftMouseButtonClicked(Self);
end;

[Jens Schumann]

Hallo,
ich würde im protected Abschnitt die Methoden DoLeftMouseButtonDown und DoRightMouseButtonDown einführen. Das vereinfacht das Überschreiben der Events in Nachfahren erheblich.

Delphi-Quellcode:

unit AdvMainMenu; 

interface 

uses 
  Windows, Menus, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, 
  Dialogs, StdCtrls; 

type 
  TAdvMainMenu = class(TMainMenu) 
  private
    { Private-Deklarationen }
    FOnLMBClicked: TNotifyEvent;
    FOnRMBClicked: TNotifyEvent;
    procedure LeftMouseButtonDown(var Msg : TMouseInput); message WM_LBUTTONDOWN;
    procedure RightMouseButtonDown(var Msg : TMouseInput); message WM_RBUTTONDOWN;
  protected 
    { Protected-Deklarationen }
    procedure DoLeftMouseButtonDown(var Msg : TMouseInput); dynamic;
    procedure DoRightMouseButtonDown(var Msg : TMouseInput); dynamic;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override; 
    destructor Destroy; override; 
   published 
    { Published-Deklarationen }
     property OnLMBClick: TNotifyEvent read FOnLMBClicked write FOnLMBClick;
     property OnRMBClick: TNotifyEvent read FOnRMBClicked write FOnRMBClick;
  end;

procedure Register;

implementation

procedure Register;
begin 
  RegisterComponents('Standard', [TAdvMainMenu]);
end;

constructor TAdvMainMenu.Create(AOwner: TComponent);
begin 
  inherited Create(AOwner); 
end;

destructor TAdvMainMenu.Destroy;
begin 
  inherited Destroy;
end;

procedure TAdvMainMenu.DoLeftMouseButtonDown(var Msg: TMouseInput);
begin
  If Assigned(FOnLMBClicked) then
    FOnLMBClicked(Self);
end;

procedure TAdvMainMenu.DoRightMouseButtonDown(var Msg: TMouseInput);
begin
  If Assigned(FOnRMBClicked) then
    FOnRMBClicked(Self);
end;

procedure TAdvMainMenu.LeftMouseButtonDown(var Msg: TMouseInput);
begin
  DoLeftMouseButtonDown(Msg);
end;

procedure TAdvMainMenu.RightMouseButtonDown(var Msg: TMouseInput);
begin
  DoRightMouseButtonDown(Msg);
end;

end.

[marabu]

Hallo, nochmal zurück zum eigentlichen Problem.

Zitat:

Zitat von TriphunEM

ich will einem MainMenu-Eintrag der zur Laufzeit erstellt wurde ein bestimmtes Popup hinzufügen!

Du möchtest die Items aus einem PopupMenu als dynamisches DropDown-Menü im MainMenu wiederverwenden? Das ist selten sinnvoll, weil das PopupMenu ein Kontextmenü ist und seine Aktionen nicht über das Hauptmenü ausgeführt werden sollen. Es ist ein Verstoß gegen die guten Sitten, aber technisch sehr einfach zu realisieren, wenn du deinen Aktionscode in einer ActionList verwaltest und den Items in deinem PopupMenu zugewiesen hast:

Delphi-Quellcode:

procedure AddMenuItems(miTake, miGive: TMenuItem);
var
  i: integer;
  mi: TMenuItem;
begin
  // get rid of existing items
  miTake.Clear;
  for i := 0 to Pred(miGive.Count) do
  begin
    // create new menuItem
    mi := TMenuItem.Create(miTake);
    // share action with popup menuItem
    mi.Action := miGive[i].Action;
    // associate new item with menu
    miTake.Add(mi);
  end;
end;

procedure TDemoForm.FormCreate(Sender: TObject);
var
  mi: TMenuItem;
begin
  // dynamic creation of menuItem
  mi := NewItem('&Test', TextToShortCut(''), false, true, nil, 0, '');
  // make right most dropdownMenu
  MainMenu.Items.Add(mi);
  // populate dropdownMenu from popupMenu
  AddMenuItems(mi, PopupMenu.Items);
end;

Silvestergrüße vom marabu

[TriphunEM]

@ Jens Schumann

Danke, das funzt soweit, allerdings habe ich die OnLMBClick und OnRMBClick nur auf dem Mainmenü und nicht auf den Items!
Ich brauch das auch auf den Items??? Kannst mir da helfen!

Achja, die Komponente funzt zwar jetzt, aber wenn ich die einträge dynamisch erstellen, bleibt das mainmenü leer!
fehlt da vielleicht was bei
constructor Create(AOwner: TComponent); override;

@ marabu

Sinnvoll ist das schon. Nehmen wir mal den Favoritenliste im Firefox oder IE, dort bekommt auf einem Order ein anderes popup als wie auf einem link. ist zwar sowas wie ne toolbar, aber will das für ein Mainmenü!

[TriphunEM]

also wenn ich das auf ein item legen will, muss ich doch dann noch extra ne klasse ableiten.
aber von welcher, den TMenuItem gibts ja nicht zum ableiten????

[Der_Unwissende]

Zitat:

Zitat von TriphunEM

also wenn ich das auf ein item legen will, muss ich doch dann noch extra ne klasse ableiten.
aber von welcher, den TMenuItem gibts ja nicht zum ableiten????

Lustige Idee, warum genau sollte es denn die Klasse nicht zum Ableiten geben? Konnte man in Delphi überhaupt eine Klasse als nicht weiter ableitbar deklarieren? Dachte hier ging das nur mit den Methoden, bin mir aber gerade nicht sicher (hab ich hier nie gebraucht).

Jedenfalls solltest du kein Problem damit haben TMenuItem abzuleiten.

Gruß Der Unwissende

[TriphunEM]

mmhh und wie dann, so lässt es sich zwar kompilieren, aber die eregnisse seh ich aber ne:

Delphi-Quellcode:

unit AdvMainMenu;

interface

uses
  Windows, Menus, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TAdvMainMenu = class(TMainMenu)
  private
    { Private-Deklarationen }
    FOnLMBClicked: TNotifyEvent;
    FOnRMBClicked: TNotifyEvent;
    procedure LeftMouseButtonDown(var Msg : TMouseInput); message WM_LBUTTONDOWN;
    procedure RightMouseButtonDown(var Msg : TMouseInput); message WM_RBUTTONDOWN;
  protected
    { Protected-Deklarationen }
    procedure DoLeftMouseButtonDown(var Msg : TMouseInput); dynamic;
    procedure DoRightMouseButtonDown(var Msg : TMouseInput); dynamic;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property OnLMBClick: TNotifyEvent read FOnLMBClicked write FOnLMBClicked;
    property OnRMBClick: TNotifyEvent read FOnRMBClicked write FOnRMBClicked;
  end;
  TAdvMenuItem = class(TMenuItem)
  private
    { Private-Deklarationen }
    FOnLMBClicked: TNotifyEvent;
    FOnRMBClicked: TNotifyEvent;
    procedure LeftMouseButtonDown(var Msg : TMouseInput); message WM_LBUTTONDOWN;
    procedure RightMouseButtonDown(var Msg : TMouseInput); message WM_RBUTTONDOWN;
  protected
    { Protected-Deklarationen }
    procedure DoLeftMouseButtonDown(var Msg : TMouseInput); dynamic;
    procedure DoRightMouseButtonDown(var Msg : TMouseInput); dynamic;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property OnLMBClick: TNotifyEvent read FOnLMBClicked write FOnLMBClicked;
    property OnRMBClick: TNotifyEvent read FOnRMBClicked write FOnRMBClicked;
  end;


procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Standard', [TAdvMainMenu]);
end;

constructor TAdvMainMenu.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
end;

destructor TAdvMainMenu.Destroy;
begin
  inherited Destroy;
end;

procedure TAdvMainMenu.DoLeftMouseButtonDown(var Msg: TMouseInput);
begin
  If Assigned(FOnLMBClicked) then
    FOnLMBClicked(Self);
end;

procedure TAdvMainMenu.DoRightMouseButtonDown(var Msg: TMouseInput);
begin
  If Assigned(FOnRMBClicked) then
    FOnRMBClicked(Self);
end;

procedure TAdvMainMenu.LeftMouseButtonDown(var Msg: TMouseInput);
begin
  DoLeftMouseButtonDown(Msg);
end;

procedure TAdvMainMenu.RightMouseButtonDown(var Msg: TMouseInput);
begin
  DoRightMouseButtonDown(Msg);
end;

constructor TAdvMenuItem.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
end;

destructor TAdvMenuItem.Destroy;
begin
  inherited Destroy;
end;

procedure TAdvMenuItem.DoLeftMouseButtonDown(var Msg: TMouseInput);
begin
  If Assigned(FOnLMBClicked) then
    FOnLMBClicked(Self);
end;

procedure TAdvMenuItem.DoRightMouseButtonDown(var Msg: TMouseInput);
begin
  If Assigned(FOnRMBClicked) then
    FOnRMBClicked(Self);
end;

procedure TAdvMenuItem.LeftMouseButtonDown(var Msg: TMouseInput);
begin
  DoLeftMouseButtonDown(Msg);
end;

procedure TAdvMenuItem.RightMouseButtonDown(var Msg: TMouseInput);
begin
  DoRightMouseButtonDown(Msg);
end;

end.

???

[TriphunEM]

wie muss das nun aussehen, wenn ich die ereignisse zusätzlich den items bereitstellen will????

[marabu]

Hallo Frank,

Zitat:

Zitat von TriphunEM

@ marabu

Sinnvoll ist das schon. Nehmen wir mal den Favoritenliste im Firefox oder IE, dort bekommt auf einem Order ein anderes popup als wie auf einem link. ist zwar sowas wie ne toolbar, aber will das für ein Mainmenü!

du hast mich überzeugt. Auch wenn du mittlerweile in Richtung ToolBar2000 abgetrudelt bist - im Anhang mein Code dazu.

Grüße vom marabu

[TriphunEM]

@marabu

hi. danke dir für die mühe, aber das problem mit der Mainmenü habe ich selber schon gelöst.
Allerdings brauch ich sowas in der Art wie eine Toolbar.

Wenn ich das Mainmenü in eine Standard-Toolbar packe funktioniert dein Code sowie auch mein Code nicht mehr.

Also hab ich mich von der Mainmenü-Toolbar-Variante abgetan und versuche mich an der Toolbar2000.

Wenn Du dafür eine Lösung hättest, wärst Du mein Gott!?

Ich ärgere mich jetzt schon über einen Monat damit rum.


MfG & big thx

Frank

[Flocke]

Du hast ja inzwischen schon so einige Hebel in Bewegung gesetzt (z.B. hier ;))

Zu deiner PN: ich hatte gestern wirklich etwas Zeit und bin so weit gekommen, dass ich die WM_RBUTTONDOWN-Meldung auf dem Popup-Fenster abfangen kann, allerdings fehlt noch die Lokalisierung des betreffenden TTBItem mit Hilfe der Koordinaten.

Bis jetzt:

Delphi-Quellcode:

var
  HookHandle: THandle;

function HookRightButton(nCode: Integer; wp: WPARAM; lp: LPARAM): LRESULT;
  stdcall;
var
  Wnd: TWinControl;
  Pnt: TPoint;
begin
  if nCode = HC_ACTION then
  begin
    with PMsg(lp)^ do
      if message = WM_RBUTTONDOWN then
      begin
        Wnd := Controls.FindControl(hWnd);
        if Wnd is TTBToolbar then
        begin
          Pnt := SmallPointToPoint(TSmallPoint(lParam));
          // ...
        end;
      end;
  end;

  Result := CallNextHookEx(HookHandle, nCode, wp, lp);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  HookHandle := SetWindowsHookEx(WH_GETMESSAGE, HookRightButton, 0, GetCurrentThreadId);
end;

An der Stelle mit ... fehlen halt noch einige Überprüfungen.

Wichtig: du solltest an der gehookten Stellen nicht selbst etwas tun, sondern dir einfach per PostMessage eine selbstdefinierte Meldung an das Hauptfenster schicken und dort dann ggf. eine Aktion vornehmen.

[marabu]

Hallo Frank,

Zitat:

Zitat von TriphunEM

... das problem mit der Mainmenü habe ich selber schon gelöst.

entschuldige, aus deinen Beiträgen hier und in den anderen Foren hatte ich einen anderen Schluss gezogen.

Zitat:

Zitat von TriphunEM

Allerdings brauch ich sowas in der Art wie eine Toolbar.

Deine Lösung kenne ich ja nicht, aber meine Lösung funktioniert nach einer entsprechenden Anpassung auch mit einem ToolBarMenu - allerdings nicht mit ToolBar2000, weil dort wohl keine Windows Menüs verwendet werden, der Autor malt wohl selbst. Viel Glück mit ToolBar2000.

Freundliche Grüße vom marabu

[TriphunEM]

@Flocke :

danke. aber bei mir funzt das irgendwie nicht.

bekomme folgenden Fehlermeldung :

Zitat:

[Fehler] Unit1.pas(34): Inkompatible Typen: 'Reguläre Prozedur und Methodenzeiger'

bei (hinter HookRightButton, )

Delphi-Quellcode:

 HookHandle := SetWindowsHookEx(WH_GETMESSAGE, HookRightButton, 0, GetCurrentThreadId);

und

Zitat:

[Fehler] Unit1.pas(48) : '[' erwartet, aber '.' gefunden

bei (hinter Controls.)

Delphi-Quellcode:

  
with PMsg(lp)^ do
      if message = WM_RBUTTONDOWN then
      begin
        Wnd := Controls.FindControl(hWnd);
        if Wnd is TTBToolbar then
        begin

thx

[Flocke]

So, hier eine `richtige´ Lösung für Toolbar2000. Damit erhältst du in der Routine WMMyPopup sowohl den Toolbar-Eintrag unter der Maus als auch die Mauskoordinaten für's Popup-Menü.

Delphi-Quellcode:

const
  WM_MYPOPUP = WM_USER + 123;  // Beliebig

type
  TForm1 = class(TForm)
    // ... alle anderen Controls, u.a.
    PopupMenu1: TPopupMenu;
    Label2: TLabel;
    Label3: TLabel;
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    procedure WMMyPopup(var Msg: TMessage); message WM_MYPOPUP;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

var
  HookHandle: THandle;

function HookRightButton(nCode: Integer; wp: WPARAM; lp: LPARAM): LRESULT;
  stdcall;
var
  Wnd: TWinControl;
  Frm: TWinControl;
  View: TTBView;
  Item: TTBItemViewer;
  Pnt: TPoint;
begin
  if nCode = HC_ACTION then
  begin
    with PMsg(lp)^ do
      if message = WM_RBUTTONDOWN then
      begin
        Wnd := FindControl(hWnd);
        if Wnd is TTBToolbar then
        begin
          Pnt := SmallPointToPoint(TSmallPoint(lParam));
          ClientToScreen(hWnd, Pnt);

          Frm := Wnd.Parent;
          while (Frm <> nil) and not (Frm is TCustomForm) do
            Frm := Frm.Parent;
          if Frm = nil then
            Frm := Application.MainForm;

          View := TTBToolbar(Wnd).View;
          while View <> nil do
          begin
            Item := View.ViewerFromPoint(View.Window.ScreenToClient(Pnt));
            if Assigned(Item) then
            begin
              PostMessage(Frm.Handle, WM_MYPOPUP, UINT(Item.Item),
                          UINT(PointToSmallPoint(Pnt)));
              break;
            end;

            if Assigned(View.OpenViewerView) and (View <> View.OpenViewerView) then
              View := View.OpenViewerView
            else if Assigned(View.Selected.View) and (View <> View.Selected.View) then
              View := View.Selected.View
            else
              View := nil;
          end;
        end;
      end;
  end;

  Result := CallNextHookEx(HookHandle, nCode, wp, lp);
end;

procedure TForm1.WMMyPopup(var Msg: TMessage);
var
  Item: TTBCustomItem;
  Pnt: TPoint;
begin
  Item := TTBCustomItem(Msg.WParam);
  Pnt := SmallPointToPoint(TSmallPoint(Msg.LParam));

  Label2.Caption := Item.Caption;
  Label3.Caption := Format('%d,%d', [Pnt.X, Pnt.Y]);

  PopupMenu1.Popup(Pnt.X, Pnt.Y);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  HookHandle := SetWindowsHookEx(WH_GETMESSAGE, @HookRightButton, 0, GetCurrentThreadId);
end;

end.

// Edit: kleine Korrekturen

[TriphunEM]

DANKE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Du bist absofort mein Gott. Endlich ist das Problem gelöst!

1000 Dank nochmal. Von dir sollte es 10000000000000 geben!

Mfg

Frank