Examen INGI 2113: Conception et r ealisation d’un...

Examen INGI 2113:

Conception et realisation d’un logiciel de gestion de bibliotheque

Pierre Lison

Universite Catholique de Louvain

Faculte des Sciences Appliquees

Departement d’ingenierie informatique

18 aout 2003

INGI 2113Conception d’un logiciel de gestion de bibliotheque

Pierre Lison 18 aout 2003

Table des matieres

1 Introduction 3

2 Analyse du probleme 4

2.1 Cahier des charges general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 Difficultes particulieres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.2.1 Structure de la bibliotheque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.2.2 Recherche dans la bibliotheque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.2.3 Projection memoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.2.4 Communication inter-processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.2.5 Nombre de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.2.6 Interface utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Architecture du logiciel 11

3.1 Architecture generale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.2 Contenu des modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4 Documentation 13

4.1 Reference du fichier mnemo.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.1.1 Documentation de la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.1.2 Documentation de la fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.2 Reference du fichier interface1.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18







TABLE DES MATIERES 1/76





4.5 Reference du fichier modifier.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42


4.6 Reference du fichier consulter.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49


4.7 Reference du fichier IO.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57



4.7.3 Documentation de la variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

5 Mode d’emploi de MNEMO 71

5.1 Configuration requise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.2 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.3 Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.4 Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.5 Integrite des donnees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

6 Glossaire 74

7 Bibliographie 76

TABLE DES MATIERES 2/76



Chapitre 1

Introduction

Ce rapport a pour objectif d’expliquer la conception et la realisation d’un logiciel de gestion de bibliotheque,en vue de passer l’examen du cours INGI 2113 - Structure et utilisation des systemes informatiques.

Le logiciel s’appelle Mnemo, en reference a Mnemosyne, la deesse grecque de la memoire. Cette reference nous aparu tout indiquee car, comme nous le verrons, la principale difficulte qui surgira lors de la conception du logicielsera de gerer de facon a la fois pratique, efficace et sure la masse d’informations contenue dans la bibliotheque :

– Pratique : l’interface doit permettre a l’utilisateur de realiser son travail de facon intuitive et directe, en geranttoutes les eventualites.

– Efficace : il faut que l’utilisateur - le bibliothecaire - puisse consulter et modifier rapidement le contenu de labibliotheque.

– Sure : un grand nombre d’utilisateurs peuvent travailler en parallele sur la bibliotheque. Il faut donc pouvoirgarantir la consistance des donnees lorsque plusieurs demandes de modification ont lieu en meme temps.

Les pages suivantes tenteront d’analyser ce que ces exigences signifient, et les solutions informatiques qui per-mettent de les verifier.

CHAPITRE 1. INTRODUCTION 3/76



Chapitre 2

Analyse du probleme

2.1 Cahier des charges general

Avant de reflechir a la conception meme de notre logiciel, nous devons detailler toutes les fonctionnalites quidevront etre integrees au logiciel final. Nous pouvons les regrouper en trois grands groupes :

1. Consultation de la bibliotheque :

(a) L’utilisateur doit pouvoir, a partir d’une interface graphique adaptee, faire une recherche sur la bi-bliotheque sur base de criteres. Il est libre de remplir zero, un ou plusieurs champs pour elargir oupreciser sa recherche. Les livres qui seront renvoyes par la recherche seront les livres dont les champsrespecteront chacun des criteres.

(b) Les differents champs relatifs a un livre sont :

– auteur– titre– nombre de pages– ISBN– date d’edition– maison d’edition– liste de mots-cles– cote– emprunteur

(c) Nous disons qu’un champ “respecte” un critere quand le critere (qui est une chaıne de caracteres) estune sous-chaıne du champ. De facon formelle, en utilisant la formalisation des expressions regulieres :soit un alphabet “classique” Σ (contenant les lettres majuscules et minuscules, mais egalement lesespaces et ponctuations), et deux mots critere et champ appartenant a Σ∗. Nous dirons que le critereest respecte ssi

champ ∈ (Σ∗.critere.Σ∗)

.

(d) Lorsque l’utilisateur a rempli ses criteres, le logiciel doit rechercher, dans l’ensemble de la bibliotheque,les livres correspondants, et les afficher a l’ecran sous forme de liste. Chaque ligne de cette liste cor-respond donc a un livre, et les colonnes correspondent aux differents champs.

CHAPITRE 2. ANALYSE DU PROBLEME 4/76



(e) Lorsque cette liste a ete construite, l’utilisateur peut cliquer sur un de ses elements. Cette action feraapparaıtre une nouvelle fenetre affichant les differents champs du livre. Selon l’operation voulue parl’utilisteur (modifier/supprimer un livre existant OU emprunter un livre), cette fenetre permettrad’editer certains champs, et d’enregistrer les modifications (voir plus bas).

(f) Apres cette operation, la liste doit etre mise a jour pour refleter le changement

(g) Enfin, un bouton “initialiser” permettra de remettre a zero les criteres.

L’interface de consultation dans la bibliotheque.

2. Modification de la bibliotheque :

(a) L’utilisateur peut modifier la bibliotheque de 4 facons :

i. Enregistrer un nouveau livre.

ii. Emprunter un livre existant

iii. Modifier les informations relatives a un livre existant

iv. Supprimer un livre existant.

(b) L’utilisateur pourra acceder a une interface “enregistrement” directement a partir du menu principal.Pour les 3 autres operations, il devra d’abord passer par l’interface de recherche, et cliquer sur unlivre specifique.

(c) Avant d’enregistrer ou de modifier les informations a propos d’un livre, une verification des champssera faite. En particulier, les champs “auteur” et “titre” sont obligatoires pour tous les livres.

(d) Le logiciel doit garantir a tout moment la consistance des donnees de la bibliotheque. Il faut doncassurer qu’un seul seul processus pourra acceder a l’ecriture dans le fichier, a un moment et une zonedonnee.

(e) Un fichier “log” tient a jour tous les changements effectues sur la bibliotheque.




(f) Enfin, un bouton “initialiser” permettra de remettre a zero les criteres.

L’interface de modification de la bibliotheque.

3. Administration de la bibliotheque :

(a) Une troisieme partie du logiciel permet d’obtenir diverses informations sur l’etat de la bibliotheque :

i. Dernieres modifications effectuees

ii. Nombre de livres en bibliotheque

iii. Date et heure

iv. Espace disque utilise

v. Nombre de processus de gestion de la bibliotheque en cours d’execution

(b) Ces informations seront periodiquement reactualisees, a une frequence qui pourra etre modifiee parl’utilisateur.

(c) La partie “dernieres modifications effectuees” indiquera les 5 dernieres lignes contenues dans le fichierde log.

L’interface d’administration de la bibliotheque.




2.2 Difficultes particulieres

A partir de ce cachier des charges, nous pouvons pointer quelques difficultes particulieres qu’il faudra resoudre :

2.2.1 Structure de la bibliotheque

Comment le (ou les) fichier(s) 1 contenant(s) la bibliotheque vont-ils se structurer ? Plusieurs considerationsdoivent entrer en compte :

1. Espace disque : il faut veiller a ne pas gaspiller inutilement de la place sur le disque.

2. Performance : le parcours de la bibliotheque doit se faire le plus rapidement possible.

3. Nous pouvons faire l’hypothese que les operations de consultation et d’emprunt de livres seront beaucoupplus frequentes que l’enregistrement ou la modification de livres. Elles doivent donc etre particulierementrapides.

Deux possibilites principales d’implementation s’offrent a nous :

1. Soit chaque champ de chaque livre se voit allouer une taille fixe. Cette solution a le grand avantage depermettre a un acces direct2 a une information : si nous voulons acceder au livre dont le numero de ligneest le 53, et que nous savons que chaque ligne a une longueur de 220 octets, il nous suffit de nous placer(via fseek() en C) a l’octet 53 ∗ 220 du fichier pour recuperer l’information.

Mais le desavantage de cette structure est evident : beaucoup d’espace disque est gaspille puisque chaquechamp se voit allouer une taille fixe, meme si elle ne l’utilise pas integralement. Et certains champs peuventetre tres variables : la liste de mots-cles peut aller de 0 a 200 caracteres...

De plus, la modification du champ d’un livre est aisee : il suffit de se positionner au debut de celui-ci, etde remplacer la ligne.

2. A l’inverse, on peut allouer une taille variable a chaque livre. En pratique, on peut par exemple utiliserun caractere de tabulation pour separer chaque champ, et un retour a la ligne pour separer chaque livre.Ici, l’espace disque est bien utilise : on ne perd que les quelques caracteres necessaires a la separation deschamps et des lignes.

Mais le parcours du contenu de la bibliotheque est plus fastidieux : il est impossible d’acceder directementa une information concernant un livre, puisque sa position est inconnue. Il faut donc avancer dans le fichierjusqu’a trouver l’information recherchee.

La modification d’un champ est ici plus difficile : comme la taille de celui-ci est variable, si il y a ne fut-cequ’un seul caractere de plus ou de moins dans le champ modifie, il faudra decaler tous les octets situesapres le champ.

Que faire ? Les deux solutions possedant leurs avantages et inconvenients, nous avons choisi un compromis.Nous avons fait l’hypotheque que l’operation d’emprunt etait beaucoup plus frequemment utilisee que la modi-fication des autres champ du livre. Il serait inconcevable de devoir, a chaque emprunt, modifier l’ensemble dufichier a cause du decalage resultant d’une difference de taille. Pour les autres champs, il sera rare de devoirfaire des modifications en milieu de fichier : la modification / suppression de livres existants etant rare .Pourenregistrer un nouveau livre, le probleme ne se pose pas puisque l’ecriture se fait a la fin du fichier.

La solution retenue est donc d’utiliser 2 fichiers :

1Voir glossaire2voir glossaire




1. Un fichier (appele fichier BIBLIO) avec des champs de taille variable, contenant l’ensemble du contenu dela bibliotheque

2. Un fichier (appele fichier EMPRUNT) avec des champs de taille fixe (taille que nous appelerons TAILLE EMPRUNTEUR),contenant, pour chaque livre, le nom de l’emprunteur (et uniquement cela).

La correspondance entre les deux fichiers se fait a partir des numeros de ligne. Prenons un exemple : nousvoulons emprunter un livre dont nous connaissons le nom. Nous procederons comme suit :

1. On parcourt, ligne par ligne, caractere par caractere, le fichier BIBLIO jusqu’a trouver la ligne correspon-dant au livre recherche.

2. Lors de ce parcours, on incremente une variable nb lignes representant le nombre de lignes parcourues.

3. Grace a cette taille emprunteur, nous pouvons nous positionner a l’octet nb lignes * TAILLE EMPRUNTEUR

dans le fichier EMPRUNT.

4. Nous modifions a cet emplacement le nom de l’emprunteur.

Grace a cette structure, nous pouvons concilier deux objectifs : permettre d’effectuer rapidement les operationsde consultation et d’emprunt de livres, tout en gardant des fichiers de taille raisonnable.

2.2.2 Recherche dans la bibliotheque

Comment, a partir d’un ensemble de criteres et du contenu de la bibliotheque, en retirer une liste de livres ? Onprocede par etapes :

1. On parcourt la bibliotheque ligne par ligne.

2. On divise chaque ligne en champs.

3. A l’interieur d’une ligne, on itere sur les champs

4. Pour chaque champ, on regarde s’il verifie le critere indique.

5. Si oui, on passe au champ suivant. Sinon, on passe directement a la ligne suivante : il est inutile de verifierles autres champs puisque qu’au moins un de ceux-ci ne respecte pas les criteres, le livre n’est donc pasaccepte.

6. Si tous les champs respectent les criteres, le livre est accepte : on l’insere donc dans la liste.

7. On procede ainsi jusqu’a epuiser le contenu de la bibliotheque.

Notre implementation pourra se construire a partir de ce canevas. Nous avons laisse en suspens la question desavoir comment verifier l’eventuelle correspondance entre un critere et un champ. Nous avions evoque, dans lecahier des charges, l’utilisation d’expressions regulieres. Or il existe deja de puissantes librairies pour le traite-ment d’expressions regulieres3. Nous utiliserons la librairie regex.h. L’utilisation de celle-ci procede en deuxetapes :

1. Un pre-calcul de l’expression reguliere, a partir de la chaıne de caracteres la representant.

2. La comparaison entre cette expression reguliere, et le champ a verifier.

2.2.3 Projection memoire

Pour acceder a l’information contenue dans le fichier, nous n’allons pas utiliser les instructions “classiques”d’entrees-sorties4. Ce serait une serieux handicap au niveau de la performance : pour chaque mise a jour del’affichage a l’ecran d’une liste de livres, il faudrait proceder a la lecture complete de tout le fichier BIBLIO...

3voir glossaire4voir glossaire




Nous utiliserons plutot la technique qui consiste a projeter en memoire5 le contenu du fichier (en anglais :memory-mapped files). Au lieu de lire directement dans le fichier (a l’aide d’instructions comme fread()), nousdemanderons de projeter en memoire le fichier, et il nous pourrons alors acceder au contenu du fichier en pointantdirectement sur une adresse memoire, comme pour un simple tableau de caracteres. Le fonctionnement precisde cette technique est explique dans les pages suivantes, nous nous contentons ici d’expliquer son utilisation.

Lors de l’etablissement de cette projection en memoire, nous precisons que cette projection peut etre partagee6

avec tout autre processus utilisant le meme fichier. Ceci est tres utile, puisque nous savons que plusieurs bi-bliothecaires peuvent travailler en meme temps sur le contenu de la bibliotheque : grace a cette configuration,une seule zone memoire est allouee.

Pour s’assurer que posseder la version la plus recente du contenu de la bibliotheque en cas de modifications parplusieurs utilisateurs, nous demanderons systematiquement de synchroniser7 le fichier et la projection memoire,apres chaque modification.

Pour terminer, il nous faut aussi noter qu’un probleme technique apparaıt lorsque l’on veut enregistrer de nou-veaux livres dans la projection memoire : en effet lors de la synchronisation du fichier et de la projection, touteinformation situee au-dela de l’espace memoire initialement prevu est ignoree. Il nous faut donc, pour pouvoirecrire de nouveaux enregistrements :

