Gestion d’un calepin

La seconde étape consiste à partager l’espace de la fenêtre en unités plus petites. Vous devez utiliser des Panels en « jouant » sur la propriété gérant leur alignement. Le calepin utilise trois zones différentes. Vous poseriez ainsi trois Panels sur la fiche. Le premier étant aligné sur le haut de la fenêtre (propriété Align = alTop), le second sur le bas (Align = alBottom) et le troisième prenant tout l’espace restant (Align = alClient).
Attention, lorsque vous posez des Panels, faites-le sur le fond de la fiche et non les uns sur les autres… Les Panels peuvent contenir d’autres Panels, mais ceux-ci se trouvent alors limités à l’espace du Panel parent, ce qui n’est pas toujours souhaitable.
Les Panels possèdent une propriété Caption, celle-ci n’ayant pas d’intérêt lorsque les Panels servent de « conteneurs », effacez-les (plusieurs objets peuvent être sélectionnés en même temps en maintenant la touche Shift enfoncée pendant la sélection par le clic gauche de la souris).

DELPHI propose, dans la palette « supplément », des boutons avec bitmap (type TbitBtn ou TSpeedButton). Utilisez un bouton de type TBitBtn et exploitez les styles prédéfinis en modifiant la propriété « Kind » du bouton. Il faut choisir « bkClose » pour obtenir à la fois le bitmap et le texte d’un bouton « Fermer ». Vous pouvez personnaliser le bouton en chargeant une autre bitmap et en changeant le texte.
Dans la page événement de l’inspecteur d’objets double-cliquez dans la zone de saisie de « OnClick » du bouton. DELPHI écrivant l’entête de la procédure automatiquement, vous ne tapez ici qu’une seule instruction : « Close ; » méthode de l’objet Tform effectuant la fermeture de la fiche.

Le moteur de base de données étant relationnel, il faudrait d’ailleurs dire « tables » plutôt que fichiers. Il est généralement préférable d’avoir créé toutes les tables avant de débuter l’application, mais la flexibilité de DELPHI nous permet d’être moins « scolaire ».
Depuis le menu de DELPHI choisissez « Outils | Base de données » pour appeler le Database Desktop. Une fois cet utilitaire chargé, dans son menu, choisissez « Fichier | Nouveau | Table ». Le type de la table utilisée par le calepin est « Paradox 5.0 pour Windows », c’est un format performant, si vous n’avez pas de contraintes de développement particulières préférez-le au format dBase, plus « rustique ». Pour les perfectionnistes le moteur Interbase Local fourni avec DELPHI est un excellent choix. De plus, l’application sera portable en Client/Serveur très facilement.
Saisissez les champs, les index, puis enregistrez le fichier dans un répertoire ou dans un Alias.
Il n’est pas obligatoire de travailler avec les Alias, même si cela est préférable pour de nombreuses raisons (et obligatoire avec des bases SQL). Le calepin n’utilise pas d’Alias pour démontrer cette possibilité.
La définition de la table CALEPIN.DB se trouve sur la disquette dans le fichier « Table.txt »
(voir en fin de document).

L’index principal d’une table Paradox doit être une clé unique. Comme vous devez pouvoir saisir des homonymes dans votre calepin, il est plus malin de créer une clé primaire automatique. C’est la raison d’être du champ « Code Interne » de type auto-incrémental qui est marqué comme clé principale de la table. Ce champ n’est pas utilisé par l’application.

