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

Nach oben zu Ihre erste Anwendung mit RAD Studio - 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ü.

Mit der Programmierung beginnen

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. Wechseln Sie in den Quelltext-Editor, indem Sie in der Statusleiste das Register Code neben dem Register Designauswählen. Um zwischen dem Formular-Designer und dem Quelltext-Editor zu wechseln, drücken Sie die Taste F12.

Delphi: Definieren Sie im Bereich interface des Abschnitts "private" der Klasse TTextEditorForm eine String-Variable namens CurrentFile (siehe die folgende Abbildung).

Abbildung 3-18. Definieren der private Variable CurrentFile (Delphi)

C++: Zeigen Sie mithilfe des Registers unten im Quelltext-Editor-Fenster die Datei TextEditor.h an. Deklarieren Sie die Variable currentFile im private-Abschnitt von TTextEditorForm (siehe die folgende Abbildung).

Abbildung 3-19. Definieren der private Variable currentFile (C++Builder)

Erstellen einer Ereignisbehandlungsroutine für den Befehl "New"

Nun können Sie mit der Definition der Reaktionen auf die Auswahl der Menüeinträge beginnen. Klicken Sie im Formular-Designer in der Menüleiste Ihres Texteditorformulars auf Datei > New. Wählen Sie dann im Objektinspektor das Register Ereignisse, wie in der folgenden Abbildung gezeigt, aus. Klicken Sie auf das Pluszeichen (+), um die Liste Action einzublenden.

Abbildung 3-20. Öffnen der Registerkarte "Ereignisse" im Objektinspektor

Doppelklicken Sie auf das Eingabefeld neben dem Ereignis OnExecute. Der Quelltext-Editor wird geöffnet und zeigt für Delphi bzw. C++Builder das folgende Funktions-Skeleton an.

Abbildung 3-21. Automatische Erzeugung des Code-Skeleton für das Ereignis OnExecute (Delphi)

Abbildung 3-22. Automatische Erzeugung des Code-Skeleton für das Ereignis OnExecute (C++Builder)

Schreiben Sie nun in das zuvor erzeugte Code-Skeleton den folgenden Quellcode, der ausgeführt wird, wenn der Benutzer Datei > New wählt:

 // Ereignisbehandlungsroutine für den Delphi-Menüeintrag New 
 procedure TTextEditorForm.NewExecute(Sender: TObject); 
 var 
   UserResponse : Integer; 
 begin
   // Eigenschaft "Anzahl der Zeilen" des TMemo-Feldes überprüfen
   if TextMemo.Lines.Count > 0 then 
   begin 
     UserResponse := MessageDlg( 
       'This will clear the current document. ' + 'Do you want to continue?' , 
       mtInformation, 
       mbYesNo, 0); 
 
     if UserResponse = mrYes then 
     begin 
       TextMemo.Clear; 
       CurrentFile := ''; 
     end; 
   end; 
 end;

 // Ereignisbehandlungsroutine für den C++-Menüeintrag New
 void __fastcall TTextEditorForm::NewExecute(TObject *Sender)
 {
   // Eigenschaft "Anzahl der Zeilen" des TMemo-Feldes überprüfen
   if (TextMemo->Lines->Count > 0)
   {
     int userResponse = MessageDlg(
     String("This will clear the current document. ")
     + "Do you want to continue?", mtInformation,
     TMsgDlgButtons() << mbYes << mbNo, 0);
 
     if (userResponse == mrYes) {
       TextMemo->Clear();
       currentFile = "";
     }
   }
 }

Erstellen der Ereignisbehandlungsroutinen für den Befehl "Open"

