Quel composant pour présenter des enregistrements ?

**crassetph** · 18/06/2008, 13h04

Bonjour

Je créee un petit fichier avec quelques champs (mais pas une base de données) mais des "records" structurés afin de mettre à jour un fichier indexé. Ex contact . nom, prénom, etc..

Q1 : Quel est le composant delphi idéal pour présenter ce type de données? pour ensuite pouvoir y donner accès par sélection ensuite pour visualisation, modif

Q2 : j'ai utilisé actuellement une combobox, .. avec une seule colonne! Puis-je gérer les différentes col , nom, prénom dans combo (ou dans TStrinList ou dans TList?)

Même si la réponse à la Q1 oriente vers un composant autre que Combo, merci de répondre à la Q2 aussi (j'adapterai dans un premier temps et ensuite je redévelopperai avec le composant idéal

Merci

**Aka Guymelef** · 18/06/2008, 13h38

Bonjour,

Il n'existe pas de contrôle capable d'afficher directement un tableau de record. Donc pour ce faire il faut utiliser un autre contrôle visuel (typiquement une TStringGrid) puis remplir la TStringGrid avec les valeurs dans les records puis au moment de la sauvegarde retransférer (ou recréer) vers le tableau de record et sérialiser dans un fichier texte.

**crassetph** · 18/06/2008, 15h23

Envoyé par Aka Guymelef

Bonjour,

Il n'existe pas de contrôle capable d'afficher directement un tableau de record. Donc pour ce faire il faut utiliser un autre contrôle visuel (typiquement une TStringGrid) puis remplir la TStringGrid avec les valeurs dans les records puis au moment de la sauvegarde retransférer (ou recréer) vers le tableau de record et sérialiser dans un fichier texte.

Merci .Si j'ai bien compris votre réponse (sauver dans un texte et charger le texte dans le TstringList) j'ai procédé comme cela avec une Combo. Pouvez-vous répondre dés lors répondre à la question 2 svp ?

**Aka Guymelef** · 18/06/2008, 15h29

Pour répondre à la seconde question oui c'est possible avec le composant TDBLookUpCombobBox mais vous allez devoir passer par des ClientDataSet.

De plus je trouves ça beaucoup moins ergonomique que de passer par une TStringGrid, mais c'est mon avis.

**crassetph** · 19/06/2008, 16h25

Envoyé par Aka Guymelef

seconde question oui c'est possible avec le composant TDBLookUpCombobBox mais vous allez devoir passer par des ClientDataSet.
De plus je trouves ça beaucoup moins ergonomique que de passer par une TStringGrid, mais c'est mon avis.
-------------------------------
Première question : ....contrôle visuel (typiquement une TStringGrid) puis remplir la TStringGrid avec les valeurs dans les records puis au moment de la sauvegarde retransférer (ou recréer) vers le tableau de record et sérialiser dans un fichier texte."

Merci pour vos réponses

Pour la Q2 réponse 2 :
Je dois donc utiliser un compo TDBlookUpCombo et mettre aussi des? client data set sur ma fiche .. ? ensuite comment les parmétrer (désolé débutant !) (un exemple ou un tuto svp)

Par rapport à la Q1 Réponse 1
A moment du chargement : on met tous les champs du record sur une ou su r plusieurs chaîne(s) dans le TstringList ? et ce via une procédure ?
Qu'entendez-vous par sérialiser .. dans un fichier texte ?
Auriez-vous un exemple (ou un tuto ) de référence ?

Merci

**ShaiLeTroll** · 19/06/2008, 19h36

Pour l'histoire de ComboBox, je n'ai pas bien compris, la ComboLookup sert normalement pour le choix d'une valeur dans un dictionnaire ou depuis un Thésaurus, ... mettre le nom, prénom dans ce type de composant pour choisir une personne est étrange ...

Si tu as un fichier de record, autant laisser cela dans un Record ...

le terme sérialiser c'est justement de prendre un record et de l'écrire dans un fichier, une recherche t'aurais répondue ...

par contre, lorsque tu parle de record, c'est le type des structures en Delphi, ou Record dans un sens générique pour désigner une ligne de données ...

tient, je me suis aussi essayer à ce genre de chose, ou je lit un fichier, je rempli une liste pour chaque ligne, puis lorsque je sélectionne une ligne, cela me rempli des Edit ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
type
   TStructRec = packed record
      ID: Integer;
      Nom: string[50];
      Memo: string[255];
      Date: TDateTime;
   end;
 
procedure TFrmTestFichier.BtnLoadClick(Sender: TObject);
var
   Fichier: file of TStructRec;
   TmpStructRec: TStructRec;
   i: Integer;
begin
   if not FileExists(EdPathStructFile.Text) then begin
      ListBoxRecords.Items.Clear();
      ListBoxRecords.Items.Add('New');
      Exit; // Rien à Charger
   end else begin
      ListBoxRecords.Items.Clear();
      ListBoxRecords.Items.Add('New');
 
      AssignFile(Fichier, EdPathStructFile.Text);
      Reset(Fichier); //
      try
         while not Eof(Fichier) do begin
            Read(Fichier, TmpStructRec);
            i := ListBoxRecords.Items.Add(IntToStr(TmpStructRec.ID) + ' : ' + TmpStructRec.Nom);
            ListBoxRecords.Items.Objects[i] := Pointer(TmpStructRec.ID);
         end;
      finally
        CloseFile(Fichier);
      end;
   end;
end;
 
 
procedure TFrmTestFichier.BtnEcrireClick(Sender: TObject);
var
   Fichier: file of TStructRec;
   TmpStructRec: TStructRec;
begin
   ZeroMemory(@TmpStructRec, SizeOf(TmpStructRec));
   TmpStructRec.ID := StrToInt(EdID.Text);
   TmpStructRec.Nom := EdName.Text;
   TmpStructRec.Memo := EdMemo.Text;
   TmpStructRec.Date := Now();
 
 
   AssignFile(Fichier, EdPathStructFile.Text);
   if not FileExists(EdPathStructFile.Text) then begin
      ReWrite(Fichier);
   end else begin
      Reset(Fichier);
      Seek(Fichier, TmpStructRec.ID); // Magique le BlockSize est SizeOf(TStructRec); mais faudrait peut-être un test de longueur de fichier ...
   end;
   try
      Write(Fichier, TmpStructRec);
   finally
      CloseFile(Fichier);
   end;
 
   BtnLoad.Click();
end;
 
procedure TFrmTestFichier.ListBoxRecordsClick(Sender: TObject);
var
   Fichier: file of TStructRec;
   TmpStructRec: TStructRec;
begin
   if ListBoxRecords.ItemIndex >= 0 then begin
      if ListBoxRecords.Items[ListBoxRecords.ItemIndex] = 'New' then begin
         EdID.Text := IntToStr(ListBoxRecords.Items.Count - 1);
         EdName.Text := 'Item ' + EdID.Text;
         EdMemo.Text := 'Memo ' + EdID.Text;
         EdDate.Text := 'N.C.';
      end else begin
         TmpStructRec.ID := Integer(ListBoxRecords.Items.Objects[ListBoxRecords.ItemIndex]);
 
         AssignFile(Fichier, EdPathStructFile.Text);
         Reset(Fichier); //
         try
            Seek(Fichier, TmpStructRec.ID);
            Read(Fichier, TmpStructRec);
            EdID.Text := IntToStr(TmpStructRec.ID);
            EdName.Text := TmpStructRec.Nom;
            EdMemo.Text := TmpStructRec.Memo;
            EdDate.Text := FormatDateTime('dd/mm/yyyy hh:nn:ss', TmpStructRec.Date);
         finally
            CloseFile(Fichier);
         end;
      end;
   end;
end;
 
procedure TFrmTestFichier.BtnPathStructFileClick(Sender: TObject);
begin
   OpenDialogPathFile.Filter := 'Fichier Structure|*.struct|Tout Fichier|*.*';
   OpenDialogPathFile.FileName := ExtractFileName(EdPathStructFile.Text);
   OpenDialogPathFile.InitialDir := ExtractFileDir(EdPathStructFile.Text);
   if OpenDialogPathFile.Execute() then
   begin
      EdPathStructFile.Text := OpenDialogPathFile.FileName;
   end;
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
object GrpFichierData: TGroupBox
  Left = 4
  Top = 8
  Width = 560
  Height = 283
  Anchors = [akLeft, akTop, akRight, akBottom]
  Caption = 'Donn'#233'es Fichier Structure'
  TabOrder = 0
  DesignSize = (
    560
    283)
  object lblID: TLabel
    Left = 200
    Top = 59
    Width = 17
    Height = 13
    Caption = 'ID :'
  end
  object lblName: TLabel
    Left = 200
    Top = 82
    Width = 34
    Height = 13
    Caption = 'Name :'
  end
  object lblMemo: TLabel
    Left = 200
    Top = 128
    Width = 35
    Height = 13
    Caption = 'Memo :'
  end
  object lblDate: TLabel
    Left = 200
    Top = 106
    Width = 29
    Height = 13
    Caption = 'Date :'
  end
  object lblPathStructFile: TLabel
    Left = 8
    Top = 16
    Width = 84
    Height = 13
    Caption = 'Chemin du Fichier'
  end
  object ListBoxRecords: TListBox
    Left = 8
    Top = 64
    Width = 185
    Height = 179
    Anchors = [akLeft, akTop, akBottom]
    ItemHeight = 13
    TabOrder = 0
    OnClick = ListBoxRecordsClick
  end
  object EdID: TEdit
    Left = 248
    Top = 56
    Width = 300
    Height = 21
    Anchors = [akLeft, akTop, akRight]
    TabOrder = 1
    Text = '0'
  end
  object EdName: TEdit
    Left = 248
    Top = 80
    Width = 300
    Height = 21
    Anchors = [akLeft, akTop, akRight]
    MaxLength = 50
    TabOrder = 2
    Text = 'EdName'
  end
  object EdMemo: TMemo
    Left = 200
    Top = 144
    Width = 348
    Height = 99
    Anchors = [akLeft, akTop, akRight, akBottom]
    MaxLength = 255
    ScrollBars = ssBoth
    TabOrder = 3
  end
  object BtnEcrire: TButton
    Left = 200
    Top = 250
    Width = 81
    Height = 25
    Anchors = [akLeft, akBottom]
    Caption = 'Ecrire'
    TabOrder = 4
    OnClick = BtnEcrireClick
  end
  object BtnLoad: TButton
    Left = 8
    Top = 250
    Width = 185
    Height = 25
    Anchors = [akLeft, akBottom]
    Caption = 'Charger List'
    TabOrder = 5
    OnClick = BtnLoadClick
  end
  object EdDate: TEdit
    Left = 248
    Top = 104
    Width = 300
    Height = 21
    Anchors = [akLeft, akTop, akRight]
    Enabled = False
    MaxLength = 50
    TabOrder = 6
    Text = 'EdName'
  end
  object EdPathStructFile: TEdit
    Left = 8
    Top = 32
    Width = 540
    Height = 21
    Anchors = [akLeft, akTop, akRight]
    TabOrder = 7
  end
  object BtnPathStructFile: TButton
    Left = 525
    Top = 34
    Width = 21
    Height = 17
    Anchors = [akTop, akRight]
    Caption = '...'
    Font.Charset = OEM_CHARSET
    Font.Color = clWindowText
    Font.Height = -13
    Font.Name = 'Terminal'
    Font.Style = []
    ParentFont = False
    TabOrder = 8
    OnClick = BtnPathStructFileClick
  end
end

**crassetph** · 19/06/2008, 22h53

CITATION Pour l'histoire de ComboBox, je n'ai pas bien compris, la ComboLookup sert normalement pour le choix d'une valeur dans un dictionnaire ou depuis un Thésaurus, ... mettre le nom, prénom dans ce type de composant pour choisir une personne est étrange ... FIN

EXPLICATION .. longues -...
En fait, je n'ai pas tout dit.... au niveau des combo. Je m'explique. J'ai réalisé tant bien que mal, une mini appli pour enregistrer les titres des livres de la bibli de mon fils (pour lui). J'ai géré sur la fiche, une combo, des boutons d'ajout, de modif, de sélection et de suppression pour "le titre de livre"... c'est pas mal, on peut même envisager de coller ensuite le type (bd, roman), l'auteur (spirou, titeuf) à la suite du string, séparé par une virgule.....dans un premier temps...dans le fichier texte chargé dans la combo. Ce n'est peut-être pas le composant idéal ? (Listbox mieux ?)

Fier de ma première fiche, je l'ai donc copiée et son code avec, dans une seconde unit du même projet. Le but est de gérer les Type de livre. Ensuite je ferai pareil avec l'éditeur, l'auteur Rq : je n'ai pas du proceder dans un ordre correct car j'ai eu un mal fou pour renommer les composants et les procédures mais j'y suis arrivé. Au passage, tu peux peut-être me donner un truc pour copier Toute une unit avec sa fiche et l'ordre dans lequel procéder pour éviter les interminables erreurs.(d'abord copier la form ?copier coller? copier le dfm?) ...

