9 respuestas en este tema

[escafandra]

El título lleva a engaño puesto que el mensaje WM_MOUSEENTER no existe aunque para casi todos, el concepto si.
 
Se trata de manejar los eventos OnMouseEnter y OnMouseLeave de una ventana en versiones Delphi antiguas que no implementan esta característica, al igual que en versiones Builder de la misma época. También servirá para usarlo con cualquier ventana sin necesidad de que se trate de un control - componente específico.
 
El mensaje WM_MOUSELEAVE es recibido por una ventana si preparó previamente su solicitud con una llamada a TrackMouseEvent. Simplemente informa que el cursor del ratón abandonó el área cliente de dicha ventana. Para detectar la presencia del cursor en la ventana (WM_MOUSEENTER) basta con gestionar WM_MOUSEMOVE.
 
Propongo una clase que habilita el tratamiento del mensaje WM_MOUSELEAVE recibido por cualquier ventana (incluidos componentes derivados de TControl) Para conseguirlo realiza un Hook a la función de tratamiento de mensajes realizando un subclassing que genere dos eventos: OnMouseLeave y OnMouseEnter.
 
Este sería el código de la Unit:

delphi

unit MouseLeave;
 
//--------------------------------------------------------------------------------------------------
// TMouseLeave (Versión Hook estilo C++)
// escafandra 2017
// Clase para manejo de WM_MOUSELEAVE de una ventana
 
interface
 
uses Windows, Messages;
 
type
  TOnMouseLeave = procedure(Handle: HWND) of object;
  TOnMouseEnter = procedure(Handle: HWND) of object;
 
type
  TMouseLeave = class
  private
    Handle: HWND;
    OldWndProc: Pointer;
    function WndProc(Handle: HWND; Msg: DWORD; WParam: Longint; LParam: Longint): Longint; stdcall;
  public
    OnMouseLeave: TOnMouseLeave;
    OnMouseEnter: TOnMouseEnter;
    constructor Create; overload;
    constructor Create(WND: HWND); overload;
    destructor Destroy; override;
    procedure  SetHandle(WND: HWND);
  end;
 
implementation
 
 
function DefWndProc(Handle: HWND; Msg: DWORD; WParam: Longint; LParam: Longint): Longint; stdcall;
var
  pMouseLeave: TMouseLeave;
begin
  pMouseLeave:= TMouseLeave(GetWindowLong(Handle, GWL_USERDATA));
  if pMouseLeave <> nil then
    Result:= pMouseLeave.WndProc(Handle, Msg, WParam, LParam)
  else
    Result:= DefWindowProc(Handle, Msg, WParam, LParam);
end;
 
constructor TMouseLeave.Create;
begin
  OnMouseLeave:= nil;
  OnMouseEnter:= nil;
  SetHandle(0);
end;
 
constructor TMouseLeave.Create(WND: HWND);
begin
  OnMouseLeave:= nil;
  OnMouseEnter:= nil;
  SetHandle(WND);
end;
 
function TMouseLeave.WndProc(Handle: HWND; Msg: DWORD; WParam: Longint; LParam: Longint): Longint; stdcall;
var
  TE: TTRACKMOUSEEVENT;
begin
  if (Msg = WM_MOUSELEAVE) and (@OnMouseLeave <> nil) then
    OnMouseLeave(Handle)
 
  else if (Msg = WM_MOUSEMOVE) and (@OnMouseEnter <> nil) then
  begin
    TE.cbSize:= sizeof(TTRACKMOUSEEVENT);
    TE.dwFlags:= TME_LEAVE;
    TE.hwndTrack:= Handle;
    TE.dwHoverTime:= HOVER_DEFAULT;
    TrackMouseEvent(TE);
    OnMouseEnter(Handle);
  end;
  Result:= CallWindowProc(OldWndProc, Handle, Msg, WParam, LParam);
end;
 
 
procedure TMouseLeave.SetHandle(WND: HWND);
begin
  if (WND <> INVALID_HANDLE_VALUE) and (WND <> Handle) then
  begin
    if WND = 0 then
    begin
      SetWindowLong(Handle, GWL_USERDATA, 0);
      SetWindowLong(Handle, GWL_WNDPROC, LongInt(OldWndProc));
    end;
    if WND <> 0 then
    begin
      SetWindowLong(WND, GWL_USERDATA, LongInt(self));
      OldWndProc:= Pointer(SetWindowLong(WND, GWL_WNDPROC, LongInt(@DefWndProc)));
    end;
    Handle:= WND;
  end;
end;
 
destructor TMouseLeave.Destroy;
begin
  OnMouseLeave:= nil;
  OnMouseEnter:= nil;
  SetHandle(0);
end;
 