Wechseln Sie zurück auf die Registerkarte Design. Führen Sie ähnliche Schritte wie für das Erstellen der Ereignisbehandlungsroutine für den Menüeintrag New aus. Klicken Sie in der Menüleiste Ihres Texteditorformulars auf Datei > Open. Wählen Sie im Objektinspektor das Register Ereignisse aus, und klicken Sie auf das Pluszeichen (+), um die Liste Action einzublenden. Doppelklicken Sie auf das Ereignis OnAccept, und schreiben Sie den folgenden Code in das erzeugte Skeleton.

 // Delphi
 procedure TTextEditorForm.FileOpen1Accept(Sender: TObject); 
 var 
   FileName: String; 
 begin
   // Dateinamen aus der Komponente TFileOpen ermitteln
   FileName := FileOpen1.Dialog.FileName; 
   if FileExists(FileName) then 
   begin 
     TextMemo.Lines.LoadFromFile(FileName); 
     CurrentFile := FileName; 
     Self.Caption := 'Text Editor - ' + ExtractFileName(FileName); 
   end; 
 end;

 // C++
 void __fastcall TTextEditorForm::FileOpen1Accept(TObject *Sender) 
 {
   // Dateinamen aus der Komponente TFileOpen ermitteln
   String fileName = FileOpen1->Dialog->FileName; 
   if (FileExists(fileName)) { 
     TextMemo->Lines->LoadFromFile(fileName); 
     currentFile = fileName; 
     this->Caption = "Text Editor - " + ExtractFileName(fileName); 
   }
 }

Erstellen der Ereignisbehandlungsroutinen für den Befehl "Save As"

Wechseln Sie zum Formular, und doppelklicken Sie auf das Ereignis OnAccept von Datei > Save As, und schreiben Sie in das erzeugte Skeleton den folgenden Code.

 // Delphi
 procedure TTextEditorForm.FileSaveAs1Accept(Sender: TObject); 
 var 
   FileName: String; 
   UserResponse : Integer; 
 begin 
   // Dateinamen aus der Komponente TFileSaveAs ermitteln
   FileName := FileSaveAs1.Dialog.FileName; 
 
   if FileExists(FileName) then 
   begin 
     UserResponse := MessageDlg( 
       'File already exists. ' + 
       'Do you want to overwrite?' , mtInformation, 
       mbYesNo, 0); 
     if UserResponse = mrNo then 
       Exit(); 
   end; 
 
   TextMemo.Lines.SaveToFile(FileName); 
   CurrentFile := FileName; 
   Self.Caption := ExtractFileName(FileName); 
 end;

 // C++
 void __fastcall TTextEditorForm::FileSaveAs1Accept(TObject *Sender) 
 {
   // Dateinamen aus der Komponente TFileSaveAs ermitteln
   String fileName = FileSaveAs1->Dialog->FileName; 
 
   if (FileExists(fileName)) { 
     int userResponse = MessageDlg( 
       String( "File already exists. " ) + 
       "Do you want to overwrite?" , mtInformation, 
       TMsgDlgButtons() << mbYes << mbNo, 0); 
     if (userResponse == mrNo) { 
       return; 
     }
   }
 
   TextMemo->Lines->SaveToFile(fileName); 
   currentFile = fileName; 
   this->Caption = ExtractFileName(fileName); 
 }

Erstellen der Ereignisbehandlungsroutinen für den Befehl "Save"

Doppelklicken Sie auf das Ereignis OnExecute von Datei > Save, und schreiben Sie den folgenden Code in das erzeugte Skeleton.

 // Delphi
 procedure TTextEditorForm.SaveExecute(Sender: TObject); 
 begin 
   if CurrentFile = '' then 
     Self.FileSaveAs1.Execute() 
   else 
     TextMemo.Lines.SaveToFile(CurrentFile); 
 end;

 // C++
 void __fastcall TTextEditorForm::SaveExecute(TObject *Sender) 
 {
   if (currentFile == "") { 
   this->FileSaveAs1->Execute(); 
   }
   else { 
   TextMemo->Lines->SaveToFile(currentFile); 
   }
 }

Erstellen der Ereignisbehandlungsroutinen für den Befehl "Font"

Doppelklicken Sie auf das Ereignis OnAccept von Format > Font, und schreiben Sie den folgenden Code in das erzeugte Skeleton.

 // Delphi
 procedure TTextEditorForm.FontEdit1Accept(Sender: TObject); 
 begin
   // Eigenschaft Font des TMemo-Feldes setzen
   TextMemo.Font := FontEdit1.Dialog.Font; 
 end;

 // C++
 void __fastcall TTextEditorForm::FontEdit1Accept(TObject *Sender) 
 {
   // Eigenschaft Font des TMemo-Feldes setzen
   TextMemo->Font = FontEdit1->Dialog->Font; 
 }

