8 respuestas en este tema

[escafandra]

Tras una pregunta en CD sobre la detección de la aparición de nuevo texto en el Clipboard, desarrolle un pequeño visor del Clipboard que puede servir de ejemplo para usarlo tal cual o de base para futuros desarrollos.

La técnica que he seguido para el primer ejemplo es compatible desde Windows 2000 en adelante y requiere tratar varios mensajes tras colocarnos en la lista de visores del Clipboard. El código está comentado para comprender bien como y porqué tratamos los mensajes.

El corazón es el mensaje WM_DRAWCLIPBOARD que recibiremos cuando se produzcan cambios en el Clipboard, tanto al cambiar éste como al entrar otro visor en la cola.

Código delphi:

delphi

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Clipbrd;
 
type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
  private
    NextViewer: HWND;
    procedure GetData;
  protected
    procedure WndProc(var Message: TMessage); override;
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
  //Clipboard.Clear;  // Podemos limpiar o no el clipboard al comenzar
  // Nos registramos como ClipboardViewer y guardamos el anterior de la cadena
  NextViewer:= SetClipboardViewer(Handle);
end;
 
 
// Procesamos los mensajes a bajo nivel
procedure TForm1.WndProc(var Message: TMessage);
begin
  case Message.Msg of
  WM_DRAWCLIPBOARD:
  begin
    // Si tenemos un visor en la cadena, le reenviamos el mensaje
    if NextViewer <> 0 then
      SendMessage(NextViewer, WM_DRAWCLIPBOARD, 0, 0);
    // Miramos el ClipBoard
    GetData();
  end;
 
  WM_DESTROY:
    // Notificamos que dejamos de ser visor del ClipBoard
    ChangeClipboardChain(Handle, NextViewer);
 
  WM_CHANGECBCHAIN:
    // Nos notifican que otra App deje de ser visor del ClipBoard
    if HWND(Message.WParam) = NextViewer then
      // Alctualizamos NextViewer
      NextViewer:= Message.LParam
    else if NextViewer <> 0 then
      // Si no se actualizó reenviamos el mensaje
      SendMessage(NextViewer, WM_CHANGECBCHAIN, Message.WParam, Message.LParam);
  
  end;
  inherited WndProc(Message);
end;
 
procedure TForm1.GetData;
begin
  if Clipboard.HasFormat(CF_TEXT) then
    Memo1.Lines.Add(Clipboard.AsText);
end;
 
end.

El equivalente en BuilderC++ sería el siguiente:

cpp

//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
        TMemo *Memo1;
private:	// User declarations
  void __fastcall WndProc(Messages::TMessage &Message);
  void __fastcall GetData();
public:		// User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

cpp

#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include <Clipbrd.hpp>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
HWND   NextViewer;
HWND   OldViewer;
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
  //Clipboard()->Clear();  // Podemos limpiar o no el clipboard al comenzar
  // Nos registramos como ClipboardViewer y guardamos el anterior de la cadena
  NextViewer = SetClipboardViewer(Handle);
}
 
//---------------------------------------------------------------------------
// Procesamos los mensajes a bajo nivel
void __fastcall TForm1::WndProc(Messages::TMessage &Message)
{
  switch (Message.Msg){
    case WM_DRAWCLIPBOARD:
      // Si tenemos un visor en la cadena, le reenviamos el mensaje
      if(NextViewer!=0)
        SendMessage(NextViewer, WM_DRAWCLIPBOARD, 0, 0);
      GetData();
      break;
 
    case WM_DESTROY:
      // Notificamos que dejamos de ser visor del ClipBoard
      ChangeClipboardChain(Handle, NextViewer);
      break;
 
    case WM_CHANGECBCHAIN:
      // Nos notifican que otra App deje de ser visor del ClipBoard
      if((HWND)Message.WParam == NextViewer)
        // Alctualizamos NextViewer
        NextViewer = (HWND)Message.LParam;
      else if(NextViewer != NULL)
        // Si no se actualizó reenviamos el mensaje
        SendMessage(NextViewer, WM_CHANGECBCHAIN, Message.WParam, Message.LParam);
      break;
  }
 
  TForm::WndProc(Message);
}
 
//---------------------------------------------------------------------------
void __fastcall TForm1::GetData()
{
  if(Clipboard()->HasFormat(CF_TEXT))
    Memo1->Lines->Add(Clipboard()->AsText);
}

En la siguiente entrada de este hilo explico como hacerlo más sencillo pero a partir de Windows Vista en adelante.


Saludos.

[escafandra]

Ahora vamos a ver un código bastante más sencillo pero no compatible con WinXP. Nos serviría para Windows Vista en adelante.

Sólo usamos 2 APIs y un sólo mensaje, el WM_CLIPBOARDUPDATE que se nos enviará cada vez que aparezca un cambio en el ClipBoard.

El código delphi es el siguiente:

delphi

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Clipbrd;
 
  function AddClipboardFormatListener(hWindow: HWND): BOOL; stdcall; external  User32;
  function RemoveClipboardFormatListener(hWindow: HWND): BOOL; stdcall; external  User32;
 
  const WM_CLIPBOARDUPDATE = $031D;
type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    procedure GetData;
  protected
    procedure WndProc(var Message: TMessage); override;
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  AddClipboardFormatListener(Handle);
end;
 
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  RemoveClipboardFormatListener(Handle);
end;
 
procedure TForm1.GetData;
begin
  if Clipboard.HasFormat(CF_TEXT) then
    Memo1.Lines.Add(Clipboard.AsText);
end;
 