La grille elle-même ne possède pas de paramètres pour choisir les champs de la table à visualiser. Il faut instancier des champs Tfields pour ce faire. Les Tfields sont des objets dont le rôle est d’effectuer une liaison entre chaque colonne de la table et l’application. Par défaut, lors de l’ouverture d’une table, DELPHI instancie automatiquement un Tfield par colonne. L’avantage est évident puisque c’est toujours cela de moins à programmer. Toutefois, il est généralement préférable de gérer les Tfields soi-même. Par exemple, si la structure de la table est modifiée, la méthode automatique de DELPHI ne le détectera pas. Dans certain cas une telle souplesse est souhaitable, mais que se passe-t-il si vous faites des calculs sur un champ que vous croyez être à virgule flottante alors qu’il est devenu un entier ?
Pour protéger vos applications, la création des Tfields lors du design de l’application est la meilleure solution. Si, à l’exécution, DELPHI découvre que les champs ne correspondent pas à ceux que vous avez créés, un message avertira l’utilisateur et la table ne sera pas ouverte. L’exception (erreur) qui sera générée pourra aussi être traitée plus finement.
Le type Tfield est un type générique décliné en sous-classes adaptées à chaque type de donnée géré par le moteur BDE. TStringField est le Tfield spécialisé pour les chaînes, TCurrencyField pour les zones monétaires, etc. Chaque Tfield possède des paramètres (propriétés) communs à toute la famille plus d’autres spécifiques au type de champ traité (par exemple un TIntegerField possède les propriétés MinValue et MaxValue pour créer des bornes de validité).
L’objet Tfield possède aussi des événements pour déclencher une notification lors d’un changement de contenu, pour transcoder les informations, pour gérer des validations sophistiquées, etc.
Accessoirement, les Tfields gèrent l’ordre d’affichage dans les grilles ainsi que le libellé de colonne (les noms de champs ne sont parfois pas très éloquents pour l’utilisateur).
Pour le calepin nous avons utilisé les propriétés Index et Visible des Tfields. La première gère l’ordre des colonnes dans une grille, la seconde la présence d’une colonne dans cette même grille.

Pour créer les Tfields lors du design vous pouvez sélectionner l’objet Ttable puis afficher le menu popup par un clic droit et choisir « Éditeur de champ » ou bien simplement double-cliquer sur l’objet Ttable directement.

Une première fenêtre (vide au départ) sera affichée, elle contient la liste des Tfields créés et permet de les afficher dans l’inspecteur d’objets. Choisissez « Ajouter ». Une seconde fenêtre s’ouvre alors. Elle contient toutes les colonnes de la table qui n’ont pas encore de Tfield associé.

Une fois les Tfields créés, vous pouvez tester la grille pour la dimensionner en fonction des champs affichés.
DELPHI permet l’ouverture d’une table en mode design, utilisez cette facilité en passant la propriété « Active » de la table à True. Vous pouvez ainsi régler la largeur des colonnes, celle de la grille, modifier les libellés affichés, changer les fontes, tout en voyant les véritables données ou, au moins, les entêtes si la table est vide.
En ce sens DELPHI est plus puissant que tous les L4G qui ne permettent pas de voir les données pendant la création d’une fiche.
Une fois les réglages effectués, fermez la table, car il est préférable de gérer son ouverture par programmation. Toutefois dans un logiciel simple comme le calepin, il serait possible de laisser la table ouverte depuis le mode design.

Il est souvent souhaitable de garder une trace des dates de création et de modification des données. Le calepin démontre la simplicité de mise en œuvre d’une telle technique.
La date de création ne doit être renseignée qu’une seule fois lors de la création d’un nouvel enregistrement. Lorsque vous devrez gérer de telles initialisations, il faudra utiliser l’événement « OnNewRecord » de l’objet Ttable.
Une seule ligne de code suffira : MonChampDateHeure.value :=Now;
Le nom du champ dépend de l’application et de la table bien entendu.
La propriété Value d’un Tfield est toujours du type de la colonne. Ainsi, la propriété Value d’un TIntegerField est de type LongInt, celle d’un TStringField est de type String, et celle d’un champ Date/Heure de type TdateTime.
« Now » est une fonction standard de DELPHI qui renvoie la date et l’heure courante.

Pour la date de dernière modification, il faut qu’elle soit modifiée à chaque fois que la fiche elle-même l’est. Toute modification passe par une validation, donc un « Post ». Vous utiliserez ici l’événement « BeforePost » du composant Ttable qui est déclenché juste avant que l’écriture réelle dans la table ne soit effectuée.
La ligne de code est identique à celle de la date de création.