1. Suspendre la projection memoire (unmap(...)

2. Augmenter la taille du fichier en rajoutant des caracteres nuls a la fin de celui-ci (ftruncate (...)

3. Retablir la projection memoire, sur le fichier “augmente”

4. Ecrire sur la projection memoire le nouvel enregistrement

5. Synchroniser le fichier et la projection.

C’est un technique plutot compliquee pour un simple enregistrement, mais c’est, a notre connaissance, la seulemaniere de faire si l’on veut realiser toute operation de lecture ou d’ecriture sans passer par des instructionsd’entrees-sorties telles que fwrite(...). Notons enfin que la taille minimum de “l’augmentation” du fichierest SC PAGESIZE, c’est-a-dire la taille d’une page8 (4096 octets en general). Cette particularite est due aufonctionnement des memory-mapped files.

2.2.4 Communication inter-processus

Il nous reste a determiner comment assurer la consistance des donnees lorsque plusieurs utilisateurs effectuentdes modifications en meme temps. Sans protection, si deux utilisateurs modifient la meme zone du fichier,en meme temps, le resultat est indetermine. C’est evidemment inacceptable, il nous faut donc trouver unmoyen efficace pour que ces differents processus se coordonnent pour entrer dans la “region critique” qu’est laprojection memoire du fichier BIBLIO. C’est un probleme classique de communication interprocessus9 (Inter-

process commmunication ou IPC en anglais)

La solution que nous avons choisie est le mecanisme de verrou (lock)10. Plus precisement, nous utiliserons l’ins-truction fcntl(...). Cela fonctionne comme suit :

1. Lorsque qu’un processus veut acceder a la projection memoire, il demande a placer un verrou sur celui-ci.

2. Soit la demande est acceptee immediatement, soit la demande est mise “en attente” car un autre processusa deja place un verrou et ne l’a pas encore relache. Dans ce cas, le processus attend que ce verrou soitrelache pour continuer son execution.

3. Lorsque le processus obtient la mise en place de son verrou, il peut acceder a la ressource.

4. Quand il a termine son operation, il relache son verrou.

5voir glossaire6voir glossaire7voir glossaire8voir glossaire9voir glossaire

10voir glossaire




Deux types de verrou sont utilises : lecture et ecriture. Lors de la mise en place d’un verrou en lecture, d’autresprocessus peuvent egalement placer un verrou en lecture, mais pas en ecriture. Pour le cas d’un verrou enecriture au contraire, ni la lecture ni l’ecriture d’autre processus ne sont autorises.

Pour que la coordination entre les differents processus fonctionne, il est essentiel de s’assurer que chaque pro-cessus relache son verrou des qu’il a termine son operation, pour que les autres processus puissent acceder a laressource.

Le test du fonctionnement de cette implementation s’est effectue en bloquant, apres mise en place d’un verrou,une instance du programme (via l’instruction getchar()), et en executant une autre instance pour verifier soncomportement. Rien a redire : le mecanisme fonctionne bien.

2.2.5 Nombre de processus

La partie “administration de la bibliotheque” de notre logiciel doit afficher le nombre de processus de gestion dela bibliotheque en execution. Pour implementer cette fonctionnalite, la solution que nous avons utilisee consistea parcourir, dans le repertoire “virtuel” /proc11, l’ensemble des processus en execution, et de comparer lesfichiers /proc/<pid>/exe au fichier /proc/self/exe. Ce fichier contient le chemin de l’executable relatif auprocessus. Nous faisons l’hypothese (plausible) que le logiciel est installe a un endroit unique sur le disque. Lenombre de processus qui partagent le meme chemin d’executable sont donc des executions du meme programme.

2.2.6 Interface utilisateur

Terminons sur la realisation de l’interface graphique. L’interface a ete creee a partir des librairies GTK 1.2. Ceslibrairies sont disponibles sous l’immense majorite des systemes UNIX. Gnome se base d’ailleurs sur elles. Leurutilisation est simple et directe.

Comme nous avons vu que les fonctionnalites de notre logiciel se partageaient entre 3 grands groupes, il etaitlogique de concevoir 3 interfaces : interface1 concerne donc l’interface de recherche dans la bibliotheque,interface2 la modification (enregistrement, emprunt, modification, suppression) de livres, et interface3 l’ad-ministration.

Pour chaque interface, il existe des variantes suivant l’operation specifique a realiser : ainsi, pour l’emprunt delivres, seul le champ “emprunt” est accessible a l’edition.

11voir glossaire




Chapitre 3

Architecture du logiciel

3.1 Architecture generale

Architecture du logiciel Mnemo (Desole pour la pietre qualite graphique de ce diagramme).Une fleche indique une dependance.

Avant toute chose, precisons qu’un seul fichier d’en-tete est utilise par l’ensemble des modules : mnemo.h. Cefichier contient les declarations de l’ensembles des fonctions “publiques” pouvant etre appelees a partir de n’im-porte quel module dans le programme. Elle contient egalement la definition des chemins aux fichiers de donneesBIBLIO et EMPRUNT. Enfin, une structure denommee livre y est declaree, qui represente dans tout le pro-gramme les champs d’un livre :

struct livre {

char *auteur ;

char *titre ;

char *nb_pages ;

CHAPITRE 3. ARCHITECTURE DU LOGICIEL 11/76



char *ISBN ;

char *date_edition ;

char *maison_edition ;

char *mot_cles ;

char *cote ;

char *emprunteur;

} ;

Il nous a semble preferable, plutot que de creer des executables separes “enregistrer lib”, “emprunter lib” commepropose dans l’enonce, d’integrer l’ensemble de ceux-ci dans un seul executable. Cela rend le programme pluslisible, en reduisant le nombre de fichiers. Neammoins, si l’on desire respecter a la lettre l’enonce, il suffiraitd’ecire 4 nouveaux fichiers contenant simplement une methode main() apppelant l’interface graphique relativea l’operation, comme dans le fichier mnemo.c.

3.2 Contenu des modules

Au total, notre logiciel est separe en 7 modules :

1. mnemo.c : C’est la ou se trouve la fonction main(). On n’y trouve pas grand-chose : une interface mini-maliste avec 4 boutons qui lancent chacun une operation particuliere, apres avoir etabli la projection enmemoire des fichiers BIBLIO et EMPRUNT

2. interface1.c : C’est l’interface de consultation de la bibliotheque. On y trouve toutes les fonctions trai-tant des aspets graphiques des operations de recherche (activation des boutons, insertion dans une liste,...)

3. interface2.c : C’est l’interface de modification de la bibliotheque. La aussi, on y trouve tout ce qui atrait a l’aspect “graphique” des modifications

4. interface3.c : C’est l’interface de l’administration de la bibliotheque. Les fonctions permettant d’obteniret d’afficher des informations sur l’etat de la bibliotheque y sont implementees.

5. modifier.c : C’est dans ce fichier qu’on trouve toutes les fonctions permettant de modifier le contenude la bibliotheque (enregistrement, emprunt, modification, suppression). Elle se base sur IO.c pour lesoperations d’ecriture de base, et sur consulter.c pour le traitement du contenu de la bibliotheque

6. consulter.c : Contient toutes les fonctions ayant trait a la lecture du contenu de la bibliotheque et a sontraitement. Elle se base sur IO.c pour les operations de lecture de base

7. IO.c : C’est ici que sont implementees toutes les fonctions de bases relatives a la lecture et la l’ecrituredans le fichier : projection en memoire, mise en place de verrou, insertion de lignes, modification du nomd’un emprunteur, ....

CHAPITRE 3. ARCHITECTURE DU LOGICIEL 12/76



Chapitre 4

Documentation

Notes prealables :

1. Cette documentation a ete generee a l’aide du logiciel Doxygen

2. Nous avons pris le soin d’ecrire des specifications pour toutes les fonctions implementees. Toutefois, ellesont ete ecrites au moment ou l’implementation se construisait, certaines d’entres elles ne refletent doncpas la version definitive du programme. Vu la taille de celui-ci, il n’a pas ete possible de re-verifiersystematiquement l’ensemble des specifications.

3. Nous avons mis un effort particulier dans la redaction des specifications des modules modifier.c, consulter.c,

IO.c au detriment de celles de l’interface graphique, qui ont un interet virtuellement nul au niveau del’application des concepts informatiques de base.

CHAPITRE 4. DOCUMENTATION 13/76



4.1 Reference du fichier mnemo.c

#include <stdio.h>

#include <stdlib.h>

#include <gtk/gtk.h>

#include <unistd.h>

#include "mnemo.h"

Definitions des macros

– #define LARGEUR 200– #define HAUTEUR 200

Fonctions

– void interface0 (void)Creation de l’interface graphique pour l’enregistrement dans la bibliotheque.

– void quitter (void)Ferme l’interface graphique.

– void demarrer enregistrer (void)Demarrer l’enregistrement d’un nouveau livre.

– void demarrer modifier (void)Demarrer la consultation des livres existants.

– void demarrer emprunter (void)Demarrer l’emprunt de livres.

– void demarrer administrer (void)Demarrer l’administration.

– int main (int argc, char ∗argv[ ])

Variables

– GtkWidget ∗ fenetre– GtkWidget ∗ boite horizontale– GtkWidget ∗ boite verticale– GtkWidget ∗ label intro– GtkWidget ∗ separateur1– GtkWidget ∗ bouton enregistrer– GtkWidget ∗ bouton modifier– GtkWidget ∗ bouton emprunter– GtkWidget ∗ bouton administrer– GtkWidget ∗ pixmapwid

4.1.1 Documentation de la macro

4.1.1.1 #define HAUTEUR 200

Definition a la ligne 11 du fichier mnemo.c.




4.1.1.2 #define LARGEUR 200


4.1.2 Documentation de la fonction

4.1.2.1 void demarrer administrer (void)

Demarrer l’administration.


217 {

218 etablir_projection_memoire ();

219

220 interface3_administrer();

221

222 supprimer_projection_memoire();

223

224 }

4.1.2.2 void demarrer emprunter (void)

Demarrer l’emprunt de livres.


203 {


205

206 interface1_emprunter();

207


209 }

4.1.2.3 void demarrer enregistrer (void)

Demarrer l’enregistrement d’un nouveau livre.


171 {


173

174 interface2_enregistrer();

175


177 }

4.1.2.4 void demarrer modifier (void)

Demarrer la consultation des livres existants.


186 {





188

189 interface1_modifier();

190


192

193 }

4.1.2.5 void interface0 (void)

Creation de l’interface graphique pour l’enregistrement dans la bibliotheque.


65 {

66

67 /* La fenetre */

68 fenetre = gtk_window_new (GTK_WINDOW_TOPLEVEL);

69 gtk_widget_show (fenetre);

70

71 gtk_window_set_default_size (GTK_WINDOW (fenetre), LARGEUR, HAUTEUR);

72 gtk_window_set_title (GTK_WINDOW (fenetre), "MNEMO - gestion de bibliotheque");

73

74

75 /* La procedure quitter() est appelee quand l’utilisateur ferme la fenetre */

76 gtk_signal_connect (GTK_OBJECT (fenetre), "delete_event",

77 GTK_SIGNAL_FUNC (quitter), NULL);

78

79 /* Mise en page */

80 gtk_container_border_width (GTK_CONTAINER (fenetre), 20);

81 boite_horizontale = gtk_hbox_new(FALSE, 20);

82 gtk_container_add (GTK_CONTAINER (fenetre), boite_horizontale);

83

84 boite_verticale = gtk_vbox_new(FALSE, 20);

85 gtk_container_add (GTK_CONTAINER (boite_horizontale), boite_verticale);

86

87

88 /* Partie introductive, avec un label et un separateur */

89 label_intro = gtk_label_new ("Bienvenue dans MNEMO - logiciel de gestion de bibliotheque.\n\n************\n\n Realise par Pierre Lison pour le cours INGI 2113\[email protected]");

90 gtk_container_add (GTK_CONTAINER (boite_verticale), label_intro);

91 separateur1 = gtk_hseparator_new ();

92 gtk_container_add (GTK_CONTAINER (boite_verticale), separateur1);

93

94

95 /* Image de Mnemosyne, deesse grecque de la memoire */

96 GdkPixmap *pixmap;

97 GdkBitmap *mask;

98 GtkStyle *style;

99 style = gtk_widget_get_style( fenetre );

100 pixmap = gdk_pixmap_create_from_xpm(fenetre->window, NULL, NULL, IMAGE );

101

102 pixmapwid = gtk_pixmap_new( pixmap, mask );

103 gtk_container_add (GTK_CONTAINER (boite_horizontale), pixmapwid);

104 gtk_widget_show( pixmapwid );

105

106

107 /* Boutons enregistrer, modifier et administrer */

108 bouton_enregistrer = gtk_button_new_with_label ("Enregistrer un nouveau livre");

109 bouton_modifier = gtk_button_new_with_label ("Modifier / Supprimer un livre existant");

110 bouton_emprunter = gtk_button_new_with_label ("Emprunter un livre");

111

112 bouton_administrer = gtk_button_new_with_label ("Administration");

113 gtk_container_add (GTK_CONTAINER (boite_verticale), bouton_enregistrer);

114 gtk_container_add (GTK_CONTAINER (boite_verticale), bouton_modifier);

115 gtk_container_add (GTK_CONTAINER (boite_verticale), bouton_emprunter);

116 gtk_container_add (GTK_CONTAINER (boite_verticale), bouton_administrer);

117

118

119

120 /* La procedure start_enregistrer () est appelee lorsque

121 l’utilisateur clique sur le bouton "enregistrer" */




122 gtk_signal_connect (GTK_OBJECT (bouton_enregistrer), "clicked",

123 GTK_SIGNAL_FUNC (demarrer_enregistrer), NULL);

124

125 /* La procedure start_modifier() est appelee lorsque

126 l’utilisateur clique sur le bouton "modifier" */

127 gtk_signal_connect (GTK_OBJECT (bouton_modifier), "clicked",

128 GTK_SIGNAL_FUNC (demarrer_modifier), NULL);

129

130 /* La procedure start_consulter() est appelee lorsque


132 gtk_signal_connect (GTK_OBJECT (bouton_emprunter), "clicked",

133 GTK_SIGNAL_FUNC (demarrer_emprunter), NULL);

134

135 /* La procedure start_consulter() est appelee lorsque


137 gtk_signal_connect (GTK_OBJECT (bouton_administrer), "clicked",

138 GTK_SIGNAL_FUNC (demarrer_administrer), NULL);

139

140 /* Affichage */

141 gtk_widget_show (label_intro);

142 gtk_widget_show (separateur1);

143

144 gtk_widget_show(bouton_enregistrer);

145 gtk_widget_show(bouton_modifier);

146 gtk_widget_show(bouton_emprunter);

147 gtk_widget_show(bouton_administrer);

148 gtk_widget_show(boite_horizontale);

149

150 gtk_widget_show(boite_verticale);

151 }

4.1.2.6 int main (int argc, char ∗ argv[ ])


48 {

49 gtk_init(&argc, &argv);

50

51 interface0();

52

53 gtk_main();

54

55 return EXIT_SUCCESS;

56 }

4.1.2.7 void quitter (void)

Ferme l’interface graphique.


158 {

159 gtk_exit (EXIT_SUCCESS);

160 }




4.2 Reference du fichier interface1.c

#include <stdio.h>

#include <stdlib.h>


#include "mnemo.h"



Fonctions

– void vider label interface1 ()Vide le label situe sous les boutons.

– void reinitialiser interface1 ()Reinitialise toutes les zones de texte.

– void selectionner modifier (GtkWidget ∗, gint, gint, GdkEventButton ∗, gpointer)Affiche l’interface de modification d’un titre apres la selection d’un titre dans la liste de recherche.

– void selectionner emprunter (GtkWidget ∗, gint, gint, GdkEventButton ∗, gpointer)Affiche l’interface de modification d’un titre apres la selection d’un titre dans la liste de recherche.

– void quitter interface1 (void)Quitte l’interface graphique.

– void interface1 (void)Creation de l’interface graphique pour la consultation dans la bibliotheque (partie commune).

– livre ∗ remplir structure (int)Retourne une structure ”livre” contenant les donnees d’une rangee.

– void interface1 emprunter (void)Creation de l’interface graphique pour interface1 des livres a emprunter.

– void interface1 modifier (void)Creation de l’interface graphique pour interface1 des livres a modifier.

– livre ∗ donnees interface1 ()Retourne une structure contenant les chaınes de caracteres ecrites dans les zones de texte.

– void ecrire label interface1 (char ∗texte)Ecris la chaıne de caractere dans le label situe sous les boutons.

– void inserer item (gchar ∗item[9])Insere une rangee (tableau de 9 chaınes de caracteres) dans la liste de recherche.

– void vider liste (void)Vide la liste de recherche de toutes ses rangees.

Variables

– GtkWidget ∗ fenetre interface1– GtkWidget ∗ boite verticale interface1– GtkWidget ∗ label intro interface1




– GtkWidget ∗ separateur1 interface1– GtkWidget ∗ separateur2 interface1– GtkWidget ∗ label resultat interface1– GtkWidget ∗ boite auteur interface1– GtkWidget ∗ label auteur interface1– GtkWidget ∗ zone auteur interface1– GtkWidget ∗ boite titre interface1– GtkWidget ∗ label titre interface1– GtkWidget ∗ zone titre interface1– GtkWidget ∗ boite nb pages interface1– GtkWidget ∗ label nb pages interface1– GtkWidget ∗ zone nb pages interface1– GtkWidget ∗ boite ISBN interface1– GtkWidget ∗ label ISBN interface1– GtkWidget ∗ zone ISBN interface1– GtkWidget ∗ boite date edition interface1– GtkWidget ∗ label date edition interface1– GtkWidget ∗ zone date edition interface1– GtkWidget ∗ boite maison edition interface1– GtkWidget ∗ label maison edition interface1– GtkWidget ∗ zone maison edition interface1– GtkWidget ∗ boite mot cles interface1– GtkWidget ∗ label mot cles interface1– GtkWidget ∗ zone mot cles interface1– GtkWidget ∗ boite cote interface1– GtkWidget ∗ label cote interface1– GtkWidget ∗ zone cote interface1– GtkWidget ∗ boite emprunteur interface1– GtkWidget ∗ label emprunteur interface1– GtkWidget ∗ zone emprunteur interface1– GtkWidget ∗ boite boutons interface1– GtkWidget ∗ bouton rechercher interface1– GtkWidget ∗ bouton reinitialiser interface1– GtkWidget ∗ fenetre defilement– GtkWidget ∗ liste recherche– gchar ∗ titres [9] = { ”Auteur”, ”Titre”,”Maison d’edition”, ”Annee”, ”Pages”, ”ISBN”,”Cote”, ”Mot-cles”,

”emprunteur” }– int activewindows interface1 = 0



Definition a la ligne 8 du fichier interface1.c.




4.2.2.1 struct livre∗ donnees interface1 ()

Retourne une structure contenant les chaınes de caracteres ecrites dans les zones de texte.


359 {

360 struct livre *donnees ;

361 donnees=(struct livre *)malloc(sizeof(struct livre));

362

363 donnees->auteur = gtk_entry_get_text (GTK_ENTRY (zone_auteur_interface1)) ;

364 donnees->titre = gtk_entry_get_text (GTK_ENTRY (zone_titre_interface1)) ;

365 donnees->nb_pages = gtk_entry_get_text (GTK_ENTRY (zone_nb_pages_interface1)) ;




366 donnees->ISBN = gtk_entry_get_text (GTK_ENTRY (zone_ISBN_interface1)) ;

367 donnees->date_edition = gtk_entry_get_text (GTK_ENTRY (zone_date_edition_interface1)) ;

368 donnees->maison_edition = gtk_entry_get_text (GTK_ENTRY (zone_maison_edition_interface1)) ;

369 donnees->mot_cles = gtk_entry_get_text (GTK_ENTRY (zone_mot_cles_interface1)) ;

370 donnees->cote = gtk_entry_get_text (GTK_ENTRY (zone_cote_interface1)) ;

371 donnees->emprunteur = gtk_entry_get_text (GTK_ENTRY (zone_emprunteur_interface1)) ;

372 return donnees ;

373 }

4.2.2.2 void ecrire label interface1 (char ∗ texte)

Ecris la chaıne de caractere dans le label situe sous les boutons.


381 {

382 gtk_label_set (GTK_LABEL (label_resultat_interface1), texte);

383 }

4.2.2.3 void inserer item (gchar ∗ item[9])

Insere une rangee (tableau de 9 chaınes de caracteres) dans la liste de recherche.

Precondition :les 9 chaınes doivent etre alloues.


458 {

459 gtk_clist_append( (GtkCList *) liste_recherche, item);

460 }


Creation de l’interface graphique pour la consultation dans la bibliotheque (partie commune).


151 {

152

153 /* La fenetre */

154 fenetre_interface1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);

155 gtk_window_set_default_size (GTK_WINDOW (fenetre_interface1), LARGEUR, HAUTEUR);

156 gtk_window_set_title (GTK_WINDOW (fenetre_interface1), "MNEMO - Recherche dans la bibliotheque");

157

158


160 gtk_signal_connect (GTK_OBJECT (fenetre_interface1), "delete_event",

161 GTK_SIGNAL_FUNC (quitter_interface1), NULL);

162

163

164 /* La procedure vider_label() est appelee quand l’utilisateur presse une touche */

165 gtk_signal_connect (GTK_OBJECT (fenetre_interface1), "key_press_event",

166 GTK_SIGNAL_FUNC (vider_label_interface1), (gpointer) NULL);

167

168


170 gtk_container_border_width (GTK_CONTAINER (fenetre_interface1), 20);

171 boite_verticale_interface1 = gtk_vbox_new(FALSE, 0);

172 gtk_container_add (GTK_CONTAINER (fenetre_interface1), boite_verticale_interface1);

173





175 label_intro_interface1 = gtk_label_new ("Veuillez saisir vos criteres de recherche: ");

176 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), label_intro_interface1);

