Codage des réponses aux actions des utilisateurs dans l'éditeur de code (tutoriel de l'EDI)

Remonter à Démarrage de votre première application RAD Studio - Index (tutoriel de l'EDI)

En suivant les instructions de cette section, vous rendrez votre application interactive et lui fournirez les fonctionnalités de votre choix. Vous coderez les gestionnaires d'événements, c'est-à-dire les réponses aux clics sur les divers éléments du menu principal.

Commencement du code

Commencez l'écriture du code en définissant une variable String que vous utiliserez pendant l'exécution de l'application pour stocker le nom du fichier texte ouvert. Assurez-vous que vous êtes en mode Editeur de code en sélectionnant l'onglet Code, auprès de l'onglet Conception dans la barre d'état. Pour permuter entre les modes Concepteur de fiches et Editeur de code, appuyez sur F12.

Dans Delphi, définissez une variable String appelée CurrentFile dans la section private de la classe TTextEditorForm dans la partie interface, comme illustré dans la figure suivante.

Figure 3-18. Définition de la variable private CurrentFile (vue Delphi)

Dans C++, utilisez les onglets situés en bas de la fenêtre Editeur de code pour afficher le fichier TextEditor.h. Déclarez la variable currentFile dans la section private de TTextEditorForm, comme illustré dans la figure suivante.

Figure 3-19. Définition de la variable private currentFile (vue C++Builder)

Création d'un gestionnaire d'événements pour la commande Nouveau

Vous êtes maintenant prêt à définir les réponses aux clics sur les éléments de menu. Dans le Concepteur de fiches, cliquez sur Fichier > Nouveau sur la barre de menus de votre fiche éditeur de texte. Sélectionnez ensuite l'onglet Evénements de l'inspecteur d'objets, comme illustré dans l'image suivante. Cliquez sur le signe plus (+) pour développer la liste Action, si nécessaire.

Figure 3-20. Ouverture de l'onglet Evénements de l'inspecteur d'objets

Double-cliquez sur la zone d'édition relative à l'événement OnExecute. L'éditeur de code s'ouvre et affiche le squelette de fonction suivant, en utilisant respectivement Delphi ou C++Builder.

Figure 3-21. Génération automatique du squelette de code pour l'événement OnExecute (vue Delphi)

Figure 3-22. Génération automatique du squelette de code pour l'événement OnExecute (vue C++Builder)

Ecrivez maintenant le code qui s'exécute quand l'utilisateur sélectionne Fichier > Nouveau dans le squelette de code préalablement généré, comme suit :

 // New menu item event handler Delphi
 procedure TTextEditorForm.NewExecute(Sender: TObject); 
 var 
   UserResponse : Integer; 
 begin
   // Check TMemo number of lines property
   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;

 // New menu item event handler C++
 void __fastcall TTextEditorForm::NewExecute(TObject *Sender)
 {
   // Check TMemo number of lines property
   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 = "";
     }
   }
 }

Création des gestionnaires d'événements pour la commande Ouvrir

Revenez à la fiche sur l'onglet Conception. Effectuez un ensemble d'étapes similaire à la création du gestionnaire pour l'élément de menu Nouveau. Cliquez sur Fichier > Ouvrir sur la barre de menus de votre fiche éditeur de texte. Sélectionnez l'onglet Evénements de l'inspecteur d'objets, et cliquez sur le signe plus (+) pour développer la liste Action, si nécessaire. Double-cliquez sur l'événement OnAccept et écrivez le code affiché ci-dessous.

// Delphi
 procedure TTextEditorForm.FileOpen1Accept(Sender: TObject); 
 var 
   FileName: String; 
 begin
   // Get file name from TFileOpen component
   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) 
 {
   // Get file name from TFileOpen component
   String fileName = FileOpen1->Dialog->FileName; 
   if (FileExists(fileName)) { 
     TextMemo->Lines->LoadFromFile(fileName); 
     currentFile = fileName; 
     this->Caption = "Text Editor - " + ExtractFileName(fileName); 
   }
 }