// Procesamos los mensajes a bajo nivel
procedure TForm1.WndProc(var Message: TMessage);
begin
  if Message.Msg = WM_CLIPBOARDUPDATE then
    GetData();
  
  inherited WndProc(Message);
end;
 
end.

y el código BuilderC++:

cpp

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
  TMemo *Memo1;
  void __fastcall FormDestroy(TObject *Sender);
private:
  void __fastcall WndProc(Messages::TMessage &Message);
  void __fastcall GetData();
public:		// User declarations
  __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

cpp

#include <vcl.h>
#include <Clipbrd.hpp>
#pragma hdrstop
 
#include "Unit1.h"
 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
 
 
#define WM_CLIPBOARDUPDATE              0x031D
typedef bool (__stdcall *PAddClipboardFormatListener)(HWND hWnd);
// "User32.dll", "AddClipboardFormatListener"
typedef bool (__stdcall *PRemoveClipboardFormatListener)(HWND hWnd);
// "User32.dll", "RemoveClipboardFormatListener"
 
 
 
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
  PAddClipboardFormatListener _AddClipboardFormatListener =
                      (PAddClipboardFormatListener)GetProcAddress(GetModuleHandle("User32.dll"), "AddClipboardFormatListener");
  _AddClipboardFormatListener(Handle);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
  PRemoveClipboardFormatListener _RemoveClipboardFormatListener =
                      (PRemoveClipboardFormatListener)GetProcAddress(GetModuleHandle("User32.dll"), "RemoveClipboardFormatListener");
  _RemoveClipboardFormatListener(Handle);
}
 
//---------------------------------------------------------------------------
// Procesamos los mensajes a bajo nivel
void __fastcall TForm1::WndProc(Messages::TMessage &Message)
{
  if(Message.Msg == WM_CLIPBOARDUPDATE)
    GetData();
  TForm::WndProc(Message);
}
 
//---------------------------------------------------------------------------
void __fastcall TForm1::GetData()
{
  if(Clipboard()->HasFormat(CF_TEXT))
    Memo1->Lines->Add(Clipboard()->AsText);
}

Saludos.

[seoane]

No conocia esas dos funciones, me las apunto.

Aunque sugiero que para tratar con mensajes podemos usar las facilidades que da delphi

delphi

const
  WM_CLIPBOARDUPDATE = $031D;
 
type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    { Private declarations }
    procedure WMCLIPBOARDUPDATE(var Msg: TMessage); message WM_CLIPBOARDUPDATE;
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
 function AddClipboardFormatListener(hWindow: HWND): BOOL; stdcall; external  User32;
 function RemoveClipboardFormatListener(hWindow: HWND): BOOL; stdcall; external  User32;
 
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  RemoveClipboardFormatListener(Handle);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  AddClipboardFormatListener(Handle);
end;
 
procedure TForm1.WMCLIPBOARDUPDATE(var Msg: TMessage);
begin
  if Clipboard.HasFormat(CF_TEXT) then
    Memo1.Lines.Add(Clipboard.AsText);
end;

[poliburro]

Muchas gracias amigo escafandra por el aporte. Vaya que dominas el tema de las APIs de windows.

[escafandra]

...sugiero que para tratar con mensajes podemos usar las facilidades que da delphi...

Sabía que ahondarías en el tema y no te falta razón. Soy un clásico y aunque builderC++ tiene un sistema muy similar a delphi para tratar mensajes individuales, yo prefiero reescribir el método virtual WndProc y tratarlos en bloque, y a bajo nivel. Son manías mias.

Saludos.

[poliburro]

No conocia esas dos funciones, me las apunto.

Aunque sugiero que para tratar con mensajes podemos usar las facilidades que da delphi

yo prefiero reescribir el método virtual WndProc y tratarlos en bloque, y a bajo nivel. Son manías mias.

Hola amigos, ¿sería mucho pedir si nos contaran los prosy  contras de hacerlo con lo que menciona seoane y como lo hace escafandra?

Yo conozco poco del manejo del API y creo que me sería sumamente enriquecedor saber cuál es la diferencia de hacerlo de una u otra manera.

Saludos.

[escafandra]

Hola amigos, ¿sería mucho pedir si nos contaran los prosy  contras de hacerlo con lo que menciona seoane y como lo hace escafandra?

Yo conozco poco del manejo del API y creo que me sería sumamente enriquecedor saber cuál es la diferencia de hacerlo de una u otra manera.

Pues en realidad no hay mucha diferencia, salvo que la forma delphi aumenta el número de llamadas a procedimientos. A mi me gusta el estilo API porque estoy más acostumbrado a hacerlo en pregramas API puros y porque veo los mensajes de un sólo golpe de vista en ún sólo procedimiento o función (en C), si tengo que manejar varios mensajes al tiempo.  A veces también uso el estilo delphi, es cuestión de gustos, de estado de ánimo y velocidad de escritura.

Que cada cual que escoja la técnica que prefiera, ambas van a funcionar bien y la diferencia de velocidad de ejecución es despreciable.

Ya conocéis otra forma alternativa menos popular. 


Saludos.

[poliburro]

Que cada cual que escoja la técnica que prefiera, ambas van a funcionar bien y la diferencia de velocidad de ejecución es despreciable.

Ya conocéis otra forma alternativa menos popular. 


Saludos.

Gracias por la info amigo.

[escafandra]

Me acabo de dar cuente que en nuestro DA se había hecho una pregunta similar a la que originó este truco y que se hizo en CD, como comenté al inicio del mismo. Siento no haberme dado cuenta antes systemix, creo que con este truco, o lo que publiqué en CD, la pregunta está respondida.


Saludos.