177 separateur1_interface1 = gtk_hseparator_new ();

178 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), separateur1_interface1);

179

180 /* La partie "auteur", avec label et zone de texte */

181 boite_auteur_interface1 = gtk_hbox_new(TRUE, 0);

182 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_auteur_interface1);

183 label_auteur_interface1 = gtk_label_new ("Auteur: ");

184 zone_auteur_interface1 = gtk_entry_new();

185

186 /* La partie "titre", avec label et zone de texte */

187 boite_titre_interface1 = gtk_hbox_new(TRUE, 0);

188 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_titre_interface1);

189 label_titre_interface1 = gtk_label_new ("Titre: ");

190 zone_titre_interface1 = gtk_entry_new();

191

192 /* La partie "nombre de pages", avec label et zone de texte */

193 boite_nb_pages_interface1 = gtk_hbox_new(TRUE, 0);

194 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_nb_pages_interface1);

195 label_nb_pages_interface1 = gtk_label_new ("Nombre de pages: ");

196 zone_nb_pages_interface1 = gtk_entry_new();

197

198 /* La partie "ISBN", avec label et zone de texte */

199 boite_ISBN_interface1 = gtk_hbox_new(TRUE, 0);

200 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_ISBN_interface1);

201 label_ISBN_interface1 = gtk_label_new ("Numero ISBN: ");

202 zone_ISBN_interface1 = gtk_entry_new();

203

204 /* La partie "date d’edition", avec label et zone de texte */

205 boite_date_edition_interface1= gtk_hbox_new(TRUE, 0);

206 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_date_edition_interface1);

207 label_date_edition_interface1 = gtk_label_new ("Date d’edition: ");

208 zone_date_edition_interface1 = gtk_entry_new();

209

210 /* La partie "maison d’edition", avec label et zone de texte */

211 boite_maison_edition_interface1= gtk_hbox_new(TRUE, 0);

212 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_maison_edition_interface1);

213 label_maison_edition_interface1 = gtk_label_new ("Maison d’edition: ");

214 zone_maison_edition_interface1 = gtk_entry_new();

215

216 /* La partie "mot-cles", avec label et zone de texte */

217 boite_mot_cles_interface1= gtk_hbox_new(TRUE, 0);

218 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_mot_cles_interface1);

219 label_mot_cles_interface1 = gtk_label_new ("Mot-cles: ");

220 zone_mot_cles_interface1 = gtk_entry_new();

221

222 /* La partie "Cote", avec label et zone de texte */

223 boite_cote_interface1 = gtk_hbox_new(TRUE, 0);

224 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_cote_interface1);

225 label_cote_interface1 = gtk_label_new ("Cote: ");

226 zone_cote_interface1 = gtk_entry_new();

227

228 /* La partie "emprunteur", avec label et zone de texte */

229 boite_emprunteur_interface1 = gtk_hbox_new(TRUE, 0);

230 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_emprunteur_interface1);

231 label_emprunteur_interface1 = gtk_label_new ("Emprunteur: ");

232 zone_emprunteur_interface1 = gtk_entry_new();

233

234 /* La taille maximale du nom d’un emprunteur est TAILLE_EMPRUNTEUR */

235 gtk_entry_set_max_length (GTK_ENTRY(zone_emprunteur_interface1), 20);

236

237

238 /* Le bas de l’interface graphique, avec 1 separateur, 2 boutons et un label */



241 gtk_widget_set_usize(separateur2_interface1, LARGEUR, 30);

242

243 boite_boutons_interface1 = gtk_hbox_new(TRUE, 0);

244 gtk_container_add (GTK_CONTAINER (boite_verticale_interface1), boite_boutons_interface1);

245 bouton_rechercher_interface1 = gtk_button_new_with_label ("Rechercher");

246

247 bouton_reinitialiser_interface1 = gtk_button_new_with_label ("Reinitialiser");




248 label_resultat_interface1 = gtk_label_new ("");

249 gtk_widget_set_usize(label_resultat_interface1, LARGEUR, 50);

250

251

252 /* La procedure consulter() est appelee lorsque


254 gtk_signal_connect (GTK_OBJECT (bouton_rechercher_interface1), "clicked",

255 GTK_SIGNAL_FUNC (consulter), NULL);

256

257 /* La procedure reinitialiser() est appelee lorsque

258 l’utilisateur clique sur le bouton "reinitialiser" */

259 gtk_signal_connect (GTK_OBJECT (bouton_reinitialiser_interface1), "clicked",

260 GTK_SIGNAL_FUNC (reinitialiser_interface1), NULL);

261

262

263 /* Fenetre de defilement pour la liste de recherche */

264 fenetre_defilement = gtk_scrolled_window_new (NULL, NULL);

265 gtk_widget_set_usize(fenetre_defilement, LARGEUR, HAUTEUR/3);

266 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (fenetre_defilement),

267 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

268

269

270 /* La liste de recherche */

271 liste_recherche = gtk_clist_new_with_titles( 9, titres);

272 gtk_clist_set_shadow_type (GTK_CLIST(liste_recherche), GTK_SHADOW_OUT);

273 gtk_clist_set_column_width (GTK_CLIST(liste_recherche), 0, 200);









282

283 gtk_container_add(GTK_CONTAINER(fenetre_defilement), liste_recherche);

284

285


287 gtk_box_pack_start(GTK_BOX(boite_auteur_interface1), label_auteur_interface1, TRUE, TRUE, 0);

288 gtk_box_pack_start(GTK_BOX(boite_auteur_interface1), zone_auteur_interface1, TRUE, TRUE, 0);

289 gtk_box_pack_start(GTK_BOX(boite_titre_interface1), label_titre_interface1, TRUE, TRUE, 0);

290 gtk_box_pack_start(GTK_BOX(boite_titre_interface1), zone_titre_interface1, TRUE, TRUE, 0);

291 gtk_box_pack_start(GTK_BOX(boite_nb_pages_interface1), label_nb_pages_interface1, TRUE, TRUE, 0);

292 gtk_box_pack_start(GTK_BOX(boite_nb_pages_interface1), zone_nb_pages_interface1, TRUE, TRUE, 0);

293 gtk_box_pack_start(GTK_BOX(boite_ISBN_interface1), label_ISBN_interface1, TRUE, TRUE, 0);

294 gtk_box_pack_start(GTK_BOX(boite_ISBN_interface1),zone_ISBN_interface1, TRUE, TRUE, 0);

295 gtk_box_pack_start(GTK_BOX(boite_date_edition_interface1), label_date_edition_interface1, TRUE, TRUE, 0);

296 gtk_box_pack_start(GTK_BOX(boite_date_edition_interface1), zone_date_edition_interface1, TRUE, TRUE, 0);

297 gtk_box_pack_start(GTK_BOX(boite_maison_edition_interface1), label_maison_edition_interface1, TRUE, TRUE, 0);

298 gtk_box_pack_start(GTK_BOX(boite_maison_edition_interface1), zone_maison_edition_interface1, TRUE, TRUE, 0);

299 gtk_box_pack_start(GTK_BOX(boite_mot_cles_interface1), label_mot_cles_interface1, TRUE, TRUE, 0);

300 gtk_box_pack_start(GTK_BOX(boite_mot_cles_interface1), zone_mot_cles_interface1, TRUE, TRUE, 0);

301 gtk_box_pack_start(GTK_BOX(boite_cote_interface1), label_cote_interface1, TRUE, TRUE, 0);

302 gtk_box_pack_start(GTK_BOX(boite_cote_interface1), zone_cote_interface1, TRUE, TRUE, 0);

303 gtk_box_pack_start(GTK_BOX(boite_emprunteur_interface1), label_emprunteur_interface1, TRUE, TRUE, 0);

304 gtk_box_pack_start(GTK_BOX(boite_emprunteur_interface1), zone_emprunteur_interface1, TRUE, TRUE, 0);

305 gtk_box_pack_start(GTK_BOX(boite_verticale_interface1), label_resultat_interface1, TRUE, TRUE, 0);

306 gtk_box_pack_start(GTK_BOX(boite_boutons_interface1), bouton_reinitialiser_interface1, TRUE, TRUE, 0);

307 gtk_box_pack_start(GTK_BOX(boite_boutons_interface1), bouton_rechercher_interface1, TRUE, TRUE, 0);

308 gtk_box_pack_start(GTK_BOX(boite_verticale_interface1), fenetre_defilement, TRUE, TRUE, 0);

309

310

311 /* Affichage */

312 gtk_widget_show (label_intro_interface1);

313 gtk_widget_show (separateur1_interface1);

314 gtk_widget_show (label_auteur_interface1);

315 gtk_widget_show (zone_auteur_interface1);

316 gtk_widget_show (boite_auteur_interface1);

317 gtk_widget_show (label_titre_interface1);

318 gtk_widget_show (zone_titre_interface1);

319 gtk_widget_show (boite_titre_interface1);

320 gtk_widget_show (label_nb_pages_interface1);

321 gtk_widget_show (zone_nb_pages_interface1);




322 gtk_widget_show (boite_nb_pages_interface1);

323 gtk_widget_show (label_ISBN_interface1);

324 gtk_widget_show (zone_ISBN_interface1);

325 gtk_widget_show (boite_ISBN_interface1);

326 gtk_widget_show (label_date_edition_interface1);

327 gtk_widget_show (zone_date_edition_interface1);

328 gtk_widget_show (boite_date_edition_interface1);

329 gtk_widget_show (label_maison_edition_interface1);

330 gtk_widget_show (zone_maison_edition_interface1);

331 gtk_widget_show (boite_maison_edition_interface1);

332 gtk_widget_show (label_mot_cles_interface1);

333 gtk_widget_show (zone_mot_cles_interface1);

334 gtk_widget_show (boite_mot_cles_interface1);

335 gtk_widget_show (label_cote_interface1);

336 gtk_widget_show (zone_cote_interface1);

337 gtk_widget_show (boite_cote_interface1);

338 gtk_widget_show (label_emprunteur_interface1);

339 gtk_widget_show (zone_emprunteur_interface1);

340 gtk_widget_show (boite_emprunteur_interface1);


342 gtk_widget_show (bouton_rechercher_interface1);

343 gtk_widget_show (bouton_reinitialiser_interface1);

344 gtk_widget_show (label_resultat_interface1);

345 gtk_widget_show (boite_boutons_interface1);

346 gtk_widget_show (fenetre_defilement);

347 gtk_widget_show (liste_recherche);

348 gtk_widget_show (boite_verticale_interface1);

349 gtk_widget_show (fenetre_interface1);

350

351 }

4.2.2.5 void interface1 emprunter (void)

Creation de l’interface graphique pour interface1 des livres a emprunter.


106 {

107 /* Une seule fenetre active est autorisee a la fois pour le meme processus

108 (pour des raison techniques propres a GTK) */

109 if (activewindows_interface1>0) return;

110 activewindows_interface1++;

111

112 interface1();

113

114 /* La fonction selectionner_emprunter() est appelee lorsque

115 l’utilisateur clique sur un element de la liste */

116 gtk_signal_connect (GTK_OBJECT (liste_recherche), "select_row",

117 GTK_SIGNAL_FUNC (selectionner_emprunter),NULL);

118

119 gtk_main();

120 }

4.2.2.6 void interface1 modifier (void)

Creation de l’interface graphique pour interface1 des livres a modifier.


128 {

129





134




135 interface1();

136

137 /* La fonction selectionner_emprunter() est appelee lorsque

138 l’utilisateur clique sur un element de la liste */

139 gtk_signal_connect(GTK_OBJECT(liste_recherche), "select_row",

140 GTK_SIGNAL_FUNC(selectionner_modifier), NULL);

141

142 gtk_main();

143 }

4.2.2.7 void quitter interface1 (void)

Quitte l’interface graphique.


478 {

479 gtk_widget_destroy(fenetre_interface1);

480 activewindows_interface1--;

481 }

4.2.2.8 void reinitialiser interface1 ()

Reinitialise toutes les zones de texte.


401 {

402 gtk_entry_set_text (GTK_ENTRY (zone_auteur_interface1), "");

403 gtk_entry_set_text (GTK_ENTRY (zone_titre_interface1), "");

404 gtk_entry_set_text (GTK_ENTRY (zone_nb_pages_interface1), "");

405 gtk_entry_set_text (GTK_ENTRY (zone_ISBN_interface1), "");

406 gtk_entry_set_text (GTK_ENTRY (zone_date_edition_interface1), "");

407 gtk_entry_set_text (GTK_ENTRY (zone_maison_edition_interface1), "");

408 gtk_entry_set_text (GTK_ENTRY (zone_mot_cles_interface1), "");

409 gtk_entry_set_text (GTK_ENTRY (zone_cote_interface1), "");

410 gtk_entry_set_text (GTK_ENTRY (zone_emprunteur_interface1), "");

411 gtk_label_set (GTK_LABEL (label_resultat_interface1), "");

412

413 }

4.2.2.9 struct livre ∗ remplir structure (int row)

Retourne une structure ”livre” contenant les donnees d’une rangee.

Renvoie :livre le livre selectionne


491 {



494

495 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 0, &donnees->auteur);

496 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 1, &donnees->titre);

497 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 4, &donnees->nb_pages);

498 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 5, &donnees->ISBN);

499 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 3, &donnees->date_edition);

500 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 2, &donnees->maison_edition);

501 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 7, &donnees->mot_cles);




502 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 6, &donnees->cote);

503 gtk_clist_get_text (GTK_CLIST(liste_recherche), row, 8, &donnees->emprunteur);

504

505 return donnees;

506 }

4.2.2.10 void selectionner emprunter (GtkWidget ∗ clist, gint row, gint column,GdkEventButton ∗ event, gpointer data)

Affiche l’interface de modification d’un titre apres la selection d’un titre dans la liste de recherche.


442 {

443 /* Lance la modification du livre selectionne */

444 interface2_emprunter (remplir_structure (row));

445

446 return;

447 }

4.2.2.11 void selectionner modifier (GtkWidget ∗ clist, gint row, gint column, GdkEventButton∗ event, gpointer data)

Affiche l’interface de modification d’un titre apres la selection d’un titre dans la liste de recherche.


425 {

426 /* Lance la modification du livre selectionne */

427 interface2_modifier (remplir_structure (row));

428

429 return;

430 }

4.2.2.12 void vider label interface1 ()

Vide le label situe sous les boutons.


391 {

392 ecrire_label_interface1 ("");

393 }

4.2.2.13 void vider liste (void)

Vide la liste de recherche de toutes ses rangees.


468 {

469 gtk_clist_clear ((GtkCList *) liste_recherche);

470 }





#include <stdio.h>

