O SetTimer é uma função disponibilizada pela plataforma Windows ( API ) que consiste em criar um Temporizador que notifica um Objeto Windows ( Handle ) sempre que atingir o términio do tempo estipulado. Um temporizador desse tipo é gerenciado pelo Windows, ou seja, não será relacionado com o processamento do seu aplicativo, ficando assim com uma precisão boa mesmo enquanto seu aplicativo processa alguma coisa.

Um detalhe muito importante sobre o processamento da notificação do temporizador ( Timer ), é que como a notificação padrão é feita via mensagem, a WM_TIMER, e mensagens são administradas pela VCL através do Objeto TApplication application, em 2 respectivos locais, o primeiro em ProcessMessages que processa a fila inteira de mensagens que a aplicação possuí, e o segundo HandleMessage que processa apenas a primeira mensagem da fila, se existir alguma, sinaliza o Evento OnIde e aguarda uma nova mensagem (em caso de fila a liberação é instantanea), você podera perder a precisão do temporizador por falta de manipulação da recepção de mensagens. Já vi muita gente reclamando a precisão do SetTimer na utilização dentro de um aplicativo Delphi, mas nunca vi essa reclamação de um programador C, pois o mesmo tem o trabalho de gerênciar as notificações para o objeto receptor.

Então o fato é, temporizadores não são ruins, são ótimas opções para criação de simuladores de interação, Inteligências artificiais em alguns pontos, e até mesmo para criação de cronometros e agendamentos.

{$EXTERNALSYM SetTimer}
function SetTimer(hWnd: HWND; nIDEvent, uElapse: UINT;
  lpTimerFunc: TFNTimerProc): UINT; stdcall;

Chegando neste ponto, podemos perceber que possuímos 2 caminhos, o primerio através de um Objeto Windows e o outro através de um Callback, a escolha é você quem faz na hora da utilização, vou exemplificar as duas maneiras de utilização, então preste atenção, pois é bastante interessante .

Como utilizar um temporizador através de um Objeto Windows?

Para facilitar o entendimento e não aprofundar muito em matérias que não são a questão do artigo, vamos utilizar a VCL para administrar nosso Objeto Windows.

  TfrmTest = class(TForm)
    btnStart: TButton;
    procedure btnStartClick(Sender: TObject);
  private
    { Private declarations }
  public
    procedure WMTimer(var Msg: TWMTimer); message WM_TIMER;
  end;

procedure TfrmTest.btnStartClick(Sender: TObject);
begin
  SetTimer(Handle, 0, 1000, nil);
end;

Handle é o Handle do frmTest, como é Handle é Objeto Windows e pode receber mensagens.

0 é o índice que eu informei para o temporizador, então sempre que eu receber um WM_TIMER vou verificar qual índice ele contém e poder estruturar tarefas em cima disso.

1000 é o intervalo em milisegundos que o temporizador irá me notificar no Handle do frmTest. 1000 milisegundos = 1 segundo, logo 60000 milisegundos = 1 minuto.

nil é indicado como NIL pois queremos interagir com a mensagem através de mensagens.

procedure TfrmTest.WMTimer(var Msg: TWMTimer);
begin
  KillTimer(Handle, Msg.TimerID);
  ShowMessage('Evento do temporizador: ' + IntToStr(Msg.TimerID));
end;

{$EXTERNALSYM KillTimer}
function KillTimer(hWnd: HWND; uIDEvent: UINT): BOOL; stdcall;

Pois bem, já vimos que a utilização do temporizador através da VCL é fácil, e pode se extender a um universo infinito de possibilidades. Vou mostrar um exemplo prático:

type
  PTimerParam = ^TTimerParam;
  TTimerParam = record
    s: string;
    i: integer;
  end;
 
procedure TfrmTest.btnStartClick(Sender: TObject);
var
  Param: PTimerParam;
begin
  New(Param);
  Param^.s := 'Teste de título animado';
  Param^.i := 1;
  SetTimer(Handle, Integer(Param), 100, nil);
end;
 
procedure TfrmTest.WMTimer(var Msg: TWMTimer);
begin
  KillTimer(Handle, Msg.TimerID);
  with PTimerParam(Msg.TimerID)^ do
  begin
    Caption := Copy(s, 1, i);
    i := i + 1;
    if i <= Length(s) then
      SetTimer(Handle, Msg.TimerID, 100, nil)
    else
      Dispose(Pointer(Msg.TimerID));
  end;
end;

Agora a segunda parte da história:

Como utilizar um temporizador através de um Callback?

Primeiramente, a utilização do SetTimer por Callback é mais eficiente em relação ao processo via Objeto Windows, pois não há dependência de objeto para que o reconhecimento da notificação do temporizador seja feita em relação a aplicação, pois o callback será chamado internamente pela DefWindowProc.

Então vamos entender como declarar um procedimento no padrão do Callback TimerProc:

VOID CALLBACK TimerProc(      
    HWND hwnd,
    UINT uMsg,
    UINT_PTR idEvent,
    DWORD dwTime
);

procedure TimerProc(hwnd: HWND; uMsg, idEvent: UINT; dwTime: DWORD); stdcall;

Então após entendermos a estrutura do último parametro do SetTimer podemos escrever um exemplo prático de resultado semelhante ao exemplo anterior:

type
  PTimerParam = ^TTimerParam;
  TTimerParam = record
    s: string;
    i: integer;
  end;
 
