Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor (IDE-Tutorial)

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Ihre erste Anwendung mit Appmethod - Index (IDE-Tutorial)


Mithilfe der Anleitungen in diesem Abschnitt gestalten Sie Ihre Anwendung interaktiv und fügen die gewünschte Funktionalität hinzu. In diesem Abschnitt werden die Ereignisbehandlungsroutinen programmiert, d. h. die Reaktionen auf die Auswahl der verschiedenen Einträge im Hauptmenü und auf andere Arten von Benutzerinteraktionen.

Beginnen der Programmierung

Fangen Sie mit der Definition einer String-Variable an, die während der Ausführung der Anwendung den Namen der aktuell geöffneten Textdatei aufnimmt.

Klicken Sie auf das Register Code in der Statusleiste, um der Quelltext-Editor zu öffnen. Mit dem Quelltext-Editor können Sie im Abschnitt "private" der Klasse TTextEditorForm eine String-Variable namens CurrentFile und zwar im interface-Teil definieren:

TutorialIDENewFig3-18kh2.PNG
Definieren der "private" Variable CurrentFile

Um zwischen dem Formular-Designer und dem Quelltext-Editor zu wechseln, drücken Sie die Taste F12.

Aktualisieren der Statusleiste als Reaktion auf Aktionen im Texteditor

Wenn der Benutzer den Textcursor bewegt oder den Inhalt der TMemo-Komponente ändert, müssen Sie die Statusleiste aktualisieren. Da die Statusleiste als Reaktion auf viele verschiedene Ereignisse aktualisiert werden muss, können Sie eine einzige Prozedur im Code definieren und diese Prozedur dann später von jeder Ereignisbehandlungsroutine aus aufrufen, die die Statusleiste aktualisieren muss.

Fügen Sie zum Definieren dieser neuen Prozedur in Ihrer Anwendung die folgende Prozedursignatur dem "private" Abschnitt der Klasse TTextEditorForm hinzu und zwar im interface-Teil direkt unterhalb der Variable CurrentFile, die Sie zuvor definiert haben:

 
 procedure UpdateStatusBar;

Klicken Sie im Code mit der rechten Maustaste auf UpdateStatusBar, und wählen Sie Klasse beim Cursor vervollständigen, damit Appmethod ein Grundgerüst für die Definition der Prozedur hinzufügt und zwar im implementation-Teil des Codes:

 
 procedure TTextEditorForm.UpdateStatusBar;
 begin
 
 end;

Definieren Sie die Logik der Prozedur UpdateStatusBar zwischen den Schlüsselwörtern begin und end wie folgt:

 
 LineNumber.Text := 'L: ' + (Editor.CaretPosition.Line+1).ToString;
 ColumnNumber.Text := 'C: ' + (Editor.CaretPosition.Pos+1).ToString;
 LineCount.Text := 'Lines: ' + Editor.Lines.Count.ToString;

Sie können jetzt UpdateStatusBar aus allen Ereignisbehandlungsroutinen aufrufen, um die Statusleiste zu aktualisieren.

Das erste Mal sollten Sie die in der Statusleiste angezeigten Informationen beim Start Ihrer Anwendung aktualisieren. Dafür können Sie das Ereignis OnCreate des Formulars verwenden:

  1. Klicken Sie auf die Registerkarte Design, um zurück zum Formular-Designer zu wechseln.
  2. Wählen Sie in der Strukturansicht die Formular-Komponente mit dem Namen TextEditorForm aus.
  3. Klicken Sie im Objektinspektor auf die Registerkarte Ereignisse.
  4. Doppelklicken Sie auf der Registerkarte Ereignisse auf das Wertefeld des OnCreate-Ereignisses. Appmethod wechselt zum Quelltext-Editor und fügt ein Grundgerüst für die Definition der neuen Ereignisbehandlungsroutine hinzu. Rufen Sie mit dieser Ereignisbehandlungsroutine die UpdateStatusBar-Prozedur auf:
 
 procedure TTextEditorForm.FormCreate(Sender: TObject);
 begin
   Editor.Lines.Add('');
   UpdateStatusBar;
 end;

Beachten Sie, dass vor dem Aufruf von UpdateStatusBar eine leere Zeile in der TMemo-Komponente eingefügt wird. Dadurch wird der Zeilenzähler des Memofeldes initialisiert, damit der Zeilenzähler in der Statusleiste am Anfang "1" Zeile anstatt "0" Zeilen anzeigt.

Wiederholen Sie die obigen Schritte für die Ereignisse OnKeyUp und OnMouseUp der TMemo-Komponente (Editor):

 
 procedure TTextEditorForm.EditorKeyUp(Sender: TObject; var Key: Word;
   var KeyChar: Char; Shift: TShiftState);
 begin
   UpdateStatusBar;
 end;
 
 procedure TTextEditorForm.EditorMouseUp(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; X, Y: Single);
 begin
   UpdateStatusBar;
 end;

Erstellen von Ereignisbehandlungsroutinen für die Einträge im Menü "File"

Nun können Sie mit der Definition der Reaktionen auf die Auswahl der Menüeinträge beginnen. Wählen Sie bei geöffnetem Formular-Designer in der Strukturansicht den Eintrag NewAction aus:

IDETutorialSelectingNewAction.png