#include <stdlib.h>


#include "mnemo.h"



Fonctions

– void vider label interface2 ()Vide le label situe sous les boutons.

– void quitter interface2 ()Ferme l’interface graphique.

– void interface2 (void)Creation de l’interface graphique (partie commune).

– void interdire edition (GtkEditable ∗)Interdit l’ecriture dans l’objet GtkEditable, et change la couleur de fond.

– void interface2 enregistrer (void)Charge l’interface graphique pour l’enregistrement dans la bibliotheque.

– void interface2 modifier (struct livre ∗donnees)Charge l’interface graphique pour la modification dans la bibliotheque.

– void interface2 emprunter (struct livre ∗donnees)– livre ∗ donnees interface2 ()


– void ecrire label interface2 (char ∗texte)Ecris la chaıne de caractere dans le label situe sous les boutons.

– void reinitialiser interface2 ()Reinitialise toutes les zones de texte.

– livre ∗ livre initial (void)Retourne le livre a modifier.

Variables

– GtkWidget ∗ fenetre interface2– GtkWidget ∗ boite verticale interface2– GtkWidget ∗ label intro interface2– GtkWidget ∗ separateur1 interface2– GtkWidget ∗ separateur2 interface2– GtkWidget ∗ label resultat interface2– GtkWidget ∗ boite auteur interface2– GtkWidget ∗ label auteur interface2– GtkWidget ∗ zone auteur interface2– GtkWidget ∗ boite titre interface2– GtkWidget ∗ label titre interface2– GtkWidget ∗ zone titre interface2




– GtkWidget ∗ boite nb pages interface2– GtkWidget ∗ label nb pages interface2– GtkWidget ∗ zone nb pages interface2– GtkWidget ∗ boite ISBN interface2– GtkWidget ∗ label ISBN interface2– GtkWidget ∗ zone ISBN interface2– GtkWidget ∗ boite date edition interface2– GtkWidget ∗ label date edition interface2– GtkWidget ∗ zone date edition interface2– GtkWidget ∗ boite maison edition interface2– GtkWidget ∗ label maison edition interface2– GtkWidget ∗ zone maison edition interface2– GtkWidget ∗ boite mot cles interface2– GtkWidget ∗ label mot cles interface2– GtkWidget ∗ zone mot cles interface2– GtkWidget ∗ boite cote interface2– GtkWidget ∗ label cote interface2– GtkWidget ∗ zone cote interface2– GtkWidget ∗ boite emprunteur interface2– GtkWidget ∗ label emprunteur interface2– GtkWidget ∗ zone emprunteur interface2– GtkWidget ∗ boite boutons interface2– GtkWidget ∗ bouton enregistrement interface2– GtkWidget ∗ bouton reinitialiser interface2– GtkWidget ∗ bouton supprimer interface2– int activewindows interface2 = 0– livre ∗ livre a modifier







4.3.2.1 struct livre∗ donnees interface2 ()



434 {



437

438 donnees->auteur = gtk_entry_get_text (GTK_ENTRY (zone_auteur_interface2)) ;

439 donnees->titre = gtk_entry_get_text (GTK_ENTRY (zone_titre_interface2)) ;

440 donnees->nb_pages = gtk_entry_get_text (GTK_ENTRY (zone_nb_pages_interface2)) ;

441 donnees->ISBN = gtk_entry_get_text (GTK_ENTRY (zone_ISBN_interface2)) ;

442 donnees->date_edition = gtk_entry_get_text (GTK_ENTRY (zone_date_edition_interface2)) ;

443 donnees->maison_edition = gtk_entry_get_text (GTK_ENTRY (zone_maison_edition_interface2)) ;

444 donnees->mot_cles = gtk_entry_get_text (GTK_ENTRY (zone_mot_cles_interface2)) ;

445 donnees->cote = gtk_entry_get_text (GTK_ENTRY (zone_cote_interface2)) ;

446 donnees->emprunteur = gtk_entry_get_text (GTK_ENTRY (zone_emprunteur_interface2)) ;

447

448

449 return donnees ;

450 }




4.3.2.2 void ecrire label interface2 (char ∗ texte)



457 {

458 gtk_label_set (GTK_LABEL (label_resultat_interface2), texte);

459 }

4.3.2.3 void interdire edition (GtkEditable ∗ w)

Interdit l’ecriture dans l’objet GtkEditable, et change la couleur de fond.


238 {

239 GtkRcStyle *rc_style;

240 gtk_editable_set_editable (w, FALSE);

241 GdkColor gray = {1, 0x9999, 0x9999, 0x9999};

242

243 rc_style = gtk_rc_style_new ();

244 rc_style->fg[GTK_STATE_NORMAL] = gray;

245 rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;

246 gtk_widget_modify_style (GTK_WIDGET (w), rc_style);

247 gtk_rc_style_unref (rc_style);

248 }


Creation de l’interface graphique (partie commune).


259 {

260

261 /* La fenetre */



264 gtk_window_set_title (GTK_WINDOW (fenetre_interface2), "MNEMO - Enregistrement dans la bibliotheque");

265

266




270

271

272 /* La procedure vider_label() est appelee quand l’utilisateur presse une touche */

273 gtk_signal_connect (GTK_OBJECT (fenetre_interface2), "key_press_event",

274 GTK_SIGNAL_FUNC (vider_label_interface2), (gpointer) NULL);

275

276



279 boite_verticale_interface2 = gtk_vbox_new(TRUE, 0);


281


283 label_intro_interface2 = gtk_label_new ("Veuillez saisir les informations relatives au livre a enregistrer: ");

284 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), label_intro_interface2);



287





289 boite_auteur_interface2 = gtk_hbox_new(TRUE, 0);

290 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_auteur_interface2);

291 label_auteur_interface2 = gtk_label_new ("Auteur: ");

292 zone_auteur_interface2 = gtk_entry_new();

293

294 /* La partie "titre", avec label et zone de texte */

295 boite_titre_interface2 = gtk_hbox_new(TRUE, 0);

296 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_titre_interface2);

297 label_titre_interface2 = gtk_label_new ("Titre: ");

298 zone_titre_interface2 = gtk_entry_new();

299


301 boite_nb_pages_interface2 = gtk_hbox_new(TRUE, 0);

302 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_nb_pages_interface2);

303 label_nb_pages_interface2 = gtk_label_new ("Nombre de pages: ");

304 zone_nb_pages_interface2 = gtk_entry_new();

305

306 /* La partie "ISBN", avec label et zone de texte */

307 boite_ISBN_interface2 = gtk_hbox_new(TRUE, 0);

308 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_ISBN_interface2);

309 label_ISBN_interface2 = gtk_label_new ("Numero ISBN: ");

310 zone_ISBN_interface2 = gtk_entry_new();

311

312 /* La partie "date d’edition", avec label et zone de texte */

313 boite_date_edition_interface2= gtk_hbox_new(TRUE, 0);

314 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_date_edition_interface2);

315 label_date_edition_interface2 = gtk_label_new ("Date d’edition: ");

316 zone_date_edition_interface2 = gtk_entry_new();

317

318 /* La partie "maison d’edition", avec label et zone de texte */

319 boite_maison_edition_interface2= gtk_hbox_new(TRUE, 0);

320 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_maison_edition_interface2);

321 label_maison_edition_interface2 = gtk_label_new ("Maison d’edition: ");

322 zone_maison_edition_interface2 = gtk_entry_new();

323

324 /* La partie "mot-cles", avec label et zone de texte */

325 boite_mot_cles_interface2= gtk_hbox_new(TRUE, 0);

326 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_mot_cles_interface2);

327 label_mot_cles_interface2 = gtk_label_new ("Mot-cles: ");

328 zone_mot_cles_interface2 = gtk_entry_new();

329

330 /* La partie "Cote", avec label et zone de texte */

331 boite_cote_interface2 = gtk_hbox_new(TRUE, 0);

332 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_cote_interface2);

333 label_cote_interface2 = gtk_label_new ("Cote: ");

334 zone_cote_interface2 = gtk_entry_new();

335

336 /* La partie "Emprunteur", avec label et zone de texte */

337 boite_emprunteur_interface2 = gtk_hbox_new(TRUE, 0);

338 gtk_container_add (GTK_CONTAINER (boite_verticale_interface2), boite_emprunteur_interface2);

339


341 label_emprunteur_interface2 = gtk_label_new ("Emprunteur: ");

342 zone_emprunteur_interface2 = gtk_entry_new();

343

344 gtk_box_pack_start(GTK_BOX(boite_emprunteur_interface2), label_emprunteur_interface2, TRUE, TRUE, 0);

345 gtk_box_pack_start(GTK_BOX(boite_emprunteur_interface2), zone_emprunteur_interface2, TRUE, TRUE, 0);

346

347 /* La taille maximale du nom d’un emprunteur est TAILLE_EMPRUNTEUR */

348 gtk_entry_set_max_length (GTK_ENTRY(zone_emprunteur_interface2), 19);

349

350 /* Le bas de l’interface graphique, avec 1 separateur, 2 boutons et un label */



353 boite_boutons_interface2 = gtk_hbox_new(TRUE, 0);


355 bouton_enregistrement_interface2 = gtk_button_new_with_label ("Enregistrer");

356 bouton_reinitialiser_interface2 = gtk_button_new_with_label ("Reinitialiser");

357 label_resultat_interface2 = gtk_label_new ("");

358

359

360 /* La fonction reinitialiser() est appelee lorsque

361 l’utilisateur clique sur le bouton "reinitialiser" */

362 gtk_signal_connect (GTK_OBJECT (bouton_reinitialiser_interface2), "clicked",




363 GTK_SIGNAL_FUNC (reinitialiser_interface2), NULL);

364

365


367 gtk_box_pack_start(GTK_BOX(boite_auteur_interface2), label_auteur_interface2, TRUE, TRUE, 0);

368 gtk_box_pack_start(GTK_BOX(boite_auteur_interface2), zone_auteur_interface2, TRUE, TRUE, 0);

369 gtk_box_pack_start(GTK_BOX(boite_titre_interface2), label_titre_interface2, TRUE, TRUE, 0);

370 gtk_box_pack_start(GTK_BOX(boite_titre_interface2), zone_titre_interface2, TRUE, TRUE, 0);

371 gtk_box_pack_start(GTK_BOX(boite_nb_pages_interface2), label_nb_pages_interface2, TRUE, TRUE, 0);

372 gtk_box_pack_start(GTK_BOX(boite_nb_pages_interface2), zone_nb_pages_interface2, TRUE, TRUE, 0);

373 gtk_box_pack_start(GTK_BOX(boite_ISBN_interface2), label_ISBN_interface2, TRUE, TRUE, 0);

374 gtk_box_pack_start(GTK_BOX(boite_ISBN_interface2),zone_ISBN_interface2, TRUE, TRUE, 0);

375 gtk_box_pack_start(GTK_BOX(boite_date_edition_interface2), label_date_edition_interface2, TRUE, TRUE, 0);

376 gtk_box_pack_start(GTK_BOX(boite_date_edition_interface2), zone_date_edition_interface2, TRUE, TRUE, 0);

377 gtk_box_pack_start(GTK_BOX(boite_maison_edition_interface2), label_maison_edition_interface2, TRUE, TRUE, 0);

378 gtk_box_pack_start(GTK_BOX(boite_maison_edition_interface2), zone_maison_edition_interface2, TRUE, TRUE, 0);

379 gtk_box_pack_start(GTK_BOX(boite_mot_cles_interface2), label_mot_cles_interface2, TRUE, TRUE, 0);

380 gtk_box_pack_start(GTK_BOX(boite_mot_cles_interface2), zone_mot_cles_interface2, TRUE, TRUE, 0);

381 gtk_box_pack_start(GTK_BOX(boite_cote_interface2), label_cote_interface2, TRUE, TRUE, 0);

382 gtk_box_pack_start(GTK_BOX(boite_cote_interface2), zone_cote_interface2, TRUE, TRUE, 0);

383 gtk_box_pack_start(GTK_BOX(boite_verticale_interface2), label_resultat_interface2, TRUE, TRUE, 0);

384 gtk_box_pack_start(GTK_BOX(boite_boutons_interface2), bouton_reinitialiser_interface2, TRUE, TRUE, 10);

385 gtk_box_pack_end(GTK_BOX(boite_boutons_interface2), bouton_enregistrement_interface2, TRUE, TRUE, 10);

386

387

388 /* Affichage */

389 gtk_widget_show (label_intro_interface2);


391 gtk_widget_show (label_auteur_interface2);

392 gtk_widget_show (zone_auteur_interface2);

393 gtk_widget_show(boite_auteur_interface2);

394 gtk_widget_show (label_titre_interface2);

395 gtk_widget_show (zone_titre_interface2);

396 gtk_widget_show(boite_titre_interface2);

397 gtk_widget_show (label_nb_pages_interface2);

398 gtk_widget_show (zone_nb_pages_interface2);

399 gtk_widget_show(boite_nb_pages_interface2);

400 gtk_widget_show (label_ISBN_interface2);

401 gtk_widget_show (zone_ISBN_interface2);

402 gtk_widget_show(boite_ISBN_interface2);



405 gtk_widget_show(boite_date_edition_interface2);



408 gtk_widget_show(boite_date_edition_interface2);

409 gtk_widget_show (label_maison_edition_interface2);

410 gtk_widget_show (zone_maison_edition_interface2);

411 gtk_widget_show(boite_maison_edition_interface2);

412 gtk_widget_show (label_mot_cles_interface2);

413 gtk_widget_show (zone_mot_cles_interface2);

414 gtk_widget_show(boite_mot_cles_interface2);

415 gtk_widget_show (label_cote_interface2);

416 gtk_widget_show (zone_cote_interface2);

417 gtk_widget_show(boite_cote_interface2);


419 gtk_widget_show(bouton_enregistrement_interface2);

420 gtk_widget_show(bouton_reinitialiser_interface2);

421 gtk_widget_show (label_resultat_interface2);


423 gtk_widget_show(boite_verticale_interface2);


425

426 }

4.3.2.5 void interface2 emprunter (struct livre ∗ donnees)


179 {








184

185 /* Chargement de l’interface commune */

186 interface2();

187



190 gtk_widget_show(boite_emprunteur_interface2);

191

192

193 gtk_window_set_title (GTK_WINDOW (fenetre_interface2), "MNEMO - Emprunt d’un livre dans la bibliotheque");

194

195 /* La fonction emprunter est appelee lorsque l’utilisateur clique sur le

196 bouton "enregistrer */

197 gtk_signal_connect (GTK_OBJECT (bouton_enregistrement_interface2), "clicked",

198 GTK_SIGNAL_FUNC (emprunter),NULL);

199

200 /* Ecriture dans les champs de texte des donnees du livre a modifier */

201 gtk_entry_set_text (GTK_ENTRY (zone_auteur_interface2), donnees->auteur);

202 gtk_entry_set_text (GTK_ENTRY (zone_titre_interface2), donnees->titre);

203 gtk_entry_set_text (GTK_ENTRY (zone_nb_pages_interface2), donnees->nb_pages);

204 gtk_entry_set_text (GTK_ENTRY (zone_ISBN_interface2), donnees->ISBN);

205 gtk_entry_set_text (GTK_ENTRY (zone_date_edition_interface2), donnees->date_edition);

206 gtk_entry_set_text (GTK_ENTRY (zone_maison_edition_interface2), donnees->maison_edition);

207 gtk_entry_set_text (GTK_ENTRY (zone_mot_cles_interface2), donnees->mot_cles);

208 gtk_entry_set_text (GTK_ENTRY (zone_cote_interface2), donnees->cote);

209 gtk_entry_set_text (GTK_ENTRY (zone_emprunteur_interface2), donnees->emprunteur);

210

211 /* Interdire l’edition dans les champs du livre */

212 interdire_edition (GTK_EDITABLE(zone_auteur_interface2));

213 interdire_edition (GTK_EDITABLE(zone_titre_interface2));

214 interdire_edition (GTK_EDITABLE(zone_nb_pages_interface2));

215 interdire_edition (GTK_EDITABLE(zone_ISBN_interface2));

216 interdire_edition (GTK_EDITABLE(zone_date_edition_interface2));

217 interdire_edition (GTK_EDITABLE(zone_maison_edition_interface2));

218 interdire_edition (GTK_EDITABLE(zone_mot_cles_interface2));

219 interdire_edition (GTK_EDITABLE(zone_cote_interface2));

220

221 gtk_widget_hide (bouton_reinitialiser_interface2);

222

223

224 /* Les donnees du livre a emprunter sont conservees dans une variable globale*/

225 livre_a_modifier = donnees;

226

227 gtk_main();

228

229

230 }

4.3.2.6 void interface2 enregistrer (void)

Charge l’interface graphique pour l’enregistrement dans la bibliotheque.

Precondition ::

Postcondition :L’interface graphique est chargee, dans la configuration ”enregistrement” (11 labels, 9 champs de texte, 2boutons).


