La classe Fichier :
Elle permet à partir du chemin complet du répertoire d'un fichier et de son nom, de connaître
toutes les informations disponibles sur un fichier : savoir si c'est un répertoire, sa taille,
sa date de dernière modification, son extension ...
Son attribut estSelectionne permet
de renseigner si un fichier est selectionné (lors d'un clic de souris).
Ses attributs :
- string nom : chaîne
de caractère contenant le nom du fichier (sans le chemin).
- string chemin :
chaîne de caractère contenant le chemin complet du fichier (sans le nom).
- bool répertoire :
booléen renseignant s'il s'agit d'un répertoire.
- unsigned int taille :
entier positif renseignant la taille du fichier.
- long int noeud :
entier renseignant le numéro d'inode du fichier (qui est utile pour vérifier
l'unicité d'un fichier).
- string dateDerniereModif : chaîne de caractère renseignant la date de dernière
modification.
- string dateDernierAcces : chaîne de caractère renseignant la date de dernier accès.
Ses fonctions membres :
- Fichier() :
constructeur par défaut, il ne fait rien.
- Fichier(string lNom,string lChemin,bool lEstSelectionne=true) : constructeur qui instancie
un objet Fichier à partir de son chemin complet,
de son nom, et éventuellement renseigne si il est sélectionné.
- ~Fichier() :
destructeur, il ne fait rien (toutes les variables allouées se désalloueront
automatiquement).
- Fonctions d'accès et de modification des attributs
privés, pour chacun d'entre eux.
- string getExtension() : retourne l'extension d'un fichier. Si c'est un répertoire,
l'extension retournée est une chaîne vide, sinon c'est la chaîne de caractère suivant le dernier
point du nom.
La classe ListeFichiers :
Elle permet principalement de stocker un ensemble de fichiers en mémoire afin d'y effectuer des actions
systèmes, des opérations ensemblistes (union de deux listes, intersection, ...) ou des tris. Elle peut être
obtenue à partir d'un chemin (elle listera alors le contenu de ce répertoire), ou suite à une commande
système (par exemple un grep), ou encore après une opération ensembliste sur une ou plusieurs listes.
Ses attributs : cet objet ne contient que des méthodes et aucun attribut. En effet, elle hérite de std::list<Fichier *>.
Ses fonctions membres :
- ListeFichiers() :
constructeur par défaut, il ne fait rien.
- ListeFichiers(string source) : constructeur qui instancie un objet ListeFichiers
à partir du chemin passé en paramètre, pendant laquelle le contenu de ce répertoire
est listé et les objets de la classe Fichier sont donc créés et ajoutés
à la liste.
- ~ListeFichiers() : destructeur, il vide la liste.
- void triNom() :
effectue un tri selon le nom des fichiers de cette liste.
- void triTaille() :
effectue un tri selon la taille des fichiers de cette liste.
- void triType() :
effectue un tri selon le type des fichiers de cette liste.
- void triDate() :
effectue un tri selon la date de dernière modification des fichiers de cette
liste.
- void unionListe(ListeFichiers l) : insère les éléments de la liste passée en
paramètre dans la liste appelante en évitant les doublons.
- void intersection(ListeFichiers l) : place dans la liste appelante les
éléments qui sont dans la liste appelante et dans la liste passée en
paramètre.
- void privation(ListeFichiers l) : enlève de la liste appelante les éléments
de la liste passée en paramètre (si ils y sont).
- ListeFichiers sousListeExtension(string ext) : retourne la liste des fichiers de la
liste appelante ayant comme extension la chaîne de caractère passée en
paramètre.
- ListeFichiers sousListeExpressionReguliere(string exp) : retourne la liste des
fichiers de la liste appelante ayant un nom contenant la chaîne de caractère
passée en paramètre.
- ListeFichiers listeSelectionne() : renvoie la sous-liste qui contient les éléments sélectionnés de la liste appelante.
- ListeFichiers & operator =(const ListeFichiers &l) : surcharge de l'opérateur = pour réaliser l'affectation entre listes
La classe ActionSyst :
La liste des actions systèmes est stockée dans un fichier avec le format suivant :
Chaque action doit commencer par <ACTION> et se finir par </ACTION>
il doit y avoir 4 lignes entre ces deux balises:
- une ligne de description (max 1023 caractères)
- la ligne de commande paramétrée (max 1023 caractères)
- true ou false selon si on veut que le chemin complet soit utilisé ou non
- true ou false selon si on veut que la commande soit lancée sur chacun des fichiers
séparément (true) ou sur l'ensemble des fichier (false)
De plus, la ligne de commande doit contenir des caractères spéciaux pour spécifier les fichiers
qu'elle doit prendre en arguments.
Rôle de la classe :
Cette classe représente le moteur interne de gror. C'est elle qui permet d'interpréter et d'exécuter des lignes de
commandes paramétrées.
Les actions systèmes sont stockées sur le disque dans le fichier .GrorAction (dans le répertoire de l'utilisateur).
Elles sont chargées en mémoire par la classe ListeActionSyst qui les stock sous forme de liste chainée (c.f. ListeActionSyst).
Les champs :
- description :
Ce champ permet de décrire l'action, c'est lui qui est affiché dans la 'comboBox' de sélection d'une action lorsque l'utilisateur
désire en lancer une.
- ligne de commande :
Il s'agit de la ligne de commande paramétrée (c.f. plus bas pour le paramétrage de cette ligne de commande).
C'est elle qui sera interprétée en fonction des paramètres et de la liste des fichiers sélectionnés puis exécutée
avec un appel à la fonction systeme(command) du C.
- booléens (chemin, separate, bloquant) :
Ce sont des booléens permettant de contrôler la façon dont l'action va s'exécuter:
-> chemin: signale si le chemin complet doit être utilisé pour lancer l'action ou non (dans ce cas seul les
noms de fichier sont utilisés).
-> separate: sert a savoir si l'action doit être lancée plusieurs fois sur chacun des fichiers (un par un) ou
une seule fois avec l'ensemble des fichiers. Dans le premier cas, la ligne de commande doit comporter des balises
__GROR et GROR__ délimitant les fichiers a "séparer" (c.f. ligne de commande).
-> bloquant: Ce booléen signale si la commande doit être bloquante ou non... Dans certains cas on préfère attendre
la fin de l'action dans d'autres, on préfère reprendre la main avant (surtout dans le cas des commandes longues a exécuter).
Cependant cette fonctionnalité n'est pas encore prise en compte dans la classe ActionSyst. Pour le moment, toutes les actions sont bloquantes.
Cela fait partie des amméliorations a apporter a gror.
La ligne de commande :
La ligne de commande paramétrée est une ligne de commande linux classique comportant en plus des paramètres
qui peuvent avoir les formes suivantes :
- %i , i entier => ListeFichier[i]
ex : rm %1
Quand l'interpréteur de gror rencontre un %i, il le remplace par le ième fichier de la liste des fichiers sélectionnés.
Si la liste comporte moins de i fichiers, alors l'action n'est pas lancée et l'utilisateur est prévenu.
Dans l'exemple la commande lancée sera "rm nomDuPremierFichierSélectionné". Ce qui supprime le fichier sélectionné.
- %%i ,i entier => ListeFichier[i], ListeFichier[i+1], ..., ListeFichier[n]
ex : touch %%1
Cela ressemble beaucoup au premier cas, la différence est que le %%i sera remplacé par tous les fichiers de la liste
des fichiers sélectionnés à partir du ième. Donc %%1 représente tous les fichiers sélectionnés.
L'exemple lance donc "touch" suivit de l'ensemble des fichiers sélectionnés (séparés par un espace). Ce qui aura pour
effet de mettre l'heure de ces fichiers à l'heure actuelle du système.
- %?question? : Boîte de dialogue où question est la question de celle-ci, et le champ
demandé renseigne le paramètre à ajouter dans la ligne de commande.
ex : tar cvzf %%1 %?nom de l'archive :?
Dans certains cas, l'utilisateur peut vouloir lancer une même action sur une liste de fichiers avec un paramètre changeant,
il peut aussi vouloir saisir un nom d'archive par exemple. Pour permettre cela Gror propose ce système de variable: lorsque
l'interpréteur de Gror rencontre %? XXXXXX ? il ouvre une boite de dialogue posant la question à l'utilisateur, ce dernier saisit
la réponse, alors %? XXXXXX ? est remplacer par la saisie de l'utilisateur.
- fixe1 __GRORvariableGROR__ fixe2: lancer la même commande sur chacun des fichiers passés en paramètre.
ex : g++ -c __GROR%%1GROR__ -Wall
Ceci correspond au cas 'separate'. Si la partie variable contient k questions, alors k questions seront posées,
et k commandes (avec chacune une des réponses) seront lancées. De même si la partie variable contient k fichiers.
Cependant on peut conserver une partie fixe (si on désire une seule saisie utilisateur par exemple) en dehors des
balises __GROR et GROR__. Dans l'exemple, on va lancer g++ sur chacun des fichiers sélectionnés.
Note: avec ce même schéma, on pourrait ajouter une fonctionnalité __WarnMessage de warningWarn__ pour
faire des lignes de commandes plus sécurisées...
Gestion des exceptions
Les cas "exceptionnels d'erreurs de l'utilisateur sont en partie contrôlés:
- fichiers manquants
- mauvaises formulation
Dans ces deux cas des exceptions sont levées, elles sont ensuite récupérées dans la partie graphique affichant
un message d'erreur adéquat.
Une classe GrorException a été créée a cet usage.