was ist neu ¦  programmier tips ¦  indy artikel ¦  intraweb artikel ¦  informationen ¦  links ¦  interviews
 sonstiges ¦  tutorials ¦  Add&Win Gewinnspiel

Tips (1541)

Dateien (137)
Datenbanken (90)
Drucken (35)
Grafik (114)
IDE (21)
Indy (5)
Internet / LAN (130)
IntraWeb (0)
Mathematik (76)
Multimedia (45)
Oberfläche (107)
Objekte/
ActiveX (51)

OpenTools API (3)
Sonstiges (126)
Strings (83)
System (266)
VCL (242)

Tips sortiert nach
Komponente


Tip suchen

Tip hinzufügen

Add&Win Gewinnspiel

Werbung

42 Visitors Online


 
...Windows Nachrichten in einer Komponente abfangen?
Autor: Thomas Stutz
[ Tip ausdrucken ]  

Tip Bewertung (10):  
     


{
  TApplication includes a method called HookMainWindow that allows you to
  insert your own message handler at the top of WndProc to intercept messages sent
  to your application before they're handled by the Application object.

  HookMainWindow() is declared under TApplication as follows:
}

procedure HookMainWindow(Hook : TWindowHook);

{
  HookMainWindow() takes one parameter (Hook of type TWindowHook).
  TWindowHook is a method pointer type that's defined like so:
}

type
  
TWindowHook = function(var Message : TMessage) : Boolean of object;

{
  Since TWindowHook is a method pointer, you can define your own method as
  the hook function as long as it follows the nomenclature defined for TWindowHook.
  The return value of the function is of type Boolean.
  This is the equivalent of the "Handled" parameter of OnMessage.
  If your function handles a particular message, you'd return true.
  This will be passed back to the Application's WndProc and message processing for that
  message will be terminated. Otherwise, you'd return False.

  The Component "MessageReceiver" intercepts user-definded messages
  (> WM_USER) und as example the message WM_TIMECHANGE.
}

{*************************************************************************}

{
  TApplication besitzt eine Methode HookMainWindow.
  Damit kann man in die Windows Prozedur (WndProc) "einhaken" und Nachrichten,
  welche an die Applikation geschickt werden, abfangen und behandeln.

  HookMainWindow is wie folgt deklariert:
}

procedure HookMainWindow(Hook : TWindowHook);

{ Und der Parameter TWindowHook (Methoden Pointer) so: }

type
  
TWindowHook = function(var Message : TMessage) : Boolean of object;

{
  Der Rückgabewert der Funktion ist vom Type Boolean.
  Dieser enspricht dem "Handled" Parameter von OnMessage.
  Wenn nun eine bestimmte Nachricht behandlet wird, kann True zurückgegeben
  werden, sonst False.

  Die Komponente "MessageReceiver" fängt einerseits benuterdefinierte Nachrichten
  (> WM_USER) und als Beispiel die Nachricht WM_TIMECHANGE ab.

  Im OnCreate() wird Application.HookMainWindow aufgerufen und im OnDestroy() dann
  - falls nötig - Application.UnhookMainWindow.
}

{*************************************************************************}

unit MessageReceiver;

interface

uses
  
Windows, Messages, SysUtils, Classes, Forms, Dialogs;

type
  
TOnReceiveUserMessage = procedure(Msg: Cardinal; wParam, lParam: Integer;
    var Handled: Boolean) of object;
  TOnReceiveOtherMessage = procedure(var Handled: Boolean) of object;

  TMessageReceiver = class(TComponent)
  private
    
{ Private declarations }
    
FHooked: Boolean;

    FOnReceiveUserMessage: TOnReceiveUserMessage;
    FOnDateTimeChange: TOnReceiveOtherMessage;

    function MessageHook(var Msg: TMessage): Boolean;
  protected
    function 
DoDateTimeChange(Msg: TMessage): Boolean; dynamic;
    function DoUserMessage(Msg: TMessage): Boolean; dynamic;
  public
    
{ Public declarations }
    
constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    
{ Published declarations }
    
property OnDateTimeChange: TOnReceiveOtherMessage
      read FOnDateTimeChange write FOnDateTimeChange;
    property OnReceiveUserMessage: TOnReceiveUserMessage
      read FOnReceiveUserMessage write FOnReceiveUserMessage;
  end;
  
procedure Register;

implementation

procedure Register
;
begin
  
RegisterComponents('System', [TMessageReceiver]);
end;

function TMessageReceiver.MessageHook(var Msg: TMessage): Boolean;
begin
  
Result := False;
  // User defined messages
  
if (Msg.Msg >= WM_USER) then
    
Result := DoUserMessage(Msg)
  else
    
// Other messages
    
case Msg.Msg of
      
WM_TIMECHANGE: Result := DoDateTimeChange(Msg);
      // ...
    
end;
end;

function TMessageReceiver.DoDateTimeChange(Msg : TMessage): Boolean;
begin
  
Result := False;
  if Assigned(FOnDateTimeChange) then
    
FOnDateTimeChange(Result);
end;

function TMessageReceiver.DoUserMessage(Msg: TMessage): Boolean;
begin
  
Result := False;
  if Assigned(FOnReceiveUserMessage) then
    
FOnReceiveUserMessage(Msg.Msg, Msg.wParam, Msg.LParam, Result);
end;

constructor TMessageReceiver.Create(AOwner: TComponent);
begin
  inherited 
Create(AOwner);
  FHooked := False;
  if not (csDesigning in ComponentState) then
  begin
    
Application.HookMainWindow(MessageHook);
    FHooked := True;
  end;
end;

destructor TMessageReceiver.Destroy;
begin
  if 
FHooked then Application.UnhookMainWindow(MessageHook);
  inherited Destroy;
end;

end.


 

Bewerten Sie diesen Tipp:

dürftig
ausgezeichnet


Copyright © by SwissDelphiCenter.ch
All trademarks are the sole property of their respective owners