95 {








100

101 interface2();

102

103 /* La fonction enregistrer() est appelee lorsque


105 gtk_signal_connect (GTK_OBJECT (bouton_enregistrement_interface2), "clicked", GTK_SIGNAL_FUNC (enregistrer), NULL);

106

107 gtk_main();

108 }

4.3.2.7 void interface2 modifier (struct livre ∗ donnees)

Charge l’interface graphique pour la modification dans la bibliotheque.

Parametres :donnees un livre.

Precondition :les donnees du livre sont remplies

Postcondition :L’interface graphique est chargee, dans la configuration ”modification” (11 labels, 9 champs de texte, 3boutons).


124 {

125





130

131 /* Chargement de l’interface commune */

132 interface2();

133

134


136



139 gtk_widget_show(boite_emprunteur_interface2);

140

141 interdire_edition (GTK_EDITABLE(zone_emprunteur_interface2));

142

143

144 gtk_window_set_title (GTK_WINDOW (fenetre_interface2), "MNEMO - Modification d’une entree dans la bibliotheque");

145

146 gtk_signal_connect (GTK_OBJECT (bouton_enregistrement_interface2), "clicked",

147 GTK_SIGNAL_FUNC (modifier),NULL);

148

149 /* Ecriture dans les champs de texte des donnees du livre a modifier */

150 gtk_entry_set_text (GTK_ENTRY (zone_auteur_interface2), donnees->auteur);

151 gtk_entry_set_text (GTK_ENTRY (zone_titre_interface2), donnees->titre);

152 gtk_entry_set_text (GTK_ENTRY (zone_nb_pages_interface2), donnees->nb_pages);

153 gtk_entry_set_text (GTK_ENTRY (zone_ISBN_interface2), donnees->ISBN);

154 gtk_entry_set_text (GTK_ENTRY (zone_date_edition_interface2), donnees->date_edition);

155 gtk_entry_set_text (GTK_ENTRY (zone_maison_edition_interface2), donnees->maison_edition);

156 gtk_entry_set_text (GTK_ENTRY (zone_mot_cles_interface2), donnees->mot_cles);

157 gtk_entry_set_text (GTK_ENTRY (zone_cote_interface2), donnees->cote);

158 gtk_entry_set_text (GTK_ENTRY (zone_emprunteur_interface2), donnees->emprunteur);

159

160

161 /* Creation et mise en place du bouton "supprimer" */

162 bouton_supprimer_interface2 = gtk_button_new_with_label ("Supprimer l’entree");

163




164 gtk_signal_connect (GTK_OBJECT (bouton_supprimer_interface2), "clicked",

165 GTK_SIGNAL_FUNC (supprimer), NULL);

166

167 gtk_box_pack_start(GTK_BOX(boite_boutons_interface2), bouton_supprimer_interface2, TRUE, TRUE, 10);

168 gtk_widget_show (bouton_supprimer_interface2);

169

170

171 /* Les donnees du livre a modifier sont conservees dans une variable globale*/

172 livre_a_modifier = donnees;

173

174 gtk_main();

175 }

4.3.2.8 struct livre∗ livre initial (void)

Retourne le livre a modifier.

Precondition :: - La variable a ete allouee. ( = l’interface ”GUI modification” a ete chargee)

Postcondition :: Si la variable n’a pas ete allouee, indication du probleme sur la sortie standard..


511 {

512 if (livre_a_modifier==NULL) puts ("Attention: la variable livre_a_modifier n’a pas ete allouee");

513 return livre_a_modifier;

514 }




493 {



496 }

4.3.2.10 void reinitialiser interface2 ()

Reinitialise toutes les zones de texte.


475 {

476 gtk_entry_set_text (GTK_ENTRY (zone_auteur_interface2), "");

477 gtk_entry_set_text (GTK_ENTRY (zone_titre_interface2), "");

478 gtk_entry_set_text (GTK_ENTRY (zone_nb_pages_interface2), "");

479 gtk_entry_set_text (GTK_ENTRY (zone_ISBN_interface2), "");

480 gtk_entry_set_text (GTK_ENTRY (zone_date_edition_interface2), "");

481 gtk_entry_set_text (GTK_ENTRY (zone_maison_edition_interface2), "");

482 gtk_entry_set_text (GTK_ENTRY (zone_mot_cles_interface2), "");

483 gtk_entry_set_text (GTK_ENTRY (zone_cote_interface2), "");

484

485 gtk_label_set (GTK_LABEL (label_resultat_interface2), "");

486 }




4.3.2.11 void vider label interface2 ()

Vide le label situe sous les boutons.


466 {

467 ecrire_label_interface2 ("");

468 }





#include <sys/param.h>

#include <sys/types.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <sys/file.h>

#include <stdio.h>

#include <stdlib.h>


#include <dirent.h>

#include <string.h>

#include <time.h>

#include "mnemo.h"


– #define LARGEUR 800– #define HAUTEUR 400– #define FREQUENCE 5000

Fonctions

– void quitter interface3 (void)Ferme l’interface graphique.

– int rafraichir interface3 (void)Ecris la chaıne de caractere dans le label situe sous les boutons.

– void modif log interface3 (void)Modifie le texte contenant le log dans l’interface.

– void modif nb livres interface3 (void)Modifie le nombre de livres dans l’interface.

– void modif date interface3 (void)Modifie la date dans l’interface.

– void modif espace interface3 (void)Modifie l’espace disque dans l’interface.

– void modif nb processus interface3 (void)Modifie le nombre de processus dans l’interface.

– void modif frequence interface3 (void)Modifie la frequence de rafraichissement dans l’interface.

– void interface3 administrer (void)Creation de l’interface graphique (partie commune).




Variables

– GtkWidget ∗ fenetre interface3– GtkWidget ∗ boite verticale interface3– GtkWidget ∗ label log interface3– GtkWidget ∗ texte log interface3– GtkWidget ∗ separateur1 interface3– GtkWidget ∗ label nb livres interface3– GtkWidget ∗ separateur2 interface3– GtkWidget ∗ label date interface3– GtkWidget ∗ separateur3 interface3– GtkWidget ∗ label espace interface3– GtkWidget ∗ separateur4 interface3– GtkWidget ∗ label nb processus interface3– GtkWidget ∗ separateur5 interface3– GtkWidget ∗ boite boutons interface3– GtkWidget ∗ label modif frequence interface3– GtkWidget ∗ zone modif frequence interface3– GtkWidget ∗ bouton modif frequence interface3– GtkWidget ∗ label2 modif frequence interface3– int frequence– int tag– int activewindows interface3 = 0


4.4.1.1 #define FREQUENCE 5000







4.4.2.1 void interface3 administrer (void)

Creation de l’interface graphique (partie commune).


83 {

84 /* La fenetre */



87 gtk_window_set_title (GTK_WINDOW (fenetre_interface3), "MNEMO - Administration la bibliotheque");

88

89




93



96 boite_verticale_interface3 = gtk_vbox_new(FALSE, 0);





98

99 label_log_interface3 = gtk_label_new("Les 5 dernieres lignes du fichier log de la bibliotheque: ");

100 texte_log_interface3 = gtk_text_new (NULL, NULL);

101 gtk_widget_set_usize (GTK_WIDGET (texte_log_interface3), 300,250);


103 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), label_log_interface3, TRUE, TRUE, 0);

104 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), texte_log_interface3, TRUE, TRUE, 0);

105


107

108 label_nb_livres_interface3 = gtk_label_new("");


110 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), label_nb_livres_interface3, TRUE, TRUE, 0);


112

113 label_date_interface3 = gtk_label_new("");


115 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), label_date_interface3, TRUE, TRUE, 0);


117

118 label_espace_interface3 = gtk_label_new("");


120 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), label_espace_interface3, TRUE, TRUE, 0);


122

123 label_nb_processus_interface3 = gtk_label_new("");


125 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), label_nb_processus_interface3, TRUE, TRUE, 0);


127

128

129 /* Rafraıchir. La frequence de rafraichissement par defaut est de 5 secondes */

130 tag = gtk_timeout_add(FREQUENCE,(GtkFunction)rafraichir_interface3, NULL);

131

132 char *frequence = malloc (30);

133 sprintf (frequence, "Frequence actuelle: %d secondes", FREQUENCE/1000);

134 label2_modif_frequence_interface3 = gtk_label_new (frequence);

135 gtk_widget_set_usize (GTK_WIDGET (label2_modif_frequence_interface3), 5,80);

136

137 free (frequence);

138

139 gtk_box_pack_start(GTK_BOX(boite_verticale_interface3), label2_modif_frequence_interface3, TRUE, TRUE, 0);

140

141 boite_boutons_interface3 = gtk_hbox_new(FALSE, 0);

142


144 zone_modif_frequence_interface3 = gtk_entry_new();

145 label_modif_frequence_interface3 = gtk_label_new ("Modifier la frequence de rafraissement (en s.): ");

146 gtk_box_pack_start(GTK_BOX(boite_boutons_interface3), label_modif_frequence_interface3, TRUE, TRUE, 0);

147

148 gtk_widget_set_usize (GTK_WIDGET (zone_modif_frequence_interface3), 5,30);

149

150 gtk_box_pack_start(GTK_BOX(boite_boutons_interface3), zone_modif_frequence_interface3, TRUE, TRUE, 0);

151 bouton_modif_frequence_interface3 = gtk_button_new_with_label ("Valider");

152

153 gtk_box_pack_start(GTK_BOX(boite_boutons_interface3), bouton_modif_frequence_interface3, TRUE, TRUE, 2);

154

155

156

157 /* La fonction modif_frequence() est appelee lorsque

158 l’utilisateur clique sur le bouton "modif_frequence" */

159 gtk_signal_connect (GTK_OBJECT (bouton_modif_frequence_interface3), "clicked",

160 GTK_SIGNAL_FUNC (modif_frequence_interface3), NULL);

161

162

163

164 gtk_widget_show (label_log_interface3);


166 gtk_widget_show (texte_log_interface3);

167

168 gtk_widget_show (label_nb_livres_interface3);


170




171 gtk_widget_show (label_date_interface3);


173

174 gtk_widget_show (label_espace_interface3);


176

177 gtk_widget_show (label_nb_processus_interface3);


179

180 gtk_widget_show (zone_modif_frequence_interface3);

181 gtk_widget_show(bouton_modif_frequence_interface3);

182 gtk_widget_show(label_modif_frequence_interface3);

183 gtk_widget_show(label2_modif_frequence_interface3);

184

185


187

188 gtk_widget_show(boite_verticale_interface3);


190

191 rafraichir_interface3();

192

193 gtk_main();

194 }

4.4.2.2 void modif date interface3 (void)

Modifie la date dans l’interface.


277 {

278

279 char *reponse3 = malloc (100);

280 strcpy (reponse3, "Date et heure: ");

281

282 time_t current_time;

283 current_time = time (NULL);

284

285 strcat (reponse3, asctime (localtime(&current_time)));

286

287 gtk_label_set (GTK_LABEL (label_date_interface3), reponse3);

288 free (reponse3);

289

290 }

4.4.2.3 void modif espace interface3 (void)

Modifie l’espace disque dans l’interface.


301 {


303 sprintf(reponse4, "Espace disque utilise par la bibliotheque: %d Ko", (longueur_fichier_biblio() + longueur_fichier_emprunt())/1024 );

304 gtk_label_set (GTK_LABEL (label_espace_interface3), reponse4);


306

307 }

4.4.2.4 void modif frequence interface3 (void)

Modifie la frequence de rafraichissement dans l’interface.





371 {

372

373 char *changement = gtk_entry_get_text (GTK_ENTRY (zone_modif_frequence_interface3));

374

375 int nouveau_frequence;

376 if ((sscanf (changement, "%d", &nouveau_frequence)) >0)

377 {

378 if (nouveau_frequence >= 1)

379 {

380 gtk_timeout_remove(tag);

381 tag = gtk_timeout_add(nouveau_frequence*1000, (GtkFunction)rafraichir_interface3, NULL);

382

383 char *frequence = malloc (30);

384 sprintf (frequence, "Frequence actuelle: %d seconde(s)", nouveau_frequence);

385 gtk_label_set (GTK_LABEL (label2_modif_frequence_interface3), frequence);

386

387 free (frequence);

388

389 }

390 else

391 gtk_label_set_text (GTK_LABEL (label2_modif_frequence_interface3), "Impossible de mettre moins d’une seconde");

392

393 }

394

395 }

4.4.2.5 void modif log interface3 (void)

Modifie le texte contenant le log dans l’interface.


240 {

241 int log_rempli = gtk_text_backward_delete(GTK_TEXT (texte_log_interface3), 1);

242

243 while (log_rempli ==TRUE )

244 log_rempli = gtk_text_backward_delete(GTK_TEXT (texte_log_interface3), 1);

245

246 char *reponse1 = obtenir_5_lignes_blog();

247

248 gtk_text_insert (GTK_TEXT (texte_log_interface3), NULL, NULL, NULL, reponse1, strlen(reponse1));

249

250 /* free (reponse1);*/

251

252 }

4.4.2.6 void modif nb livres interface3 (void)

Modifie le nombre de livres dans l’interface.


260 {


262 sprintf (reponse2, "Le nombre de livres actuellement recenses: %d", nombre_de_livres());

263 gtk_label_set (GTK_LABEL (label_nb_livres_interface3), reponse2);

264


266

267 }




4.4.2.7 void modif nb processus interface3 (void)

Modifie le nombre de processus dans l’interface.


317 {

318 /* Le nombre de processus lies a la gestion de la bibliotheque */

319 int nombre =0;

320

321 /* chemin de notre processus */

322 char chemin_propre[30];

323 realpath ("/proc/self/exe", chemin_propre);

324

325 DIR *proc = opendir ("/proc/");

326 struct dirent *element;

327

328 /* Parcours du repertoire /proc */

329 while ((element=readdir(proc)) != NULL)

330 {

331

332 char *pid = element->d_name;

333 int chiffre;

334

335 if ((sscanf (pid,"%d",&chiffre)) > 0)

336 {

337 char *chemin = malloc (100 * sizeof(char));

338 char *lien = malloc (100 * sizeof (char));;

339

340 strcpy (lien,"/proc/");

341 strcat (lien, pid);

342 strcat (lien, "/exe");

343

344 realpath (lien, chemin);

345

346 if (strcmp (chemin, chemin_propre) ==0)

347 nombre++;

348

349 }

350 }

351

352 closedir (proc);

353

354 char *reponse5;

355 sprintf (reponse5, "Nombre de processus actuellement actifs: %d", nombre);

356 gtk_label_set (GTK_LABEL (label_nb_processus_interface3), reponse5);

357


359

360 }




202 {

203

204 gtk_timeout_remove(tag);

205



208 }




4.4.2.9 int rafraichir interface3 (void)



217 {

218

219 modif_log_interface3 ();

220

221 modif_nb_processus_interface3 ();

222

223

224 modif_nb_livres_interface3 ();

225

226 modif_date_interface3();

227

228 modif_espace_interface3 ();

229

230 return TRUE;

231 }




4.5 Reference du fichier modifier.c

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include "mnemo.h"

Fonctions

– int verifier (struct livre ∗)Verifie l’enregistrement est valide (renvoie 0 si oui, -1 sinon).

– void ecriture livre (struct livre ∗)Ecrit les donnees du livre a la fin du fichier.

– void remplacement livre (struct livre ∗, struct livre ∗)Remplace les anciennes donnees du livre par les nouvelles.

– void enregistrer (void)Ecrit un nouvel enregistrement a la fin du fichier.

– void modifier (void)Modifie un enregistrement dans le fichier.

– void supprimer (void)Supprime un enregistrement dans le fichier.

– void emprunter (void)Modifie le nom de l’emprunteur d’un fichier.


4.5.1.1 void ecriture livre (struct livre ∗ donnees)

Ecrit les donnees du livre a la fin du fichier.

Precondition :Le fichier a ete projete en memoire.

Les donnees de livre sont remplies.

Dans l’eventualite ou le fichier est verrouille (en lecture ou ecriture), l’operation se mettra en attentejusqu’au relachement du verrou.

Postcondition :Les donnees sont ecrites a la fin du fichier de donnees.

Le fichier est verrouille en ecriture pendant l’operation.

Si necessaire, la taille du fichier et de sa projection memoire sont elargies. L’elargissement minimum estd’une page memoire (requis par l’implementation de mmap).

Synchronisation du fichier et de sa projection en memoire.

On ajoute la ligne dans la biblio




Note : il n’est pas possible de verrouiller uniquement la zone dans laquelle nous allons ecrire... car elle n’existepas encore. Nous verrouillons donc tout le fichier.

Definition a la ligne 295 du fichier modifier.c.