Création des gestionnaires d'événements pour la commande Enregistrer sous

Revenez à la fiche et double-cliquez sur l'événement OnAccept de Fichier > Enregistrer sous et écrivez le code suivant.

//Delphi
 procedure TTextEditorForm.FileSaveAs1Accept(Sender: TObject); 
 var 
   FileName: String; 
   UserResponse : Integer; 
 begin 
   // Get file name from TFileSaveAs component
   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) 
 {
   // Get file name from TFileSaveAs component
   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); 
 }

Création des gestionnaires d'événements pour la commande Enregistrer

Double-cliquez sur l'événement OnExecute de Fichier > Enregistrer et écrivez le code suivant.

//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); 
   }
 }

Création des gestionnaires d'événements pour la commande Police

Double-cliquez sur l'événement OnAccept de Format > Police et écrivez le code suivant.

//Delphi
 procedure TTextEditorForm.FontEdit1Accept(Sender: TObject); 
 begin
   // Set TMemo font property
   TextMemo.Font := FontEdit1.Dialog.Font; 
 end;

//C++
 void __fastcall TTextEditorForm::FontEdit1Accept(TObject *Sender) 
 {
   // Set TMemo font property
   TextMemo->Font = FontEdit1->Dialog->Font; 
 }

Création des gestionnaires d'événements pour la commande Retour automatique à la ligne

Double-cliquez ensuite sur l'événement OnExecute de Format > Retour automatique à la ligne et écrivez le code suivant.

//Delphi
 procedure TTextEditorForm.WordWrapExecute(Sender: TObject); 
 begin 
   { Toggle the word wrapping state. } 
   TextMemo.WordWrap := not TextMemo.WordWrap; 
   WordWrap.Checked := TextMemo.WordWrap; 
   if TextMemo.WordWrap = True then 
     { Only vertical scrollbars are needed when word wrapping is set. } 
     TextMemo.ScrollBars := ssVertical 
     else 
       TextMemo.ScrollBars := ssBoth; 
 end;

//C++
 void __fastcall TTextEditorForm::WordWrapExecute(TObject *Sender) 
 {
   // Toggle the word wrapping state.
   TextMemo->WordWrap = !TextMemo->WordWrap; 
   WordWrap->Checked = TextMemo->WordWrap; 
   if (TextMemo->WordWrap == True) { 
     // Only vertical scrollbars are needed when word wrapping is set.
     TextMemo->ScrollBars = ssVertical; 
   }
   else { 
    TextMemo->ScrollBars = ssBoth; 
   }
 }

Création des gestionnaires d'événements pour la barre d'état

Utilisez la barre d'état pour afficher la position en cours du curseur et le nombre de lignes du fichier texte ouvert. Double-cliquez sur l'événement OnMouseDown du composant TextMemo et écrivez le code suivant, respectivement dans Delphi et C++. La propriété CaretPos est utilisée pour indiquer les coordonnées du curseur à l'intérieur de la zone mémo texte.

//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); 
 }

Finalement, double-cliquez sur l'événement OnKeyDown de TextMemo et écrivez le code ci-dessous. L'événement OnKeyDown est déclenché quand vous appuyez sur une touche à l'intérieur de la zone mémo texte.

//Delphi
 procedure TTextEditorForm.TextMemoKeyDown(Sender: TObject; 
   var Key: Word; Shift: TShiftState); 
 begin
   // Perform same action as for mouse down in TMemo
   TextMemoMouseDown(Sender, mbLeft, Shift, 0, 0); 
 end;

//C++
 void __fastcall TTextEditorForm::TextMemoKeyDown(TObject *Sender, 
   WORD &Key, TShiftState Shift) 
 {
   // Perform same action as for mouse down in TMemo
   TextMemoMouseDown(Sender, mbLeft, Shift, 0, 0); 
 }

Suivant

Compilation et exécution de l'application