Cours C++
TP4

Alain Plantec

Lire le sujet jusqu'au bout avant de commencer.

Gestion d'un fichier client par une IHM

On désire mettre en oeuvre un composant permettant de maintenir un fichier client via une interface homme-machine (IHM). Cette IHM est développée avec fluid.

La différence avec le TP précédent est qu'on va utiliser fluid pour construire des classes. Une interface homme-machine sera donc constituée d'objets qui interagissent et non plus construite par des fonctions manipulant des variables globales.

Les composants de l'IHM à construire

La fenêtre principale

\includegraphics[scale=0.8]{main.eps}

Elle permet :

Quand un ou tous les clients en mémoire sont modifiés par une action sur cette interface, alors, si la liste des clients est affichée (bouton «Liste»), celle-ci doit aussi être mise à jour. La cohérence entre la liste des clients en mémoire, la liste affichée et les données de la fenêtre principale doit toujours être conservée.

La liste des clients

\includegraphics[scale=0.8]{liste.eps}
Cette fenêtre est appelée par le bouton «Liste» de la fenêtre principale. La sélection d'un client dans la liste (avec la souris ou en se déplacant avec les flèches) met à jour la fenêtre principale avec les données concernant le client sélectionné.

La classe Client

L'interface minimale de cette classe est la suivante :
#ifndef __CLIENT_H__
#define __CLIENT_H__

#include <vector>
#include <string>

class Client {
 public:
  Client();
  Client(string _code, string _rs, string _adresse, string _telephone);
  void modifier(string _rs, string _adresse, string _telephone);
  string code() const { return code_; }
  string rs() const { return rs_; }
  string adresse() const { return adresse_; }
  string telephone() const { return telephone_; }

  friend ostream & operator << (ostream &, const Client &);
  friend bool operator == (const Client &, const Client &);
  
 private:
  string code_;
  string rs_;
  string adresse_;
  string telephone_;
};

#endif // __CLIENT_H__

Quelques compléments utiles

Construction de l'IHM avec fluid

On construit des classes avec des données membres, un constructeur et des fonctions membres. Tous ces composants peuvent être introduits dans fluid.

Voici l'interface de fluid après la construction de la fenêtre principale, la classe ClientUI. Les commentaires insérés indiquent comment construire les différents éléments.

\includegraphics[scale=1]{fluid-ClientUI.eps}

Pour mettre en oeuvre la liste des clients, on utilisera un objet de la classe Browser (New\other\Browser dans l'interface de fluid). Voici l'interface de fluid après la construction de la classe ListeClientsUI.

\includegraphics[scale=1]{fluid-ListeClientsUI.eps}

Le programme principale


// On inclu le fichier d'entete généré par fluid.
// On y trouve l'interface des classes ClientUI et ListeClientsUI
#include "ClientUI.h"

main()
{
  // On declare un objet ClientUI
  ClientUI ui;
  // on execute notre fonction membre show();
  ui.show();

  // On installe le gestionaire d'evennements de fltk
  // Une fois seulement pas programme, c'est une boucle du style :
  //    while (1) {
  //      yatil un evenement? (souris, clavier, ...)
  //      si oui, je le traite
  //      sinon je dors un peu ...
  //    }
  Fl::run();
}

Lecture et écriture dans un fichier

Pour choisir un fichier, on se simplifie le travail en utilisant la fonction fl_file_chooser (http://cassoulet.univ-brest.fr/DOC/FLTK/functions.html). On utilisera la classe ifstream pour lire et la classe ofstream pour écrire dans un fichier.

Pour se simplifier la vie, chaque donnée (le code, la raison sociale, ...) sera écrite encadrée par le caractère |. Voici un exemple de contenu d'un fichier produit par l'IHM :

|09456| |Jouets en bois| |22 rue rebancher| |45683995| 
|09459| |Vendeur de cartons & cie| |34 rue du bois| |49578938|

Ecriture

Voici un exemple de code qui ouvre un fichier nommé «test.txt» et qui écrit le mot «toto» dans le fichier ouvert :
#include <iostream.h>
#include <fstream.h> // pour avoir la déclaration de ofstream

main()
{
  ofstream ofile("test.txt"); // Création du fichier en écriture
  if (ofile) {  // si on a bien pu créer le fichier
    ofile << "toto" << endl; // on ecrit dans le fichier
  }
  exit(0);
  return 0;
}

Lecture

Voici un exemple de code qui ouvre un fichier nommé «test.txt» et qui le lit caractère par caractère :
#include <iostream.h>
#include <fstream.h> // pour avoir la déclaration de ifstream

main()
{
  ifstream ifile("test.txt"); // Création du fichier en lecture
  if (ifile) {  // si on a bien pu ouvrir le fichier
    while (!ifile.eof()) { // tant qu'on est pas en fin de fichier
      char c;
      ifile.get(c); // on lit un caractere
      cout << c; // et on l'envoit sur la sortie standard
    }
  }
  exit(0);
  return 0;
}

On peut amméliorer ce programme en utilisant la fonction fl_file_chooser :

#include <iostream.h>
#include <fstream.h> // pour avoir la déclaration de ifstream
#include "Fl/fl_file_chooser.h"

main()
{
  ifstream ifile;
  const char * name = fl_file_chooser("Fichier à lire", "*.txt", "toto.txt");
  if (name) {
    ifile.open(name);
    if (ifile) {  // si on a bien pu ouvrir le fichier
      while (!ifile.eof()) { 
	char c;
	ifile.get(c);
	cout << c; 
      }
    }
  }
  exit(0);
  return 0;
}

Les fichiers d'un TP fini

Client.cpp et Client.h l'interface et la mise en oeuvre de la classe Client
ClientUI.fld la spécification de l'interface avec fluid
ClientUI.cxx et ClientUI.h les fichier générés par fluid
ClientUI_.cpp mise en oeuvre des fonctions membres déclarées dans fluid mais non mise en oeuvre dans fluid
main.cpp un programme principale
tp4.mk un fichier makefile

Le gros du travail consiste donc à construire ClientUI.fld avec fluid, et de programmer ClientUI_.cpp.

Pour vous lancer voici le makefile, l'interface de la classe Client, des versions incomplètes de ClientUI.fld et de ClientUI_.cpp, le programme principale et un exemple de fichier client.txt produit par l'IHM :

La première chose à faire est donc de finir l'interface sous fluid, en completant le constructeur de ClientUI (on y ajoute une window, puis un cadre, puis des boutons, etc). Ensuite on déclare les fonctions membres manquantes, par exemple supprimer ou liste.

Bon ok, je crois que vous pouvez y aller.




Plantec Alain
2002-02-21