Wählen Sie dann im Objektinspektor die Registerkarte Ereignisse aus, und doppelklicken Sie auf das Eingabefeld neben dem Ereignis OnExecute. Der Quelltext-Editor wird geöffnet, und ein Grundgerüst für die neue Ereignisbehandlungsroutine wird angezeigt. Schreiben Sie in diese Ereignisbehandlungsroutine den Code, der ausgeführt werden soll, wenn der Benutzer File > New auswählt.

 
 procedure TTextEditorForm.NewActionExecute(Sender: TObject);
 var
   UserResponse: Integer;
 begin
   // Ask for confirmation if the memo is not empty.
   if not Editor.Text.IsEmpty then
   begin
     UserResponse := MessageDlg(
       'This will clear the current document. Do you want to continue?',
       TMsgDlgType.mtInformation, mbYesNo, 0);
     if UserResponse = mrYes then
     begin
       Editor.Text := '';
       Editor.Lines.Add(''); // Initialize the memo line count to "1".
       UpdateStatusBar;
       CurrentFile := ''; // New files have no file name until saved.
     end;
   end;
 end;

Klicken Sie auf die Registerkarte Design, um zurück zum Formular-Designer zu gelangen, und wiederholen Sie den Vorgang für die übrigen Aktionen, die von den Einträgen des Menüs "File" verwendet werden: OpenAction, SaveAction, SaveAsAction, ExitAction. Im Folgenden sind die Implementierungen der Ereignisbehandlungsroutinen des OnExecute-Ereignisses jeder dieser Aktionen aufgeführt:

 
 // File > Open
 procedure TTextEditorForm.OpenActionExecute(Sender: TObject);
 var
   FileName: String;
 begin
   if OpenFileDialog.Execute = True then
   begin
     FileName := OpenFileDialog.FileName;
     if FileExists(FileName) then
     begin
       Editor.Lines.LoadFromFile(FileName);
       CurrentFile := FileName;
       Caption := 'Text Editor - ' + ExtractFileName(FileName);
     end;
   end;
 end;
 
 // File > Save
 procedure TTextEditorForm.SaveActionExecute(Sender: TObject);
 begin
   if CurrentFile = '' then
     SaveAsAction.Execute()
   else
     Editor.Lines.SaveToFile(CurrentFile);
 end;
 
 // File > Save As
 procedure TTextEditorForm.SaveAsActionExecute(Sender: TObject);
 var
   FileName: String;
   UserResponse: TModalResult;
 begin
   if SaveFileDialog.Execute = True then
   begin
     FileName := SaveFileDialog.FileName;
     if FileExists(FileName) then
     begin
       UserResponse := MessageDlg(
         'File already exists. Do you want to overwrite?',
         TMsgDlgType.mtInformation, mbYesNo, 0);
       if UserResponse = mrNo then
         Exit;
     end;
     Editor.Lines.SaveToFile(FileName);
     CurrentFile := FileName;
     Caption := 'Text Editor - ' + ExtractFileName(FileName);
   end;
 end;
 
 // File > Exit
 procedure TTextEditorForm.ExitActionExecute(Sender: TObject);
 begin
   Application.Terminate;
 end;

Erstellen von Ereignisbehandlungsroutinen für die Einträge im Menü "Edit" und "Format"

Gehen Sie für die Implementierung der Aktionen für die Einträge in den Menüs "Edit" und "Format" genauso vor wie bei den Aktionen für das Menü "File" vor. Diese Ereignisbehandlungsroutinen sind ziemlich einfach: sie leiten die Aktion nur an das Memofeld weiter, weil die gesamte benötigte Funktionalität bereits in der Klasse TMemo implementiert ist, und sie rufen UpdateStatusBar auf, falls die Aktion Auswirkungen auf die Position des Textcursors oder den Zeilenzähler hat.

 
 // Edit > Cut
 procedure TTextEditorForm.CutActionExecute(Sender: TObject);
 begin
   Editor.CutToClipboard;
   UpdateStatusBar;
 end;
 
 // Edit > Copy
 procedure TTextEditorForm.CopyActionExecute(Sender: TObject);
 begin
   Editor.CopyToClipboard;
 end;
 
 // Edit > Paste
 procedure TTextEditorForm.PasteActionExecute(Sender: TObject);
 begin
   Editor.PasteFromClipboard;
   UpdateStatusBar;
 end;
 
 // Edit > Select All
 procedure TTextEditorForm.SelectAllActionExecute(Sender: TObject);
 begin
   Editor.SelectAll;
   UpdateStatusBar;
 end;
 
 // Edit > Undo
 procedure TTextEditorForm.UndoActionExecute(Sender: TObject);
 begin
   Editor.UnDo;
   UpdateStatusBar;
 end;
 
 // Edit > Delete
 procedure TTextEditorForm.DeleteActionExecute(Sender: TObject);
 begin
   if Editor.SelLength > 0 then
     Editor.DeleteSelection
   else
     Editor.DeleteFrom(Editor.CaretPosition, 1, [TDeleteOption.MoveCaret]);
   UpdateStatusBar;
 end;
 
 // Format > Word Wrap
 procedure TTextEditorForm.WordWrapActionExecute(Sender: TObject);
 begin
   Editor.WordWrap := not Editor.WordWrap;
   WordWrapAction.Checked := Editor.WordWrap;
   UpdateStatusBar;
 end;

Weiter

Compilieren und Ausführen der Anwendung