Le but est donc à terme de pour voir sélectionner, au départ de la fiche Titre des livres, via la combo remplie dans la seconde, la troisième fiche , le Type de livre, l'auteur...etc. Confirme moi stp que je devrai utiliser le combo lookup?

Je n'ai donc pas encore de record (au sens de la structure delphi) mais je compte les créer dans une version future (proche) mais je voudrais conserver ma combo, sa gestion et la gestion des évts autour de celle-ci (ajout, suppression, modification,) fiche que j'ai eu tant de mal à créer.. voilà tu sais tout. (utiliser une combo avec ds colonnes pour chaque élément du record?)

En fait c'est pour ne pas tout jetter...

Merci pour ton exemple, mais si je veux lecopier et l'essayer, sans tout retaper... comment procéder ? tu as une fiche dfm et une unit ?

Merci (excuse la longueur) ... l

**ShaiLeTroll** · 20/06/2008, 11h45

Désolé, mon code est noyé dans mon application à bordel, tu copie le code fourni, tu fais CTRL+MAJ+C, cela créé les prototypes, tu les déplace de private à published, ensuite, dans une forme tu colle (directement dans l'IDE en faisant CRTL+C dans la forme) le bout de dfm que j'ai mis cela va créér les composants, à toi de remettre les events si ils ne sont pas raccrochés ...

Pour moi passer par des ClientDataSet et des ComboLookup cela me parait lourd, autant directement stocké les données en XML justement via un TClientDataSet au lieu de faire un fichier à la main, soyons cohérent, si tu fais un fichier à la main, tu dois faire le reste à la main aussi ...

Si tu dois juste faire un "gestionnaire de bibliothèque" pour ton fils, tu te prends un peu la tête, déjà il en existe plein d'exemple de source ... ensuite, vois les choses plus simplement :
(format CSV à la francaise "valeur";"autre";....)

- un fichier livre :
ID;"Nom du Livre";DateDeParution
1;"Delphi 7 Studio";YYYY-MM-DD
2;"La Route de Dune";2006-11-01

- un fichier auteurs :
ID;"Nom de l'Auteur"
1;"Olivier Dahan"
2;"Paul Toth"
3;"Kevin J. Anderson"
4;"Brian Herbert"

- un fichier livre_auteur
ID_LIVRE;ID_AUTEUR
1;1
1;2
2;3
2;4

Etc ... ainsi tu as une listBox contenant tous les livres, lorsque tu clique dessus, cela ouvre la page décrivant un livre, le nom, sa date, une autre listbox qui énumérent les auteurs du livre, un bouton pour ajouter ou supprimer un auteur lier au livre, le bouton ajouter ouvre une nouvelle liste qui contient tous les auteurs connus (un bouton créer pour ajouter un auteur qui n'existait pas dans la table auteur) ...

bon, je m'arrête là, ... c'est une spécification, ... qui nous fait le diagramme UML ?

**crassetph** · 26/06/2008, 07h47

Envoyé par ShaiLeTroll

Si tu dois juste faire un "gestionnaire de bibliothèque" pour ton fils, tu te prends un peu la tête, déjà il en existe plein d'exemple de source ... ensuite, vois les choses plus simplement :
(format CSV à la francaise "valeur";"autre";....)

- un fichier livre :
ID;"Nom du Livre";DateDeParution
1;"Delphi 7 Studio";YYYY-MM-DD
2;"La Route de Dune";2006-11-01

- un fichier auteurs :
ID;"Nom de l'Auteur"
1;"Olivier Dahan"
2;"Paul Toth"
3;"Kevin J. Anderson"
4;"Brian Herbert"

- un fichier livre_auteur
ID_LIVRE;ID_AUTEUR
1;1
1;2
2;3
2;4

?

Super l'idée de la base relationnelle avec des Csv... (compris le concept et la facilité) mais en pratique ... j'ai procédé comme conseillé, avec les 3 csv , Avec loadfromfile voir code exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
txt:=''; CheminFichier:=ExtractFilePath(Application.ExeName);
  NomFichier:='TitLiv';
  ExtFichier:='csv';
  NFichPhys:=CheminFichier+NomFichier+'.'+ExtFichier;
  AssignFile(F,NFichPhys);
  {$I-} //La vérification d'E/S est désactivée
  Reset(F); {$I+} //La vérification d'E/S est activée
  if {if1} IoResult=0 
  then //Renvoie l'état de la dernière opération d'E/S
    begin{2}  ListBox1.Items.LoadFromFile(NFichPhys);

1. Est-ce correct Load from file ? (pour les visions en colonnes, autre possibilité, pour la reconnaissance des ID ...etc)
2. Je comprends tres bien le concept du fichier livre_auteur, la relation, mais en ouvrant le Csv livre-auteur dans la listbox, l'accès aux données livre et auteur via leur identifiant respectif ne ne se fait évidemment pas ...y a t'il des instructions spécifiques, sinon je ne cmprends pas l'astuce des csv qui sont faciles
3. je poursuivrai sur tes conseils .. en csv ... mais tu parles aussi xml -plus professionnel non ? (quelles sont les instructions respectives)
Merci beaucoup

**ShaiLeTroll** · 26/06/2008, 11h05

LoadFromFile c'est une méthode simple ... il serait bien de faire un Objet dédié pour chaque fichier, qui gère, lecture, écriture, création d'une ligne, une fonction ToString pour afficher ...

Le XML c'est plus compliqué à manipulé, le CSV à l'avantage d'être lu en texte, et rapidement parsé (voir ce sujet sur le CSV et ses nombreux liens, et aussi la fonction Explode qui pourrait te plaire)

Pour l'Affichage, tu peux remplacer (StringReplace), le ";" par un #10,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

StringGridAccueil.Rows[iList + 1].Text := StringReplace(ConnectedFileList[iList], ';', #10, [rfReplaceAll, rfIgnoreCase]);

Pense Objet, pour afficher un Livre correctement l'Objet TLivre va lire ses propres données, puis il va faire appel à l'Objet TLivreAuteur, en lui demandant la liste des Auteurs pour lui (via ID), et enfin, tu récupère le nom via un objet TAuteur ... la conception objet, c'est un peu long à maitriser mais une fois adopté, c'est très pratique ...

**crassetph** · 26/06/2008, 23h54

Envoyé par ShaiLeTroll

Objet dédié pour chaque fichier, qui gère, lecture, écriture, création d'une ligne, une fonction ToString pour afficher ...

Pense Objet, pour afficher un Livre correctement l'Objet TLivre va lire ses propres données, puis il va faire appel à l'Objet TLivreAuteur, en lui demandant la liste des Auteurs pour lui (via ID), et enfin, tu récupère le nom via un objet TAuteur ... la conception objet, c'est un peu long à maitriser mais une fois adopté, c'est très pratique ...

Ok Compris les concepts (théoriques..) sans prétention, :-). Mon projet dans l'état actuel, en reprend déjà (ex : par fichier lecture ecriture etc... cependant voici les différences :
1. J'ai créé une forme par fichier (une unit / par fichier)
2. Chaque form a ses procédures (mais pas d'objet !?)
3. J'affiche tout le fichier dans une combo
4. des les boutons ajout, del , mod, sont gérés ainsi que certains Keypressed
5. Les fichiers sont des txt (mais bon je pourrais les transformer rapidt)

J'ai l'impression de ne pas être loin mais la notion d'objet me manque.

J'aimerais te faire voir mon projet... la page principale contient des outils et ma boite à bordel ... tu px jetter un oeil mais clique plutôt sur les boutons LIvre et TypeLivre. (je t'envoie le folder TomBibli , tu ouvres le projet, compile ... et tu px aussi voir les sources ...invendables !

J'aurais trois Q par ordre d'importance
1. Comment introduire la notion d'objet pex sur la from Type Livre par ex avec ses procédures
2. La notion de ID des csv (qui devraient remplacer mes txt) doit être gérée manuellement (le terme ID n'entraine aucun automatisme n'est-ce pas ?
(Tuto de gestion des ID des CSV ?)
3. J'ai choisi la combo à tort ? au détriment d'une Lisbox ou tu conseilles TsritngList ?. Tdbdrid ? mais ceci pour 2 raisons: avec la listbox j'avais et j'ai toujours des prob pour travailler les records editer, ajouter supprimer .. sais pas pourquoi (avec combo ok) et la seconde raison c'est que la combo de création (p ex de type de livres ) pourrait être réutilisée pour encoder leLIvre, son type via sélection (Est ce un mauvaise idée?)
(4)Derrière ton pseudo ne se cache pas l'auteur d'un livre sur delphi 7 ?
Je vais essayer d'appliquer tout cela mais à chaque discussion je remets les concepts de base en cause, recorrrige, change et le projet n'aboutit pas !
N'rive pas à t'envoyer les fichiers attachés
Merci bcp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
unit TypLiv;
 
//-------------------------------------------------------------------------------
interface
//-------------------------------------------------------------------------------
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
     Dialogs, StdCtrls, ExtCtrls, Buttons, phcunit;
//-------------------------------------------------------------------------------
type  TFrmTypLiv=class(TForm)
    BtnModTypLiv: TButton;
    BtnSupTypLiv: TButton;
    BtnRetFrmTypLiv: TSpeedButton;
    BtnFinTypLiv: TSpeedButton;
    BtnEntTypLiv: TButton;
    BtnOuvTypLiv: TBitBtn;
    CbTypLiv: TComboBox;
    BtnCpyTypLiv: TSpeedButton;
    SavTypLiv: TSpeedButton;
    PnlTypLivLigEta: TPanel;
    LblTitreFrmTypLiv: TLabel;
procedure FormCreate(Sender: TObject);
procedure BtnOuvTypLivClick(Sender: TObject);
procedure CbColorItem(Control: TWinControl; Index: Integer;  Rect: TRect; State: TOwnerDrawState);
procedure FormKeyPress(Sender: TObject; var Key: Char);
procedure BtnCpyTypLivClick(Sender: TObject);
procedure BtnRetTypLivClick(Sender: TObject);
procedure BtnFinTypLivClick(Sender: TObject);
procedure SavTypLivClick(Sender: TObject);
procedure CbTypLivChange(Sender: TObject);
procedure BtnSupTypLivClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;Shift: TShiftState);
procedure BtnModTypLivClick(Sender: TObject);procedure BtnEntTypLivClick(Sender: TObject);
    procedure CbTypLivEnter(Sender: TObject);
    procedure FormShow(Sender: TObject);
 
 
 
//------------------------------------------------------------------------------- 
  private  { Déclarations privées }
//-------------------------------------------------------------------------------
  public end;  { Déclarations publiques }
//-------------------------------------------------------------------------------
var FrmTypLiv: TFrmTypLiv;
//-------------------------------------------------------------------------------
implementation {$R *.dfm}
//-------------------------------------------------------------------------------
procedure TFrmTypLiv.FormCreate(Sender: TObject);
var HandleMenu : THandle;
begin   HandleMenu := GetSystemMenu(Handle, False); //récupération du Handle du menu
        EnableMenuItem(HandleMenu, SC_CLOSE, MF_DISABLED); // mise à Disabled croix de fermeture
        BtnOuvTypLivClick(self);end;
//--------------------------------------------------------------------------------------------------- 
procedure TFrmTypLiv.BtnOuvTypLivClick(Sender: TObject); {Ouvrir fichier des Types de livres}
Var  F : textfile; Txt, CheminFichier, NomFichier, ExtFichier, NFichPhys:string;
begin {1} //Affectation des variables
  txt:='';  CheminFichier:=ExtractFilePath(Application.ExeName); ExtFichier:='txt';
  NomFichier:='TomTypLiv01';
  NFichPhys:=CheminFichier+NomFichier+'.'+ExtFichier;
  AssignFile(F,NFichPhys); {$I-}     //La vérification d'E/S est désactivée
  Reset(F);   {$I+} //La vérification d'E/S est activée
  if {if1} IoResult=0 
  then //Renvoie l'état de la dernière opération d'E/S           
    begin{2}CbTypLiv.items.Clear;CbTypLiv.Items.LoadFromFile(NFichPhys);CloseFile(F);
            PnlTypLivLigEta.Caption := 'Fichier "Type Livre" chargé ou re-chargé dans la boîte déroulante !';end {2} 
    else begin {3}  
    Txt:='Fichier'+#13#10+NomFichier+#13#10+' non présent ou endommagé '+#13#10; Txt:=Txt+'Restaurez le fichier'+#13#10;
    ShowMessage(txt);rewrite(F);Exit;end;{3}
end;{1}
//--------------------------------------------------------------------------------------------------- 
procedure TFrmTypLiv.CbColorItem(Control: TWinControl; Index: Integer;  Rect: TRect; State: TOwnerDrawState);
begin  //on dessine le fond des lignes en alternant les couleurs
  if  index mod 2<>1  then  begin CbTypLiv.canvas.brush.color:=clCaptionText; CbTypLiv.canvas.fillrect(rect);end
                      else  begin CbTypLiv.canvas.brush.color:=clinactivecaptiontext;CbTypLiv.canvas.fillrect(rect);end;
  {on affiche le texte}CbTypLiv.canvas.textout(rect.left+30,rect.top+2,CbTypLiv.items[index]);
  if (odSelected in state) then begin CbTypLiv.canvas.brush.color:=clsilver;CbTypLiv.canvas.fillrect(rect);
                                    CbTypLiv.canvas.font.color:=clred;
                                    CbTypLiv.canvas.font.style:=CbTypLiv.canvas.font.style +[fsbold];
                                    CbTypLiv.canvas.textout(rect.left+120,rect.top+0,CbTypLiv.items[index]);end;
end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.FormKeyPress(Sender: TObject; var Key: Char);
begin  Case key of  
#13:begin PnlTypLivLigEta.Caption :='Evénement on KEYPRESSED : touche "Enter " enfoncée';BtnEntTypLivClick(self);end;
#27:begin PnlTypLivLigEta.Caption :='Evénement on KEYPRESSED : touche "Escape" enfoncée';BtnRetTypLivClick(self);end;
end;{of case}end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.BtnEntTypLivClick(Sender: TObject);
begin If cbTypliv.Text<>'' then cbtypliv.Items.Add(PLMAJ(Minuscule(CbTypLiv.Text)));CbTypLiv.Text:='';
CbTypLiv.SetFocus;PnlTypLivLigEta.Caption:='Bouton "Enter" a été activé !';end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.BtnCpyTypLivClick(Sender: TObject);
var Txt, CheminFichier, NomFichier,NomFichierBu,ExtFichier,NFichPhys,NFichPhysBU:string;
begin 
PnlTypLivLigEta.Caption:='L'' action de "Copie" a été invoquée !';
Txt:='Voulez-vous effectuer une copie du fichier ?';
case MessageDlgPos(Txt,mtConfirmation,[mbYes,mbNo],0,530,390)  of
        mrNo : Begin close;end;
        mrYes :begin  //Copie du Fichier des Titres de livres
              CheminFichier:=ExtractFilePath(Application.ExeName);
              NomFichier:='TomTypLiv01';
              NomFichierBU:='TomTypLiv01BU';
              ExtFichier:='txt';
              NFichPhys:=CheminFichier+NomFichier+'.'+ExtFichier;
              NFichPhysBU:=CheminFichier+NomFichierBU+'.'+ExtFichier;
              PhcCpyFic(NFichPhys,NFichPhysBU,false,false,true); 
              End; end; {of case} End;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.BtnRetTypLivClick(Sender: TObject); // Fermeture de la fenêtre
begin  with FrmTypLiv do begin close; end;end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.BtnFinTypLivClick(Sender: TObject);
begin btnCpyTypLivClick(self);with FrmTypLiv do begin close; end;end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.SavTypLivClick(Sender: TObject);
Var  F : textfile; CheminFichier, NomFichier, ExtFichier, NFichPhys:string;
begin CheminFichier:=ExtractFilePath(Application.ExeName); ExtFichier:='txt';
      NomFichier:='TomTypLiv01';
      NFichPhys:=CheminFichier+NomFichier+'.'+ExtFichier;
      AssignFile(F,NFichPhys);
      CbTypLiv.Items.SaveToFile(NFichPhys);
      PnlTypLivLigEta.Caption :='L''action de sauvegarde a été invoquée !';end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.CbTypLivChange(Sender: TObject);
var i : Integer;keypressed:word;
begin
i:= CbTypLiv.ItemIndex;
PnlTypLivLigEta.Caption := 'On Change !';
 
if keypressed = VK_DELETE  then showmessage ('Delete');
//ComboBox.Items.Delete(Index); voir si pas mettre crochets //combobox.DeleteSelected
//LblSelTypLiv.Caption := 'Tu as clické sur : ' + CbTypLiv.Items.Strings[i] + ' à la position : ' + IntToStr(i + 1);
end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.BtnSupTypLivClick(Sender: TObject);
begin PnlTypLivLigEta.Caption := '';i := CbTypLiv.ItemIndex;
      PnlTypLivLigEta.Caption := '" '+cbTypLiv.items[i]+' " a été supprimé via le bouton "Supprime" !';
      CBTypLiv.Items.Delete(I); //combobox.DeleteSelected  //pour plusieurs items   (propopriété multiselect)
end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin case key of 
VK_DELETE:begin PnlTypLivLigEta.Caption :='Evénement on KEYDOWN : touche "Delete" enfoncée';BtnSupTypLivClick(self);;end;
VK_INSERT:begin PnlTypLivLigEta.Caption :='Evénement on KEYDOWN : touche "Insert" enfoncée';end;
VK_ESCAPE:begin PnlTypLivLigEta.Caption :='Evénement on KEYDOWN : touche "Escape" enfoncée';BtnFinTypLivClick(self);end;
VK_F3    :begin PnlTypLivLigEta.Caption :='Evénement on KEYDOWN : touche "F3" enfoncée';BtnFinTypLivClick(self);end;
VK_F11   :begin PnlTypLivLigEta.Caption :='Evénement on KEYDOWN : touche "F11" enfoncée';end;
VK_F12   :begin PnlTypLivLigEta.Caption :='Evénement on KEYDOWN : touche "F12" enfoncée';end;
end {of case}end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.BtnModTypLivClick(Sender: TObject);
var i :integer;
begin PnlTypLivLigEta.Caption := '';cbtypliv.text:='';i := CbTypLiv.ItemIndex;
      PnlTypLivLigEta.Caption := '" '+cbTypLiv.items[i]+' " a été modifié via le bouton "Modifie" !';
      CbTypLiv.text:=CbTypLiv.items[i]+'mod';CBTypLiv.setfocus;  end;
      //CbTypLiv.Items.Add(PLMAJ(Minuscule(CbTypLiv.Text)));CbTypLiv.Text:='';CbTypLiv.SetFocus; 
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.CbTypLivEnter(Sender: TObject);
begin
CBTypLiv.Perform(CB_SHOWDROPDOWN, Integer(True), 0);
end;
//---------------------------------------------------------------------------------------------------
procedure TFrmTypLiv.FormShow(Sender: TObject);
begin CbTypliv.SetFocus end;
//---------------------------------------------------------------------------------------------------
end.

**ShaiLeTroll** · 27/06/2008, 11h40

1, voici une idée de prototype d'objet ... bon je m'arrête là, sinon je risque de t'écrire le tout ....

Ne pas mélanger la Form qui est un objet dont le but est l'affichage, d'un objet qui a pour but de lire ou écrire de la donnée, il faut séparer (voir le modèle MVC, c'est un peu poussé et pas toujours évident en Delphi, mais c'est à connaître)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
type
  TBibliotheque = class(TObject)
  private
    FAuteurs: TObjectList;
    FLivres: TObjectList;
  protected
    function GetAuteurs(const Index: Integer): TAuteur
    procedure SetAuteurs(const Index: Integer; Value: TAuteur);
    function GetAuteurCount: Integer;
    function GetLivres(const Index: Integer): TLivre
    procedure SetLivres(const Index: Integer; Value: TLivre);
    function GetLivreCount: Integer;
  public
    property Auteurs[const Index: Integer]: TAuteur read GetAuteurs write SetAuteurs; 
    property AuteurCount: Integer read GetAuteurCount;
    property Livres[const Index: Integer]: TLivre read GetLivres write SetLivres; 
    property LivreCount: Integer read GetLivreCount;    
  end;
 
  TAuteurStruct = packed record
    ID: Integer;
    Name: shortstring;
  end;
 
  TAuteur = class(TObject) // Avec un TCollectionItem on pourrait faire pas mal aussi ! 
  private
    FData: TAuteurStruct;
  protected
    function GetID: Integer;
    function GetName: shortstring;
    procedure SetName(Value: shortstring);
  public
    constructor Create(const Name: string); overload; // Nouvel Auteur
    constructor Create(const ID: Integer); overload; // Auteur Existant
    function Exists(const ID: Integer): Boolean;
    function Save: Integer; // Ici la vraie écriture, fourni l'ID
    property ID: Integer read GetID; // Lecture Seule, car seul l'objet peut jouer avec ...
    property Name: string read GetName write SetName;
  end;
 
  TLivreStruct = packed record
    ID: Integer;
    Name: shortstring;
    DateParution: TDateTime;
  end;
 
  TLivre = class(TObject) 
  private
    FData: TLivreStruct;
  protected
    function GetID: Integer;
    function GetName: shortstring;
    procedure SetName(Value: shortstring);
    function GetAuteurs(const Index: Integer): TAuteur
    procedure SetAuteurs(const Index: Integer; Value: TAuteur);
    function GetAuteurCount: Integer;
  public
    constructor Create(const Name: string); overload; // Nouveau Livre
    constructor Create(const ID: Integer); overload; // Livre Existant
    function Exists(const ID: Integer): Boolean;
    function Save: Integer; // Ici la vraie écriture, fourni l'ID
    property ID: Integer read GetID; // Lecture Seule, car seul l'objet peut jouer avec ...
    property Name: string read GetName write SetName;
    property Auteurs[const Index: Integer]: TAuteur read GetAuteurs write SetAuteurs; // Le Top sera une TCollection
    property AuteurCount: Integer read GetAuteurCount;
  end;

2. La notion de ID des csv (qui devraient remplacer mes txt) doit être gérée manuellement (le terme ID n'entraine aucun automatisme n'est-ce pas ?
(Tuto de gestion des ID des CSV ?)
En fait, l'ID sera le numéro d'enregistrement, disons qu'avec un fichier binaire et des packed record, on peut lire très vite un enreg car les positions sont fixes (voir mon sujet sur TTextFileReader, l'index est fixe, le fichier texte est variable)

3. Pour l'interface, je trouve qu'une grille c'est plus pratique, en plus, tu peux afficher (donc lire) qu'une partie de la bibliothèque, c'est donc plus léger ...

4. Merci du compliment, mais j'ai encore beaucoup de chemin à faire, pour arriver au niveau de Paul Toth et d'Olivier Dahan (Merlin), le premier étant un phidel Paladin, le second ayant été perverti par les forces du Billou ...

phidel, ouais fidèle ...

**crassetph** · 19/08/2008, 13h16

"voici une idée de prototype d'objet ... bon je m'arrête là, sinon je risque de t'écrire le tout ...."

Merci pour les infos, je me rplonge dans ces lignes afin de pgmer en ce sens..
Connais-tu un tuto ou un cours avec un exemple d'Objet et les fonctions / procédure GET et SET comme décrit dans la dernière réponse ?

Merci

**crassetph** · 26/12/2008, 10h49

Bonjour ..je m'y suis remis... j'ai créé des objets à la manière indiquée et après maintes lectures ok pour la strucure objet ....

1. Est-il normal -malgré l'utilisation de "property" - de devoir développer en entier le code toutes les fonctions et procédures ? (j'ai été obligé de les créer avec les seules instructions begin end, car sinon j'avais le msg "Declaration forward ou external insatisfaite". Ai-je bien procédé?

2. J'aimerais avoir un exemple de code pour les fonctions et proc suivantes :
Function Tstyle.GetNom:string; begin end;
Procedure Tstyle.SetNom(Value:string);begin end;
constructor Tstyle.create(const Nom:string); // nouveau style
constructor Tstyle.create(const Id:integer); // style existant
Function Tstyle.exists(const Id:integer): Boolean;
Function Tstyle.save:integer;

Merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
unit CreationFichier; //Créé les fichiers à partir du fichier ini
 
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ActnList, Buttons, ImgList, XPMan, StdCtrls, Menus, IniFiles, Contnrs;
Procedure CreeTousFichiers;
Procedure CreeStyle;
implementation
type
TStyle = Class(TObject)
private
  Fdata:TStyleStruct;
protected
  Function    GetID :Integer;
  Function    GetLng:shortstring;
  Procedure   SetLng(Value:shortstring);
  Function    GetNom:string;
  Procedure   SetNom(Value:string);
Public
  constructor create(const Nom:string);overload; // nouveau style
  constructor create(const Id:integer);overload; // style existant
  function    exists(const Id: integer):boolean;
  function    save:integer; // ici la vraie écriture fournit l'ID
  property    ID :Integer read GetID; //Lecture seule car seul l'objet peut joueravecl'ID
  property    Nom :string read GetNom write SetNom; // lecture et écriture
  property    Lng :shortstring read GetLng write SetLng; // lecture et écriture
end;  
Type  
TLesObjetsDesMemos= class(TObject)
private
  FStyle: TObjectList;
public
  Function GetStyle(const Index:integer):TStyle;
  Procedure SetStyle(const Index:integer;value:TStyle);
    { Déclarations publiques }
  end;
 
Type
TStlStruct=Packed Record                   // Structure style mémo  // 30;F; Notes de cours; 
IDStl     : Integer;                       // Identifiant style mémo// 31;E; Course notes;
Lng       : String[1];                     // Langue du style mémo
NomStl    : String[20];                    // Libelé Nom du style
Date      : TDateTime;
end;
/////////////////est-ce nromale de devoir développerle code ?
//////////////// quel est l'avantage de property alors ?
// merci de donner un ex pour une fct et proc de chaque type
 
Function    Tstyle.GetID:Integer;
begin
end; 
Function    Tstyle.GetLng:shortstring; 
begin
end; 
Function    Tstyle.GetNom:string; 
begin
end; 
Procedure   Tstyle.SetLng(Value:shortstring);
begin
end; 
Procedure   Tstyle.SetNom(Value:string);
begin
end; 
constructor Tstyle.create(const Nom:string); // nouveau style
begin
end;
constructor Tstyle.create(const Id:integer); // style existant
begin
end;
Function    Tstyle.exists(const Id:integer): Boolean;
Begin
end; 
Function    Tstyle.save:integer;
Begin
end; 
Function    TLesObjetsDesMemos.GetStyle(const Index:integer):TStyle;
begin
end; 
Procedure TLesObjetsDesMemos.SetStyle(const Index:integer;value:TStyle);
begin
end; 
 
 
Procedure CreeStyle;
begin
Showmessage('cree fichier style ');
end;
 
Procedure CreeTousFichiers; // à partir des iniFile
Begin
Showmessage('Cree tous fichiers');
CreeStyle;
end;
end.

**ShaiLeTroll** · 30/12/2008, 11h39

Bien sur, les accesseurs DOIVENT être écrit !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Function    Tstyle.GetNom:string; 
begin
  Result := Fdata.NomStl    ; // je suppose que TStyleStruct ressemble à TStlStruct
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
constructor Tstyle.create(const ANom:string); // nouveau style
begin
  inherited Create();
 
  Fdata.NomStl := ANom; // le "A" pour garantir la différence en le paramètre et la propriété Nom, question de lisibilité surtout !
end;

Quel composant pour présenter des enregistrements ?

Composants VCL Delphi

Discussions similaires

Partager

Partager