Как использовать событие OnKeyDown в TForm для обработки нажатий клавиш в Delphi

Delphi , ОС и Железо , Клавиши

В этой статье мы рассмотрим, как перехватывать нажатия клавиш во время работы с формой в Delphi и Lazarus/Free Pascal, используя событие OnKeyDown. Этот механизм позволяет реагировать на нажатия клавиш, например, для прерывания длительных операций, как в примере с отправкой файла по последовательному порту.

Проблема:

Предположим, у вас есть длительная операция, например, отправка файла по последовательному порту, и вы хотите дать пользователю возможность прервать эту операцию нажатием клавиши, например, Escape. Как это реализовать?

Решение 1: Использование события OnKeyDown формы

Этот подход, предложенный в исходном обсуждении, является достаточно простым и эффективным. Он состоит из следующих шагов:

1. Включение свойства KeyPreview формы: Установите свойство KeyPreview формы в True. Это необходимо для того, чтобы форма получала события клавиатуры до того, как они будут обработаны другими компонентами на форме.

2. Создание обработчика события OnKeyDown: Создайте обработчик события OnKeyDown для вашей формы. Этот обработчик будет вызван при каждом нажатии клавиши, когда форма находится в фокусе.

3. Установка флага прерывания в обработчике OnKeyDown: В обработчике OnKeyDown проверяйте, какая клавиша была нажата. Если это клавиша Escape (или любая другая, которую вы хотите использовать для прерывания), установите флаг прерывания в True.

4. Проверка флага прерывания в основном цикле: В основном цикле вашей длительной операции регулярно проверяйте значение флага прерывания. Если флаг установлен в True, прервите операцию.

Пример кода:

unit MainForm;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, LCLType; // Добавлено LCLType для констант клавиш

type
  TFormMain = class(TForm)
    ButtonStart: TButton;
    MemoOutput: TMemo;
    procedure ButtonStartClick(Sender: TObject);
    procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
  private
    FAborted: Boolean;
  public
    { Public declarations }
  end;

var
  FormMain: TFormMain;

implementation

{$R *.dfm}

procedure TFormMain.ButtonStartClick(Sender: TObject);
var
  i: Integer;
begin
  FAborted := False;
  MemoOutput.Clear;
  MemoOutput.Lines.Add('Начало длительной операции...');
  for i := 1 to 100 do
  begin
    MemoOutput.Lines.Add('Шаг ' + IntToStr(i));
    Sleep(50); // Имитация длительной операции
    Application.ProcessMessages; // Важно для обработки событий!
    if FAborted then
    begin
      MemoOutput.Lines.Add('Операция прервана пользователем!');
      Break;
    end;
  end;
  if not FAborted then
    MemoOutput.Lines.Add('Операция завершена.');
end;

procedure TFormMain.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
  if Key = VK_ESCAPE then
  begin
    FAborted := True;
    MemoOutput.Lines.Add('Нажата клавиша Escape!');
  end;
end;

end.

Пояснения к коду:

• FAborted: Boolean;: Это приватная переменная класса формы, которая служит флагом прерывания.
• KeyPreview := True;: Установите это свойство в инспекторе объектов для формы.
• FormKeyDown: Обработчик события OnKeyDown. Он проверяет, была ли нажата клавиша Escape (VK_ESCAPE). Если да, то устанавливает FAborted в True.
• ButtonStartClick: Обработчик события OnClick для кнопки. Он запускает "длительную операцию". Внутри цикла проверяется значение FAborted. Если оно True, цикл прерывается.
• Application.ProcessMessages: Критически важная строка! Она позволяет приложению обрабатывать события (включая нажатия клавиш) во время длительной операции. Без нее приложение "зависнет" и не будет реагировать на нажатия клавиш.

Решение 2: Использование GetKeyState (альтернатива)

Вместо использования события OnKeyDown, можно периодически проверять состояние клавиши Escape с помощью функции GetKeyState. Этот подход может быть полезен, если вам нужно проверять состояние клавиши не только в момент ее нажатия, но и во время удержания.

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

procedure TFormMain.ButtonStartClick(Sender: TObject);
var
  i: Integer;
begin
  MemoOutput.Clear;
  MemoOutput.Lines.Add('Начало длительной операции...');
  for i := 1 to 100 do
  begin
    MemoOutput.Lines.Add('Шаг ' + IntToStr(i));
    Sleep(50); // Имитация длительной операции
    Application.ProcessMessages;
    if GetKeyState(VK_ESCAPE) < 0 then // Проверяем, нажата ли клавиша Escape
    begin
      MemoOutput.Lines.Add('Операция прервана пользователем (GetKeyState)!');
      Break;
    end;
  end;
  MemoOutput.Lines.Add('Операция завершена.');