296 {

297

298 char ligne[LINEMAX]="";

299

300 strcat (ligne, donnees->auteur);

301 strcat (ligne, "\t");

302 strcat (ligne, donnees->titre);


304 strcat (ligne, donnees->maison_edition);


306 strcat (ligne, donnees->date_edition);


308 strcat (ligne, donnees->nb_pages);


310 strcat (ligne, donnees->ISBN);


312 strcat (ligne, donnees->cote);


314 strcat (ligne, donnees->mot_cles);

315 strcat (ligne, "\n");

316

317

318 /**

319 On ajoute la ligne dans la biblio

320

321 Note: il n’est pas possible de verrouiller uniquement la zone dans laquelle

322 nous allons ecrire... car elle n’existe pas encore. Nous verrouillons donc

323 tout le fichier.

324 */

325

326 int longueur1 = longueur_fichier_biblio();

327

328 verrou_livre (0, longueur1, F_WRLCK);

329

330 ajouter_ligne (ligne);

331

332 verrou_livre (0, longueur1, F_UNLCK);

333

334

335 /* On ajoute l’emprunteur */

336 int longueur2 = longueur_fichier_emprunt();

337

338 verrou_emprunt (0, longueur2, F_WRLCK);

339

340 ajouter_emprunteur (donnees->emprunteur);

341

342 verrou_emprunt (0, longueur2, F_UNLCK);

343

344

345 /* On synchronise */

346 synchroniser();

347

348

349 /* Et on ecrit dans le log */

350 char *log = malloc (LINEMAX);

351 strcpy (log, "Ajout: ");

352 strcat (log, donnees->titre);

353 strcat (log, "\", de ");

354 strcat (log, donnees->auteur);

355 strcat (log, "\n");

356 ecrire_dans_log (log);

357 free (log);

358

359 }




4.5.1.2 void emprunter (void)

Modifie le nom de l’emprunteur d’un fichier.


L’interface graphique de consultation a ete chargee, par la methode ”GUI consultation emprunt()”

L’interface graphique pour l’emprunt a ete chargee, par la methode ”GUI consultation emprunt()”

Postcondition :Le nom de l’emprunteur est ecrit dans le fichier des emprunts (si le nom est vide, c’est le mot ”disponible”qui est indique)

Fermeture de l’interface graphique ”enregistrement”.

Mise a jour de la liste de recherche dans l’interface ”GUI consultation()”.


161 {

162

163 /* Le livre selectionne */

164 struct livre *donnees = donnees_interface2();

165

166 int longueur = longueur_fichier_biblio();

167

168 /* On verrouille en lecture le fichier biblio le temps de chercher le numero de ligne */

169

170 verrou_livre (0, longueur, F_RDLCK);

171

172 int numero_ligne = chercher_numero_ligne (livre_initial());

173

174 verrou_livre (0, longueur, F_UNLCK);

175

176

177 /* On verrouille en ecriture le fichier sur la zone precise a modifier */

178 verrou_emprunt (numero_ligne * TAILLE_EMPRUNTEUR, TAILLE_EMPRUNTEUR, F_WRLCK);

179

180 /* Ecriture des modifications */

181 if ((verifier(donnees)) == 0)

182 modifier_emprunteur (numero_ligne, donnees->emprunteur);

183 else

184 puts ("attention: probleme dans le nom de l’emprunteur");

185

186 getchar();

187

188 /* On relache le verrou */

189 verrou_emprunt (numero_ligne * TAILLE_EMPRUNTEUR , TAILLE_EMPRUNTEUR, F_UNLCK);

190



193 strcpy (log, "Emprunt de ");

194 strcat (log, donnees->emprunteur);

195 strcat (log, ": \"");


197 strcat (log, "\", de ");




201 free (log);

202

203 free (donnees);

204

205 quitter_interface2();

206 consulter();

207 synchroniser();

208 }




4.5.1.3 void enregistrer (void)

Ecrit un nouvel enregistrement a la fin du fichier.


L’interface graphique a ete chargee, par la methode ”GUI enregistrement()”

Auteur et titre du livre sont fournis dans leurs champs respectifs.

Postcondition :Les donnees sont ecrites a la fin du fichier de donnees (si des champs facultatifs sont manquants, ils sontremplaces par le mot ”inconnu”, ou ”disponible” pour l’emprunteur).

Les champs sont reinitialises.

Une confirmation de l’enregistrement est indique dans l’interface.


38 {


40

41 if (verifier (donnees) ==0)

42 {

43 ecriture_livre (donnees);

44 reinitialiser_interface2();

45 ecrire_label_interface2 ("L’information a ete correctement enregistree");

46

47 }

48 free (donnees);

49 }

4.5.1.4 void modifier (void)

Modifie un enregistrement dans le fichier.


L’interface graphique ”GUI consultation() est chargee.

L’interface graphique ”GUI modification()” est chargee. (la methode get livre a modifier() renvoie doncun livre).

Auteur et titre du livre sont fournis dans leurs champs respectifs

Postcondition :Dans le fichier, la zone contenant les donnees du livre a modifier sont remplacees par les nouvelles donnees.




72 {


74 struct livre *livre_a_modifier = livre_initial();

75

76 if (verifier (donnees) ==0)

77 {

78 remplacement_livre (donnees, livre_a_modifier);


80 consulter();

81 }

82

83 free (livre_a_modifier);

84 free (donnees);

85 }




4.5.1.5 void remplacement livre (struct livre ∗ donnees, struct livre ∗ livre a modifier)

Remplace les anciennes donnees du livre par les nouvelles.


Les donnees du livre a modifier sont presentes dans le fichier.

Les nouvelles donnees du livre sont remplies.

Dans l’eventualite ou le fichier est verrouille (en lecture ou ecriture), l’operation se mettra en attentejusqu’au relachement du verrou.

Postcondition :Les nouvelles donnees sont ecrites dans le fichier de donnees, au meme emplacement.

Le fichier est verrouille en ecriture pendant l’operation.


Synchronisation du fichier et de sa projection en memoire.

On remplace la ligne dans la biblio. Pour etre certain d’interdire toute modification entre le moment de chrecherl’emplacement de la ligne, et celui de remplacer cette meme ligne, on place un verrou en ecriture sur tout lefichier


386 {

387

388 char ligne[LINEMAX]="";

389

390

391 strcat (ligne, donnees->auteur);


393 strcat (ligne, donnees->titre);


395 strcat (ligne, donnees->maison_edition);


397 strcat (ligne, donnees->date_edition);


399 strcat (ligne, donnees->nb_pages);


401 strcat (ligne, donnees->ISBN);


403 strcat (ligne, donnees->cote);


405 strcat (ligne, donnees->mot_cles);

406 strcat (ligne, "\n");

407

408

409 /**

410 On remplace la ligne dans la biblio. Pour etre certain d’interdire toute

411 modification entre le moment de chrecher l’emplacement de la ligne, et celui

412 de remplacer cette meme ligne, on place un verrou en ecriture sur tout le fichier

413 */

414

415 int longueur = longueur_fichier_biblio();

416

417 verrou_livre (0, longueur, F_WRLCK);

418

419 int pos = chercher_position (livre_a_modifier);

420

421 if (pos !=-1)

422 remplacer_ligne (ligne, pos);

423 else

424 puts ("attention: le livre a modifier n’a pas ete trouve");

425

426 verrou_livre (0, longueur, F_UNLCK);

427




428 /* Note: Pas besoin de changer l’emprunteur, puisque la modification

429 ne concerne que les donnees du livre ! */

430

431 /* On synchronise */

432 synchroniser();

433



436 strcpy (log, "Modification: ");


438 strcat (log, "\", de ");




442 free (log);

443

444 }

4.5.1.6 void supprimer (void)

Supprime un enregistrement dans le fichier.


L’interface graphique ”GUI consultation() est chargee.

L’interface graphique a ete charge, par la methode ”GUI modification’)” (la methode get livre a modifier()renvoie donc un livre).

Postcondition :Dans le fichier, la zone contenant les donnees du livre est supprimee.




104 {

105 struct livre *livre_a_modifier = livre_initial();

106

107 int pos = chercher_position (livre_a_modifier);

108

109

110 int longueur = longueur_fichier_emprunt();

111

112 /* Il faut aussi retirer l’emprunteur */

113 verrou_emprunt (0, longueur, F_WRLCK);

114

115 int numero_ligne = chercher_numero_ligne (livre_a_modifier);

116 supprimer_emprunteur (numero_ligne);

117

118 verrou_emprunt (0, longueur, F_UNLCK);

119

120

121 supprimer_ligne (pos);

122

123



126 strcpy (log, "Suppression: ");

127 strcat (log, livre_a_modifier->titre);

128 strcat (log, "\", de ");

129 strcat (log, livre_a_modifier->auteur);



132 free (log);

133

134 free (livre_a_modifier);




135

136


138 consulter();

139 }

4.5.1.7 int verifier (struct livre ∗ donnees)

Verifie l’enregistrement est valide (renvoie 0 si oui, -1 sinon).

Parametres :donnees un livre.

Postcondition :Si l’auteur ou le titre ne sont pas indiques dans leur champ, indication de ce probleme dans l’interface.

Si un des champs facultatifs est manquant, il est remplace par le mot ”inconnu”, ou ”disponible” pourl’emprunteur.

Renvoie :’0’ si conforme, ’-1’ sinon


230 {

231

232 if (donnees->auteur[0] == ’\0’)

233 {

234 ecrire_label_interface2 ("Desole, l’auteur est obligatoire. Veillez l’inscrire dans la case prevue.");

235 return -1 ;

236 }

237

238 if (donnees->titre[0] == ’\0’)

239 {

240 ecrire_label_interface2 ("Desole, le titre est obligatoire. Veillez l’inscrire dans la case prevue.");

241 return -1;

242 }

243

244 if (donnees->nb_pages[0] == ’\0’)

245 donnees->nb_pages = "inconnu";

246

247

248 if (donnees->ISBN[0] == ’\0’)

249 donnees->ISBN = "inconnu";

250

251

252 if (donnees->date_edition[0] == ’\0’)

253 donnees->date_edition = "inconnu";

254

255

256 if (donnees->maison_edition[0] == ’\0’)

257 donnees->maison_edition = "inconnu";

258

259

260 if (donnees->mot_cles[0] == ’\0’)

261 donnees->mot_cles = "inconnu";

262

263

264 if (donnees->cote[0] == ’\0’)

265 donnees->cote = "inconnu";

266

267 if(donnees->emprunteur[0] == ’\0’)

268 donnees->emprunteur = "disponible";

269

270 return 0;

271 }




4.6 Reference du fichier consulter.c





#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <regex.h>

#include "mnemo.h"

Fonctions

– int regexp (char ∗, char ∗)Verifie si la chaıne ”str” correspond a ”regex”, une expression reguliere.

– int traiter ligne (char ∗, struct livre ∗)Verifie si la ligne repond aux criteres definis.

– int traiter champ (char ∗, int, struct livre ∗)Verifie si le champ repond a un critere, qui est le critere numerote ”numchamp” de l’ensemble de criteres ”donnees”.

– int traiter emprunteur (int numero ligne, struct livre ∗)Renvoie 0 si le nom de l’emprunteur recherche corresponda celui ecrit a la ligne numero-ligne du fichier desemprunteurs.

– char ∗ obtenir champ (char ∗ligne, int numchamp)Retourne le ieme champ d’une ligne.

– void consulter (void)Recherche les livres du fichier respectant les criteres definis et les insere dans la liste de recherche.

– int chercher position (struct livre ∗donnees)Retourne la position (offset) dans le fichier d’un livre, s’il est present.

– int nombre de livres (void)Retourne le nombre de livres dans la bibliotheque.

– int chercher numero ligne (struct livre ∗donnees)Retourne le numero de ligne dans le fichier d’un livre, s’il est present.


4.6.1.1 int chercher numero ligne (struct livre ∗ donnees)

Retourne le numero de ligne dans le fichier d’un livre, s’il est present.





Dans l’eventualite ou le fichier est verrouille en ecriture, l’operation sera mise en attente jusq’au relachementdu verrou.

Postcondition :Le fichier est verrouille en lecture durant l’operation.

Renvoie :la position du debut de la premiere ligne respectant les criteres du livre. Si rien n’est trouve, renvoie -1.

Definition a la ligne 194 du fichier consulter.c.

195 {

196

197 int index=0;

198 int numligne=0;

199 int iLigne=0;

200 char ligne[1024];

201 char c;

202

203 int len = longueur_fichier_biblio();

204

205 while (index < len)

206 {

207 if ((c = caractere(index)) != ’\n’)

208 {

209 ligne[iLigne]=c;

210 iLigne++;

211 }

212 else

213 {

214 ligne[iLigne]=’\0’;

215 if (traiter_ligne (ligne, donnees) ==0)

216 {

217 return (numligne);

218 }

219 iLigne =0;

220 numligne++;

221 }

222 index++;

223 }

224

225 return -1;

226 }

4.6.1.2 int chercher position (struct livre ∗ donnees)

Retourne la position (offset) dans le fichier d’un livre, s’il est present.



Postcondition :Le fichier est verrouille en lecture durant l’operation.






133 {

134

135 int index=0;

136 int iLigne=0;

137 int numero_ligne=0;


139 char c;

140

141 int len = longueur_fichier_biblio();

142


144 {


146 {

147 ligne[iLigne]=c;

148 iLigne++;

149 }

150 else

151 {


153 if (traiter_ligne (ligne, donnees) ==0 && traiter_emprunteur (numero_ligne, donnees)==0)

154 {

155 return (index-iLigne);

156 }

157 iLigne =0;

158 numero_ligne++;

159 }

160 index++;

161 }

162

163 return -1;

164 }

4.6.1.3 void consulter (void)

Recherche les livres du fichier respectant les criteres definis et les insere dans la liste de recherche.


L’interface graphique a ete chargee, par la methode ”GUI consultation()”.


Postcondition :Les resultats des recherches precedentes sont effaces de la liste.

Le fichier est verrouille en lecture durant l’operation.

Les livres du fichier respectant les criteres definis sont inseres dans la liste de recherche.

Le nombre de resultats est indique sur l’interface graphique.


44 {

45


47

48 int nb_trouve=0;

49 int numero_ligne =0;

50 int index=0;

51 int iLigne=0;


53 char c;

54 int len = longueur_texte_biblio();

55 int len2 = longueur_fichier_emprunt();

56

57 vider_liste();

58




59 /* Placement d’un verrou en lecture sur l’ensemble du fichier */

60 verrou_livre (0, len, F_RDLCK);

61 verrou_emprunt (0, len2, F_RDLCK);

62

63 /* Parcours du fichier */


65 {

66 /* A l’interieur d’une ligne */


68 {

69 ligne[iLigne]=c;

70 iLigne++;

71 }

72

73 /* Fin d’une ligne */

74 else

75 {


77

78 /* Teste si la ligne repond aux criteres */

79 if (traiter_ligne (ligne, donnees) ==0 && traiter_emprunteur (numero_ligne, donnees)==0)

80 {

81 /* Si oui, on recupere la valeur des champs et on insere

82 une nouvelle rangee dans la liste de recherche */

83 char *item[9]; int i=0;

84 for (i=0; i < 8; i++)

85 {

86 item[i] = obtenir_champ (ligne, i);

87 }

88

89 item[8] = obtenir_emprunteur (numero_ligne);

90

91 inserer_item (item);

92 nb_trouve++;

93 }

94 iLigne =0;

95 numero_ligne++;

96 }

97 index++;

98 }

99

100 /* Fichier deverrouille */

101 verrou_livre (0, len, F_UNLCK);

102 verrou_emprunt (0, len2, F_UNLCK);

103

104 /* Indication du nombre de resultats sur l’interface graphique */

105 char texte[50];

106

107 if (nb_trouve==0)

108 sprintf (texte, "Desole, aucun livre ne correspond a vos criteres.");

109 else

110 sprintf (texte, "Resultat de la recherche: %d livre(s) trouve(s).",nb_trouve);

111

112 ecrire_label_interface1 (texte);

113

114 free (donnees);

115 }

4.6.1.4 int nombre de livres (void)

Retourne le nombre de livres dans la bibliotheque.


174 {

175

176 return (longueur_fichier_emprunt() / TAILLE_EMPRUNTEUR);

177 }




4.6.1.5 char ∗ obtenir champ (char ∗ ligne, int champ selectionne)

Retourne le ieme champ d’une ligne.

Precondition :Les champs sont separes par une tabulation.

Au total, il y a 9 champs.

0 <= champ selectionne <= 8

Renvoie :: la chaıne de caractere contenue dans le ieme champ (i donne en parametre) de la ligne.

Si les preconditions ne sont pas satisfaites, retourne ””.


320 {

321 int iLigne=0;

322 int iChamp=0;

323 char champ[1024];

324 int numchamp = 0;

325 char c;

326 int longueur = strlen (ligne);

327

328 while (iLigne <= longueur)

329 {

330

331 if ((c = ligne[iLigne]) != ’\t’ && iLigne < longueur)

332 {

333 champ[iChamp]=c;

334 iChamp++;

335 }

336 else

337 {

338 champ[iChamp]=’\0’;

339

340 if (numchamp == champ_selectionne)

341 {

342 char *cpchamp = malloc (strlen(champ)*sizeof(char)+1);

343 strcpy (cpchamp,champ);

344 return cpchamp;

345 }

346 numchamp++;

347 iChamp =0;

348 }

349 iLigne++;

350 }

351

352 return "";

353 }

