Перехват нажатий клавиши внутри приложения. * *

Задача решается очень просто. Можно у формы установить свойство KeyPreview в True и обрабатывать событие OnKeyPress. Второй способ - перехватывать событие OnMessage для объекта Application. Однако во втором случае следует применять осторожность, т.к. обработчик OnMessage получает все сообщения, адресованные приложению

Перехват нажатия клавиши в Windows (hook) * *

Существуют приложения, которым необходимо перехватывать все нажатия клавиш в Windows, даже если в данный момент активно другое приложение. Это может быть, например, программа, переключающая раскладку клавиатуры, резидентный словарь или программа, выполняющая иные действия по нажатию "горячей" комбинации клавиш.
Перехват всех событий в Windows (в том числе и событий от клавиатуры) выполняется с помощью вызова функции SetWindowsHook(). Данная функция регистрирует в системе Windows ловушку (hook) для определенного типа событий/сообщений. Ловушка - это пользовательская процедура, которая будет обрабатывать указанное событие. Основное здесь то, что эта процедура должна всегда присутствовать в памяти Windows. Поэтому ловушку помещают в DLL и загружают эту DLL из программы. Пока хоть одна программа использует DLL, та не может быть выгружена из памяти. Приведем пример такой DLL и программы, ее использующей. В примере ловушка перехватывает нажатие клавиш на клавиатуре и записывает их в текстовый файл
// текст библиотеки, т.е. полное содержимое файла KeyHook.dpr
library KeyHook;

uses
  shellapi,
  windows;

var
g_hhk: HHOOK;

function KeyboardProc(nCode: Integer; wParam: wParam; lParam: lParam ): LParam; stdcall;
var
f:textfile;
begin
MessageBeep(0);
assignfile(f, 'c:\hook.txt');
try
  append(f);
except
  rewrite(f);
end;
writeln(f, nCode,',',wParam,',',lParam);
close(f);
end;

exports
KeyboardProc;
begin
end.

// Пример установки WindowsHook
procedure TForm1.Button1Click(Sender: TObject);
var
  hinstDLL: HINST;
  hkprcKeyboard: TFNHookProc;
  msg: TMsg;
begin
  hinstDLL := LoadLibrary('KeyHook.dll');
  hkprcKeyboard := GetProcAddress(hinstDLL, 'KeyboardProc');
  SetWindowsHookEx(WH_KEYBOARD, hkprcKeyboard, hinstDLL, 0);
end;
end.
Данный пример простейший и не учитывает того, что при завершении работы ловушку необходимо снимать. При работе он пикает при каждом нажатии клавиши и сбрасывает в текстовый файл параметры вызова. Пример рабочий, я использовал его для определения кодов клавиш при написании драйвера для мультимедийной клавиатуры Genius (родной кстати тоже писан на Delphi, но кривой до безобразия - то сам повиснет, но компьютер повесит).
Перехватчики событий

В предыдущей статье была рассмотрена обработка событий Qt в обработчике события OnEvent Kylix класса TApplication. В этой статье будет показан другой метод обработки событий Qt - использование перехватчиков событий (event hooks). Перехватчики событий подобны обработчику события OnEvent, с той разницей, что перехватчики событий позволяют подойти к обработке событий более дифференцировано. Перехватчики назначаются для отдельных объектов Qt, причем каждому объекту может быть назначено несколько перехватчиков для обработки разных типов событий.

Перехватчик может быть процедурой или функцией, являющейся методом объекта Object Pascal и использующей формат вызова cdecl. Для того, чтобы назначить перехватчик какому-либо экземпляру класса Qt, необходимо создать экземпляр класса перехватчика для данного объекта Qt и связать его с методом-обработчиком. Функции, позволяющие сделать это, как и другие функции CLXDisplay API, декларируются в модуле Qt (файл Qt.pas).

В предыдущей статье было писано демонстрационное приложение, позволяющее перемещать фрагменты текста методом Drag and Drop. Теперь мы перепишем это приложение, используя перехватчики событий. Перехватчик назначается компоненту TLabel в конструкторе главной формы. Ниже приводятся декларация класса и исходный текст конструктора.
TForm1 = class(TForm)
  Label1: TLabel;
  procedure FormClose(Sender: TObject; var Action: TCloseAction);
  procedure FormCreate(Sender: TObject);
  procedure Label1MouseMove(Sender: TObject; Shift: TShiftState; X,
    Y: Integer);
private
  { Private declarations }
public
  { Public declarations }
  DropHook: QEvent_hookH;
  function EventHandler(Handle: QObjectH; e: QEventH): Boolean; cdecl;
end;
...

procedure TForm1.FormCreate(Sender: TObject);
var
  M: TMethod;
begin
  DropHook := QEvent_hook_create(Label1.Handle);
  EventFunc(M) := EventHandler;
  Qt_hook_hook_events(DropHook, M);
end;