procedure TimerProc(hwnd: HWND; uMsg, idEvent: UINT; dwTime: DWORD); stdcall;
begin
  KillTimer(hwnd, idEvent);
  with PTimerParam(idEvent)^ do
  begin
    frmMain.Caption := Copy(s, 1, i);
    i := i + 1;
    if i <= Length(s) then
      SetTimer(hwnd, idEvent, 100, @TimerProc)
    else
    begin
      Dispose(Pointer(idEvent));
      DeallocateHWnd(hwnd);
    end;
  end;
end;
 
procedure TfrmMain.btnRunClick(Sender: TObject);
var
  Param: PTimerParam;
begin
  New(Param);
  Param^.s := 'Teste de título animado';
  Param^.i := 1;
  SetTimer(AllocateHWnd(nil), Integer(Param), 100, @TimerProc);
end;

Veja que ao chamar o SetTimer eu utilizo o AllocateHWnd como primeiro parametro, o porquê disso é que o SetTimer opera de maneira diferente ao se indicar um Objeto Windows que não pertence à aplicação, a definição é a seguinte:
Caso o Handle passado como parametro pertença a aplicação, mais especificamente a mesma Thread que chama a SetTimer. No caso do Handle ser igual a 0 ( zero ) ou não pertencer a aplicação, o parametro passado como índice do temporizador será ignorado e um novo índice será criado e o retorno da chamada ao SetTimer indicará o novo índice.

Depois de entender esse detalhe importante podemos perceber porque fazemos a criação de um Objeto Windows utilizando o AllocateHWnd. A finalidade disso é não passar um Objeto Windows inválido e ter o índice, que no nosso caso indica um ponteiro que serve de parametro, resetado.

Agora entendendo um pouco o código:

Perceba que sempre que recebemos a notificação de términio do intervalo do temporizador, finalizamos o temporizador, e porque fazemos isso? Fazemos isso pois se dentro da notificação, seja na utilização do callback ou por mensagem ( WM_Timer ), o processo que escrevermos lá demorar mais do que o intervalo, criaremos uma fila de processamento, e que acaba por criar uma sequência de processamento e o efeito de execução por intervalo não será perceptível.

Fluxograma para entendimento rápido:

Qualquer dúvida fique avontade em perguntar!

Abraço a todos

O RegisterHotkey e uma função disponibilizada pela plataforma Windows ( API ) que cria uma interação com o objeto passado como parametro no momento que o usuário faz uma combinação de teclas, exemplo: CTRL+X. Resumindo, ele registra um objeto para ser notificado quando uma combinação de teclas é acionada.

{$EXTERNALSYM RegisterHotKey}
function RegisterHotKey(hWnd: HWND; id: Integer; fsModifiers, vk: UINT): BOOL; stdcall;

Exemplo:

  RegisterHotkey(form1.Handle, 1, MOD_CONTROL or MOD_SHIFT, Byte(Ord('Q')));
  RegisterHotkey(form1.Handle, 2, MOD_CONTROL or MOD_SHIFT, Byte(Ord('A')));

Mas ainda falta uma coisa, como já sabemos objetos Windows são notificados através de mensagens ( Message ) então temos que gerenciar a mensagem certa que o Windows utiliza para notificar o objeto quando a combinação de teclas é feita. Essa mensagem é a WM_HOTKEY, uma mensagem que o Delphi já mapeia para você como TWMHotKey, então é só escrever o seguinte código para gerenciar as notificações:

type
  TForm1 = class(TForm)
  private
    { Private declarations }
  public
    procedure WMHotKey(var Msg: TWMHotKey); message WM_HOTKEY;
  end;

Exemplo:

procedure TForm1.WMHotKey(var Msg: TWMHotKey);
begin
  case Msg.HotKey of
    1: begin
      // Aqui eu recebi CTRL+SHIFT+Q
    end;
    2: begin
      // Aqui eu recebi CTRL+SHIFT+A
    end;
  end;
end;

É muito simples a utilização da API RegisterHotkey, outra parte interessante é a possibilidade de desregistrar a notificação, através da contra-API UnRegisterHotkey.

{$EXTERNALSYM UnregisterHotKey}
function UnregisterHotKey(hWnd: HWND; id: Integer): BOOL; stdcall;

Baseando no nosso exemplo, desregistramos as 2 notificações assim:

  UnRegisterHotkey(Handle, 1);
  UnRegisterHotkey(Handle, 2);

Simples não é?
Qualquer dúvida fique avontade em perguntar.

Abraço a todos

O SendMessage é uma função disponibilizada pela plataforma windows (API) que nos permite interagir sobre objetos Window, ou seja, todos os objetos que possuem Handle, seja esse handle de qual tipo for: HWND, HFILE, HMENU, HHOOK, HGLOBAL, HLOCAL, HINST e outros vários. Diante isso podemos entender que o acesso a certos objetos pode ser feito através da utilização dessa API.

{$EXTERNALSYM SendMessage}
function SendMessage(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;

Um exemplo:

  SendMessage(btn2.Handle, CN_COMMAND, BN_CLICKED, 0);

Outro exemplo interessante:

  SendMessage(form1.Handle, WM_SETTEXT, 0, Integer(PChar('Novo Título')));

A infinidade de coisas que dá pra se fazer com essa pequena API é incalculável.
Se quiser ver como é vasta a capacidade proponha-me um problema! Eu ficarei grato pelo desafio.

Abraço a todos