Onclick und rechte Maustaste!

[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 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 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 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 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, )
 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