DropHook - переменная типа QEvent_hookH, ссылка на объект-перехватчик событий. Не путайте этот объект с объектом, события которого перехватываются. В CLXDisplay API определено несколько объектов перехватчиков различных типов, и для создания каждого из них используется специальная функция. В данном примере мы создаем наиболее общий объект-перехватчик, перехватывающий события разных типов. Функция QEvent_hook_create создает экземпляр такого объекта и связывает его с экземпляром класса, события которого необходимо обрабатывать (в нашем случае - экземпляр QLabel).

Далее мы присваиваем переменной M указатель на метод перехватчик EventHandler. Обратите внимание на преобразование типов. Для того, чтобы выполнить преобразование корректно, необходимо определить тип-функцию
EventFunc = function(Handle: QObjectH; e: QEventH): Boolean of object; cdecl;

декларация которой в точности соответствует декларации метода-перехватчика.

Связывание метода перехватчика с объектом-перехватчиком выполняется функцией Qt_hook_hook_events. Первый параметр функции - указатель на объект-перехватчик, второй параметр - указатель на метод. Учтите, что для каждой пары "объект-перехватчик / тип перехватываемых событий" в модуле Qt определена своя функция, связывающая объекты и методы перехватчики.

Сам метод перехватчик похож на метод обработки событий из предыдущего примера. Ссылка на объект события передается в переменной e, а значение, указывающее на то, следует ли вызывать обработчик события, назначенный объекту по умолчанию, возвращается в качестве результата функции. Обратите внимание на то, что в новом примере мы не проверяем, с каким Qt объектом связано обрабатываемое событие. В этом нет необходимости, так как метод перехватчик связан лишь с одним экземпляром Qt класса. Однако мы могли бы связать этот метод с несколькими объектами, и тогда параметр Handle позволил бы нам определить, каким Qt объектом вызван перехватчик.

Уничтожение объекта-перехватчика выполняется в деструкторе формы. Для этого служит функция QEvent_hook_destroy.

Исходный текст демонстрационного приложения находится здесь. Как и пример из предыдущей статьи, это приложение может быть скомпилировано и в Kylix (для Linux), и в Delphi 6 (для Windows). Для того, чтобы это приложение выполнялось корректно, Вам возможно придется исправить ошибку в модуле Qt (см. предыдущую статью).

Еще один пример использования перехватчиков - приложение, отслеживающее состояние буфера обмена Qt. Это приложение отображает информацию о mime-типах данных, скопированных в буфер обмена. Кроме того, если в буфере обмена присутствуют данные в текстовом формате, приложение отображает и сами данные. Информация обновляется при изменении содержимого буфера обмена. Для того, чтобы контролировать состояние буфера обмена, мы создаем объект-перехватчик QClipboard_hook и связываем его с методом перехватчиком, имеющим тип QClipboard_dataChanged_Event. Этот метод вызывается всякий раз при изменении содержимого буфера обмена. Ниже приводится исходный текст метода перехватчика.
procedure TForm1.ClipboardDataChanged;
var
  QMS: QMimeSourceH;
  S: WideString;
  S1: string;
  i: Integer;
begin
  QMS := QClipboard_data(CB);
  Memo1.Lines.Clear;
  (* enumerating clipboard data formats *)
  i := 0;
  S1 := QMimeSource_format(QMS, i);
  while S1 <> '' do
  begin
    Memo1.Lines.Add(S1);
    Inc(i);
    S1 := QMimeSource_format(QMS, i);
  end;
  Label3.Caption := '';
  (* if text data is available, we retrieve it *)
  if QTextDrag_canDecode(QMS) then
  begin
    QTextDrag_Decode(QMS, @S);
    Label3.Caption := S;
  end;
end;

Переменная CB указывает на объект буфера обмена. При помощи функции QClipboard_data мы получаем ссылку на объект QMimeSourceH, являющийся контейнером данных, содержащихся в буфере обмена. Этот объект позволяет также получить информацию о типах данных, для чего используется функция QMimeSource_format. Эта функция возвращает строку с именем типа данных. Первый параметр функции - указатель на объект-контейнер, второй параметр - номер типа данных. Типы нумеруются с нуля. Если значение этого параметра превышает номер последнего типа, возвращается пустая строка. В нашем примере мы добавляем строки с именами типов в объект Memo1. Далее с помощью функции QTextDrag_canDecode мы проверяем, содержит ли объект-контейнер данные в текстовом формате и если содержит, извлекаем эти данные при помощи функции QTextDrag_Decode.

Полный исходный текст демонстрационного приложения находится здесь. Отслеживание содержимого буфера обмена работает корректно только для приложений, использующих Qt буфер. С учетом этих ограничений демонстрационное приложение работает и в Windows (будучи скомпилировано в Delphi 6). Для демонстрации его работы Вы можете воспользоваться либо Qt приложениями (в Linux) либо примерами использования CLXDisplay API, поставляемыми с Delphi 6 (в Windows).