Il faut gérer l’événement « OnClick » de TRadioGroup (qui offre les deux options « nom » et « société » dans le calepin). Le code consiste à changer la propriété IndexName de la table suivant la valeur de la propriété ItemIndex du TradioGroup.
Le changement d’index sera accompagné d’un changement de l’ordre d’affichage des trois colonnes dans la grille, de telle sorte que le champ utilisé comme clé soit toujours en colonne 1.

Certains champs d’une table peuvent avoir des valeurs par défaut. Vous placerez ce type d’initialisation dans l’événement « OnNewRecord » de la table déjà utilisé plus haut. Par exemple, le type de contact pourra être forcé à « personnel » ou à « professionnel » selon l’utilisation la plus fréquente qui sera faite du logiciel.

La table doit être ouverte au lancement de l’application. Vous utiliserez l’événement « OnCreate » de la Form en y plaçant MaTable.Open;.
La fermeture doit s’effectue à la sortie de l’application. Ici vous utiliserez l’événement « OnDestroy » de la Form en y plaçant MaTable.Close;.
Difficile de concevoir programmation plus simple…

Atteindre facilement un élément dans une table est un besoin de chaque instant. Proposer plusieurs index est une chose, encore faut-il les exploiter complètement. Vous y arriverez en plaçant un composant Tedit sur votre fiche et en connectant sur son événement « OnChange » le code suivant :

MaTable.SetRangeStart ; MaTable.ChampIndex.AsString :=Edit1.Text ; MaTable.ApplyRange ;

Le calepin gère deux index et s’adapte automatiquement. L’étude du code vous démontrera que cela reste très simple.

Source de l’application : calapp.zip

{ CALEPIN.EXE
 Gestion d'un calepin
 Copyright Olivier Dahan
 CompuServe: 100531,163
 V 1.0 Mars 1996
}
unit Unit1;
interface
uses
 SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
 Forms, Dialogs, DB, DBTables, Grids, DBGrids, StdCtrls, Buttons,
ExtCtrls,
 DBCtrls, Mask;
type
 TForm1 = class(TForm)
 Panel1: TPanel;
 Panel2: TPanel;
 Panel3: TPanel;
 BitBtn1: TBitBtn;
 T_calepin: TTable;
 ds_Calepin: TDataSource;
 DBGrid1: TDBGrid;
 T_calepinNom: TStringField;
 T_calepinSocit: TStringField;
 T_calepinTlphone: TStringField;
 DBEdit1: TDBEdit;
 DBEdit2: TDBEdit;
 DBComboBox1: TDBComboBox;
 DBRadioGroup1: TDBRadioGroup;
 DBEdit3: TDBEdit;
 DBEdit4: TDBEdit;
 DBEdit5: TDBEdit;
 DBEdit6: TDBEdit;
 DBMemo1: TDBMemo;
 DBEdit7: TDBEdit;
 DBEdit8: TDBEdit;
 DBMemo2: TDBMemo;
 DBNavigator1: TDBNavigator;
 Label1: TLabel;
 Label2: TLabel;
 Label3: TLabel;
 Label4: TLabel;
 Label5: TLabel;
 Label6: TLabel;
 Label7: TLabel;
 Label8: TLabel;
 Bevel1: TBevel;
 Label9: TLabel;
 Edit1: TEdit;
 RadioGroup1: TRadioGroup;
 Label10: TLabel;
 Bevel2: TBevel;
 T_calepinClInterne: TIntegerField;
 T_calepinPrnom: TStringField;
 T_calepinCivilit: TStringField;
 T_calepinTypeContact: TStringField;
 T_calepinTlcopie: TstringField;
 T_calepinEmail: TStringField;
 T_calepinAdresse: TMemoField;
 T_calepinCodePostal: TStringField;
 T_calepinVille: TStringField;
 T_calepinCommentaire: TMemoField;
 T_calepinDatedeCration: TDateTimeField;
 T_calepinDerniremodification: TDateTimeField;
 DBEdit9: TDBEdit;
 DBEdit10: TDBEdit;
 Label11: TLabel;
 Label12: TLabel;
 Label13: TLabel;
 procedure BitBtn1Click(Sender: TObject);
 procedure T_calepinNewRecord(DataSet: TDataset);
 procedure T_calepinBeforePost(DataSet: TDataset);
 procedure RadioGroup1Click(Sender: TObject);
 procedure FormCreate(Sender: TObject);
 procedure FormDestroy(Sender: TObject);
 procedure Edit1Change(Sender: TObject);
 procedure DBRadioGroup1Click(Sender: TObject);
 procedure ds_CalepinDataChange(Sender: TObject; Field: TField);
 private
 ChampIndex : String; { recherche incrémentale multiindex }
 end;
