From b4bdb16bf12ebb080fc2a6f1bf5fb495a017fd07 Mon Sep 17 00:00:00 2001 From: Remi Date: Thu, 20 Jun 2019 11:58:25 +0200 Subject: [PATCH] finish --- grid.data | Bin 1065 -> 0 bytes rapport_final.md | 489 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ rapport_finale.md | 489 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- src/ihm/TablooProto.java | 2 +- 4 files changed, 490 insertions(+), 490 deletions(-) create mode 100644 rapport_final.md delete mode 100644 rapport_finale.md diff --git a/grid.data b/grid.data index a19fca4..abdeb3e 100644 Binary files a/grid.data and b/grid.data differ diff --git a/rapport_final.md b/rapport_final.md new file mode 100644 index 0000000..34b6bdb --- /dev/null +++ b/rapport_final.md @@ -0,0 +1,489 @@ +# RAPPORT FINAL + +> ANDJEMBE Maksoudath, TANIEL Rémi + +Le but du projet est de réaliser un tableur "basique" mais facilement +extensible, l'application sera donc divisée en 2 parties : +* le coeur (ou kernel) +* la partie graphique + +Le coeur de l'application s'occupera de toutes les opérations de notre grilles, +pour simplifier le problème les cases ne pourront contenir que des réels ou des +formules(opération binaire ou des fonctions acceptant des plages de cases +comme une moyenne ou une somme). + +## 1. ANALYSE ET CONCEPTION + + +### SCHEMA UML + +Voici le schéma UML de notre application, les classes et méthodes +abstraites sont en italique : + +![UML](rapport_image/uml.png) + +### PSEUDO-JAVA CREATION GRILLE,CASES + +Voici un exemple de création d'une grid et de l'ajout / modification / +affichage de plusieurs types de case : + +```java +class Application { + + public static void main(String[] args) { + Grid g = new Grid(); + + g.createCase("b",1); //Ajout case vide + g.createCase("a",1,100.0); //Ajout case avec valeur + g.createCase("a",2,50.0); //Ajout case avec valeur + g.createCase("a",3,new Addition(g.getCase("a",2),g.getCase("a",1))); //Ajout case avec operation binaire + + List plageCase1 = new ArrayList(); // Crée une liste de case + plageCase1.add(g.getCase("a",1)); + plageCase1.add(g.getCase("a",2)); + plageCase1.add(g.getCase("a",3)); + + g.createCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions + + g.setValue("b",1,100); //Met la valeur de b1 à 100 + + List plageCase2 = new ArrayList(); // Crée une liste de case + plageCase1.add(g.getCase("a",4)); + plageCase1.add(g.getCase("a",2)); + plageCase1.add(g.getCase("a",3)); + + g.setFormula("b",2,new Moyenne(plageCase2)); //Met la formule dans b2 + + g.getValue("a",1); //Affichera 100.0 + g.getValue("a",4); //Affichera (100+50+150)=100 + g.getFormulaAsString("b",2); //Affichera MOYENNE(a4,a2,a3) + g.getDevelopedFormula("b",2); + } +} +``` + +### CHOIX STRUCTURE DE DONNÉES + +Nous devons choisir une structure de donnée pour stocker les cases dans +notre grille, nous savons déjà que nous allons utiliser une collection +pour les stocker,voici celles que nous connaissons: +- des tableaux +- des listes +- des maps +- des sets + +D'après le schéma UML ci-dessus, nous allons donc utiliser une `HashMap` +pour stocker les cases de notre grid : +* Pour rechercher une case et, effectuer des opérations dessus ce sera +plus facile, la clé de la Map sera une chaine de caractère (String) qui +représente la coordonnée de cette case (c'est-à-dire la concaténation +du nom de la ligne et de l'indice de la colonne, exemple : "A1", "B9", etc...) + +Une case peut etre utilisée dans plusieurs autres cases, on ne connait +pas le nombre d'autres cases où elle sera utilisée, on stockera donc +cette donnée dans une `ArrayList`. + +Certaines fonctions (`Average`, `Sum`) utilise également une plage de case, +pour stocker ces cases, nous allons également une `ArrayList`. + +### METHODES ESSENTIELLES EN PSEUDO-JAVA + +#### 1. Methode getValue + +Cette méthode retourne la valeur d'une case se trouvant dans une grille grâce aux coordonnées de la case. +Elle utilise la méthode getCell qui permet d'accéder à une case qui existe et qui dans le cas contraire lève une exeption. +```java +class Grid { + Map cells = new HashMap<>(); + + double getValue(String column, int line){ + return this.getCell(column, line).getValue(); + } +} + +class Cell { + String column; + int line; + double value; + + double getValue() { + return value; + } +} +``` + +#### 2. Methode getFormulaAsString + +Cette méthode permet de retourner le contenu d'une case. Si elle contient une formule, +on retourne la formule simple et dans le cas contraire ses coordonnées. + +```java +class Grid { + Map cells = new HashMap<>(); + + String getFormuleAsString(String column, int line) { + return this.getCell(column, line).toString(); + } +} + +class Cell { + String column; + int line; + double value; + Formula formula; + + String getFormuleAsString() { + if (formula != null) + return formula.toString(); + else + return toString(); + } +} +``` + +**Exemple pour Addition** (Opération Binaire) + +La classe `BinaryOperation` implémente la methode `toString()` en récuperant l'opérateur qui est définit dans la +méthode `getOperator()` défini dans ses classes filles. + +```java +class BinaryOperation { + Cell leftCell; + Cell rightCell; + + public String toString() { + return "(" + this.leftCell.getId() + this.getOperator() + this.rightCell.getId() + ")"; + } +} +class Addition { + + public String getOperator() { + return "+"; + } +} +``` + +#### 3. Methode getDevelopedFormula + +Cette méthode renvoie la formule dévéloppée d'une case, c'est à dire suivant les cas : +- Case avec une valeur : ses coordonnées (exemple: A1) +- Case avec une formule "simple" : la valeur de la case (exemple: SUM(A1,A2,A3)) +- Case avec une formule "complexe" : la valeur de la case et de ses cases utilisées (exemple: SUM(B1,(B1+B2),AVERAGE(C1,C2,C3))) + +```java +class Grid{ + Map cells = new HashMap<>(); + + String getDevelopedFormula(String column, int line) { + return this.getCell(column,line).getFormuleDeveloppe(); + } +} + +class Cell{ + String column; + int line; + double value; + Formula formula; + List usedIn = new ArrayList<>(); + + String getDevelopedFormula() { + if (formula != null) + return formula.getDevelopedFormula(); + else + return toString(); + } +} +``` + +**Exemple de la méthode getDevelopedFormula() pour la class Average** (moyenne) + +```java +class Average { + List listCases = new ArrayList(); + + String getDevelopedFormula() { + return Average + listCases.stream().map(c -> c.getFormuleDeveloppe()).collect((Collectors).joining(", ")) + ")"; + } +} + +``` + +#### 4. Methode eval + +Cette méthode permet de retourner le résultat d'un calcul avec des opérations binaires ou des fonctions. + +##### Opération Binaire + +class BinaryOperation { + Cell leftCell; + Cell rightCell; + +} +Les classes `Addition`, `Multiplication`, `Subtraction` et `Division` héritent de la classe `BinaryOperation` et utilisent +donc ses getters associés à `leftCell` et `rightCell`. + +- Dans Addition : + +```java +class Addition { + + double eval() { + return getLeftCell().getValue() + getRightCell().getValue(); + } +} + +``` + +- Dans Multiplication : + +```java +class Multiplication { + + double eval() { + return getLeftCell().getValue() * getRightCell().getValue(); + } +} +``` + +- Dans Soustraction : + +```java +class Subtraction { + + double eval() { + return getLeftCell().getValue() - getRightCell().getValue(); + } +} + +``` + +- Dans Division : + +```java +class Division { + + double eval() { + return getLeftCell().getValue() / getRightCell().getValue(); + } +} + +``` +##### Fonctions + +class Function { + List listCells; +} +Les classes `Average` et `Sum` héritent de la classe `Function` et utilisent donc le getter associé à `listCells`. + +- Dans Moyenne : + +```java +class Average { + + double eval() { + double val=0; + if (listCases.size() != 0) + for(Cell c : getUtilisedCells()) + val += c.getValue(); + return val / getUtilisedCells().size(); + else + leve une exception + } +} + +``` +- Dans Somme : + +```java +class Sum { + + double eval() { + double val=0; + for(Cell c : getUtilisedCells()) + val += c.getValue(); + return val; + } +} + +``` + +#### 5. Methode setValue + +Nous différencions une valeur fixe et une formule quand nous souhaitons une cellule. +De plus, si la cellule est utilisée dans une autre, nous propageons la nouvelle valeur +pour modifier la valeur des cellules en conséquence. + +```java +class Grid { + Map cells = new HashMap<>(); + + void setValue(String column, int line, double v) { + this.getCell(column, line).setValue(v); + } +} + +class Cell { + String column; + int line; + double value; + Formula formula; + List usedIn = new ArrayList(); + + void setValue(double v) { + value = v; + for(Cell c : usedIn) + c.updateValue(); + } +} +``` + +#### 5. Methode setFormula + +Cette méthode assigne une formule à une case en étant sûre qu'un cycle n'est pas créée, +une exception est lévée dans le cas où un cycle est crée. + +```java +class Grid { + Map cases = new HashMap<>(); + + void setFormula(String column, int line, Formula formula) { + this.getCell(column, line).setFormula(formula); + } +} + +class Cell { + String column; + int line; + double value; + Formula formula; + List usedIn = new ArrayList(); + + void updateValue() { + valeur = formula.eval(); + } + + void setFormula(Formula formula) { + if (!formula.createCycle(this)) + formule = formula; + updateValue(); + for(Cell c : usedIn) + c.updateValue(); + else + leve une exception + } +} +``` +#### 5. Methode createCycle + +Cette méthode vérifie si on crée un cycle direct ou indirect. La façon de la définir est différente +si on a une opération binaire ou une fonction. + +##### Opération binaire + +```java +class BinaryOperation { + Cell leftCell; + Cell rightCell; + + boolean createCycle(Cell cell) { + Si la case gauche contient une formule, voir si on crée un cycle avec la fonction + Sinon si la case droite en contient une, voir si on crée un cycle avec + Sinon vérifier que la case à droite et à gauche sont égales avec celle donnée en paramètre + } +} +``` + +##### Fonction + +```java +class Function { + List listCells; + + boolean creerCycle(Cell cell) { + Si la case n'est pas dans listCells + Sinon pour toute les cases dans listCells qui contiennent des formules, regarder si on crée un cycle avec + } +} + +``` + +## 2. STRUCTURE DU PROJET + +### PACKAGES, CLASSES, FICHIERS DE DONNÉES + +L'implémentation du projet peut se résumer comme suit : + +![PACKAGE](package.png) + +Le schéma ci-dessus nous montre que, l'implémentation est composé de 5 package (representant 5 repertoires) contenant des +classes (chaque classe est un fichier d'extension java). + +### MODES D'UTILISATION + +Concernant les commandes de compilation et d'exécution, sous des logiciels comme Eclipse ou IntelliJ par exemple, juste un clique bouton suffit. +Par contre, dans le cas contraire, il faut se placer dans à la racine du répertoire contenant les fichiers et lancer les commandes suivantes : + +**Commande de compilation**: + +find src -not \( -path src/kernel/test -prune \) -name \*.java|xargs -i javac -d bin {} -cp src/ + +**Commande d'exécution**: + +java -cp bin app.Menu +java -cp bin ihm.TablooProto + +## 3. BILAN + +Au cours de ce projet, voici ce que nous avons réalisé : + +### Le noyeau + +- La gestion des cycles aussi bien direct qu'indirects. +- La modification d'une case par des valeurs ou des formules et dans ce dernier cas la vérification qu'aucun cycle n'est créée. +- La gestion de la langue (en francais et en anglais). +- De supprimer une case que si elle existe et, si elle n'est pas utilisée par d'autres cases. +- De sauvegarder l'état d'une grille après avoir effectué des actions, puis de pouvoir la récupérer. + +### L'interface graphique + +L'interface graphique implementée permet d'effectuer les actions suivantes : + +- Créer une case en saisissant une valeur. +- Créer une case en saisissant une formule (aussi bien en français qu'en anglais). + Par exemple, on écrit dans la cellule A10 : "=SOMME(A1,A2,B2)" + + ![CASE](rapport_image/case_f.PNG) + + ![CASE](rapport_image/case_fv.PNG) + +- Emettre une erreur lorsque l'on saisit du texte au lieu d'un double ou une formule inconnue / incorrecte. + + ![CASE](rapport_image/erreur_s.PNG) + +- Emettre une erreur indiquant qu'un cycle est généré. +- Emettre une erreur indiquant qu'on ne peut pas supprimer une cellule qui est utilisée par d'autres cellules. + +![CASE](rapport_image/erreur_sup.PNG) + +### Les tests + +Plusieurs tests ont été réalisés au cours de ce projet notamment celles permettant de : + +- Créer une ou plusieurs cases avec une valeur fixe ou une formule +- Mettre à jour une case avec une valeur ou formule +- Créer une exception lorsqu'un cycle est créee +- Créer une exception lorsqu'on utilise une case qui n'est pas encore créée +- Effectuer le re-calcul des cases qui dépendent d'une case quand elle est modifiée +- Supprimer une case que si elle n'est pas utilisée par d'autres cases +- Sauvegarde d'une grille + +## Conclusion + +En résumé, ce projet de programmation par objet (PPO) avait pour but de développer les actions que l'on peut faire avec un classeur Excel usuel. +Il était divisé en deux parties : +- La première, créée un noyau avec differentes méthodes permettant d'effectuer et vérifier des actions comme la création, +modification d'une case avec des valeurs, opérations usuelles ou formules. +- La deuxième, de créer une interface graphique. +Ces deux parties ont été réalisées ainsi que des tests permettant de vérifier le fonctionnement de notre noyau. +ce projet nous a donc été bénéfique car, il nous a permis de pouvoir mettre en pratique nos connaisances tout en developpant des nouvelles. +Aussi, concernant les améliorations possibles , l'on pourrait envisager de pouvoir ajouter dans l'interface une option permettant de choisir la langue étant donné qu'actuellement l'on fait un choix d'affichage dans une langue et l'utilisateur ne peut la modifier mais, peut rentrer le nom de d'une fonction dans les deux langues, sera fonctionnera. \ No newline at end of file diff --git a/rapport_finale.md b/rapport_finale.md deleted file mode 100644 index 34b6bdb..0000000 --- a/rapport_finale.md +++ /dev/null @@ -1,489 +0,0 @@ -# RAPPORT FINAL - -> ANDJEMBE Maksoudath, TANIEL Rémi - -Le but du projet est de réaliser un tableur "basique" mais facilement -extensible, l'application sera donc divisée en 2 parties : -* le coeur (ou kernel) -* la partie graphique - -Le coeur de l'application s'occupera de toutes les opérations de notre grilles, -pour simplifier le problème les cases ne pourront contenir que des réels ou des -formules(opération binaire ou des fonctions acceptant des plages de cases -comme une moyenne ou une somme). - -## 1. ANALYSE ET CONCEPTION - - -### SCHEMA UML - -Voici le schéma UML de notre application, les classes et méthodes -abstraites sont en italique : - -![UML](rapport_image/uml.png) - -### PSEUDO-JAVA CREATION GRILLE,CASES - -Voici un exemple de création d'une grid et de l'ajout / modification / -affichage de plusieurs types de case : - -```java -class Application { - - public static void main(String[] args) { - Grid g = new Grid(); - - g.createCase("b",1); //Ajout case vide - g.createCase("a",1,100.0); //Ajout case avec valeur - g.createCase("a",2,50.0); //Ajout case avec valeur - g.createCase("a",3,new Addition(g.getCase("a",2),g.getCase("a",1))); //Ajout case avec operation binaire - - List plageCase1 = new ArrayList(); // Crée une liste de case - plageCase1.add(g.getCase("a",1)); - plageCase1.add(g.getCase("a",2)); - plageCase1.add(g.getCase("a",3)); - - g.createCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions - - g.setValue("b",1,100); //Met la valeur de b1 à 100 - - List plageCase2 = new ArrayList(); // Crée une liste de case - plageCase1.add(g.getCase("a",4)); - plageCase1.add(g.getCase("a",2)); - plageCase1.add(g.getCase("a",3)); - - g.setFormula("b",2,new Moyenne(plageCase2)); //Met la formule dans b2 - - g.getValue("a",1); //Affichera 100.0 - g.getValue("a",4); //Affichera (100+50+150)=100 - g.getFormulaAsString("b",2); //Affichera MOYENNE(a4,a2,a3) - g.getDevelopedFormula("b",2); - } -} -``` - -### CHOIX STRUCTURE DE DONNÉES - -Nous devons choisir une structure de donnée pour stocker les cases dans -notre grille, nous savons déjà que nous allons utiliser une collection -pour les stocker,voici celles que nous connaissons: -- des tableaux -- des listes -- des maps -- des sets - -D'après le schéma UML ci-dessus, nous allons donc utiliser une `HashMap` -pour stocker les cases de notre grid : -* Pour rechercher une case et, effectuer des opérations dessus ce sera -plus facile, la clé de la Map sera une chaine de caractère (String) qui -représente la coordonnée de cette case (c'est-à-dire la concaténation -du nom de la ligne et de l'indice de la colonne, exemple : "A1", "B9", etc...) - -Une case peut etre utilisée dans plusieurs autres cases, on ne connait -pas le nombre d'autres cases où elle sera utilisée, on stockera donc -cette donnée dans une `ArrayList`. - -Certaines fonctions (`Average`, `Sum`) utilise également une plage de case, -pour stocker ces cases, nous allons également une `ArrayList`. - -### METHODES ESSENTIELLES EN PSEUDO-JAVA - -#### 1. Methode getValue - -Cette méthode retourne la valeur d'une case se trouvant dans une grille grâce aux coordonnées de la case. -Elle utilise la méthode getCell qui permet d'accéder à une case qui existe et qui dans le cas contraire lève une exeption. -```java -class Grid { - Map cells = new HashMap<>(); - - double getValue(String column, int line){ - return this.getCell(column, line).getValue(); - } -} - -class Cell { - String column; - int line; - double value; - - double getValue() { - return value; - } -} -``` - -#### 2. Methode getFormulaAsString - -Cette méthode permet de retourner le contenu d'une case. Si elle contient une formule, -on retourne la formule simple et dans le cas contraire ses coordonnées. - -```java -class Grid { - Map cells = new HashMap<>(); - - String getFormuleAsString(String column, int line) { - return this.getCell(column, line).toString(); - } -} - -class Cell { - String column; - int line; - double value; - Formula formula; - - String getFormuleAsString() { - if (formula != null) - return formula.toString(); - else - return toString(); - } -} -``` - -**Exemple pour Addition** (Opération Binaire) - -La classe `BinaryOperation` implémente la methode `toString()` en récuperant l'opérateur qui est définit dans la -méthode `getOperator()` défini dans ses classes filles. - -```java -class BinaryOperation { - Cell leftCell; - Cell rightCell; - - public String toString() { - return "(" + this.leftCell.getId() + this.getOperator() + this.rightCell.getId() + ")"; - } -} -class Addition { - - public String getOperator() { - return "+"; - } -} -``` - -#### 3. Methode getDevelopedFormula - -Cette méthode renvoie la formule dévéloppée d'une case, c'est à dire suivant les cas : -- Case avec une valeur : ses coordonnées (exemple: A1) -- Case avec une formule "simple" : la valeur de la case (exemple: SUM(A1,A2,A3)) -- Case avec une formule "complexe" : la valeur de la case et de ses cases utilisées (exemple: SUM(B1,(B1+B2),AVERAGE(C1,C2,C3))) - -```java -class Grid{ - Map cells = new HashMap<>(); - - String getDevelopedFormula(String column, int line) { - return this.getCell(column,line).getFormuleDeveloppe(); - } -} - -class Cell{ - String column; - int line; - double value; - Formula formula; - List usedIn = new ArrayList<>(); - - String getDevelopedFormula() { - if (formula != null) - return formula.getDevelopedFormula(); - else - return toString(); - } -} -``` - -**Exemple de la méthode getDevelopedFormula() pour la class Average** (moyenne) - -```java -class Average { - List listCases = new ArrayList(); - - String getDevelopedFormula() { - return Average + listCases.stream().map(c -> c.getFormuleDeveloppe()).collect((Collectors).joining(", ")) + ")"; - } -} - -``` - -#### 4. Methode eval - -Cette méthode permet de retourner le résultat d'un calcul avec des opérations binaires ou des fonctions. - -##### Opération Binaire - -class BinaryOperation { - Cell leftCell; - Cell rightCell; - -} -Les classes `Addition`, `Multiplication`, `Subtraction` et `Division` héritent de la classe `BinaryOperation` et utilisent -donc ses getters associés à `leftCell` et `rightCell`. - -- Dans Addition : - -```java -class Addition { - - double eval() { - return getLeftCell().getValue() + getRightCell().getValue(); - } -} - -``` - -- Dans Multiplication : - -```java -class Multiplication { - - double eval() { - return getLeftCell().getValue() * getRightCell().getValue(); - } -} -``` - -- Dans Soustraction : - -```java -class Subtraction { - - double eval() { - return getLeftCell().getValue() - getRightCell().getValue(); - } -} - -``` - -- Dans Division : - -```java -class Division { - - double eval() { - return getLeftCell().getValue() / getRightCell().getValue(); - } -} - -``` -##### Fonctions - -class Function { - List listCells; -} -Les classes `Average` et `Sum` héritent de la classe `Function` et utilisent donc le getter associé à `listCells`. - -- Dans Moyenne : - -```java -class Average { - - double eval() { - double val=0; - if (listCases.size() != 0) - for(Cell c : getUtilisedCells()) - val += c.getValue(); - return val / getUtilisedCells().size(); - else - leve une exception - } -} - -``` -- Dans Somme : - -```java -class Sum { - - double eval() { - double val=0; - for(Cell c : getUtilisedCells()) - val += c.getValue(); - return val; - } -} - -``` - -#### 5. Methode setValue - -Nous différencions une valeur fixe et une formule quand nous souhaitons une cellule. -De plus, si la cellule est utilisée dans une autre, nous propageons la nouvelle valeur -pour modifier la valeur des cellules en conséquence. - -```java -class Grid { - Map cells = new HashMap<>(); - - void setValue(String column, int line, double v) { - this.getCell(column, line).setValue(v); - } -} - -class Cell { - String column; - int line; - double value; - Formula formula; - List usedIn = new ArrayList(); - - void setValue(double v) { - value = v; - for(Cell c : usedIn) - c.updateValue(); - } -} -``` - -#### 5. Methode setFormula - -Cette méthode assigne une formule à une case en étant sûre qu'un cycle n'est pas créée, -une exception est lévée dans le cas où un cycle est crée. - -```java -class Grid { - Map cases = new HashMap<>(); - - void setFormula(String column, int line, Formula formula) { - this.getCell(column, line).setFormula(formula); - } -} - -class Cell { - String column; - int line; - double value; - Formula formula; - List usedIn = new ArrayList(); - - void updateValue() { - valeur = formula.eval(); - } - - void setFormula(Formula formula) { - if (!formula.createCycle(this)) - formule = formula; - updateValue(); - for(Cell c : usedIn) - c.updateValue(); - else - leve une exception - } -} -``` -#### 5. Methode createCycle - -Cette méthode vérifie si on crée un cycle direct ou indirect. La façon de la définir est différente -si on a une opération binaire ou une fonction. - -##### Opération binaire - -```java -class BinaryOperation { - Cell leftCell; - Cell rightCell; - - boolean createCycle(Cell cell) { - Si la case gauche contient une formule, voir si on crée un cycle avec la fonction - Sinon si la case droite en contient une, voir si on crée un cycle avec - Sinon vérifier que la case à droite et à gauche sont égales avec celle donnée en paramètre - } -} -``` - -##### Fonction - -```java -class Function { - List listCells; - - boolean creerCycle(Cell cell) { - Si la case n'est pas dans listCells - Sinon pour toute les cases dans listCells qui contiennent des formules, regarder si on crée un cycle avec - } -} - -``` - -## 2. STRUCTURE DU PROJET - -### PACKAGES, CLASSES, FICHIERS DE DONNÉES - -L'implémentation du projet peut se résumer comme suit : - -![PACKAGE](package.png) - -Le schéma ci-dessus nous montre que, l'implémentation est composé de 5 package (representant 5 repertoires) contenant des -classes (chaque classe est un fichier d'extension java). - -### MODES D'UTILISATION - -Concernant les commandes de compilation et d'exécution, sous des logiciels comme Eclipse ou IntelliJ par exemple, juste un clique bouton suffit. -Par contre, dans le cas contraire, il faut se placer dans à la racine du répertoire contenant les fichiers et lancer les commandes suivantes : - -**Commande de compilation**: - -find src -not \( -path src/kernel/test -prune \) -name \*.java|xargs -i javac -d bin {} -cp src/ - -**Commande d'exécution**: - -java -cp bin app.Menu -java -cp bin ihm.TablooProto - -## 3. BILAN - -Au cours de ce projet, voici ce que nous avons réalisé : - -### Le noyeau - -- La gestion des cycles aussi bien direct qu'indirects. -- La modification d'une case par des valeurs ou des formules et dans ce dernier cas la vérification qu'aucun cycle n'est créée. -- La gestion de la langue (en francais et en anglais). -- De supprimer une case que si elle existe et, si elle n'est pas utilisée par d'autres cases. -- De sauvegarder l'état d'une grille après avoir effectué des actions, puis de pouvoir la récupérer. - -### L'interface graphique - -L'interface graphique implementée permet d'effectuer les actions suivantes : - -- Créer une case en saisissant une valeur. -- Créer une case en saisissant une formule (aussi bien en français qu'en anglais). - Par exemple, on écrit dans la cellule A10 : "=SOMME(A1,A2,B2)" - - ![CASE](rapport_image/case_f.PNG) - - ![CASE](rapport_image/case_fv.PNG) - -- Emettre une erreur lorsque l'on saisit du texte au lieu d'un double ou une formule inconnue / incorrecte. - - ![CASE](rapport_image/erreur_s.PNG) - -- Emettre une erreur indiquant qu'un cycle est généré. -- Emettre une erreur indiquant qu'on ne peut pas supprimer une cellule qui est utilisée par d'autres cellules. - -![CASE](rapport_image/erreur_sup.PNG) - -### Les tests - -Plusieurs tests ont été réalisés au cours de ce projet notamment celles permettant de : - -- Créer une ou plusieurs cases avec une valeur fixe ou une formule -- Mettre à jour une case avec une valeur ou formule -- Créer une exception lorsqu'un cycle est créee -- Créer une exception lorsqu'on utilise une case qui n'est pas encore créée -- Effectuer le re-calcul des cases qui dépendent d'une case quand elle est modifiée -- Supprimer une case que si elle n'est pas utilisée par d'autres cases -- Sauvegarde d'une grille - -## Conclusion - -En résumé, ce projet de programmation par objet (PPO) avait pour but de développer les actions que l'on peut faire avec un classeur Excel usuel. -Il était divisé en deux parties : -- La première, créée un noyau avec differentes méthodes permettant d'effectuer et vérifier des actions comme la création, -modification d'une case avec des valeurs, opérations usuelles ou formules. -- La deuxième, de créer une interface graphique. -Ces deux parties ont été réalisées ainsi que des tests permettant de vérifier le fonctionnement de notre noyau. -ce projet nous a donc été bénéfique car, il nous a permis de pouvoir mettre en pratique nos connaisances tout en developpant des nouvelles. -Aussi, concernant les améliorations possibles , l'on pourrait envisager de pouvoir ajouter dans l'interface une option permettant de choisir la langue étant donné qu'actuellement l'on fait un choix d'affichage dans une langue et l'utilisateur ne peut la modifier mais, peut rentrer le nom de d'une fonction dans les deux langues, sera fonctionnera. \ No newline at end of file diff --git a/src/ihm/TablooProto.java b/src/ihm/TablooProto.java index 0c57149..bd07370 100644 --- a/src/ihm/TablooProto.java +++ b/src/ihm/TablooProto.java @@ -249,7 +249,7 @@ public class TablooProto extends JPanel { Matcher binaryOperationMatcher = binaryOperationPattern.matcher(input); if (!binaryOperationMatcher.matches()) - throw new BadSyntaxException(); + throw new BadSyntaxException("Erreur de syntaxe."); Cell leftCell = grid.getCell(binaryOperationMatcher.group(1)); Cell rightCell = grid.getCell(binaryOperationMatcher.group(3)); -- libgit2 0.21.2