end;

Пояснения к коду:

• GetKeyState(VK_ESCAPE) < 0: Функция GetKeyState возвращает состояние указанной клавиши. Если возвращаемое значение меньше 0, это означает, что клавиша нажата.

Сравнение решений:

Важные замечания:

• Application.ProcessMessages: Как уже упоминалось, эта строка крайне важна для обработки событий во время длительных операций. Без нее ваше приложение "зависнет".
• Sleep: Использование Sleep в основном потоке приложения не рекомендуется, так как это блокирует пользовательский интерфейс. Для более сложных задач лучше использовать многопоточность.
• TLazSerial: Если вы работаете с последовательным портом, убедитесь, что компонент TLazSerial не блокирует основной поток приложения. В противном случае, даже с использованием Application.ProcessMessages, пользовательский интерфейс может быть не отзывчивым. Рассмотрите возможность использования асинхронной работы с портом.

Альтернативное решение (многопоточность):

Наиболее правильным решением для длительных операций является использование многопоточности. В этом случае, отправка файла по последовательному порту будет выполняться в отдельном потоке, не блокируя основной поток приложения. Это позволит пользовательскому интерфейсу оставаться отзывчивым, и пользователь сможет прервать операцию в любой момент.

Пример (упрощенный):

uses
  ..., Classes, Threads;

type
  TSerialThread = class(TThread)
  private
    FAbort: Boolean;
    FFileName: string;
  protected
    procedure Execute; override;
  public
    constructor Create(const AFileName: string);
    procedure Abort;
    property Aborted: Boolean read FAbort;
  end;

constructor TSerialThread.Create(const AFileName: string);
begin
  inherited Create(True); // Создаем поток в приостановленном состоянии
  FFileName := AFileName;
  FAbort := False;
  FreeOnTerminate := True; // Освобождаем поток после завершения
  Resume; // Запускаем поток
end;

procedure TSerialThread.Abort;
begin
  FAbort := True;
end;

procedure TSerialThread.Execute;
var
  i: Integer;
  ltext: string;
  VSPort: TLazSerial;
  VMTerminal: TMemo; // Нужно передавать ссылку на Memo
begin
  VSPort := TLazSerial.Create(nil); // Создавать компонент в потоке
  try
    // Настройка VSPort (скорость, порт и т.д.)
    VSPort.Port := 'COM1'; // Пример
    VSPort.BaudRate := 9600; // Пример
    VSPort.Active := True;

    VMTerminal := TMemo.Create(nil); //Создаем Memo в потоке
    try
      VMTerminal.Lines.LoadFromFile(FFileName);
      for i := 0 to VMTerminal.Lines.Count - 1 do
      begin
        if FAbort then Break;
        ltext := VMTerminal.Lines[i];
        VSPort.WriteData(ltext + LineEnding);
        Sleep(100); // Не блокирует UI, т.к. в другом потоке
      end;
    finally
      VMTerminal.Free;
    end;

  finally
    VSPort.Free;
  end;
end;

procedure TFormMain.ButtonStartClick(Sender: TObject);
begin
  FSerialThread := TSerialThread.Create('myfile.txt');
end;

procedure TFormMain.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  if Assigned(FSerialThread) then
  begin
    FSerialThread.Abort;
    while not FSerialThread.Finished do
      Application.ProcessMessages; // Ждем завершения потока
    FSerialThread.Free;
  end;
end;

procedure TFormMain.ButtonAbortClick(Sender: TObject);
begin
  if Assigned(FSerialThread) then
    FSerialThread.Abort;
end;

private
  FSerialThread: TSerialThread;

В этом примере:

• TSerialThread - класс потока, который выполняет отправку файла.
• FAbort - флаг прерывания в потоке.
• ButtonAbortClick - обработчик нажатия кнопки "Прервать", который устанавливает флаг FAbort в True.
• FormClose - обработчик закрытия формы, который корректно завершает поток перед закрытием приложения.

Заключение:

В этой статье мы рассмотрели несколько способов обработки нажатий клавиш для прерывания длительных операций в Delphi и Lazarus/Free Pascal. Выбор конкретного решения зависит от сложности задачи и требований к отзывчивости пользовательского интерфейса. Для простых случаев достаточно использования события OnKeyDown формы. Для более сложных задач рекомендуется использовать многопоточность. Всегда помните о необходимости обработки событий с помощью Application.ProcessMessages и избегайте блокировки основного потока приложения.

Создано по материалам из источника по ссылке.

В статье описывается, как использовать событие OnKeyDown в TForm в Delphi/Lazarus для перехвата нажатий клавиш, чтобы, например, прервать длительную операцию.

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: Клавиши ::