# Spécifications du module Interface Graphique
###### tags: `specs`
[TOC]
## Introduction
Le module d'interface graphique, véritable coeur de l'application, va permettre à l'utilisateur de dessiner des graphes orientés ainsi que d'intéragir avec eux.
### Bibliothèque
Pour produire l'interface graphique nous avons décider de nous tourner vers Qt, véritable référence de l'interface graphique en c++.
Ce choix a été motivé par différents facteurs :
- La documentation importante et très claire présente sur le site de l'éditeur couvrant l'intégralité de Qt
- Le fait que Qt est utilisé dans le monde professionnel et donc travailler avec est valorisable pour notre intégration sur le marché du travail
- Le fonctionnement de Qt est facilement comprehensible
- De nombreux outils existent pour travailler avec Qt, Qt Creator en tête.
- Le fait que Qt est une bibliothèque écrite en c++ permet de préserver les avantages du c++.
## Fenêtres
### Fenêtre principale
#### Ui_mainwindow (généré par Qt Designer peut changer a tout moment)
Ce fichier est généré automatiquement par Qt designer et permet d'avoir une class simple à utiliser.
```cpp=
class Ui_MainWindow
{
public:
/* ##############################################################
* Attributs des menus déroulants
* ##############################################################
* */
QMenuBar *menubar; // Objet qui englobe tous les menus déroulants
QMenu *menuFichier; // Menu déroulant qui concerne les fichiers et permet de créer un nouveau graphe, d'en ouvrir un, de l'enregistrer et l'enregistrer sous
QMenu *menuEdition; // Menu déroulant permettant l'édition d'un graphe. Tel que la suppression et duplication
QMenu *menuAlgorithmes; // Menu déroulant proposant tout les algorithmes applicables sur le graphe
QMenu *menuCalcul_du_plus_court_chemin; // Double menu déroulant proposant les différents algorithmes de calcul de plus court chemin
QMenu *menuCalcul_des_degr_s_entrant_ou_sortant_d_un_sommet; // Double menu déroulant qui propose de sélectionner le calcul des sommets entrant ou bien des sommets sortant
QMenu *menuTrouver_arborescence_anti_arborescence; // Double menu déroulant permettant de sélectionner la fonction calculant l'arborescence, ou l'anti-arborescence
QMenu *menuAide; // Menu déroulant d'aide proposant la documentation du projet ainsi que le GitHub
// Les Qaction sont des actions pouvant être insérées dans des menus déroulants.
// ### Menu FICHIER ###
QAction *actionNouveau_graphe; // Objet permettant la création d'un nouveau graphe vide et l'ouverture d'un nouvel onglet
QAction *actionNouveau_graphe_al_atoire; // Objet permettant la création d'un nouveau graphe avec un nombre de sommet aléatoire défini dans une fenêtre et l'ouverture d'un nouvel onglet
QAction *actionEnregistrer; // Permet de sauvegarder un graphe
QAction *actionCharger; // Permet d'ouvrir un graphe déjà créé
QAction *actionEnrengistrer_sous; // Permet d'enregistrer sous un graphe
// ### Menu EDITION ###
QAction *actionDupliquer_graphe; // Duplication du graphe
QAction *actionSupprimer_graphe; // Suppression du graphe
QAction *arrangerSommet; // Applique Force Atlas 2 sur le graphe courant
QAction *extraireSousGraphe; // Permet d'extraire grâce aux sommets selectionnés un sous graphe du graphe courant.
QAction *fermerGraphe; // Permet de fermer l'onglet sans sauvegarder
// ### Menu ALGORITHMES ###
QAction *actionFord_Bellman; // Appel de l'algorithme de Ford-Bellman
QAction *actionFloyd_Warshall; // Appel de l'agorithme de Floyd-Warshall
QAction *actionDegr_sortant; // Algorithme des degrés sortants
QAction *actionDegr_entrant; // Algorithme des degrés entrant
QAction *actionDegrs_entrant_et_sortant; // Selection des fonctions de calcul de degré entrant ou sortant
QAction *actionColoration_de_graphe; // Sélection de la coloration de graphe
QAction *actionD_Termination_de_stables; // Sélection de l'algorithme de détermination de stables
QAction *actionD_Termination_de_cliques; // Sélection de l'algorithme de détermination de cliques
QAction *actionVoisins_de_sommets; // Sélection de l'algorithme de calcul des voisins d'un sommet
QAction *actionGestion_de_flots; // Sélection de l'algorithme de gestion de flots
QAction *actionCr_Creer_un_graphe_d_ordonnancement; // Sélection de l'algorithme d'ordonnancement
QAction *actionArborescence; // Sélection de l'algorithme déterminant l'arborescence
QAction *actionAnti_Arborescence; // Sélection de l'algorithme déterminant l'anti-arborescence
QAction *actionRecherche_de_la_connexite; // Sélection de l'algorithme calculant la connexité du graphe
QAction *actionTrouver_chaine_eulerienne; // Sélection de l'algorithme permettant de trouver une chaine eulérienne
QAction *actionTrouver_chaine_hamiltonienne; // Sélection de l'algorithme permettant de trouver une chaine hamiltonienne
QAction *actionR_Postier_chinois; // Sélection de l'algorithme résolvant le problème du postier chinois
QAction *actionR_Voyageur_de_commerce; // Sélection de l'algorithme résolvant le problème du voyageur de commerce
// ### Menu AIDE ###
QAction *actionDocumentation; // Objet renvoyant vers la documentation du projet
QAction *actionGithub; // Objet qui renvoie le lien Github du projet
/* ##############################################################
* Liste des boutons permettant de choisir l'action a effectuer sur le dessin
* ##############################################################
* */
QRadioButton *addSommetButton; // bouton qui permet d'ajouter un sommet au graphe en cliquant
QRadioButton *addArcButton; // bouton qui permet de creer un arc entre 2 sommets
QRadioButton *selectButton; // bouton qui permet de selectioner des sommet ou des arcs dans le graphe
QRadioButton *deleteSommetButton; // Permet de supprimer les sommets sur lesquels on clic
QRadioButton *deleteArcButton; // Permet de supprimer les arcs sur lesquels on clic
// Bouton permettant d'ouvrir un nouvel onglet avec le sous graphe séléctionné issu du graphe courant.
/* ##############################################################
* Attributs des onglets
* ##############################################################
* */
QTabWidget *tabWidget; // Widget contenant les onglets
/* ##############
* Onglet
* ##############*/
QWidget *tab; // Onglet
QZoneDeDessin *zoneDessin; // Zone sur chaque onglet de dessin de graphe
QTextBrowser *caraSelection; // Caractéristiques de la sélection
QTextBrowser *console; // Console affichant les résulats des différentes fonctionnalitées.
// Barre de statut (barre en bas)
QStatusBar *statusbar; // Barre de statut
void setupUi(QMainWindow *MainWindow){
/*
* Utilise les setters des attributs de MainWindow pour leur affecter les valeurs par défaut (déterminer par le biais de Qt Designer)
* */
}
void retranslateUi(QMainWindow *MainWindow){
/*
* Affecte les textes des éléments, la séparation est rendu nécessaire par les fonctionnalités de traduction de Qt.
* */
}
};
```
#### MainWindow
Il va s'agir ici de la class qui va hériter et utiliser les attributs déclarer juste au dessus.
```cpp=
QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE
class MainWindow : public QMainWindow
{
Q_OBJECT
private:
Ui::MainWindow *ui;
Graphe grapheCourant; // Permet d'avoir en temps réel le graphe affiché à l'écran. Change lors du changement d'onglet.
int dernierBoutonEnclenche;
/* Permet de sauvegarder le dernier bouton enclenché par les outils :
- 0 : aucun valeur de base
- 1 : selection
- 2 : ajout de sommet
- 3 : ajout d'arc
- 4 : suppression sommet
- 5 : suppression arc
*/
public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();
int printConsole(string nomMethode, string valRetFunc); // Prends en paramètre le nom de la fonction appelante (nomMethode)et le résultat renvoyé par celle-ci (valRetFunc) qui pourra être casté. Renvoie un 0 en cas de succès ou -1 en cas d'erreur. On l'appelle dans une fonction pour afficher le resultat de la fonction dans la console
int printCaraSelection()
/*
* Récupère la liste des sommets séléctionnés et l'affiche en temps réel dans l'espace d'affichage des caractéristiques de le séléction.
* Renvoie 0 si pas d'erreur -1 sinon.
* */
int ajouterOnglet(Qstring nomOnglet, Graphe G);
/*
* Va permettre d'ouvrir un nouvel onglet respectant le placement (zone de dessin, spécification de la selection et console) et lui affecte le nom placé en paramètre. Le choix de mettre un Qstring plutôt qu'une string s'explique par le fait que le comportement des deux objets est très similiare et l'utilisation d'une Qstring simplifie le nommage de l'onglet dans la fonction (nativement le type du nom d'un onglet est la Qstring).
* le graphe G sera dessiné dans la zone de dessin de l'onglet.
* L'attribut "graphe_courant" va se voir affecté le graphe G.
* Retourne l'index de l'onglet si cela réussi, sinon -1
* */
int supprimerOnglet(Qstring nomOnglet);
/*
* La fonction va rechercher l'onglet portant le nom passé en paramètre puis va le fermer.
* Retourne l'index de l'onglet supprimé si cela se déroule normalement, sinon renvoie -1.
* */
public slots: // Fonctions qui seront connectées avec les boutons de différents types.
void change_onglet();
/*
* Fonction permettant de remplacer l'attribut de "graphe_courant" de mainwindow avec celui "graphe_dessine" de la zone de dessin de l'onglet nouvellement sélectionné.
* Cette fonction sera lié au signal "currentChanged"
* */
void nv_graphe_vide();
/*
* Va ouvrir un nouvel onglet en passant un graphe vide en parametres.
* */
void nv_graphe_aleatoire();
/*
* Va ouvrir en premier lieu une fenêtre de type QInputDialog permettant de récupérer le nombre de sommet à créer aléatoirement.
* Ensuite le nombre demandé de sommet vont être crééé un certain nombre d'entre eux seront lié.
* Puis un nouvel onglet sera ouvert avec le graphe ainsi créer en paramètre.
* Puis la méthode force atlas 2 sera appelée et permettra d'éloigner les sommets les uns des autres.
* */
void enregistrer();
/*
* Va appeler la fonction de sauvegarde sur le chemin présent dans grapheCourant.path et remplacer le fichier déjà existant s'il existe.
* */
void charger();
/*
* Va ouvrir le gestionnaire de fichier du système d'exploitation permttant de choisir quel fichier ouvrir en utilisant la fonction load()
* Cette fonction va ouvrir un nouvel onglet pour y afficher le graphe ouvert.
* */
void enregistrer_sous();
/*
* Va permettre de changer le chemin de sauvegarde du graphe en appelant la fonction éponyme dans gestion de fichier. Va ouvrir une fenêtre de type QInputDialog pour récupérer le nom.
* */
void dupliquer_graphe();
/*
* Va créer un nouvel onglet et y mettre une copie du graphe courant. Pour cela le nouvel onglet aura comme paramètre l'étiquette du graphe courant et le graphe courant.
* */
void supprimer_graphe();
/*
* Supprime le graphe courant en appelant le destructeur du graphe courant.
* Ferme l'onglet et supprime le fichier trouvable si on suit le chemin graphe.path
* */
void ford_Bellman();
/*
* Appelle la fonction "calc_pcc_Bellman" de calcul de plus court chemin par l'algorithme de Ford-Bellman, en lui passant en paramètre une selection de deux sommet ainsi que la matrice d'adjacence du graphe courant en utilisant la méthode "convert_to_matrice_adj".
* Le résultat est affiché dans la console.
* */
void floyd_Warshall();
/*
* Appelle la fonction "calc_pcc_Floyd_Warshall" et va lui passer en paramètre la matrice d'adjacence décrivant le graphe courant en utilisant la méthode "convert_to_matrice_adj".
* Le résultat est affiché dans la console.
* */
void degr_sortant();
/*
* Appelle la fonction "calc_deg_sortant" en lui passant en paramètre les/le sommet/s correspondant aux ID sélectionné/s dans la "QZoneDeDessin" si la liste est composée de plusieurs ID alors la fonction "calc_deg_sortant" sera appellées successivement sur chacun des sommets dont l'ID est présent dans le vecteur.
* Le résultat est affiché dans la console.
* */
void degr_entrant();
/*
* Appelle la fonction "calc_deg_entrant" en lui passant en paramètre les/le sommet/s correspondant aux ID sélectionné/s dans la "QZoneDeDessin" si la liste est composée de plusieurs ID alors la fonction "calc_deg_entrant" sera appellées successivement sur chacun des sommets dont l'ID est présent dans le vecteur.
* La mtrice d'adjacence décrivant le graphe courant sera aussi passée en paramètre.
* Le résultat est affiché dans la console.
* */
void degrs_entrant_et_sortant();
/*
* Appelle la fonction "calc_deg_ent_sor" en lui passant succesivement les sommets dont l'ID est présentes dans la liste des sommets selectionné et le graphe courant décrit par sa matrice d'adjacence en paramètre.
* Affiche le résultat dans la console.
* */
void coloration_de_graphe();
/*
* Appelle la fonction "color_graphe" en lui passant en paramètre la matrice d'adjacence du graphe courant grâce à la méthode "convert_to_matrice_adj".
* Le résultat est affiché sur le graphe courant par coloration des sommets.
* */
void determinaison_de_stables();
/*
* Va appeler la fonction de "stables_graphe" et déterminer le nombre de stable dans le graphe courant, va afficher le nombre de stable dans la console et les colorier sur le graphe.
* */
void determinaison_de_cliques();
/*
* Appelle la fonction "cliques_graphe" avec en paramètre la matrice d'adjacence du graphe courant en utilisant la méthode "convert_to_matrice_adj".
* Le résultat est affiché dans la console et sur le graphe courant, par coloration des différentes cliques.
* */
void voisins_de_sommets();
/*
* Appelle la fonction "voisin_sommet" avec en paramètre la matrice d'adjacence du sommet courant par appel de la méthode "convert_to_matrice_adj" et l'id d'un sommet qui sera, une fois le choix de l'algorithme fait, sélectionné par l'utilisateur.
* La liste des sommets du voisin sélectionnée est affichée dans la console.
* */
void gestion_de_flots();
/*
* Appelle la fonction "Edmond_Karp" et lui passe le graphe courant en paramètre.
* Pour les ID des sommets source et puit il s'agira de séléctionner les deux sommets l'un après l'autre.
* Affiche le flot maximum dans la console.
* */
void creer_un_graphe_d_ordonnancement();
/*
* Cette fonction va ouvrir une seconde fenêtre permettant d'ajouter les tâches. Une fois ceci terminé un nouvel onglet sera ouvert avec comme graphe courant le graphe PERT correspondant.
* Pour faire ceci il va appeler la fonction "pert" dans le module opération sur les graphes avec en paramètre le vecteur de pert_row issue de la fenêtre "ordoCreate" ouverte en amont.
* */
void arborescence();
/*
* Va ouvrir un nouvel onglet avec l'arborescence du graphe courant. Pour la générée la fonction "arborescence" du module opération sur les graphes sera appelée.
* */
void antiArborescence();
/*
* Va ouvrir un nouvel onglet avec l'anti-arborescence du graphe courant. Pour la générée la fonction "anti_arborescence" du module opération sur les graphes sera appelée.
* */
void recherche_de_la_connexite();
/*
* Appelle la fonction "connexite" et lui passe en paramètre la matrice d'adjacence du graphe courant grâce à la méthode "convert_to_matrice_adj". Cette fonction appelle la fonction "arborescence" du module Opération sur les graphes.
* Le nombre de graphe total est affiché dans la console.
* */
void trouver_chaine_eulerienne();
/*
* Appelle la fonction "eulerien" avec en paramètre la matrice d'adjacence du graphe courant en utilisant la méthode "convert_to_matrice_adj".
* La liste des chemins eulériens du graphe est affiché dans la console.
* */
void trouver_chaine_hamiltonienne();
/*
* Appelle la fonction "hamiltonien" en lui passant la matrice d'adjacence du graphe courant en paramètre par utilisation de la méthode "convert_to_matrice_adj".
* La liste des chemins hamiltonien du graphe est affiché dans la console.
* */
void postier_chinois();
/*
* Appelle la fonction "postier_chinois" du module Opération sur les graphes avec en paramètre la matrice d'adjacence du graphe courant en utilisant la fonction "convert_to_matrice_adj".
* Le résultat renvoyé par cette fonction est affiché dans la console.
* */
void voyageur_de_commerce();
/*
* Appelle la fonction "oyageur_commerce" du module d'opération sur les graphes. Le vecteur de sommet passé en paramètre sera déterminé par la sélection de sommet et la matrice passée en paramètre est la matrice d'adjacence du graphe courant.
* La liste des sommets entrés correspondant au plus court chemin passant par chacun de ces sommets sera affichée dans la console.
* */
void documentation(); //A FAIRE
/*
* Affiche un lien renvoyant sur la documentation complète Github du projet.
* */
void github();
/*
* Affiche un lien renvoyant sur la page Github du projet.
* */
void extraireSousGraphe();
/*
* Va récupérer via les getters le graphe courant et la liste des sommets séléctionnés (dans la zone de dessin courante) puis va ouvrir un nouvel onglet avec le graphe issue de la séléction des sommets et du graphe courant.
* */
void arrangerSommets();
/*
* Va lancer la méthode Force atlas 2 sur la zone dessin pour ré-arranger les sommets à la demande de l'utilisateur.
* */
void fermer_graphe();
/*
* Ferme l'onglet courant et détruit le graphe courant, si un autre onglet existe le graphe courant devient le graphe dessiné dans cet onglet.
* Pour fermer l'onglet la fonction "supprimerOnglet" est appelée.
* */
void DBEselection();
// Va modifier "dernierBoutonEnclenche" et va le mettre sur 1
void DBEaddSommet();
// Va modifier "dernierBoutonEnclenche" et va le mettre sur 2
void DBEaddArc();
// Va modifier "dernierBoutonEnclenche" et va le mettre sur 3
void DBEdeleteSommet();
// Va modifier "dernierBoutonEnclenche" et va le mettre sur 4
void DBEdeleteArc();
// Va modifier "dernierBoutonEnclenche" et va le mettre sur 5
};
```
#### TestMainWindow
```cpp=
#include <QtTest/QtTest>
class TestMainWindow: public QObject
{
Q_OBJECT
private slots:
void testMainWindow();
/*
* Test si la MainWindow est créé.
*/
void testDestructeur();
/*
* Test si une MainWindow créé est bien détruite apres l'appel du destructeur.
*/
void testprintConsole();
/*
* Compare les QString de la console avec ce que l'on met en argument dans la fonction printConsole().
*/
void testprintCaraSelection()
/*
* Test comparant les QString de la zone d'affichage avec les QString attendu dans notre cas de test.
*/
void testajouterOnglet()
/*
* Test qui vérifie qu'un Widget tab est bien créé avec le QString que l'on passe en argument et que le graphe passé en argument est bien dessiné dans la zone de dessin.
*/
void testsupprimerOnglet()
/*
* test qui créé un nouvel onglet puis le supprime. Vérifie si le code de retour est le bon et si le widget a bien été supprimer.
*/
void testChangeOnglet()
/*
* Va simuler un changement d'onglet et vérifier que l'attribut "graphe_courant" de mainwindow est bien changé par le graphe présent dans l'attribut "graphe_dessine" de la zone de dessin de l'onglet.
* */
void testnv_graphe_vide()
/*
* Test si la fonction créé un graphe vide dans un nouvel onglet.
*/
void testnv_graphe_aleatoire();
/*
* Test si la fonction créé graphe avec le bon nombre de sommet a été créé dans un nouvel onglet.
*/
void testenregistrer();
/*
* Test si la fonction enregistrer du module gestion de fichier a bien été appellé.
*/
void testcharger();
/*
* Test si la fonction charger du module gestion de fichier a bien été appellé.
*/
void testenregistrer_sous();
/*
* Test si la fonction enregistrer_sous du module gestion de fichier a bien été appellé.
*/
void testdupliquer_graphe();
/*
* Vérifie si le graphe créé dans le nouvel onglet est bien équivalent à celui du premier onglet.
*/
void testsupprimer_graphe();
/*
* Vérifie si le fichier et l'onglet correspondant a un graphe créé ont bien été supprimé.
*/
void testford_Bellman();
/*
* Test vérifiant si la fonction "" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testfloyd_Warshall();
/*
* Test vérifiant si la fonction "calc_pcc_Floyd_Warshall" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testfloyd_Warshall();
/*
* Test vérifiant si la fonction "calc_pcc_Floyd_Warshall" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testdegr_sortant()
/*
* Test vérifiant si la fonction "calc_deg_sortant" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testdegr_entrant()
/*
* Test vérifiant si la fonction "calc_deg_entrant" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testdegrs_entrant_et_sortant();
/*
* Test vérifiant si la fonction "calc_deg_ent_sor" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testcoloration_de_graphe();
/*
* Test verifiant si la fonction "color_graphe" du module opérations sur les graphes a bien été appellé et si les bon sommets sont colorés.
*/
void testdetermination_de_stables();
/*
* Test vérifiant si la fonction "stables_graphe" du module opérations sur les graphes a bien été appellé. vérifie aussi si les bon sommet sont colorés et si les résultats sont affichés dans la console.
*/
void testdetermination_de_cliques();
/*
* Test vérifiant si la fonction "convert_to_matrice_adj" du module opérations sur les graphes a bien été appellé. vérifie aussi si les bon sommet sont colorés et les résultats sont affichés dans la console.
*/
void testvoisins_de_sommets();
/*
* Test vérifiant si la fonction "calc_deg_ent_sor" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void (testgestion_de_flots();
/*
* Test vérifiant si la fonction "edmond_Karp" du module opérations sur les graphes a bien été appellé et si le résultat s'affiche dans la console.
*/
void testcreer_un_graphe_d_ordonnancement();
/*
* Test qui vérifie si la fenètre permettant d'ajouter les tâches s'affiche et si la fonction "pert" du module opérations sur les graphes a été appellé.
* vérifie si le bon graphe a bien été créé dans un nouvel onglet.
*/
void testarborescence();
/*
* Test vérifiant si la fonction "arborescence" du module opération sur les graphes est appellé et si le graphe créé s'affiche correctement dans un nouvel onglet.
*/
void testantiArborescence();
/*
* Test vérifiant si la fonction "anti_arborescence" du module opération sur les graphes est appellé et si le graphe créé s'affiche correctement dans un nouvel onglet.
*/
void testrecherche_de_la_connexite();
/*
* Test qui vérifie si la fonction "connexite" du module opérations sur les graphes a été appellé et si le résultat est bien affiché dans le console.
*/
void testtrouver_chaine_eulerienne();
/*
* Test qui vérifie si la fonction "eulerien" du module opérations sur les graphes a été appellé et si le résultat est bien affiché dans le console.
*/
void testtrouver_chaine_hamiltonienne();
/*
* Test qui verifie si la fonction "eulerien" du module opérations sur les graphes a été appellé et si le résultat est bien affiché dans le console.
*/
void testpostier_chinois();
/*
* Test qui vérifie si la fonction "postier_chinois" du module opérations sur les graphes a été appellé et si le résultat est bien affiché dans le console.
*/
void testvoyageur_de_commerce();
/*
*
Test qui vérifie si la fonction "voyageur_commerce" du module opérations sur les graphes a été appellé et si le résultat est bien affiché dans le console.
*/
void testextraireSousGraphe();
/*
* Test vérifiant si le bon sous-graphe est récuperer et afficher dans un nouvel .
*/
void testarrangerSommets();
/*
* Test vérifiant si la methode "Force_Atlas2" a bien été appellé.
*/
void testDBEselection();
/*
* Test si la fonction modifie bien la valeur de l'entier dernierBoutonEnclenche a 1. */
void testDBEaddSommet();
/*
* Test si la fonction modifie bien la valeur de l'entier dernierBoutonEnclenche a 2.
*/
void testDBEaddArc();
/*
* Test si la fonction modifie bien la valeur de l'entier dernierBoutonEnclenche a 3. */
void testDBEdeleteSommet();
/*
* Test si la fonction modifie bien la valeur de l'entier dernierBoutonEnclenche a 4. */
void testDBEdeleteArc();
/*
* Test si la fonction modifie bien la valeur de l'entier dernierBoutonEnclenche a 5. */
};
```
##### Dessin de graphe
###### QZoneDeDessin
Classe visant à remplacer les QGraphicsView permettant de dessiner que les sommets et les arcs.
Source : https://stackoverflow.com/questions/7830054/how-to-draw-a-point-on-mouseclick-on-a-qgraphicsscene
```cpp=
#include <QGraphicsView>
#include <QGraphicsScene>
#include <QGraphicsEllipseItem>
#include <QMouseEvent>
class QZoneDeDessin : public QGraphicView{
Q_OBJECT
private:
QGraphicsScene * scene; // Dans Qt on ajoute des objets à une scène qu'on affiche ensuite.
vector<int> selected_list; // Permet de stocker les sommets selectionnés.
Graphe graphe_dessine; // Stock le graphe dessiné actuelement dans sa forme objet.
public :
explicit QZoneDeDessin(QWidget *parent = 0); // Constructeur de la zone de dessin
void force_Atlas2()// applique l'algo de force qui permet de separer les points sur le graphe courant.
pair<int,int> distance(QSommet a, QSommet b) // renvoie la distance en pixel entre 2 sommets
void addSelect_Sommet(int ID); // Ajoute l'ID d'un sommet a "selected_list"
void deleteSelect_Sommet(int ID); // Supprime de la "selected_list" l'ID du sommet passé en paramètre.
void razSelected_list(); // Remet à 0 le list_selected
void afficher_Graphe(Graphe G); // fonction d'affichage a partir d'un Graphe
void afficher_Sommet(int id); // fonction d'affichage a partir de l'ID d'un Sommet
void afficher_arc(int id); // fonction d'affichage a partir de l'ID d'un Arc
public slots :
void mousePressEvent(QMouseEvent * e);
/*
* Surcharge de la fonction s'enclanchant lorsque l'on clic sur la QgraphicView.
* On récupère les information du mouseEvent tel que ses positions pour nous permettre de dessiner un objet sur cette position.
* Si le bouton "addSommetButton" a été cliqué alors dessine un sommet sur la position du curseur.
* Si le bouton "addArcButton" a été cliqué alors dessine un arc entre le précédent sommet et celui venant d'être cliqué.
* Si le clic est dans le vide alors la liste des sommets selectionnés est remise à zero.
*
* Si le bouton "selectButton" est enclenché et que "select" du sommet cliqué est sur false alors l'ID du sommet cliqué est ajouté a la liste des ID_selected et ce dernier est changé de couleur.
*
* Si le bouton "selectButton" est enclenché et que "select" du sommet cliqué est sur true alors l'ID du sommet cliqué est supprimé de la "selected_list" et ce dernier redevient de sa couleur original.
*
* Si le bouton "selectButton" n'est pas enclenché et que "select" du sommet cliqué est sur false alors la liste est remise à zéro et le seul le sommet selectionné sera présent dans la liste et ce dernier est changé de couleur.
*
* Si le bouton "selectButton" n'est pas enclenché et que "select" du sommet cliqué est sur true alors la liste est remise à zéro et reste vide et ce dernier redevient de sa couleur original.
*
* Si le bouton "selectButton" est enclenché et que l'utilisateur appuie sur la touche "suppr" alors tous les sommets dont l'ID est présent dans la selected_list et les arcs leur étant lié sont supprimés.
*
* On met à jour l'affichage permettant d'afficher les objets dessinés et de remettre les sommets deselectionnés à la bonne couleur ainsi que les arcs dont le puis ou la source ont changés d'emplacement .
* */
void dessiner_sommet(int x, int y)
/*
* Fonction permettant de dessiner sur la QGraphicView un sommet en lui précisant les positions x et y. Ces dernières peuvent provenir soit du public slots "mousePressEvent" de ZoneDeDessin, soit de la fonction "afficher_sommet" qui va passer en paramètre les positions d'un point déjà défini par le passé.
* Cette fonction va aussi ajouter un sommet à la liste des sommets du graphe courant.
* */
void dessiner_arc(int xA, int yA, int xB, int yB)
/*
* Fonction permettant de dessiner sur la QGraphicView un arc en lui précisant les positions x et y de son sommet de départ de son sommet d'arrivée. Ces dernières peuvent provenir soit du public slots "mousePressEvent" et des positions d'un sommet séléctionné de ZoneDeDessin, soit de la fonction "afficher_arc" qui va passer en paramètre les positions d'un arc déjà défini par le passé.
* Cette fonction va aussi ajouter un arc à la liste des arcs du graphe courant.
* */
};
```
#### TestZoneDeDessin
```cpp=
#include <QtTest/QtTest>
class TestZoneDeDessin: public QObject
{
Q_OBJECT
private slots:
void testZoneDeDessin();
/*
* test si la zone de dessin est crée.
**/
void testDestructeur;
/*
* test si une zone de dessin créé est bien détruite après l'appel du destructeur.
**/
void testForce_Atlas2();
/*
* test de l'algorithme de placement en créant un graphe dont les sommets sont surperposés. La fonction est ensuite apliquée et le test réussi, par vérification des coordonnées des sommets qui devraient être bien positionnés.
**/
void testDistance();
/*
* Test la distance sur deux sommets dont nous connaissons déjà celle si, et validation du test si cette distance est correcte.
**/
void testAddSelect_Sommet();
/*
* ajout de l'ID connu d'un sommet à une liste vide et validation du test par vérification de la "selected_liste".
**/
void testDeleteSelect_Sommet();
/*
* Appel de la fonction pour supprimer l'ID connu d'un sommet de la "selected_liste" contenant celui-ci. Validation du test si celle-ci ne comporte plus ce l'ID de ce sommet.
**/
void testRazSelected_list();
/*
* Test sur une liste non vide. Validation du test si celle-ci est à 0.
**/
void testAfficher_Graphe();
/*
* Test d'affichage. Ce test est réalisée à l'aide de la méthode itemAt de QGraphicView. Une vérification visuelle est égalemment effectuée.
**/
void testAfficher_Sommet();
/*
* Test qui vérifie la position des sommets d'un graphe. Ce test est réalisée à l'aide de la méthode itemAt de QGraphicView.
**/
void testAfficher_arc();
/*
* Test qui vérifie la position des arcs d'un graphe. Ce test est réalisée à l'aide de la méthode itemAt de QGraphicView.
**/
void mousePressEvent();
/*
* test par simulation d'un clic sur l'objet. Vérification de l'état de l'attribut de mainwindow "dernierBoutonEnclenche"
*
* Si on clic sur un sommet :
* Pour la valeur 1, on vérifie que le sommet sélectionné est ajouté à la liste des sommets sélectionné. S'il avait déjà sélectionné alors il est supprimé de la liste.
*
* Pour la valeur 2, on vérifie qu'un sommet est crée sur les positions du curseur.
* Pour la valeur 4, on vérifie que le sommet cliqué est supprimé.
*
* Si on clic sur un arc :
* Pour la valeur 3, on vérifie qu'un arc est dessiné entre le sommet cliqué et le dernier sommet selectionné.
* Pour la valeur 5, on vérifie que l'arc cliqué est supprimé.
*
* Si on clic dans le vide il faut vérifier que la liste est remise à 0
**/
Test des getters.
Test des setters.
}
```
###### QSommet
```cpp=
class QSommet : public QGraphicsItem{
private:
int id; /*
* ID du sommet à partir duquel il est construit
* */
int posx;/*
* Position x du sommet sur la graphicView
* */
int posy;/*
* Position y du sommet sur la graphicView
* */
int rayon;/*
* Rayon du sommet en pixel
* */
QColor coul; /*
* Couleur du sommet
* */
bool select; // Permet de savoir si le sommet est actuelement selectionné.
public:
QSommet(Sommet S); // constructeur d'un QSommet a partir d'un Sommet
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
/*
* Ouvre une fenêtre permettant de modifier l'étiquette ou la charge utile d'un sommet
* */
QRectF boundingRect();
/*
* Permet de déterminer les limites extérieurs de la forme qui permettront d'intéragir avec elle.
* */
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
/*
* Fonction permettant de dessiner le sommet sur une ZoneDeDessin de sa couleur "coul" ou de la couleur de selection. Et avec son étiquette.
* */
void setSelect(bool B);
/*
* Permet de modifier l'attribut du sommet mais aussi sa couleur (si selectionné ou non).
* */
void ~QSommet(); /*
* destructeur de l'objet QSommet
* */
get; // getters de tout les attributs
set; // setters de tout les attributs
};
```
###### Test QSommet
```cpp=
#include <QtTest/QtTest>
class Sommet: public QObject
{
Q_OBJECT
private slots:
void testSommet();
/*
* test si un sommet est crée.
*/
void testDestructeur;
/*
* test si un sommet créé est bien détruit après l'appel du destructeur.
*/
void testMouseDoubleClickEvent();
/*
* Vérifier que la fenêtre est ouverte.
*/
void testBoundingRect();
/*
* Test si pour un clic simulé, le bon sommet est sélectionné.
*/
void testPaint();
/*
* Vérifier que le sommet a été dessiné aux positions du curseur.
*/
void testSetSelect();
/*
* Va vérifier la modification des attributs "coul" et selected en fonction du booleen passé en paramètre.
* */
Test des getters.
Test des setters.
}
```
###### QArc
```cpp=
class Qarc : public QGraphicsItem{
private:
int id; // ID de l'arc a partir duquel il est construit
int posxA; // position x du sommet duquel sort l'arc
int posyA; // position y du sommet duquel sort l'arc
int posxB; // position x du sommet dans lequelle rentre l'arc
int posyB; // position y du sommet dans lequelle rentre l'arc
public:
Qarc (Arc A); // Constructeur d'un QArc à partir d'un Arc.
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
/*
* Ouvre une fenêtre permettant de modifier l'étiquette ou la charge utile d'un arc
* */
QRectF boundingRect();
/*
* Permet de déterminer les limites extérieurs de la forme qui permettront d'intéragir avec elle.
* */
void ~QArc(); /*
* destructeur de l'objet QArc
* */
get; // getters de tout les attributs
set; // setters de tout les attributs
};
```
###### Test QArc
```cpp=
#include <QtTest/QtTest>
class Arc: public QObject
{
Q_OBJECT
private slots:
void testArc();
/*
* test si un arc est crée.
* */
void testDestructeur;
/*
* test si un arc créé est bien détruit après l'appel du destructeur.
* */
void testMouseDoubleClickEvent();
void testBoundingRec();
/*
* Test si pour un clic simulé, le bon sommet est sélectionné.
* */
void testPaint();
/*
* Vérifier que l'arc a été dessiné entre les deux sommets sélectionné.
*/
Test des getters.
Test des setters.
}
```
### ordoCreate
Boite de dialogue permettant de créer un graphe de PERT
#### UI_Dialog
```cpp=
class Ui_Dialog
{
public:
QTableWidget *tableWidget;
/*
* Tableau où sont affiché les informations sur les tâches
* */
QLineEdit *DureelineEdit;
/*
* Zone de texte permettant de donnée la durée d'une tâche.
* */
QLineEdit *TacheAnterieurlineEdit;
/*
* Zone de texte permettant de donner les ID des tâches antérieurs
* */
QLineEdit *IDlineEdit;
/*
* Zone de texte permettant de donner l'ID de la tâche que l'on souhaite ajouter au PERT.
* */
QLineEdit *nomDeLaTachelineEdit;
/*
* Zone de texte permettant de donner le nom de la tâche que l'on souhaite ajouter au PERT.
* */
QPushButton *ajoutTacheButton;
/*
* Lorsque l'utilisateur clic sur ce bouton l'ensemble des informations présent dans les QLineEdit vont rejoindre le tableau mais aussi être convertit en pert_row puis envoyée dans la fonction "calc_post" d'opération sur les graphes permettant d'afficher en temps réel les tâches postérieurs.
* */
QPushButton *supprimeTacheButton;
/*
* La tâche actuelement séléctionnée par l'utilisateur va être supprimée.
* */
QDialogButtonBox *buttonBox;
/*
* Ici sont présent deux boutons "OK" et "Annuler"
* Si "Annuler" est cliqué, la fenêtre se ferme sans rien faire
* Si "OK" est cliqué les informations présente dans le tableaux vont être convertit ligne après ligne en pert_row, mis dans un vecteur et passé en paramètre dans la fonction "pert" d'opération sur les graphes.
* */
void setupUi(QDialog *Dialog){}
/*
* Utilise les setters des attributs de MainWindow pour leur affecter les valeurs par défaut (déterminer par le biais de Qt Designer)
*/
void retranslateUi(QDialog *Dialog){}
/*
* Affecte les textes des éléments, la séparation est rendu nécessaire par les fonctionnalités de traduction de Qt.
*/
};
```
#### ordoCreate.hh
```cpp=
class ordoCreate : public QDialog{
Q_OBJECT
private:
vector<row_pert> res; // Résultat récupéré à l'issue de cette fenêtre permettant de créer le graphe de PERT correpondant.
public:
// getters/setter (très important)
public slots:
void ajoutTache();
/*
* Fonction qui va convertir les informations présententes dans les QLineEdit vers pert_row, trouver les tâches postérieures puis afficher l'ensemble dans le tableau.
* */
void supprimerTache();
/*
* Fonction qui va détecter la tâche séléctionnée dans le tableau et va le supprimer de ce dernier.
* */
}
```
###### Test ordoCreate
```cpp=
#include <QtTest/QtTest>
class ordoCreate: public QObject
{
Q_OBJECT
private slots:
void testAjoutTache();
/*
* test si les informations des QlineEdit sont les mêmes que celles enregistrées dans "row_pert".
* */
void testSupprimerTache();
/*
* Test si une tache connue est bien supprimée du tableau des tâches.
* */
test des Getters.
test des Setters.
};
```
### modifObjet
```cpp=
class Ui_Dialog
{
public:
QLineEdit *lineEditEtiquette;
/*
* Permet de modifier l'étiquette qui s'affiche en placeholder
* */
QTableWidget *tableWidget;
/*
* Affiche l'ensemble des charges utiles (ndlr: stockée sous forme de map)
* */
QPushButton *supprimeButton;
/*
* Permet de supprimer la charge utile séléctionnée par l'utilisateur
* */
QLineEdit *NomlineEdit;
/*
* Permet d'entrer le nom d'une future charge utile
* */
QLineEdit *ValeurlineEdit;
/*
* Permet d'entrer la valeur d'une nouvelle charge utile
* */
QPushButton *addTacheButton;
/*
* Permet d'afficher dans le tableau les valeurs entrées dans les lineEdit
* */
QDialogButtonBox *buttonBox;
/*
* Valide ou annule la modification
* */
};
```
```cpp=
class modifObjet : public QDialog{
Q_OBJECT
private:
...
public:
public slots:
void supprimeCU();
/*
* Permet de supprimer la charge utile en surbrillance (aka selectionnée)
* */
void addCU();
/*
* Ajoute une charge utile respectant les informations entrées dans les lineEdit
* */
};
```
###### Test modifObject
```cpp=
#include <QtTest/QtTest>
class modifObject: public QObject
{
Q_OBJECT
private slots:
void testSuppripmerCU();
/*
* Vérifier que la ligne du tableau sélectionné a été correctement supprimée.
* */
void testAddCu();
/*
* Vérifie qu'une ligne est correctement ajouté au tableau avec les informations présents dans les QLineEdit.
* */
};
```
Sign in with Wallet
Connect another wallet