var
 Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.BitBtn1Click(Sender: TObject);
begin
{ fermeture de la fiche, donc ici de l'application }
close;
end;
procedure TForm1.T_calepinNewRecord(DataSet: TDataset);
begin
{ Date/heure de création }
T_calepinDatedeCration.value:=Now;
{ type de contact par défaut }
T_CalepinTypeContact.Value:=DBRadioGroup1.Items[0];
{ Focus sur le nom à saisir }
DBEdit1.SetFocus;
end;
procedure TForm1.T_calepinBeforePost(DataSet: TDataset);
begin
{ Date/heure de modification }
T_calepinDerniremodification.value:=now;
end;
procedure TForm1.RadioGroup1Click(Sender: TObject);
begin
{ Annulation de la recherche incrémentale éventuellement en cours }
T_Calepin.CancelRange;
{ Vidage de l'Edit servant à la recherche }
Edit1.Text:='';
{ gestion du changement d'index }
case RadioGroup1.ItemIndex of
0: begin
 { index par nom }
 T_calepin.IndexName:='IX_Nom';
 { placement des champs dans la grille }
 T_CalepinNom.index:=0;
 T_CalepinSocit.index:=1;
 T_CalepinTlphone.index:=2;
 { nom du champ index en cours }
 ChampIndex := 'Nom';
 end;
1: begin
 { index par société }
 T_Calepin.IndexName:='IX_Société';
 { placement des champs dans la grille }
 T_CalepinSocit.index:=0;
 T_CalepinNom.index:=1;
 T_CalepinTlphone.index:=2;
 { nom du champ index en cours }
 ChampIndex:='Société';
 end;
end;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
{ La table se trouve toujours dans le répertoire de l'EXE }
T_Calepin.TableName:=ExtractFilePath(Application.Exename)+'CALEPIN.DB';
{ ouverture de la table }
T_Calepin.Open;
{ initialisation du champ d'index en cours }
ChampIndex := 'Nom';
{ initialisation du champ de recherche incrémentale }
Edit1.text := '';
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
{ fermeture de la table }
T_Calepin.Close;
end;
procedure TForm1.Edit1Change(Sender: TObject);
begin
{ Edit1 à changé, on positionne la table au plus proche }
{ début d'un "range" du BDE }
T_calepin.SetRangeStart;
{ on affecte au champ index en cours le texte de Edit1 }
T_Calepin.FieldByName(ChampIndex).AsString:=Edit1.Text;
{ fin de l'opération "range" et application du résultat }
T_Calepin.ApplyRange;
end;
procedure TForm1.DBRadioGroup1Click(Sender: TObject);
begin
{ si "Société" est choisi alors DBedit3 est disponible }
DBEdit3.Enabled:= (dbradiogroup1.itemindex=1);
end;
procedure TForm1.ds_CalepinDataChange(Sender: TObject; Field: TField);
begin
{ Field=nil teste le changement de tous les champs en même temps,
 donc un changement d'enregistrement...
 On peut ainsi mettre en/hors le champ de saisie "société" suivant
 le contenu du champ qui vient juste d'être lu. }
if Field=Nil
 then DBEdit3.Enabled:=
 T_CalepinTypeContact.value='Travail';
end;
end.