Erstellen der Ereignisbehandlungsroutinen für den Befehl "Word Wrap"

Doppelklicken Sie nun auf das Ereignis OnExecute von Format > Word Wrap, und schreiben Sie den folgenden Code in das erzeugte Skeleton.

 // Delphi
 procedure TTextEditorForm.WordWrapExecute(Sender: TObject); 
 begin 
   { Status des Zeilenumbruchs umschalten. } 
   TextMemo.WordWrap := not TextMemo.WordWrap; 
   WordWrap.Checked := TextMemo.WordWrap; 
   if TextMemo.WordWrap = True then 
     { Wenn der Zeilenumbruch aktiviert ist, dann ist nur die vertikale Bildlaufleiste erforderlich. } 
     TextMemo.ScrollBars := ssVertical 
     else 
       TextMemo.ScrollBars := ssBoth; 
 end;

 // C++
 void __fastcall TTextEditorForm::WordWrapExecute(TObject *Sender) 
 {
   // Status des Zeilenumbruchs umschalten.
   TextMemo->WordWrap = !TextMemo->WordWrap; 
   WordWrap->Checked = TextMemo->WordWrap; 
   if (TextMemo->WordWrap == True) { 
     // Wenn der Zeilenumbruch aktiviert ist, dann ist nur die vertikale Bildlaufleiste erforderlich.
     TextMemo->ScrollBars = ssVertical; 
   }
   else { 
    TextMemo->ScrollBars = ssBoth; 
   }
 }

Erstellen der Ereignisbehandlungsroutinen für die Statusleiste

In der Statusleiste soll die aktuelle Cursorposition und die Anzahl der Zeilen in der geöffneten Textdatei angezeigt werden. Doppelklicken Sie auf das Ereignis OnMouseDown der TextMemo-Komponente, und schreiben Sie den folgenden Code für Delphi bzw. C++ in das erzeugte Code-Skeleton. Mit der Eigenschaft CaretPos werden die Koordinaten des Cursors in dem Textmemofeld ermittelt.

 // Delphi
 procedure TTextEditorForm.TextMemoMouseDown(Sender: TObject; 
   Button: TMouseButton; Shift: TShiftState; X, Y: Integer); 
 begin 
   TextStatus.Panels.Items[ 0].Text := 
     'L: ' + IntToStr(TextMemo.CaretPos.Y + 1); 
   TextStatus.Panels.Items[ 1].Text := 
     'C: ' + IntToStr(TextMemo.CaretPos.X + 1); 
   TextStatus.Panels.Items[ 2].Text := 
     'Lines: ' + IntToStr(TextMemo.Lines.Count); 
 end;

 // C++
 void __fastcall TTextEditorForm::TextMemoMouseDown(TObject *Sender, 
   TMouseButton Button, TShiftState Shift, int X, int Y) 
 {
   TextStatus->Panels->Items[ 0]->Text = 
     "L: " + String (TextMemo->CaretPos.y + 1); 
   TextStatus->Panels->Items[ 1]->Text = 
     "C: " + String (TextMemo->CaretPos.x + 1); 
   TextStatus->Panels->Items[ 2]->Text = 
     "Lines: " + IntToStr (TextMemo->Lines->Count); 
 }

Doppelklicken Sie schließlich auf das Ereignis OnKeyDown von TextMemo, und schreiben Sie den folgenden Code in das erzeugte Code-Skeleton. Das Ereignis OnKeyDown wird ausgelöst, wenn in dem Textmemofeld eine Taste gedrückt wird.

 // Delphi
 procedure TTextEditorForm.TextMemoKeyDown(Sender: TObject; 
   var Key: Word; Shift: TShiftState); 
 begin
   // Dieselbe Aktion wie bei einem Mausklick in TMemo ausführen
   TextMemoMouseDown(Sender, mbLeft, Shift, 0, 0); 
 end;

 // C++
 void __fastcall TTextEditorForm::TextMemoKeyDown(TObject *Sender, 
   WORD &Key, TShiftState Shift) 
 {
   // Dieselbe Aktion wie bei einem Mausklick in TMemo ausführen
   TextMemoMouseDown(Sender, mbLeft, Shift, 0, 0); 
 }

Weiter

Compilieren und Ausführen der Anwendung