Tout d'abord, comme nous allons beaucoup utiliser des chaînes de caractères représentant des noms de dossiers, il serait pratique de disposer d'un type prévu pour. Nous allons le déclarer comme le type TFileName qui, je vous le rappelle, désigne une chaîne de caractères représentant un nom de fichier :

type
  TDirName = type string;

Il faut aussi savoir comment nous comptons utiliser la boîte de dialogue classique de Windows...

L'unité FileCtrl propose une routine SelectDirectory surchargée de deux façons :

function SelectDirectory(var Directory: string;
  Options: TSelectDirOpts; HelpCtx: Longint): Boolean; overload;
function SelectDirectory(const Caption: string; const Root: WideString;
  var Directory: string; Options: TSelectDirExtOpts = [sdNewUI]; Parent: TWinControl = nil): Boolean; overload;

Ces deux surcharges font apparaître la boîte de dialogue avec diverses information.

Nous utiliserons la seconde surcharge, car elle est plus complète.

Définissons maintenant quelques propriétés pour notre composant. Nous aurons besoin des divers renseignements demandés en paramètres par la fonction SelectDirectory.

Nous aurons donc besoin de quatre propriétés :

Nous ajouterons un constructeur pour les initialiser et une méthode Execute qui affichera la boîte de dialogue :

function TSelectDirDialog.Execute : boolean;
begin
  Result := SelectDirectory(FCaption, FRoot, string(FDirectory), FOptions);
end;

Rappelons la déclaration de la fonction SelectDirectory afin de comprendre les différents paramètres passés :

function SelectDirectory(const Caption: string; const Root: WideString;
  var Directory: string; Options: TSelectDirExtOpts = [sdNewUI]; Parent: TWinControl = nil): Boolean; overload;

Rien de tout ceci n'est plus compliqué que la création d'une classe implémentant une certaine fonctionnalité. Nous ne nous attarderons pas là-dessus.

Voici le code actuel :

unit SelDirDlg;

interface

uses
  Classes, FileCtrl;

type
  TDirName = type string;

  TSelectDirDialog = class(TComponent)
  private
    FCaption : string;
    FRoot : TDirName;
    FDirectory : TDirName;
    FOptions : TSelectDirExtOpts;
  public
    constructor Create(AOwner : TComponent); override;

    function Execute : boolean;

    property Caption : string read FCaption write FCaption;
    property Root : TDirName read FRoot write FRoot;
    property Directory : TDirName read FDirectory write FDirectory;
    property Options : TSelectDirExtOpts read FOptions write FOptions;
  end;

implementation

constructor TSelectDirDialog.Create(AOwner : TComponent);
begin
  inherited;
  FCaption := 'Sélectionnez un dossier';
  FRoot := 'C:\';
  FDirectory := 'C:\';
  FOptions := [sdNewUI];
end;

function TSelectDirDialog.Execute : boolean;
begin
  Result := SelectDirectory(FCaption, FRoot, string(FDirectory), FOptions);
end;

end.

En Delphi, il est très simple d'ajouter un événement à vos composants. Voici comment procéder.

Premièrement, vous avez besoin d'un type événementiel. En réalité, ce sont des types méthodes.

Un type méthode est déclaré de cette façon :

type
  TTypeMethode = procedure(Param1 : TType1; Param2 : TType2; ...) of object;

Les deux mots-clés of object signifient qu'il s'agit d'un type méthode et non d'un type routine. N'oublions pas qu'une méthode est une routine de classe.

Dans le cas d'un type événementiel, un type méthode est requis, et donc ces deux mots-clés le sont aussi.

On peut déclarer des variables de ce type de la même manière que n'importe quel autre.

Pour les utiliser dans la partie gauche d'une affectation, il suffit d'utiliser le nom de la variable à gauche et le nom de la fonction dont on veut enregistrer l'adresse à droite (il est également possible d'affecter la valeur nil qui permettra de tester si la variable est assignée ou non) :

var VarMethode : TTypeMethode;
...
VarMethode := nil;
VarMethode := MaMethode;