end.

 
Un ejemplo de uso con un botón, coloco la Unit completa para mostrar todos los pasos de uso y declaración de los eventos:

delphi

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, MouseLeave;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    ME: TMouseLeave;
    procedure OnMouseLeave(Wnd: HWND);
    procedure OnMouseEnter(Wnd: HWND);
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  ME:= TMouseLeave.Create(Button1.Handle);
  ME.OnMouseEnter:= OnMouseEnter;
  ME.OnMouseLeave:= OnMouseLeave;
end;
 
procedure TForm1.OnMouseLeave(Wnd: HWND);
begin
  with FindControl(Wnd) as TButton do Caption:= 'Adios';
end;
 
procedure TForm1.OnMouseEnter(Wnd: HWND);
begin
  with FindControl(Wnd) as TButton do Caption:= 'Hola';
end;
 
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  ME.Free;
end;
 
end.

Se precisa crear tantos objetos TMouseLeave como ventanas a controlar.
 
Subo el código.
 
 
Saludos.

Archivos adjuntos

•  MouseLeave_Delphi.zip   191,96KB   7 descargas

[Dante]

jejej voy a revisar esto seguro q me resuleve algunos problemitas con mi aplicación q se me marea con estas funciones.

[escafandra]

jejej voy a revisar esto seguro q me resuleve algunos problemitas con mi aplicación q se me marea con estas funciones.

 

Si estás usando Berlin busca esos eventos en los controles, es posible que no te haga falta este truco.

 

Saludos.

[escafandra]

Para los amantes de Builder es sus antiguas versiones y para algunos casos de las nuevas, publico el mismo truco en C++

cpp

//--------------------------------------------------------------------------------------------------
// TMouseLeave (Versión Hook estilo C++)
// escafandra 2017
// Clase para manejo de WM_MOUSELEAVE de una ventana
 
 
#ifndef MouseLeaveCPP
#define MouseLeaveCPP
 
#include <Windows.h>
 
#ifndef STRICT
  typedef int  (__stdcall *PLRESULT)();
#else
  typedef WNDPROC PLRESULT;
#endif
 
//typedef void (__fastcall *POnMouseLeave)(HWND hWnd, BOOL Enter);
typedef void __fastcall(__closure* POnMouseLeave)(HWND hWnd);
typedef void __fastcall(__closure* POnMouseEnter)(HWND hWnd);
 
 
class TMouseLeave
{
  private:
  HWND Handle;
  PLRESULT OldWndProc;
  static LRESULT __stdcall DefWndProc(HWND hWnd, UINT Msg, WPARAM WParam, LPARAM LParam)
  {
    TMouseLeave* pMouseLeave = (TMouseLeave*)GetWindowLongPtr(hWnd, GWL_USERDATA);
    if(pMouseLeave)
      return pMouseLeave->WndProc(hWnd, Msg, WParam, LParam);
    else
      return DefWindowProc(hWnd, Msg, WParam, LParam);
  }
 
  LRESULT __stdcall WndProc(HWND hWnd, UINT Msg, WPARAM WParam, LPARAM LParam)
  {
    if(Msg == WM_MOUSELEAVE && OnMouseLeave)
      OnMouseLeave(Handle);
 
    else if(Msg == WM_MOUSEMOVE && OnMouseEnter){
      TRACKMOUSEEVENT TE = {sizeof(TRACKMOUSEEVENT)};
      TE.dwFlags = TME_LEAVE;
      TE.hwndTrack = Handle;
      TE.dwHoverTime = HOVER_DEFAULT;
      TrackMouseEvent(&TE);
      OnMouseEnter(Handle);
    }
 
    return CallWindowProc(OldWndProc, hWnd, Msg, WParam, LParam);
  }
 
  public:
  POnMouseLeave OnMouseLeave;
  POnMouseEnter OnMouseEnter;
 
  void SetHandle(HWND hWnd)
  {
    if(hWnd != INVALID_HANDLE_VALUE && hWnd != Handle){
      if(!hWnd){
        SetWindowLong(GetParent(Handle), GWL_USERDATA, 0);
        SetWindowLong(GetParent(Handle), GWL_WNDPROC, (LONG)OldWndProc);
      }
      if(hWnd){
        SetWindowLongPtr(hWnd, GWL_USERDATA, (LONG)this);
        OldWndProc = (PLRESULT)SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG)TMouseLeave::DefWndProc);
      }
      Handle = hWnd;
    }
  }
 
  TMouseLeave(HWND hWnd = 0)
  {
    OnMouseLeave = 0;
    OnMouseEnter = 0;
    SetHandle(hWnd);
  }
 
  ~TMouseLeave() {SetHandle(0);}
};
#endif