4.6.1.6 int regexp (char ∗ str, char ∗ regex)

Verifie si la chaıne ”str” correspond a ”regex”, une expression reguliere.

(retourne 0 si oui, -1 sinon)

Renvoie :0 si ”str” correspond a ”regex”, -1 sinon.

Auteur :bout de code tire de http ://www.linuxgazette.com/issue55/misc/tindale/mygrep.c.txt





241 {

242

243 regex_t *preg= (regex_t *) malloc(sizeof(regex_t));

244

245 regcomp (preg, regex, REG_ICASE);

246

247 int reponse = regexec(preg, str,0,NULL,0);

248

249 regfree (preg);

250

251 if (reponse != REG_NOMATCH)

252 return 0;

253

254 return -1;

255 }

4.6.1.7 int traiter champ (char ∗ champ, int numchamp, struct livre ∗ donnees)

Verifie si le champ repond a un critere, qui est le critere numerote ”numchamp” de l’ensemble de criteres”donnees”.

Precondition :0 <= numchamp <= 8

Renvoie :: - Retourne 0 si le champ respecte le critere, -1 sinon.– Si le critere est vide, retourne 0.


366 {

367 switch (numchamp)

368 {

369 case 0:

370 if (donnees->auteur[0]==’\0’)

371 return 0;

372 else

373 return regexp (champ, donnees->auteur);

374

375 case 1:

376 if (donnees->titre[0]==’\0’)

377 return 0;

378 else

379 return regexp (champ, donnees->titre);

380 case 2:

381 if (donnees->maison_edition[0]==’\0’)

382 return 0;

383 else

384 return regexp (champ, donnees->maison_edition);

385 case 3:

386 if (donnees->date_edition[0]==’\0’)

387 return 0;

388 else

389 return regexp (champ, donnees->date_edition);

390 case 4:

391 if (donnees->nb_pages[0]==’\0’)

392 return 0;

393 else

394 return regexp (champ, donnees->nb_pages);

395 case 5:

396 if (donnees->ISBN[0]==’\0’)

397 return 0;

398 else

399 return regexp (champ, donnees->ISBN);

400 case 6:

401 if (donnees->cote[0]==’\0’)

402 return 0;

403 else




404 return regexp (champ, donnees->cote);

405 case 7:

406 if (donnees->mot_cles[0]==’\0’)

407 return 0;

408 else

409 return regexp (champ, donnees->mot_cles);

410 }

411 return -1;

412 }

4.6.1.8 int traiter emprunteur (int numero ligne, struct livre ∗ donnees)

Renvoie 0 si le nom de l’emprunteur recherche corresponda celui ecrit a la ligne numero-ligne du fichier desemprunteurs.


422 {

423

424 char *emprunteur = obtenir_emprunteur (numero_ligne);

425

426 return regexp (emprunteur, donnees->emprunteur);

427 }

4.6.1.9 int traiter ligne (char ∗ ligne, struct livre ∗ donnees)

Verifie si la ligne repond aux criteres definis.

Precondition :Les champs sont separes par une tabulation.

Au total, il y a 9 champs.



269 {

270

271 int iLigne=0;

272 int iChamp=0;

273 char champ[1024];

274

275 int numchamp = 0;

276 char c;

277 int longueur = strlen (ligne);

278

279 /* Parcours de la ligne */

280 while (iLigne <= longueur)

281 {

282 /* A l’interieur d’un champ */

283 if ((c = ligne[iLigne]) != ’\t’ && iLigne < longueur)

284 {

285 champ[iChamp]=c;

286 iChamp++;

287 }

288

289 /* Fin d’un champ */

290 else

291 {

292 champ[iChamp]=’\0’;

293 if (traiter_champ (champ, numchamp, donnees) != 0)

294 return -1;




295 numchamp++;

296 iChamp =0;

297 }

298 iLigne++;

299 }

300

301 return 0;

302 }




4.7 Reference du fichier IO.c





#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include "mnemo.h"


– #define max(a, b) ((a) > (b) ? (a) : (b))

Fonctions

– char ∗ remplacer sous chaine (char ∗, char ∗, char ∗)Remplace, a l’interieur de la chaıne ’str’, la sous-chaıne ’old’ par une nouvelle chaıne ’new’.

– int longueur fichier biblio (void)Retourne la taille totale du fichier.

– int augmenter taille biblio (int increase)Agrandit la taille du fichier, et met a jour la projection en memoire.

– char ∗ ligne (int pos)Retourne la ligne situee entre pos et le premier ’retour a la ligne’ dans la projection en memoire (le retour a laligne est compris).

– void etablir projection memoire (void)Ouverture et projection en memoire (mmap) des fichiers ”biblio” et ”emprunts”.

– void supprimer projection memoire (void)Fermeture et suppression de la projection en memoire des fichiers.

– void verrou livre (int debut, int longueur, int type)Placement d’un verrou sur le fichier BIBLIO.

– void verrou emprunt (int debut, int longueur, int type)Placement d’un verrou sur le fichier EMPRUNT.

– char caractere (int pos)Retourne le caractere situe a l’emplacement pos dans le fichier.

– int longueur texte biblio (void)Retourne la longueur de la partie textuelle dans le fichier (c’est-a-dire : la longueur du fichier MOINS les caracteresnuls de fin de fichier).

– int longueur fichier emprunt (void)Retourne la taille totale du fichier.




– int ajouter ligne (char ∗chaine)Ajoute une ligne a la fin du fichier.

– int remplacer ligne (char ∗chaine, int pos)Remplace une ligne a l’interieur du fichier (a l’emplacement pos).

– void synchroniser (void)Synchronisation de la projection en memoire du fichier.

– char ∗ obtenir emprunteur (int numero ligne)Retourne le nom de l’emprunteur a la ligne numero ligne du fichier EMPRUNT.

– void modifier emprunteur (int numero ligne, char ∗nom)Modifie le nom de l’emprunteur a la ligne numero ligne du fichier EMPRUNT.

– void ajouter emprunteur (char ∗nom)Ajoute le nom de l’emprunteur a la fin du fichier EMPRUNT.

– int supprimer emprunteur (int numero ligne)Supprime un emprunteur du fichier.

– int supprimer ligne (pos)Supprime une ligne a l’interieur du fichier (a l’emplacement pos).

– void ecrire dans log (char ∗chaine)Ajoute une chaıne de caracteres dans le fichier log.

– char ∗ obtenir 5 lignes blog (void)Retourne les 5 dernieres lignes du fichier log.

Variables

– int fdb– int fde– char ∗ projection biblio– char ∗ projection emprunt


4.7.1.1 #define max(a, b) ((a) > (b) ? (a) : (b))

Definition a la ligne 12 du fichier IO.c.


4.7.2.1 void ajouter emprunteur (char ∗ nom)

Ajoute le nom de l’emprunteur a la fin du fichier EMPRUNT.


561 {

562

563 /* Ici nous sommes obliges de passer par l’ecriture I/O dans le fichier

564 au lieu de la projection en memoire (pour des problemes de dimensionnement).*/

565

566 char emprunteur[TAILLE_EMPRUNTEUR];

567




568

569 FILE *emprunt = fopen (EMPRUNT, "a");

570

571 strcpy (emprunteur, nom);

572

573 fwrite (emprunteur, sizeof(emprunteur), 1, emprunt);

574

575 fclose (emprunt);

576

577

578 synchroniser();

579

580 }

4.7.2.2 int ajouter ligne (char ∗ chaine)

Ajoute une ligne a la fin du fichier.

Precondition :le fichier a ete projete en memoire

Renvoie :0 si l’operation est effectuee avec succes, -1 sinon.

Postcondition :La ligne est ecrite a la fin du fichier de donnees


En cas d’echec, indication du probleme a la sortie standard.

Auteur :: http ://gd.tuwien.ac.at/gnu/Manuals/glibc-2.2.5/html node/File-Size.html


327 {

328 off_t len = longueur_texte_biblio();

329 int long_chaine = strlen(chaine);

330

331 /* S’il faut agrandir la taille du fichier... */

332 if (len + long_chaine > longueur_fichier_biblio())

333 augmenter_taille_biblio (longueur_fichier_biblio() - (len + long_chaine));

334

335 /* On ajoute la ligne a la fin du fichier */

336 memcpy (projection_biblio + len, chaine, long_chaine);

337

338 return 0;

339 }

4.7.2.3 int augmenter taille biblio (int increase)

Agrandit la taille du fichier, et met a jour la projection en memoire.

La taille de l’agrandissement esttoujours un multiple (entier) de la taille d’un page memoire. L’elargissementminimum est donc d’une page memoire.


Renvoie :0 si l’operation se passe bien, -1 sinon.




Auteur :http ://gd.tuwien.ac.at/gnu/Manuals/glibc-2.2.5/html node/File-Size.html


404 {

405

406 /* Resize the file and remap. */

407 size_t ps = sysconf (_SC_PAGESIZE);

408 size_t ns = (increase + longueur_fichier_biblio() + ps - 1) & ~(ps - 1);

409 void *np;

410

411 if (ftruncate (fdb, ns) < 0)

412 {

413 puts ("attention: probleme pour agrandir le fichier avec ftruncate");

414 return -1;

415 }

416 np = mmap (NULL, ns, PROT_READ|PROT_WRITE, MAP_SHARED, fdb, 0);

417

418 if (np == MAP_FAILED)

419 {

420 puts ("attention: probleme pour projeter en memoire le fichier");

421 return -1;

422 }

423 projection_biblio = np;

424 return 0;

425 }

4.7.2.4 char caractere (int pos)

Retourne le caractere situe a l’emplacement pos dans le fichier.

Precondition :0 <= pos <= len

le fichier a ete projete en memoire

Postcondition :Si la precondition n’est pas satisfaite, indication du probleme a la sortie standard


225 {

226 if (pos > longueur_fichier_biblio()) puts ("attention: pos > len");

227

228 return projection_biblio[pos];

229 }

4.7.2.5 void ecrire dans log (char ∗ chaine)

Ajoute une chaıne de caracteres dans le fichier log.

On supprime le fichier s’il devient trop gros (Il sera bien sur recree des le prochain appel a la fonction)


664 {

665 FILE *fichier;

666

667 if ((fichier = fopen (LOG, "a")) <0)

668 puts ("attention: probleme pour l’ouverture du log");

669




670 fputs (chaine, fichier);

671

672

673 /** On supprime le fichier s’il devient trop gros

674 (Il sera bien sur recree des le prochain appel a la fonction) */

675

676 struct stat *statbuf =(struct stat*)malloc(sizeof(struct stat));

677 if(fstat(fileno(fichier),statbuf)<0)

678 {

679 perror("attention: probleme pour determiner la taille du blog");

680 exit(EXIT_FAILURE);

681 }

682

683 if (statbuf->st_size > 10000)

684 unlink (LOG);

685

686 free (statbuf);

687

688 fclose (fichier);

689

690 }

4.7.2.6 void etablir projection memoire (void)

Ouverture et projection en memoire (mmap) des fichiers ”biblio” et ”emprunts”.

Precondition :Le fichier existe et est accessible en lecture et ecriture

Postcondition :Les donnees contenues dans le fichier sont directement accessibles par le biais de projection.


54 {

55 /* Ouverture du fichier biblio */

56 if((fdb=open(BIBLIO, O_RDWR))<0)

57 {

58 perror("attention: probleme lors de l’ouverture du fichier ’biblio.txt’");


60 }

61

62 /* Ouverture du fichier emprunts */

63 if((fde=open(EMPRUNT, O_RDWR))<0)

64 {

65 perror("attention: probleme lors de l’ouverture du fichier ’emprunts.txt’");


67 }

68

69

70 /* Projection en memoire de biblio*/

71 if((projection_biblio = mmap(0,longueur_fichier_biblio(),PROT_WRITE|PROT_READ, MAP_SHARED, fdb, 0))==(void *)-1)

72 {

73 perror("Attention: probleme lors de la projection en memoire du fichier ’biblio.txt’");


75 }

76

77

78 /* Projection en memoire de emprunts*/

79 if((projection_emprunt = mmap(0,longueur_fichier_emprunt(),PROT_WRITE|PROT_READ, MAP_SHARED, fde, 0))==(void *)-1)

80 {

81 perror("Attention: probleme lors de la projection en memoire du fichier ’biblio.txt’");


83 }

84

85 }




4.7.2.7 char ∗ ligne (int pos)

Retourne la ligne situee entre pos et le premier ’retour a la ligne’ dans la projection en memoire (le retour a laligne est compris).


Renvoie :la ligne entre pos et le premier

’, ou la fin du fichier.


440 {

441

442 char c;

443 int index = 0;

444 char *chaine = malloc (LINEMAX * sizeof(char));

445

446 while ((c = projection_biblio [pos+index]) != ’\n’ && c!= ’\0’)

447 {

448 chaine[index]=c;

449 index++;

450 }

451

452 chaine[index]=’\n’;

453 chaine[index+1]=’\0’;

454

455 return chaine;

456 }

4.7.2.8 int longueur fichier biblio (void)

Retourne la taille totale du fichier.

Precondition :le fichier a ete ouvert (fd a ete alloue)

Renvoie :la longueur totale du fichier

Postcondition :indication du probleme a la sortie standard en cas d’erreur.


262 {

263


265 if(fstat(fdb,statbuf)<0)

266 {

267 perror("attention: probleme pour determiner la taille du fichier");


269 }

270

271 int longueur = statbuf->st_size;

272 free (statbuf);

273

274 return longueur;

275 }




4.7.2.9 int longueur fichier emprunt (void)

Retourne la taille totale du fichier.

Precondition :le fichier a ete ouvert (fd a ete alloue)

Renvoie :la longueur totale du fichier

Postcondition :indication du probleme a la sortie standard en cas d’erreur.


291 {

292


294 if(fstat(fde,statbuf)<0)

295 {

296 perror("attention: probleme pour determiner la taille du fichier");


298 }

299

300 int longueur = statbuf->st_size;

301 free (statbuf);

302

303 return longueur;

304 }

4.7.2.10 int longueur texte biblio (void)

Retourne la longueur de la partie textuelle dans le fichier (c’est-a-dire : la longueur du fichier MOINS lescaracteres nuls de fin de fichier).


Renvoie :la longueur de la partie textuelle dans le fichier


244 {

245

246 return strlen (projection_biblio);

247 }

4.7.2.11 void modifier emprunteur (int numero ligne, char ∗ nom)

Modifie le nom de l’emprunteur a la ligne numero ligne du fichier EMPRUNT.


542 {

543

544 /* Ecriture dans la projection memoire */

545




546 char *emplacement = projection_emprunt + (numero_ligne) * TAILLE_EMPRUNTEUR ;

547

548 strcpy (emplacement, nom);

549

550 }

4.7.2.12 char∗ obtenir 5 lignes blog (void)

Retourne les 5 dernieres lignes du fichier log.


698 {

699 FILE *fichier;

700

701 /* Si le fichier n’existe pas */

702 if ((fichier = fopen (LOG, "r")) == NULL)

703 {

704 return "";

705 }

706

707 /* On initialise un tableau de 5 lignes */

708 int i=0;

709 char *lignes[5];

710 for (i=0; i<5; i++)

711 lignes[i] = malloc (LINEMAX);

712

713 /* On remplit ce tableau

714

715 Note: les 5 lignes ne sont pas necessairement dans l’ordre. On fait l’hypothese

716 que cela n’a pas grande importance, ce qui a l’avantage de simplifier l’implementation. */

717

718 char *ligne = malloc (LINEMAX);

719 int j = 0;

720

721 while ((fgets (ligne, LINEMAX, fichier)) != NULL)

722 {

723 strcpy (lignes[j], ligne);

724

725 if (j ==4)

726 j = 0;

727 else

728 j++;

729 }

730

731 free (ligne);

732

733 /* On construit la chaıne de caractere qui sera renvoyee */

734

735 char *resultat = malloc (LINEMAX);

736 strcpy (resultat, "");

737

738 int k;

739 for (k =0 ; k < 5; k++)

740 {

741 if (lignes[k][0] != ’\0’)

742 {

743 strcat (resultat, lignes[k]);

744 strcat (resultat, "------------------\n");

745 }

746 }

747

748

749 fclose (fichier);

750

751 return resultat;

752

753 }




4.7.2.13 char∗ obtenir emprunteur (int numero ligne)

Retourne le nom de l’emprunteur a la ligne numero ligne du fichier EMPRUNT.