Pour appeler la méthode associée, il suffit d'utiliser la variable comme s'il s'agissait du nom de la méthode en question :

VarMethode(Param1, Param2, ...);

Si l'on veut tester qu'une méthode a été assignée, on peut utiliser la fonction Assigned qui prend pour unique paramètre la variable méthode et renvoie True si et seulement si elle n'est pas vide (différent de nil).

Finalement, mais cela est moins important et uniquement à titre indicatif, si vous devez comparer deux variables de type méthode pour savoir si elles contiennent la même adresse, vous devrez les transtyper en type TMethod et comparer les champs Code et Data de ce record.

if (TMethod(VarMethode).Code = TMethod(VarMethode2).Code) and  // C'est la même méthode
   (TMethod(VarMethode).Data = TMethod(VarMethode2).Data) then // C'est le même objet
  ...

Nous allons donc ajouter deux événements à notre composant : un qui sera appelé lorsque l'utilisateur aura cliqué sur OK dans la boîte de dialogue, et un autre lorsqu'il aura cliqué sur Annuler.

Le second n'est qu'un événement de notification, donc qui n'a pas besoin de paramètre particulier en dehors du paramètre Sender qui indique le composant appelant l'événement. Nous utiliserons donc pour celui-là le type TNotifyEvent, déclaré comme suit dans l'unité Classes :

type
  TNotifyEvent = procedure(Sender : TObject) of object;

Pour le premier, nous aurons besoin d'un type d'événement spécifique puisqu'il devra envoyer comme paramètre le dossier sélectionné dans la boîte de dialogue. Voici la déclaration de ce dernier :

type
  TAcceptDirEvent = procedure(Sender : TObject; Directory : TDirName) of object;

Voici comment se présente maintenant notre interface :

interface

uses
  Classes, FileCtrl;

type
  TDirName = type string;
  TAcceptDirEvent = procedure(Sender : TObject; Directory : TDirName) of object;

  TSelectDirDialog = class(TComponent)
  private
    FCaption : string;
    FRoot : TDirName;
    FDirectory : TDirName;
    FOptions : TSelectDirExtOpts;

    FOnAccept : TAcceptDirEvent;
    FOnCancel : TNotifyEvent;
  public
    constructor Create(AOwner : TComponent); override;

    function Execute : boolean;
  published
    property Caption : string read FCaption write FCaption;
    property Root : TDirName read FRoot write FRoot;
    property Directory : TDirName read FDirectory write FDirectory;
    property Options : TSelectDirExtOpts read FOptions write FOptions;

    property OnAccept : TAcceptDirEvent read FOnAccept write FOnAccept;
    property OnCancel : TNotifyEvent read FOnCancel write FOnCancel;
  end;

Il ne reste plus qu'à appeler ces événements lorsque le cas se présente. Rappelons qu'il suffit d'utiliser le nom de la variable comme nom de la méthode à appeler.

function TSelectDirDialog.Execute : boolean;
begin
  Result := SelectDirectory(FCaption, FRoot, string(FDirectory), FOptions);
  if Result then
  begin
    if Assigned(FOnAccept) then
      FOnAccept(Self, FDirectory);
  end else
  begin
    if Assigned(FOnCancel) then
      FOnCancel(Self);
  end;
end;

Vous êtes-vous jamais demandé comment Delphi enregistrait tout ce que vous lui indiquiez lorsque vous êtes en mode conception. Il est assez simple de le savoir en cliquant droit sur une fiche en mode conception et sélectionnez le menu Voir comme texte.

Votre fiche disparaîtra alors pour laisser place à sa forme texte. Voici un exemple avec un bouton et un éditeur :

object FormMain: TFormMain
  Left = 0
  Top = 0
  Width = 434
  Height = 320
  Caption = 'Essais'
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'Tahoma'
  Font.Style = []
  OldCreateOrder = False
  OnCreate = FormCreate
  PixelsPerInch = 96
  TextHeight = 13
  object Button1: TButton
    Left = 32
    Top = 32
    Width = 121
    Height = 33
    Caption = 'Button1'
    TabOrder = 0
  end
  object Edit1: TEdit
    Left = 32
    Top = 96
    Width = 361
    Height = 21
    TabOrder = 1
    Text = 'Edit1'
  end