Con una pequeña aplicación de ejemplo similar a la versión Delphi:

cpp

#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "MouseLeave.cpp"
//---------------------------------------------------------------------------
class TForm2 : public TForm
{
__published:	// IDE-managed Components
  TButton *Button1;
private:
  TMouseLeave ML;
  void __fastcall OnMouseLeave(HWND hWnd);
  void __fastcall OnMouseEnter(HWND hWnd);
public:		// User declarations
  __fastcall TForm2(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm2 *Form2;
//---------------------------------------------------------------------------
#endif

cpp

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
  : TForm(Owner)
{
  ML.SetHandle(Button1->Handle);
  ML.OnMouseLeave = OnMouseLeave;
  ML.OnMouseEnter = OnMouseEnter;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm2::OnMouseLeave(HWND hWnd)
{
  TButton *B = static_cast<TButton*>(FindControl(hWnd));
  if(B) B->Caption = "Adios";
}
 
void __fastcall TForm2::OnMouseEnter(HWND hWnd)
{
  TButton *B = static_cast<TButton*>(FindControl(hWnd));
  if(B) B->Caption = "Hola";
}

Subo el código.

Archivos adjuntos

•  MouseLeave_Builder.zip   184,16KB   1 descargas

[egostar]

Por demás interesante, gracias amigo.

 

Saludos

[Agustin Ortu]

Maestro escafandra, si me pongo en modo "programadoril", no seria el codigo de los constructores y del destructor de la clase inncesarios? Se supone que el constructor heredado de TObject inicializa todas las variables internas a cero. Obviamente que la version sobrecargada que acepta un Handle y lo asigna es un tema aparte
 
Yo lo simplificaria asi:

delphi

type
  TMouseLeave = class
  public
    constructor Create(const WND: HWND);
    destructor Destroy; override;
  end;
 
constructor TMouseLeave.Create(const WND: HWND);
begin
  inherited Create;
  SetHandle(WND);
end;
 
destructor TMouseLeave.Destroy;
begin
  SetHandle(0);
  inherited Destroy;
end;

 
 
Por lo demas, aprobado     

Editado por Agustin Ortu, 02 febrero 2017 - 04:09 .

[escafandra]

Maestro escafandra, si me pongo en modo "programadoril", no seria el codigo de los constructores y del destructor de la clase inncesarios? Se supone que el constructor heredado de TObject inicializa todas las variables internas a cero. Obviamente que la version sobrecargada que acepta un Handle y lo asigna es un tema aparte
 
Yo lo simplificaria asi:

delphi

type
  TMouseLeave = class
  public
    constructor Create(const WND: HWND);
    destructor Destroy; override;
  end;
 
constructor TMouseLeave.Create(const WND: HWND);
begin
  inherited Create;
  SetHandle(WND);
end;
 
destructor TMouseLeave.Destroy;
begin
  SetHandle(0);
  inherited Destroy;
end;

 
 
Por lo demas, aprobado     

 

Buena observación, vicios que tengo de C++. La clase original en C++ no se deriva de ninguna otra a propósito, no deriva de TObject, es el motivo por el que la versión delphi permanece fiel inicializando las variables, aunque como dices, podría obviarlo. En C++ una clase base no se deriva de nada y el constructor debe especificarlo todo.

 

Esperaba incluso que alguien propusiera clases comodín para delphi y no le faltaría razón, ahorran código al romper la privacidad y protección de métodos y podría usarse el sistema de subclassing de la VCL, pero la hace dependiente de esa librería y quería evitarlo. En C++ no existen las clases comodín, impidiendo romper la protección inherente al diseño de una clase, aunque existen clases amigas. En su momento pensé en usar ese truco de Delphi, pero preferí un diseño más similar a C++ e independiente por completo de la VCL para que sirva para cualquier ventana y en aplicaciones API puras.

 

 

Saludos.

[Agustin Ortu]

La clase comodin como seria? Te referis a las clases "interpuestas"?

delphi

type
  TForm = class(Forms.TForm)
    // metodos propiedades etc
  end;
 
  TForm1 = class(TForm)
  end;

[escafandra]

 

La clase comodin como seria? Te referis a las clases "interpuestas"?

delphi

type
  TForm = class(Forms.TForm)
    // metodos propiedades etc
  end;
 
  TForm1 = class(TForm)
  end;

 

Exacto.

 

 

Saludos.

[sir.dev.a.lot]

Gracias por el tiempo invertido @Escafandra

 

El Codigo sera muy util para mi y algo que tengo... +1

 

Parece haber un problema con el sistema de Votaciones en el Foro, no puedo dejar puntos... me muestra este mensaje

 

 

 

Hubo un problema almacenando tu voto de reputación

 

 

Saludos!