В демонстрационном приложении содержится также другой пример использования перехватчиков, в котором с одним объектом-перехватчиком связываются два метода перехватчика. Метод ButtonPressed вызывается в момент, когда кнопка Button1 нажата, метод ButtonReleased в момент, когда кнопка отпущена.
Операционная система Windows - многозадачная, т.е. несколько программ в ней могут функционировать одновременно. Когда, например, мы щёлкаем по кнопке в окне нашей программы, система Windows определяет, что произошло событие именно в нашей программе, и посылает ей сообщение об этом. Наша программа должна соответствующим образом отреагировать на него. Для этого мы, как программисты, должны написать код-обработчик этого события. Таким образом, структура программы для Windows представляет собой набор подпрограмм, каждая из которых ответственна за обработку конкретного события и вызывается только при его возникновении. Удобство Delphi состоит в том, что мы избавлены от необходимости получать сообщения от Windows сами, Delphi это делает за нас. Каждый компонент имеет впечатляющий набор событий, на которые он может реагировать. Программист сам определяет, какие события в программе требуется обрабатывать.

   Откройте наш проект из предыдущего урока. Щелкните на компоненте Edit1. Он "появится" в Инспекторе объектов. Посмотрите: в Инспекторе объектов две вкладки: Properties (свойства) и Events (события). Перейдите на вкладку Events. Чтобы создать обработчик нужного события, нужно дважды кликнуть по нему мышкой. А если раскрыть выпадающий список, в нём будут находиться уже готовые обработчики, которые могут подходить для этого компонента. Таким образом, один обработчик может вызываться для обработки событий нескольких компонентов.

    Изменим нашу программу так, чтобы текст на форме появлялся прямо в момент его ввода. В момент ввода у Edit1 меняется свойство Text - в нём появляется новая буква! Значит, воспользуемся событием onChange (change - изменение (англ.)), которое и происходит в этот момент. Итак:  Кликаем дважды по onChange, и оказываемся внутри только что созданного обработчика.
Присваиваем свойству Caption компонента Label1 значение свойства Text компонента Edit1, то есть делаем то же, что и в прошлом уроке:

    Label1.Caption := Edit1.Text;

Или просто копируем из обработчика нажатия кнопки.
Запускаем программу, всё работает. Как видим, всё очень просто.

    Теперь рассмотрим событие onClick. Как вы догадываетесь, это событие возникает при щелчке мышкой на компоненте. Воспользуемся им, чтобы очищать строку ввода от уже введённых символов. Вы сами уже должны сообразить, что сделать. В обработчике нужно присвоить свойству Text значение пустой строки. Строка в Delphi образуется заключением текста в одинарные кавычки (находятся на кнопке Э):
    'Так в Delphi образуется строка'
Значит, пустая строка - это кавычки без текста: ''. Не должно быть даже пробела, иначе он окажется в строке ввода:

    Edit1.Text:='';

Есть другой способ, воспользоваться специально предназначенным для этого методом компонента Edit, который так и называется Clear (очистка англ.):

    Edit1.Clear;

    Но подумайте о пользователе, который будет работать с вашей программой. Ему должно быть удобно. Если при вводе текста он захочет что-то исправить, и щёлкнет мышкой в том месте текста, где нужно внести изменение?! И всё сотрётся! Поэтому лучше использовать событие onEnter, которое происходит, когда вы "входите" в него и компонент получает фокус ввода, или использовать для очистки специальную кнопку и её событие onClick.
    Конечно, у каждого компонента свой набор событий. Мы познакомились с тремя из них:onChange
onClick
onEnter

    Другие важные события, которые есть почти у каждого визуального компонента: onExit - возникает, когда компонент теряет фокус ввода;
onDblClick - возникает при двойном щелчке мышкой по компоненту;
onKeyDown - когда при нажатии на кнопку на клавиатуре она оказалась в нижнем положении;
onKeyUp - когда при отпускании клавиатурной кнопки она оказалась в верхнем положении;
onKeyPress - возникает при нажатии на клавиатурную кнопку. От событий onKeyDown и onKeyUp оно отличается типом используемого параметра Key ;
onMouseDown - когда при нажатии кнопки мышки она оказалась в нижнем положении;
onMouseUp - когда при отпускании кнопки мышки она оказалась в верхнем положении;
onMouseMove - возникает при перемещении указателя мышки над компонентом.
    В начале работы любой программы происходит очень важное событие событие нашего основного компонента - Формы, onCreate. Оно происходит перед появлением Формы на экране. Это событие используется для задания свойств тех элементов программы, которые нуждаются в настройке, например, размеры и положение Формы на экране. Если вы захотите сделать невидимую программу, можно приравнять нулю ширину Width и высоту Height Формы. На этапе проектирования сделать этого нельзя, т.к. это помешает работе, поэтому делаем это по событию onCreate:

    Form1.Width := 0;
    Form1.Height := 0;

Дополнительно нужно убрать и заголовок Формы, выбрав в Инспекторе Объектов параметр BorderStyle равным None. Теперь Форма на экране не появится. Единственным визуальным признаком останется появление её "значка" на панели задач. В дальнейшем я расскажу, как избавиться и от него.