end

Mais qu'y a-t-il donc d'intéressant à découvrir dans ce code ? Eh bien, c'est que toutes les propriétés ne sont pas enregistrées ! Si vous consultez l'inspecteur d'objet pour ces trois types de composants, vous remarquerez qu'il y a beaucoup plus de propriétés que ça.

Ceci s'explique par le fait que Delphi n'enregistre pas les propriétés dont la valeur est celle par défaut. Mais comment sait-il quelle est la valeur par défaut d'une propriété ? C'est ce que nous allons voir.

Dans l'interface d'une classe de composant (et même de persistent, donc descendant de TPersistent), on peut définir les valeurs par défaut d'une propriété au moyen des spécificateurs default ou stored. On peut aussi utiliser le spécificateur nodefault pour supprimer une valeur par défaut héritée. Voici comment utiliser ces spécificateurs.

Pour les propriétés de type scalaire, il suffit d'utiliser le spécificateur default suivi de la valeur par défaut. Voici deux exemples :

// Propriétés scalaires avec valeur par défaut
type
  TMonSet = set of #0..#31;

...

property MonEntier : integer read FMonEntier write FMonEntier default 1;
property MonSet : TMonSet read FMonSet write FMonSet default [#0, #10, #13];

Signalons à cette occasion qu'il est impossible d'utiliser des propriétés publiées de type ensemble dont la taille est plus grande que 4 octets, donc qui contient plus de 32 éléments (d'où la définition TMonSet = set of #0..#31).

Une valeur par défaut ne sert qu'à savoir s'il faut enregistrer la variable ou pas. À la relecture du fichier .dfm, cette valeur par défaut n'est pas utilisée. Vous devez donc prendre garde à bien initialiser la propriété dans le constructeur de l'objet.

Pour les valeurs chaînes, cela se complique un peu. Si la valeur par défaut est une chaîne vide, ne touchez à rien, Delphi utilise cette valeur comme valeur par défaut si rien n'est indiqué.

Si vous voulez utiliser une autre valeur par défaut, vous devrez définir un spécificateur stored. Ce qui suit ce spécificateur est un nom de méthode de la classe en cours qui ne prend aucun paramètre et qui renvoie une valeur de type boolean. Cette valeur doit être True s'il faut enregistrer la valeur et False dans le cas contraire. Voici un exemple :

// Propriétés non scalaires avec valeur par défaut
function MaChaineStored : boolean;
property MaChaine : string read FMaChaine write FMaChaine stored MaChaineStored;

...

function TMonObjet.MaChaineStored : boolean;
begin
  Result := MaChaine <> 'C:\Temp\';
end;

Si vous voulez supprimer toute valeur par défaut, vous pouvez utiliser le spécificateur nodefault :

property Font nodefault;

Vous pouvez obtenir le même résultat en utilisant stored True, puisque cette dernière spécification indique que la propriété sera enregistrée si True est vrai, donc toujours. De même, vous pouvez utiliser stored False si vous voulez que la propriété ne soit jamais enregistrée.

Code extrait de l'aide de Delphi 6 :

type
  TSampleComponent = class(TComponent)
  protected
    function StoreIt: Boolean;
  public
    ...
  published
    property Important: Integer stored True; { toujours stockée }
    property Unimportant: Integer stored False; { jamais stockée }
    property Sometimes: Integer stored StoreIt; { dépend de la valeur de la fonction }
  end;

Vous pouvez aussi redéfinir la valeur par défaut d'une propriété héritée très simplement :

property Visible default False;
property Font stored FontStored;
property Color nodefault;

Voici un petit récapitulatif :

Si toutefois vous n'êtes pas certain de ce que vous faites, vérifiez que tout se passe bien dans le fichier .dfm sous forme texte.

Il ne reste plus qu'à mettre cela en pratique. Avec toute la théorie que nous avons acquise, je crois qu'il n'y a plus besoin de détailler la procédure.