520 {

521 char emprunteur [TAILLE_EMPRUNTEUR];

522

523 char *emplacement = projection_emprunt + (numero_ligne) * TAILLE_EMPRUNTEUR ;

524

525 strncpy (emprunteur, emplacement, 20);

526

527 char *resultat = malloc (TAILLE_EMPRUNTEUR * sizeof(char));

528 strcpy (resultat, emprunteur);

529

530 return resultat;

531

532 }

4.7.2.14 int remplacer ligne (char ∗ chaine, int pos)

Remplace une ligne a l’interieur du fichier (a l’emplacement pos).


Renvoie :: 0 si l’operation est effectuee avec succes, -1 sinon.

Postcondition :La ligne est ecrite a la fin du fichier de donnees




360 {

361

362 /* La partie du fichier situee apres l’emplacement pos */

363 char *partie = projection_biblio + pos;

364

365 /* Remplacement de la ligne, dans la partie*/

366 char *chaine_a_remplacer = ligne(pos);

367 char *nouvelle_partie = remplacer_sous_chaine (partie, chaine_a_remplacer, chaine);

368 int long_partie = strlen (nouvelle_partie);

369

370 /* Si on doit agrandir le fichier ... */

371 if (pos+ long_partie > longueur_fichier_biblio())

372 augmenter_taille_biblio (longueur_fichier_biblio() - pos - long_partie);

373

374

375 /* Recopie la nouvelle partie dans la projection en memoire */

376 if (nouvelle_partie != NULL)

377 memcpy (projection_biblio + pos, nouvelle_partie, long_partie);

378

379

380 /* Et on marque la fin de la partie textuelle du fichier */

381 projection_biblio [pos+long_partie] = ’\0’;

382

383 return 0;

384 }




4.7.2.15 char ∗ remplacer sous chaine (char ∗ str, char ∗ old, char ∗ new)

Remplace, a l’interieur de la chaıne ’str’, la sous-chaıne ’old’ par une nouvelle chaıne ’new’.

Precondition :La chaine str contient la sous-chaıne old

Postcondition :Si la chaıne ’str’ contient la sous-chaıne ’old’, celle-ci est remplacee par ’new’, quelle que soit sa taille.

Sinon, ’str’ est retourne sans changement


492 {

493 char *result;

494 result = malloc(max (sizeof(char)*(strlen (str) - strlen (old) + strlen(new)), sizeof(char)*strlen(str)));

495 char *part2 = strstr (str, old);

496 char *ptr = part2+strlen(old);

497 char part3[strlen(ptr)];

498 strcpy (part3, ptr);

499

500 strcpy (result, str);

501

502 if (part2 != NULL)

503 {

504 result[part2-str]=’\0’;

505 strcat (result, new);

506 strcat (result, part3);

507 return (result);

508 }

509 else

510 return str;

511 }

4.7.2.16 int supprimer emprunteur (int numero ligne)

Supprime un emprunteur du fichier.



Postcondition :La ligne a ete supprimee du fichier de donnees



597 {

598 /* La partie du fichier qui va de l’offset ’numero_ligne * 20’ a la fin du fichier */

599 char *partie1 = projection_emprunt + numero_ligne * TAILLE_EMPRUNTEUR;

600

601 /* La partie du fichier situee apres l’emprunteur a supprimer */

602 char *partie2 = projection_emprunt + numero_ligne * TAILLE_EMPRUNTEUR + TAILLE_EMPRUNTEUR;

603

604 int long_partie = longueur_fichier_emprunt() - (numero_ligne * TAILLE_EMPRUNTEUR + TAILLE_EMPRUNTEUR);

605 char nouvelle_partie[long_partie];

606

607 memcpy (nouvelle_partie, partie2, long_partie);

608




609 /* Recopie la partie dans la projection en memoire */

610 if (nouvelle_partie != NULL) memcpy (partie1, nouvelle_partie, long_partie);

611

612 /* Et on marque la fin du fichier */

613 projection_emprunt [longueur_fichier_emprunt()-TAILLE_EMPRUNTEUR] = ’\0’;

614 ftruncate (fde, longueur_fichier_emprunt() - TAILLE_EMPRUNTEUR);

615

616 return 0;

617 }

4.7.2.17 int supprimer ligne (pos)

Supprime une ligne a l’interieur du fichier (a l’emplacement pos).



Postcondition :La ligne a ete supprimee du fichier de donnees



634 {

635 /* La partie du fichier situee apres l’emplacement pos */

636 char *partie = projection_biblio + pos;

637

638 /* La ligne a supprimer */

639 char *chaine_a_supprimer = ligne (pos);

640

641 /* Suppression de la ligne */

642 char *nouvelle_partie = remplacer_sous_chaine (partie, chaine_a_supprimer, "");

643

644 int long_partie = strlen (nouvelle_partie);

645

646 /* Recopie la partie dans la projection en memoire */

647 if (nouvelle_partie != NULL) memcpy (partie, nouvelle_partie, long_partie);

648

649 /* Et on marque la fin de la partie textuelle du fichier */

650 projection_biblio [pos+long_partie] = ’\0’;

651

652 return 0;

653 }

4.7.2.18 void supprimer projection memoire (void)

Fermeture et suppression de la projection en memoire des fichiers.


Postcondition :La projection est supprimee : le fichier physique et la projection memoire sont synchronises.

Le fichier est ferme.





101 {

102 munmap (projection_biblio, longueur_fichier_biblio());

103 close(fdb);

104

105 munmap (projection_emprunt, longueur_fichier_emprunt());

106 close(fde);

107 }

4.7.2.19 void synchroniser (void)

Synchronisation de la projection en memoire du fichier.


Postcondition :La projection est synchronisee.


470 {

471 msync (projection_biblio, longueur_fichier_biblio(), MS_SYNC);

472 msync (projection_emprunt, longueur_fichier_emprunt(), MS_SYNC);

473

474 }

4.7.2.20 void verrou emprunt (int debut, int longueur, int type)

Placement d’un verrou sur le fichier EMPRUNT.

Precondition :le fichier a ete ouvert ( = fd a recu une valeur)

Parametres :debut : emplacement dans le fichier ou commence le verrou. longueur : longueur du verrou. type : type

du verrou place : F RDLCK, F WRLCK, F UNLCK,...

Postcondition :la zone comprise entre debut et debut+longueur est verrouillee

Si le verrou ne peut etre immediatement place (a cause, par exemple, d’un autre verrou), l’operation estmise en attente jusqu’au relachement du verrou.


179 {

180

181 struct flock lock ;;

182 lock.l_whence = SEEK_SET;

183 lock.l_start = debut ;

184 lock.l_len = longueur;

185 lock.l_type = type ;

186

187 if (fcntl (fde , F_SETLKW, &lock)==0)

188 {

189 if (lock.l_type == F_WRLCK)

190 puts ("verrou en ecriture place sur emprunt");

191

192 return;

193 }

194 else




195 {

196 puts ("Attention: probleme lors du placement du verrou emprunt");

197 printf ("Debut du lock %d - Longueur: %d", debut, longueur);

198 puts ("-");

199

200 fcntl (fdb, F_GETLK, &lock);

201

202 switch (lock.l_type)

203 {

204 case (F_RDLCK): puts ("verrou en lecture"); break;

205 case (F_WRLCK): puts ("verrou en ecriture"); break;

206 case (F_UNLCK): puts ("pas de verrou"); break;

207 }

208 }

209 }

4.7.2.21 void verrou livre (int debut, int longueur, int type)

Placement d’un verrou sur le fichier BIBLIO.

Precondition :le fichier a ete ouvert ( = fd a recu une valeur)

Parametres :debut : emplacement dans le fichier ou commence le verrou. longueur : longueur du verrou. type : type

du verrou place : F RDLCK, F WRLCK, F UNLCK,...

Postcondition :la zone comprise entre debut et debut+longueur est verrouillee

Si le verrou ne peut etre immediatement place (a cause, par exemple, d’un autre verrou), l’operation estmise en attente jusqu’au relachement du verrou.


129 {

130 struct flock lock ;;

131 lock.l_whence = SEEK_SET ;

132 lock.l_start = debut ;

133 lock.l_len = longueur;

134 lock.l_type = type ;

135

136 if (fcntl (fdb , F_SETLKW, &lock)==0)

137 {

138 if (lock.l_type == F_WRLCK)

139 puts ("verrou en ecriture place sur biblio");

140 return;

141 }

142 else

143 {

144 puts ("Attention: probleme lors du placement du verrou biblio");

145 printf ("Debut du lock %d - Longueur: %d", debut, longueur);

146 puts ("-");

147

148 fcntl (fdb, F_GETLK, &lock);

149

150 switch (lock.l_type)

151 {

152 case (F_RDLCK): puts ("verrou en lecture"); break;

153 case (F_WRLCK): puts ("verrou en ecriture"); break;

154 case (F_UNLCK): puts ("pas de verrou"); break;

155 }

156 }

157 }




4.7.3 Documentation de la variable

4.7.3.1 int fdb


4.7.3.2 int fde


4.7.3.3 char∗ projection biblio


4.7.3.4 char∗ projection emprunt





Chapitre 5

Mode d’emploi de MNEMO

5.1 Configuration requise

Pour pouvoir compiler le programme :

1. La version “developpement” de la librairie GTK-1.2 est necessaire. Sous debian, vous pouvez installer lepackage libgtk-1.2-dev en ecrivant, en mode root :

#apt-get install libgtk-1.2-dev

2. L’executable “pkg-config” est egalement necessaire :

#apt-get install pkg-config

3. Et bien sur, les librairies C standards.

5.2 Compilation

Pour lancer la compilation du programme, rien de plus simple :

\$ make

5.3 Execution

Pour lancer l’execution du logiciel MNEMO :

\$./mnemo

5.4 Navigation

Vous devriez maintenant obtenir sur votre ecran cette fenetre :

CHAPITRE 5. MODE D’EMPLOI DE MNEMO 71/76



La navigation est assez intuitive. Pour enregistrer un nouveau livre, cliquons sur ... “Enregistrer un nouveaulivre”. Nous obtenons la fenetre suivante :

L’auteur et le titre du livre sont obligatoires, les autres champs sont facultatifs.

Pour faire une recherche dans la bibliotheque, cliquons, a partir du menu principal, sur “Emprunter un nouveaulivre”. Nous obtenons :

Grace a l’utilisation des expressions regulieres pour la recherche de livres, la recherche est assez souple : si, pourtous les criteres, on peut trouver une sous-chaıne du champ du livre correspondant au critere indique, alors lelivre est considere comme “valide”.




Pour connaıtre l’etat de la bibliotheque, cliquons sur “Administration”. Cette fenetre apparaıt :

Le taux de rafraissement peut etre modifie. La valeur par defaut est de 5 secondes, la valeur minimum est de 1seconde.

5.5 Integrite des donnees

Nous avons place des fichiers de donnees “par defaut” dans le logiciel. Ceux-ci se trouvent dans le repertoiredata, ils ont pour noms biblio.txt (pour la bibliotheque) et emprunts.txt. Par defaut, 365 livres sont presentsdans cette bibliotheque. Pas besoin de quelque manipulation que ce soit pour les utiliser ; ils sont chargesautomatiquement. Au passage, ils proviennent d’un fichier de la bibliotheque INGI “reformate” pour l’occasion.

Si une erreur survient lors de l’utilisation du programme, et que cette erreur corrompt d’une facon ou d’une autreles donnees de la bibliotheque, des fichiers de sauvegarde backup biblio.txt et backup emprunts.txt sontpresents dans le repertoire data, il suffit alors d’ecraser les fichiers corrompus par les versions de sauvegarde, etnous retrouvons la bibliotheque de depart.




Chapitre 6

Glossaire

Il est inutile de recopier ici des pages de cours ou de livres. Nous nous contenterons de definir, en quelques mots,la signification de quelques termes techniques utilises dans ce rapport. Pour plus de details, nous vous renvoyonsa la bibliographie.

1. Acces direct : Par opposition a l’acces sequentiel, designe un mecanisme de lecture et d’ecriture defichiers ou il est possible d’acceder directement a n’importe quelle position dans le fichier, sans devoirparcourir l’ensemble du fichier. En C, la fonction fseek() permet de realiser l’acces direct.

2. Communication inter-processus : Dans un environnement temps reel multi-taches (plusieurs proces-sus independants s’executent donc “pseudo-parallelement”, et peuvent donc demander en meme tempsl’acces a une ressource, ou s’echanger des messages), le systeme d’exploitation doit fournir les mecanismespour permettre aux differents programmes de communiquer entre-eux. C’est ce qu’on appelle la commu-nication inter-processus. Quelques exemples de ces mecanismes : queues de messages, memoire partagee,semaphores,...

3. Entrees-sorties : Designe les operations permettant a un programme de communiquer (lire -ecrire) “avecl’exterieur”, c’est-a-dire soit avec l’utilisateur (par le biais de peripheriques d’entree-sorties), soit avec unmateriel de stockage (disque dur, CD-ROM), soit encore avec d’autres machines par le biais d’un reseau.

4. expressions regulieres Expression permettant de caracteriser un ensemble de mots appartenant a unlangage dit regulier. Une expression reguliere est definie a partir d’elements de base : ε, ∅, et les symbolesd’un alphabet Σ, et d’operations sur ces ensembles : l’union α

⋃β, la concatenation α.β, la fermeture

iterative α∗, le complement α.

5. fichiers (sous UNIX) : tout simplement une suite de caracteres que le systeme d’exploitation regroupesous un (ou plusieurs) nom(s), et auquel on peut eventuellement acceder. Cela peut representer un en-semble de donnees, sur le disque, mais pas toujours : ainsi les fichiers des repertoires /proc ou /dev sontbien des fichiers, mais presents en memoire, pas sur le disque.

6. memoire partagee : partie de la memoire qui peut etre accedee par plusieurs processus. Par defaut, lamemoire allouee pour un processus n’est pas partagee. Il faut donc demander aux systeme d’exploitationde permettre a plusieurs processus d’acceder a la meme zone en memoire.

7. page : unite de division de l’espace d’adressage virtuel lors de l’utilisation du mecanisme de pagination.Celui-ci permet a un processus d’utiliser un espace d’adressage plus grand que ne le permet la memoirephysique disponible, en creant un mapping entre l’espace d’adressage et la memoire physique. Lorsqueun processus demande a acceder a une adresse, la demande arrive au MMU (memory management unit

qui regarde si cette information est disponible en memoire. Si oui, l’information est directement redirigee.Si non, un defaut de page intervient : le systeme d’exploitation prend une page de la memoire physiquepeu utilisee, ecrit son contenu sur le disque, et la remplace par la page recherchee. Cela permet de gerer

CHAPITRE 6. GLOSSAIRE 74/76



efficacement les donnees en memoire et leur utilisation quand l’espace disponible est limite.

8. processus : Un programme (ou plutot, une abstraction de celui-ci) en cours d’execution. Il possede uneserie de caracteristiques : espace d’adressage, etat, programme, descripteurs de fichiers, ....

9. projection en memoire d’un fichier : Mecanisme permettant d’acceder au contenu d’un fichier, nonpar les operations d’entrees-sorties, mais par un simple pointeur sur une zone en memoire. En pratique, lesysteme ne copie evidemment pas tout le contenu du fichier en memoire ; il se contente changer les tablesinternes du systeme : quand le programme demande le contenu d’une adresse situee dans la projection,un defaut de page intervient, et la page correspondante est recopiee dans la memoire.

10. Repertoire /proc : repertoire “virtuel” (dont les informations sont situees en memoire, pas sur le disque)contenant toute une serie d’informations sur les processus en cours d’execution.

11. Synchronisation projection memoire-fichier : lorsqu’un fichier a ete projete en memoire et que lecontenu de celle-ci a ete modifie, la synchronisation permet de recopier ces modifications sur le fichierphysique (sur le disque).

12. Verrou sur un fichier : Mecanisme, apparente a la communication inter-processus, permettant d’indi-quer au systeme que le programe desire acceder a une ressource particuliere, et que tout autre processusdesirant acceder a cette meme ressource est prie d’attendre le relachement de ce verrou pour eviter decorrompre les donnees en effectuant des modifications en parallele.

CHAPITRE 6. GLOSSAIRE 75/76



Chapitre 7

Bibliographie

– Claude Delannoy, “Langage C”, Editions Eyrolles, 1999.

– Matt Welsh, Matthias Kalle Dalheimer et Lar Kaufman, “Running Linux”, 3eme edition, O’Reilly, 1999.

– Andrew S. Tanenbaum, “Modern Operating Systems”, 2eme edition, Prentice Hall, 2001.

– Pierre Wolper, “Introduction a la calculabilite”, Dunod, 1991.

– Kurt Wall, “Linux Programming Unleashed”, Sam’s, 1998.

– GNU C Library, http ://gd.tuwien.ac.at/gnu/Manuals/glibc-2.2.5/libc.html

Merci de votre lecture.

CHAPITRE 7. BIBLIOGRAPHIE 76/76

Examen INGI 2113: Conception et r ealisation d’un...

Documents

Transcript of Examen INGI 2113: Conception et r ealisation d’un...